Partager via

Porter la boucle de jeu

  • Article

Résumé

Montre comment implémenter une fenêtre pour un jeu de plateforme Windows universelle (UWP) et comment effectuer le basculement de la boucle de jeu, notamment comment créer un IFrameworkView pour contrôler un CoreWindow en plein écran. Partie 3 du port d’une application Direct3D 9 simple vers DirectX 11 et UWP .

Créer une fenêtre

Pour configurer une fenêtre de bureau avec une fenêtre d’affichage Direct3D 9, nous avons dû implémenter l’infrastructure de fenêtrage traditionnelle pour les applications de bureau. Nous avons dû créer un HWND, définir la taille de la fenêtre, fournir un rappel de traitement de fenêtre, le rendre visible, et ainsi de suite.

L’environnement UWP a un système beaucoup plus simple. Au lieu de configurer une fenêtre traditionnelle, un jeu Microsoft Store utilisant DirectX implémente IFrameworkView. Cette interface existe pour que les applications et les jeux DirectX s’exécutent directement dans un CoreWindow à l’intérieur du conteneur d’application.

Notez que Windows fournit des pointeurs managés vers des ressources telles que l’objet d’application source et CoreWindow. Voir Handle to Object Operator (^).

 

Votre classe « main » doit hériter de IFrameworkView et implémenter les cinq méthodes IFrameworkView : Initialize, SetWindow, Load, Run et Uninitialize. En plus de créer l’IFrameworkView, qui est (essentiellement) où réside votre jeu, vous devez implémenter une classe de fabrique qui crée une instance de votre IFrameworkView. Votre jeu a toujours un exécutable avec une méthode appelée main(), mais tout le principal peut faire est d’utiliser la fabrique pour créer l’instance IFrameworkView .

Fonction main

//-----------------------------------------------------------------------------
// Required method for a DirectX-only app.
// The main function is only used to initialize the app's IFrameworkView class.
//-----------------------------------------------------------------------------
[Platform::MTAThread]
int main(Platform::Array<Platform::String^>^)
{
    auto direct3DApplicationSource = ref new Direct3DApplicationSource();
    CoreApplication::Run(direct3DApplicationSource);
    return 0;
}

Fabrique IFrameworkView

//-----------------------------------------------------------------------------
// This class creates our IFrameworkView.
//-----------------------------------------------------------------------------
ref class Direct3DApplicationSource sealed : 
    Windows::ApplicationModel::Core::IFrameworkViewSource
{
public:
    virtual Windows::ApplicationModel::Core::IFrameworkView^ CreateView()
    {
        return ref new Cube11();
    };
};

Porter la boucle de jeu

Examinons la boucle de jeu à partir de notre implémentation Direct3D 9. Ce code existe dans la fonction principale de l’application. Chaque itération de cette boucle traite un message de fenêtre ou restitue un cadre.

Boucle de jeu dans le jeu de bureau Direct3D 9

while(WM_QUIT != msg.message)
{
    // Process window events.
    // Use PeekMessage() so we can use idle time to render the scene. 
    bGotMsg = (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE) != 0);

    if(bGotMsg)
    {
        // Translate and dispatch the message
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    else
    {
        // Render a new frame.
        // Render frames during idle time (when no messages are waiting).
        RenderFrame();
    }
}

La boucle de jeu est similaire , mais plus facile - dans la version UWP de notre jeu :

La boucle de jeu se trouve dans la méthode IFrameworkView ::Run (au lieu de main()), car nos fonctions de jeu dans la classe IFrameworkView.

Au lieu d’implémenter un framework de gestion des messages et d’appeler PeekMessage, nous pouvons appeler la méthode ProcessEvents intégrée à coreDispatcher de notre fenêtre d’application. Il n’est pas nécessaire que la boucle de jeu pour brancher et gérer les messages - il vous suffit d’appeler ProcessEvents et de continuer.

Boucle de jeu dans le jeu Direct3D 11 Du Microsoft Store

// UWP apps should not exit. Use app lifecycle events instead.
while (true)
{
    // Process window events.
    auto dispatcher = CoreWindow::GetForCurrentThread()->Dispatcher;
    dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);

    // Render a new frame.
    RenderFrame();
}

Maintenant, nous avons une application UWP qui configure la même infrastructure graphique de base et affiche le même cube coloré, comme notre exemple DirectX 9.

Étapes suivantes

Signetez le FAQ sur le portage DirectX 11.

Les modèles UWP DirectX incluent une infrastructure d’appareil Direct3D robuste prête à être utilisée avec votre jeu. Consultez Créer un projet de jeu DirectX à partir d’un modèle pour obtenir des conseils sur la sélection du modèle approprié.

Consultez les articles de développement de jeux microsoft Store détaillés suivants :