Konfigurowanie projektu 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.

Pierwszym krokiem tworzenia gry jest utworzenie projektu w programie Microsoft Visual Studio. Po skonfigurowaniu projektu specjalnie na potrzeby tworzenia gier możesz później użyć go jako rodzaju szablonu.

Cele i zadania

Utwórz nowy projekt w programie Visual Studio przy użyciu szablonu projektu.
Poznaj punkt wejścia i inicjowanie gry, sprawdzając plik źródłowy dla klasy App.
Spójrz na pętlę gry.
Przejrzyj plik package.appxmanifest projektu.

Tworzenie nowego projektu w programie Visual Studio

Uwaga / Notatka

Aby uzyskać informacje na temat konfigurowania programu Visual Studio dla programowania w języku C++/WinRT — w tym instalowania i używania rozszerzenia C++/WinRT Visual Studio (VSIX) oraz pakietu NuGet (który razem zapewnia obsługę szablonu projektu i kompilacji) — zobacz obsługa programu Visual Studio dla języka C++/WinRT.

Najpierw zainstaluj (lub zaktualizuj do) najnowszą wersję rozszerzenia C++/WinRT Visual Studio (VSIX); zobacz notatkę powyżej. Następnie w programie Visual Studio utwórz nowy projekt na podstawie szablonu projektu Core App (C++/WinRT). Umożliwia określenie najnowszej ogólnie dostępnej wersji zestawu Windows SDK ( czyli nie wersji zapoznawczej).

Przejrzyj klasę App, aby zrozumieć IFrameworkViewSource oraz IFrameworkView.

W projekcie Aplikacji Podstawowej otwórz plik kodu źródłowego App.cpp. W tym miejscu znajduje się implementacja klasy App, która reprezentuje aplikację i jej cykl życia. W tym przypadku oczywiście wiemy, że aplikacja jest grą. Jednak będziemy odwoływać się do niej jako aplikacji , aby bardziej ogólnie mówić o tym, jak aplikacja Universal Windows Platform (UWP) inicjuje.

Funkcja wWinMain

Funkcja wWinMain jest punktem wejścia dla aplikacji. Oto jak wygląda wWinMain (z App.cpp).

int __stdcall wWinMain(HINSTANCE, HINSTANCE, PWSTR, int)
{
    CoreApplication::Run(winrt::make<App>());
}

Tworzymy wystąpienie klasy App (jest to jedno i tylko wystąpienie utworzonej aplikacji App) i przekazujemy je do metody static CoreApplication.Run. Należy pamiętać, że CoreApplication.Run oczekuje interfejsu IFrameworkViewSource. Dlatego klasa App musi zaimplementować ten interfejs.

W kolejnych dwóch sekcjach w tym temacie opisano interfejsy IFrameworkViewSource i IFrameworkView. Te interfejsy (a także CoreApplication.Run) reprezentują sposób dostarczania systemowi Windows komponentu dostarczającego widoki. System Windows używa tego dostawcy widoków do łączenia aplikacji z powłoką systemu Windows, aby umożliwić obsługę zdarzeń cyklu życia aplikacji.

Interfejs IFrameworkViewSource

Klasa App rzeczywiście implementuje IFrameworkViewSource, jak widać na poniższej liście.

struct App : winrt::implements<App, IFrameworkViewSource, IFrameworkView>
{
    ...
    IFrameworkView CreateView()
    {
        return *this;
    }
    ...
}

Obiekt implementujący IFrameworkViewSource jest obiektem fabryki dostawcy widoku . Zadaniem tego obiektu jest tworzenie i zwrócenie obiektu dostarczającego widok.

IFrameworkViewSource ma pojedynczą metodę IFrameworkViewSource::CreateView. System Windows wywołuje tę funkcję w obiekcie przekazywanym do CoreApplication.Run. Jak widać powyżej, implementacja App::CreateView tej metody zwraca *this. Innymi słowy obiekt App zwraca sam siebie. Ponieważ IFrameworkViewSource::CreateView ma typ zwracanej wartości IFrameworkView, oznacza to, że klasa App musi również zaimplementować ten interfejs. I widać, że to robi na powyższej liście.

Interfejs IFrameworkView

Obiekt implementujący IFrameworkView jest obiektem dostawcy widoków . Teraz wyposażyliśmy system Windows w tego dostawcę widoków. To ten sam obiekt App, który stworzyliśmy w wWinMain. Dlatego klasa App służy zarówno jako fabryka dostawców widoków oraz jako dostawca widoków .

Teraz system Windows może wywoływać implementacje metod klasy App z IFrameworkView. W implementacjach tych metod aplikacja ma szansę na wykonanie zadań, takich jak inicjowanie, rozpoczęcie ładowania potrzebnych zasobów, łączenie odpowiednich procedur obsługi zdarzeń i odbieranie CoreWindow, które aplikacja będzie używać do wyświetlania danych wyjściowych.

Implementacje metod IFrameworkView są wywoływane w kolejności pokazanej poniżej.

Zainicjuj
UstawOkno
ładunek
Zdarzenie CoreApplicationView::Activated zostało zgłoszone. Jeśli więc (opcjonalnie) zarejestrowałeś się do obsługi tego zdarzenia, to w tym momencie wywoływany jest Twój program obsługi OnActivated.
Uruchom
dezainicjalizować

Oto szkielet klasy App (w App.cpp), przedstawiający podpisy tych metod.

struct App : winrt::implements<App, IFrameworkViewSource, IFrameworkView>
{
    ...
    void Initialize(Windows::ApplicationModel::Core::CoreApplicationView const& applicationView) { ... }
    void SetWindow(Windows::UI::Core::CoreWindow const& window) { ... }
    void Load(winrt::hstring const& entryPoint) { ... }
    void OnActivated(
        Windows::ApplicationModel::Core::CoreApplicationView const& applicationView,
        Windows::ApplicationModel::Activation::IActivatedEventArgs const& args) { ... }
    void Run() { ... }
    void Uninitialize() { ... }
    ...
}

To było tylko wprowadzenie do IFrameworkView. Bardziej szczegółowo omawiamy te metody i sposób ich implementowania w Definiowanie platformy aplikacji uniwersalnej systemu Windows w kontekście gry.

Porządkowaj projekt

Projekt Aplikacji podstawowej utworzony na podstawie szablonu projektu zawiera funkcje, które należy uporządkować w tym momencie. Następnie możemy użyć projektu, aby odtworzyć grę galerii fotografowania (Simple3DGameDX). Wprowadź następujące zmiany w klasie App w App.cpp.

Usuń jego elementy danych.
Usuń OnPointerPressed; OnPointerMovedi AddVisual
Usuń kod z SetWindow.

Projekt zostanie skompilowany i uruchomiony, ale będzie wyświetlać tylko jednolity kolor w obszarze klienta.

Pętla gry

Aby zrozumieć, jak wygląda pętla gry, poszukaj w kodzie źródłowym pobranej przykładowej gry Simple3DGameDX.

Klasa App ma składową danych o nazwie m_maintypu GameMain. Ten element jest używany w App::Run w następujący sposób.

void Run()
{
    m_main->Run();
}

GameMain::Run można znaleźć w GameMain.cpp. Jest to główna pętla gry, a oto bardzo szorstki zarys przedstawiający najważniejsze cechy.

void GameMain::Run()
{
    while (!m_windowClosed)
    {
        if (m_visible)
        {
            CoreWindow::GetForCurrentThread().Dispatcher().ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
            Update();
            m_renderer->Render();
            m_deviceResources->Present();
        }
        else
        {
            CoreWindow::GetForCurrentThread().Dispatcher().ProcessEvents(CoreProcessEventsOption::ProcessOneAndAllPending);
        }
    }
}

Oto krótki opis tego, co robi ta główna pętla gry.

Jeśli okno twojej gry nie jest zamknięte, wyślij wszystkie zdarzenia, zaktualizuj licznik, a następnie renderuj i przedstaw wyniki potoku graficznego. Istnieje o wiele więcej do powiedzenia na temat tych problemów, a zrobimy to w tematach Definiowanie frameworku aplikacji UWP gry, Framework renderowania I: Wprowadzenie do renderowaniaoraz Framework renderowania II: Renderowanie gry. Ale jest to podstawowa struktura kodu gry DIRECTX platformy UWP.

Przejrzyj i zaktualizuj plik package.appxmanifest

Plik Package.appxmanifest zawiera metadane dotyczące projektu platformy UWP. Te metadane są używane do tworzenia pakietów i uruchamiania gry oraz do przesyłania ich do Sklepu Microsoft. Plik zawiera również ważne informacje, których system gracza używa w celu zapewnienia dostępu do zasobów systemowych, które należy uruchomić w grze.

Uruchom projektanta manifestu , klikając dwukrotnie plik Package.appxmanifest w eksploratorze rozwiązań .

zrzut ekranu edytora manifestu package.appx.

Aby uzyskać więcej informacji na temat pliku i pakowania pliku package.appxmanifest, zobacz Manifest Designer. Na razie przyjrzyj się karcie Możliwości i zapoznaj się z podanymi opcjami.

zrzut ekranu z domyślnymi możliwościami aplikacji direct3d.

Jeśli nie wybierzesz możliwości używanych przez twoją grę, takich jak dostęp do Internet dla globalnej tablicy wyników, nie będziesz mógł uzyskać dostępu do odpowiednich zasobów ani funkcjonalności. Podczas tworzenia nowej gry upewnij się, że wybierasz wszystkie funkcje wymagane przez interfejsy API, które wywołuje twoja gra.

Teraz przyjrzyjmy się pozostałym plikom, które pochodzą z przykładowej gry Simple3DGameDX.

Przejrzyj inne ważne biblioteki i pliki kodu źródłowego

Jeśli zamierzasz utworzyć dla siebie rodzaj szablonu projektu gry, aby można było go ponownie użyć jako punktu wyjścia dla przyszłych projektów, należy skopiować GameMain.h i GameMain.cpp z Simple3DGameDX projektu, który został pobrany, i dodać te do nowego projektu aplikacji Core App. Zapoznaj się z tymi plikami, dowiedz się, co robią, i usuń wszystkie elementy specyficzne dla Simple3DGameDX. Zakomentuj również wszelkie elementy, które są zależne od kodu, którego jeszcze nie skopiowano. Na przykład GameMain.h zależy od GameRenderer.h. Możesz usunąć komentarz podczas kopiowania większej liczby plików z Simple3DGameDX.

Poniżej przedstawiono krótki przegląd niektórych plików w Simple3DGameDX, które warto uwzględnić w szablonie, jeśli taki tworzysz. W każdym razie są one równie ważne, aby zrozumieć, jak Simple3DGameDX działa sam.

Plik źródłowy	Folder plików	Opis
DeviceResources.h/.cpp	Usługi komunalne	Definiuje klasę DeviceResources, która steruje wszystkimi zasobami urządzeń DirectX. Definiuje również interfejs IDeviceNotify używany do powiadamiania aplikacji o utracie lub ponownym utworzeniu urządzenia karty graficznej.
DirectXSample.h	Usługi komunalne	Implementuje funkcje pomocnicze, takie jak ConvertDipsToPixels. ConvertDipsToPixels konwertuje długość w pikselach niezależnych od urządzenia (DIPs) na długość w pikselach fizycznych.
GameTimer.h/.cpp	Usługi komunalne	Definiuje czasomierz o wysokiej rozdzielczości przydatny w przypadku gier lub interaktywnych aplikacji renderowania.
GameRenderer.h/.cpp	Renderowanie	Definiuje klasę GameRenderer, która implementuje podstawową ścieżkę renderowania.
GameHud.h/.cpp	Renderowanie	Definiuje klasę do renderowania wyświetlacza head up (HUD) dla gry przy użyciu direct2D i DirectWrite.
VertexShader.hlsl i VertexShaderFlat.hlsl	Shadery	Zawiera kod języka wysokopoziomowego cieniowania (HLSL) dla podstawowych shaderów wierzchołków.
PixelShader.hlsl i PixelShaderFlat.hlsl	Shadery	Zawiera kod języka cieniowania wysokiego poziomu (HLSL) dla podstawowych pixel shaderów.
ConstantBuffers.hlsli	Shadery	Zawiera definicje struktur danych dla stałych buforów i struktur shaderów używanych do przekazywania macierzy model-widok-projekcja (MVP) i danych wierzchołków do shadera wierzchołków.
pch.h/.cpp	N/A	Zawiera typowe składniki C++/WinRT, Windows i DirectX.

Dalsze kroki

W tym momencie pokazaliśmy, jak utworzyć nowy projekt UWP dla gry DirectX, przyjrzeliśmy się niektórym jego elementom i zaczęliśmy się zastanawiać, jak przekształcić ten projekt w szablon wielokrotnego użytku dla gier. Przyjrzeliśmy się również na niektóre ważne elementy przykładowej gry Simple3DGameDX.

Następna sekcja to Definiowanie frameworka aplikacji UWP dla gry. Przyjrzymy się bliżej temu, jak działa Simple3DGameDX.

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-06-10