Udostępnij przez

Rozszerzanie przykładowej gry

Uwaga / Notatka

Ten temat jest częścią serii samouczków pt. Tworzenie prostej gry na uniwersalną platformę Windows (UWP) z użyciem DirectX. Ten temat pod tym linkiem ustawia kontekst serii.

Aby pobrać wersję tej gry, która używa XAML dla nakładki, zobacz DirectX i XAML game sample. Pamiętaj, aby zapoznać się tam z plikiem readme, aby uzyskać szczegółowe informacje na temat tworzenia przykładu.

W tym momencie omówiliśmy kluczowe składniki podstawowej gry DirectX 3D platformy uniwersalnej systemu Windows (UWP). Możesz skonfigurować strukturę gry, w tym dostawcę widoków i potok renderowania oraz zaimplementować podstawową pętlę gry. Możesz również utworzyć podstawową nakładkę interfejsu użytkownika, dołączyć dźwięki i zaimplementować kontrolki. Jesteś w drodze do utworzenia własnej gry, ale jeśli potrzebujesz więcej pomocy i informacji, zapoznaj się z tymi zasobami.

Używanie języka XAML dla nakładki

Jedną z alternatyw, której nie omówiliśmy szczegółowo, jest użycie języka XAML zamiast Direct2D dla nakładki. XAML ma wiele zalet w porównaniu do Direct2D w rysowaniu elementów interfejsu użytkownika. Najważniejszą korzyścią jest to, że wygodniej jest wprowadzić wygląd i odczucie Windows 10 do swojej gry DirectX. Wiele typowych elementów, stylów i zachowań, które definiują aplikację UWP, jest ściśle zintegrowanych z modelem XAML, co znacznie ułatwia implementację dla dewelopera gier. Jeśli twój własny projekt gry ma skomplikowany interfejs użytkownika, rozważ użycie języka XAML zamiast Direct2D.

Za pomocą języka XAML możemy utworzyć interfejs gry, który wygląda podobnie do interfejsu Direct2D wykonanego wcześniej.

XAML

nakładki XAML

Direct2D

nakładka D2D

Chociaż mają podobne wyniki końcowe, istnieje wiele różnic między implementacją interfejsów Direct2D i XAML.

Funkcja XAML Direct2D
Definiowanie nakładki Zdefiniowane w pliku XAML \*.xaml. Po zrozumieniu języka XAML tworzenie i konfigurowanie bardziej skomplikowanych nakładek jest prostsze w porównaniu z direct2D. Zdefiniowane jako zbiór prymitywów Direct2D i ciągów DirectWrite , ręcznie umieszczonych i zapisanych w buforze przeznaczenia Direct2D.
Elementy interfejsu użytkownika Elementy interfejsu użytkownika XAML pochodzą ze standardowych elementów, które są częścią interfejsów API XAML środowiska uruchomieniowego systemu Windows, w tym Windows::UI::Xaml i Windows::UI::Xaml::Controls. Kod, który obsługuje zachowanie elementów interfejsu użytkownika XAML, jest zdefiniowany w pliku codebehind Main.xaml.cpp. Proste kształty, takie jak prostokąty i elipsy, można rysować.
Zmiana rozmiaru okna Naturalnie obsługuje zdarzenia zmiany rozmiaru oraz stanu widoku, odpowiednio przekształcając nakładkę. Należy ręcznie określić sposób ponownego rysowania składników nakładki.

Kolejną dużą różnicą dotyczącą jest łańcuch wymiany. Nie musisz dołączać łańcucha wymiany do obiektu Windows::UI::Core::CoreWindow. Zamiast tego aplikacja DirectX, która zawiera XAML, kojarzy łańcuch swapów, gdy jest tworzony nowy obiekt SwapChainPanel.

Poniższy fragment kodu pokazuje, jak zadeklarować język XAML dla SwapChainPanel w pliku 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>

Obiekt SwapChainPanel jest ustawiany jako właściwość Content bieżącego obiektu okna utworzonego podczas uruchamiania przez singleton aplikacji.

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

Aby dołączyć skonfigurowany łańcuch wymiany do wystąpienia SwapChainPanel zdefiniowanego przez XAML, należy uzyskać wskaźnik do bazowego natywnego ISwapChainPanelNative implementacji interfejsu i wywołać ISwapChainPanelNative::SetSwapChain na nim, przekazując mu skonfigurowany łańcuch wymiany.

Poniższy fragment kodu z DX::DeviceResources::CreateWindowSizeDependentResources szczegółowo opisuje międzyoperacyjność DirectX/XAML:

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

Aby uzyskać więcej informacji na temat tego procesu, zobacz Międzyoperacyjność DirectX i XAML.

Przykład

Aby pobrać wersję tej gry, która używa XAML dla nakładki, zobacz DirectX i XAML game sample. Pamiętaj, aby zapoznać się tam z plikiem readme, aby uzyskać szczegółowe informacje na temat tworzenia przykładu.

W przeciwieństwie do wersji przykładowej gry omówionej w pozostałych tematach, wersja XAML definiuje jej strukturę w plikach App.xaml.cpp i DirectXPage.xaml.cpp, zamiast App.cpp i GameInfoOverlay.cpp, odpowiednio.

  • Last updated on