Freigeben über

Portieren der Spielschleife

  • Artikel

Zusammenfassung

In diesem Thema wird veranschaulicht, wie Sie ein Fenster für ein UWP-Spiel (Universelle Windows-Plattform) implementieren und die Spielschleife übertragen. Außerdem wird die Erstellung eines IFrameworkView-Elements zum Steuern eines CoreWindow-Vollbilds erläutert. Teil 3 der exemplarischen Vorgehensweise Portieren einer einfachen Direct3D 9-App zu DirectX 11 und UWP .

Erstellen eines Fensters

Zum Einrichten eines Desktopfensters mit einem Direct3D 9-Viewport musste das herkömmliche Fensterframework für Desktop-Apps implementiert werden. Es musste ein HWND-Element erstellt, die Fenstergröße festgelegt, ein Rückruf zur Fensterverarbeitung eingerichtet, die Sichtbarkeit hergestellt werden usw.

Dagegen verfügt die UWP-Umgebung über ein deutlich einfacheres System. Anstatt ein herkömmliches Fenster einzurichten, implementiert ein Microsoft Store-Spiel mit DirectX IFrameworkView. Diese Schnittstelle ist für DirectX-Apps und -Spiele vorhanden, um die direkte Ausführung in einem CoreWindow innerhalb des App-Containers zu ermöglichen.

Hinweis Windows stellt verwaltete Zeiger auf Ressourcen wie das Quellanwendungsobjekt und den CoreWindow bereit. Weitere Informationen finden Sie unter Handle to Object Operator (^).

 

Ihre main-Klasse muss von IFrameworkView erben und die fünf IFrameworkView-Methoden implementieren: Initialize, SetWindow, Load, Run und Uninitialize. Zusätzlich zur Erstellung des IFrameworkView-Elements, in dem Ihr Spiel (im Wesentlichen) enthalten ist, müssen Sie eine Factoryklasse implementieren, über die eine Instanz des IFrameworkView-Elements erstellt wird. Das Spiel verfügt weiterhin über eine ausführbare Datei mit einer main()-Methode. Mithilfe von "main" kann jedoch lediglich die Factory verwendet werden, um die IFrameworkView-Instanz zu erstellen.

main-Funktion

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

IFrameworkView-Factory

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

Portieren der Spielschleife

Sehen wir uns die Spielschleife unserer Direct3D 9-Implementierung an. Dieser Code ist in der main-Funktion der App vorhanden. Mit jeder Iteration dieser Schleife wird eine Fenstermeldung verarbeitet oder ein Frame gerendert.

Spielschleife im Direct3D 9-Desktopspiel

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

Die Spielschleife in der UWP-Version unseres Spiels ist ähnlich, dabei jedoch einfacher aufgebaut:

Die Spielschleife befindet sich in der IFrameworkView::Run-Methode (anstatt main()), weil die Funktionen des Spiels über die IFrameworkView-Klasse abgewickelt werden.

Anstatt ein Framework zur Behandlung von Meldungen zu implementieren und PeekMessage aufzurufen, können wir die ProcessEvents-Methode aufrufen, die in das CoreDispatcher-Element des App-Fensters integriert ist. Es ist nicht erforderlich, dass die Spielschleife über Verzweigungen verfügt und Meldungen behandelt. Rufen Sie einfach ProcessEvents auf, und fahren Sie fort.

Spielschleife im Direct3D 11 Microsoft Store-Spiel

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

Nun verfügen wir über eine UWP-App, von der die gleiche grundlegende Grafikinfrastruktur eingerichtet und der gleiche farbige Würfel wie im DirectX 9-Beispiel gerendert wird.

Wie geht es weiter?

Richten Sie ein Lesezeichen für DirectX 11-Portierung – Häufig gestellte Fragen ein.

Die DirectX-UWP-Vorlagen enthalten eine stabile Direct3D-Geräteinfrastruktur, die bereit für die Nutzung mit Ihrem UWP-Spiel ist. Eine Anleitung zum Auswählen der richtigen Vorlage finden Sie unter Erstellen eines DirectX-Spieleprojekts aus einer Vorlage.

Lesen Sie die folgenden ausführlichen Artikel zur Spieleentwicklung im Microsoft Store: