Einrichten des Spieleprojekts
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.
Der erste Schritt bei der Entwicklung Ihres Spiels besteht darin, ein Projekt in Microsoft Visual Studio zu erstellen. Nachdem Sie ein Projekt speziell für die Spieleentwicklung konfiguriert haben, können Sie es später als eine Art Vorlage erneut verwenden.
Ziele
- Erstellen Sie ein neues Projekt in Visual Studio mithilfe einer Projektvorlage.
- Verstehen Sie den Einstiegspunkt und die Initialisierung des Spiels, indem Sie die Quelldatei für die App-Klasse untersuchen.
- Sehen Sie sich die Spielschleife an.
- Überprüfen Sie die Datei "package.appxmanifest" des Projekts.
Erstellen eines neuen Projekts in Visual Studio
Hinweis
Informationen zum Einrichten von Visual Studio für die C++/WinRT-Entwicklung – einschließlich Installieren und Verwenden der C++/WinRT Visual Studio-Erweiterung (VSIX) und des NuGet-Pakets (die zusammen die Projektvorlage und Buildunterstützung bereitstellen) – finden Sie unter Visual Studio-Unterstützung für C++/WinRT.
Installieren (oder aktualisieren) Sie zuerst die neueste Version der C++/WinRT Visual Studio-Erweiterung (VSIX); siehe oben die Notiz. Erstellen Sie dann in Visual Studio ein neues Projekt basierend auf der Projektvorlage "Core App (C++/WinRT) ". Die neueste allgemein verfügbare Version von Windows SDK (d. h. keine Vorschauversion).
Überprüfen Sie die App-Klasse, um IFrameworkViewSource und IFrameworkView zu verstehen.
Öffnen Sie in Ihrem Core App-Projekt die Quellcodedatei App.cpp. Es gibt die Implementierung der App-Klasse , die die App und deren Lebenszyklus darstellt. In diesem Fall wissen wir natürlich, dass es sich bei der App um ein Spiel handelt. Wir bezeichnen sie jedoch als App, um allgemeiner darüber zu sprechen, wie eine Universelle Windows-Plattform (UWP)-App initialisiert wird.
Die wWinMain-Funktion
Die wWinMain-Funktion ist der Einstiegspunkt für die App. Hier sehen Sie, wie wWinMain aussieht (von App.cpp).
int __stdcall wWinMain(HINSTANCE, HINSTANCE, PWSTR, int)
{
CoreApplication::Run(winrt::make<App>());
}
Wir erstellen eine Instanz der App-Klasse (dies ist die einzige und nur instanz der erstellten App), und wir übergeben dies an die statische CoreApplication.Run-Methode. Beachten Sie, dass CoreApplication.Run eine IFrameworkViewSource-Schnittstelle erwartet. Daher muss die App-Klasse diese Schnittstelle implementieren.
In den nächsten beiden Abschnitten in diesem Thema werden die IFrameworkViewSource- und IFrameworkView-Schnittstellen beschrieben. Diese Schnittstellen (sowie CoreApplication.Run) stellen eine Möglichkeit dar, wie Ihre App Windows mit einem Ansichtsanbieter bereitstellen kann. Windows verwendet diesen Ansichtsanbieter, um Ihre App mit der Windows-Shell zu verbinden, damit Sie Anwendungslebenszyklusereignisse behandeln können.
Die IFrameworkViewSource-Schnittstelle
Die App-Klasse implementiert tatsächlich IFrameworkViewSource, wie Sie in der nachstehenden Auflistung sehen können.
struct App : winrt::implements<App, IFrameworkViewSource, IFrameworkView>
{
...
IFrameworkView CreateView()
{
return *this;
}
...
}
Ein Objekt, das IFrameworkViewSource implementiert, ist ein Ansichtsanbieter-Factoryobjekt. Der Auftrag dieses Objekts besteht darin, ein Ansichtsanbieterobjekt herzustellen und zurückzugeben.
IFrameworkViewSource verfügt über die einzige Methode IFrameworkViewSource::CreateView. Windows ruft diese Funktion für das Objekt auf, das Sie an CoreApplication.Run übergeben. Wie Sie oben sehen können, gibt die App::CreateView-Implementierung dieser Methode zurück *this. Mit anderen Worten, das App-Objekt gibt sich selbst zurück. Da IFrameworkViewSource::CreateView über einen Rückgabewerttyp von IFrameworkView verfügt, muss auch die App-Klasse diese Schnittstelle implementieren. Und Sie können sehen, dass dies in der obigen Auflistung erfolgt.
Die IFrameworkView-Schnittstelle
Ein Objekt, das IFrameworkView implementiert, ist ein Ansichtsanbieterobjekt. Und wir haben jetzt Windows mit diesem Ansichtsanbieter bereitgestellt. Es ist dasselbe App-Objekt , das wir in wWinMain erstellt haben. Daher dient die App-Klasse sowohl als Ansichtsanbieter-Factory als auch als Ansichtsanbieter.
Jetzt kann Windows die Implementierungen der App-Klasse der Methoden von IFrameworkView aufrufen. In den Implementierungen dieser Methoden hat Ihre App die Möglichkeit, Aufgaben wie Initialisierung auszuführen, mit dem Laden der benötigten Ressourcen zu beginnen, die entsprechenden Ereignishandler zu verbinden und den CoreWindow zu empfangen, den Ihre App zum Anzeigen der Ausgabe verwendet.
Ihre Implementierungen der Methoden von IFrameworkView werden in der unten gezeigten Reihenfolge aufgerufen.
- Initialize
- SetWindow
- Einlesen
- Das CoreApplicationView::Activated-Ereignis wird ausgelöst. Wenn Sie also (optional) für die Behandlung dieses Ereignisses registriert haben, wird der OnActivated-Handler zu diesem Zeitpunkt aufgerufen.
- Ausführen
- Aufheben der Initialisierung
Und hier sehen Sie das Skelett der App-Klasse (in App.cpp), das die Signaturen dieser Methoden zeigt.
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() { ... }
...
}
Dies war nur eine Einführung in IFrameworkView. Ausführlichere Informationen zu diesen Methoden und deren Implementierung finden Sie im Definieren des UWP-App-Frameworks des Spiels.
Aufräumen des Projekts
Das core App-Projekt, das Sie aus der Projektvorlage erstellt haben, enthält Funktionen, die wir zu diesem Zeitpunkt aufräumen sollten. Danach können wir das Projekt verwenden, um das Shooting Gallery-Spiel (Simple3DGameDX) neu zu erstellen. Nehmen Sie die folgenden Änderungen an der App-Klasse in App.cpp.
- Löschen Deren Datenmmber.
- OnPointerPressed, OnPointerMoved und AddVisual löschen
- Löschen Sie den Code aus SetWindow.
Das Projekt wird erstellt und ausgeführt, zeigt aber nur eine Volltonfarbe im Clientbereich an.
Die Spielschleife
Um eine Vorstellung davon zu erhalten, wie eine Spielschleife aussieht, sehen Sie sich den Quellcode für das von Ihnen heruntergeladene Simple3DGameDX-Beispielspiel an.
Die App-Klasse verfügt über ein Datenmememm namens "m_main" vom Typ "GameMain". Und dieses Mitglied wird in "App::Run " wie folgt verwendet.
void Run()
{
m_main->Run();
}
Sie finden GameMain::Run in GameMain.cpp. Es ist die Hauptschleife des Spiels, und hier ist eine sehr grobe Gliederung, die die wichtigsten Features zeigt.
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);
}
}
}
Und hier ist eine kurze Beschreibung der Funktionsweise dieser Hauptspielschleife.
Wenn das Fenster für Ihr Spiel nicht geschlossen ist, verteilen Sie alle Ereignisse, aktualisieren Sie den Timer, und rendern Und präsentieren Sie die Ergebnisse der Grafikpipeline. Es gibt viel mehr zu diesen Bedenken zu sagen, und das tun wir in den Themen Definieren des UWP-App-Frameworks des Spiels, Rendering-Framework I: Einführung in das Rendern und Rendering-Framework II: Spielrendering. Dies ist jedoch die grundlegende Codestruktur eines UWP-DirectX-Spiels.
Überprüfen und Aktualisieren der Datei "package.appxmanifest"
Die Datei "Package.appxmanifest " enthält Metadaten zu einem UWP-Projekt. Diese Metadaten werden zum Packen und Starten Ihres Spiels und zum Übermitteln an den Microsoft Store verwendet. Die Datei enthält auch wichtige Informationen, die das System des Spielers verwendet, um Zugriff auf die Systemressourcen bereitzustellen, die das Spiel ausführen muss.
Starten Sie den Manifest-Designer, indem Sie in Projektmappen-Explorer auf die Datei "Package.appxmanifest" doppelklicken.
Weitere Informationen zur Datei "package.appxmanifest " und zum Verpacken finden Sie im Manifest-Designer. Sehen Sie sich nun die Registerkarte "Funktionen " an, und sehen Sie sich die verfügbaren Optionen an.
Wenn Sie nicht die Funktionen auswählen, die Ihr Spiel verwendet, z. B. den Zugriff auf das Internet für ein globales Highscoreboard, können Sie nicht auf die entsprechenden Ressourcen oder Features zugreifen. Wenn Sie ein neues Spiel erstellen, stellen Sie sicher, dass Sie alle funktionen auswählen, die von APIs benötigt werden, die Ihr Spiel aufruft.
Sehen wir uns nun die restlichen Dateien an, die im Beispielspiel "Simple3DGameDX " enthalten sind.
Überprüfen anderer wichtiger Bibliotheken und Quellcodedateien
Wenn Sie eine Art Spielprojektvorlage für sich selbst erstellen möchten, damit Sie diese als Ausgangspunkt für zukünftige Projekte wiederverwenden können, sollten Sie das heruntergeladene Simple3DGameDX-Projekt kopieren GameMain.h und GameMain.cpp aus dem heruntergeladenen Simple3DGameDX-Projekt kopieren und diese dem neuen Core App-Projekt hinzufügen. Lernen Sie diese Dateien kennen, erfahren Sie, was sie tun, und entfernen Sie alles, was für Simple3DGameDX spezifisch ist. Kommentieren Sie auch alles aus, was von Code abhängt, den Sie noch nicht kopiert haben. Ganz nach einem Beispiel hängt davon GameRenderer.hab. GameMain.h Sie können kommentare aufheben, wenn Sie weitere Dateien aus Simple3DGameDX kopieren.
Hier ist eine kurze Umfrage zu einigen der Dateien in Simple3DGameDX , die Sie für die Aufnahme in Ihre Vorlage hilfreich finden, wenn Sie eine erstellen. In jedem Fall sind diese gleichermaßen wichtig, um zu verstehen, wie Simple3DGameDX selbst funktioniert.
Nächste Schritte
An diesem Punkt haben wir gezeigt, wie Sie ein neues UWP-Projekt für ein DirectX-Spiel erstellen, einige der darin aufgeführten Teile betrachtet und darüber nachgedacht haben, wie sie dieses Projekt in eine Art wiederverwendbare Vorlage für Spiele umwandeln. Wir haben uns auch einige der wichtigen Teile des Simple3DGameDX-Beispielspiels angesehen.
Im nächsten Abschnitt wird das UWP-App-Framework des Spiels definiert. Dort werden wir genauer untersuchen, wie Simple3DGameDX funktioniert.