Configurer le projet de jeu

La première étape du développement de votre jeu consiste à créer un projet dans Microsoft Visual Studio. Une fois que vous avez configuré un projet spécifiquement pour le développement de jeux, vous pouvez l’utiliser ultérieurement comme un type de modèle.

Objectifs

• Créez un projet dans Visual Studio à l’aide d’un modèle de projet.
• Comprendre le point d’entrée et l’initialisation du jeu en examinant le fichier source de la classe App .
• Regardez la boucle du jeu.
• Passez en revue le fichier package.appxmanifest du projet.

Création d'un projet dans Visual Studio

Première installation (ou mise à jour vers) de la dernière version de l’extension Visual Studio C++/WinRT (VSIX) ; voir la remarque ci-dessus. Ensuite, dans Visual Studio, créez un projet basé sur le modèle de projet Core App (C++/WinRT ). Ciblez la dernière version en disponibilité générale (autrement dit, pas la préversion) du SDK Windows.

Passez en revue la classe App pour comprendre IFrameworkViewSource et IFrameworkView

Dans votre projet Core App, ouvrez le fichier App.cppde code source . Il existe l’implémentation de la classe App , qui représente l’application et son cycle de vie. Dans ce cas, bien sûr, nous savons que l’application est un jeu. Mais nous allons l’utiliser en tant qu’application pour parler plus généralement de l’initialisation d’une application plateforme Windows universelle (UWP).

La fonction wWinMain

La fonction wWinMain est le point d’entrée de l’application. Voici à quoi ressemble wWinMain (de App.cpp).

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

Nous créons une instance de la classe App (il s’agit de la seule instance de l’application créée) et nous transmettons cette instance à la méthode static CoreApplication.Run. Notez que CoreApplication.Run attend une interface IFrameworkViewSource. Par conséquent, la classe App doit implémenter cette interface.

Les deux sections suivantes de cette rubrique décrivent les interfaces IFrameworkViewSource et IFrameworkView. Ces interfaces (ainsi que CoreApplication.Run) représentent un moyen pour votre application de fournir à Windows un fournisseur d’affichage. Windows utilise ce fournisseur d’affichage pour connecter votre application à l’interpréteur de commandes Windows afin de pouvoir gérer les événements de cycle de vie des applications.

Interface IFrameworkViewSource

La classe App implémente en effet IFrameworkViewSource, comme vous pouvez le voir dans la liste ci-dessous.

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

Un objet qui implémente IFrameworkViewSource est un objet de fabrique de fournisseur d’affichage. Le travail de cet objet consiste à fabriquer et à retourner un objet fournisseur d’affichage.

IFrameworkViewSource a la méthode unique IFrameworkViewSource ::CreateView. Windows appelle cette fonction sur l’objet que vous passez à CoreApplication.Run. Comme vous pouvez le voir ci-dessus, l’implémentation App ::CreateView de cette méthode retourne *this. En d’autres termes, l’objet App se retourne. Étant donné que IFrameworkViewSource ::CreateView a un type de valeur de retour IFrameworkView, il suit que la classe App doit également implémenter cette interface. Et vous pouvez voir qu’il le fait dans la liste ci-dessus.

Interface IFrameworkView

Un objet qui implémente IFrameworkView est un objet de fournisseur d’affichage. Et nous avons maintenant fourni Windows à ce fournisseur d’affichage. Il s’agit de ce même objet App que nous avons créé dans wWinMain. Ainsi, la classe App sert de fabrique de fournisseur d’affichage et de fournisseur d’affichage.

Maintenant, Windows peut appeler les implémentations de la classe App des méthodes d’IFrameworkView. Dans les implémentations de ces méthodes, votre application a la possibilité d’effectuer des tâches telles que l’initialisation, de commencer à charger les ressources dont elle aura besoin, de connecter les gestionnaires d’événements appropriés et de recevoir coreWindow que votre application utilisera pour afficher sa sortie.

Vos implémentations des méthodes d’IFrameworkView sont appelées dans l’ordre indiqué ci-dessous.

• Initialize
• SetWindow
• Charge
• L’événement CoreApplicationView ::Activated est déclenché. Par conséquent, si vous avez (éventuellement) inscrit pour gérer cet événement, votre gestionnaire OnActivated est appelé pour l’instant.
• Exécuter
• Annuler l’initialisation

Et voici le squelette de la classe App (en App.cpp), montrant les signatures de ces méthodes.

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() { ... }
    ...
}

C’était juste une introduction à IFrameworkView. Nous allons plus en détail sur ces méthodes et comment les implémenter, dans Définir l’infrastructure d’application UWP du jeu.

Tidy up the project

Le projet Core App que vous avez créé à partir du modèle de projet contient des fonctionnalités que nous devrions ranger à ce stade. Ensuite, nous pouvons utiliser le projet pour recréer le jeu de galerie de tirs (Simple3DGameDX). Apportez les modifications suivantes à la classe App dans App.cpp.

• Supprimez ses membres de données.
• Supprimer OnPointerPressed, OnPointerMoved et AddVisual
• Supprimez le code de SetWindow.

Le projet génère et s’exécute, mais il affiche uniquement une couleur unie dans la zone cliente.

Boucle de jeu

Pour avoir une idée de ce à quoi ressemble une boucle de jeu, regardez dans le code source de l’exemple de jeu Simple3DGameDX que vous avez téléchargé.

La classe App a un membre de données, nommé m_main, de type GameMain. Et ce membre est utilisé dans App ::Run comme suit.

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

Vous pouvez trouver GameMain ::Run in GameMain.cpp. C’est la boucle principale du jeu, et voici un contour très approximatif de celui-ci montrant les caractéristiques les plus importantes.

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

Et voici une brève description de ce que fait cette boucle de jeu principale.

Si la fenêtre de votre jeu n’est pas fermée, distribuez tous les événements, mettez à jour le minuteur, puis affichez et présentez les résultats du pipeline graphique. Il y a beaucoup plus à dire sur ces préoccupations, et nous allons le faire dans les rubriques Définir l’infrastructure d’application UWP du jeu, Infrastructure de rendu I : Présentation du rendu et infrastructure de rendu II : Rendu du jeu. Mais il s’agit de la structure de code de base d’un jeu UWP DirectX.

Examiner et mettre à jour le fichier package.appxmanifest

Le fichier Package.appxmanifest contient des métadonnées sur un projet UWP. Ces métadonnées sont utilisées pour l’empaquetage et le lancement de votre jeu et pour la soumission au Microsoft Store. Le fichier contient également des informations importantes que le système du joueur utilise pour fournir l’accès aux ressources système dont le jeu a besoin pour s’exécuter.

Lancez le concepteur de manifeste en double-cliquant sur le fichier Package.appxmanifest dans Explorateur de solutions.

Pour plus d’informations sur le fichier package.appxmanifest et l’empaquetage, consultez le Concepteur de manifeste. Pour l’instant, examinez l’onglet Fonctionnalités et examinez les options fournies.

Si vous ne sélectionnez pas les fonctionnalités utilisées par votre jeu, telles que l’accès à Internet pour un tableau de score élevé global, vous ne pourrez pas accéder aux ressources ni aux fonctionnalités correspondantes. Lorsque vous créez un jeu, veillez à sélectionner toutes les fonctionnalités nécessaires par les API que votre jeu appelle.

Examinons maintenant le reste des fichiers fournis avec l’exemple de jeu Simple3DGameDX .

Passer en revue d’autres bibliothèques importantes et fichiers de code source

Si vous envisagez de créer un type de modèle de projet de jeu pour vous-même, afin de pouvoir le réutiliser comme point de départ pour les projets futurs, vous souhaiterez copier et sortir GameMain.h du projet Simple3DGameDX que vous avez téléchargé et ajouter ceux-ci à votre nouveau GameMain.cpp projet Core App. Étudiez ces fichiers, découvrez ce qu’ils font et supprimez tout ce qui est spécifique à Simple3DGameDX. Commentez également tout ce qui dépend du code que vous n’avez pas encore copié. Juste à l’instar d’un exemple, GameMain.h dépend GameRenderer.hde . Vous serez en mesure de supprimer les marques de commentaire lorsque vous copiez d’autres fichiers à partir de Simple3DGameDX.

Voici un bref aperçu de certains fichiers de Simple3DGameDX que vous trouverez utiles à inclure dans votre modèle, si vous en faites un. Dans tous les cas, il est tout aussi important de comprendre comment Simple3DGameDX fonctionne lui-même.

Étapes suivantes

À ce stade, nous avons montré comment créer un projet UWP pour un jeu DirectX, examiné certains des éléments qu’il contient, et nous avons commencé à réfléchir à la façon de transformer ce projet en un modèle réutilisable pour les jeux. Nous avons également examiné certains des éléments importants de l’exemple de jeu Simple3DGameDX .

La section suivante est Définir l’infrastructure d’application UWP du jeu. Nous allons examiner plus en détail le fonctionnement de Simple3DGameDX .