Compartir a través de

Portar el bucle del juego

  • Artículo

Resumen

Muestra cómo implementar una ventana para un juego de Plataforma universal de Windows (UWP) y cómo llevar el bucle del juego, incluido cómo crear un IFrameworkView para controlar un CoreWindow de pantalla completa. Parte 3 del tutorial Puerto de una aplicación sencilla de Direct3D 9 a DirectX 11 y UWP .

Crear una ventana

Para configurar una ventana de escritorio con una ventanilla de Direct3D 9, tuvimos que implementar el marco de ventanas tradicional para las aplicaciones de escritorio. Tuvimos que crear un HWND, establecer el tamaño de la ventana, proporcionar una devolución de llamada de procesamiento de ventanas, hacer que sea visible, etc.

El entorno de UWP tiene un sistema mucho más sencillo. En lugar de configurar una ventana tradicional, un juego de Microsoft Store con DirectX implementa IFrameworkView. Esta interfaz existe para que las aplicaciones y juegos de DirectX se ejecuten directamente en coreWindow dentro del contenedor de aplicaciones.

Nota Windows proporciona punteros administrados a recursos como el objeto de aplicación de origen y CoreWindow. Vea Handle to Object Operator (^).

 

La clase "main" debe heredar de IFrameworkView e implementar los cinco métodos IFrameworkView: Initialize, SetWindow, Load, Run y Uninitialize. Además de crear IFrameworkView, que es (básicamente) donde residirá el juego, debes implementar una clase de fábrica que cree una instancia de tu IFrameworkView. El juego todavía tiene un archivo ejecutable con un método denominado main(), pero todo lo principal puede hacer es usar la fábrica para crear la instancia de IFrameworkView .

Función 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;
}

Fábrica de 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();
    };
};

Portar el bucle del juego

Echemos un vistazo al bucle del juego desde nuestra implementación de Direct3D 9. Este código existe en la función principal de la aplicación. Cada iteración de este bucle procesa un mensaje de ventana o representa un marco.

Bucle de juego en el juego de escritorio 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();
    }
}

El bucle del juego es similar, pero más fácil, en la versión de UWP de nuestro juego:

El bucle del juego entra en el método IFrameworkView::Run (en lugar de main()) porque nuestras funciones de juego dentro de la clase IFrameworkView.

En lugar de implementar un marco de control de mensajes y llamar a PeekMessage, podemos llamar al método ProcessEvents integrado en la ventana de la aplicación CoreDispatcher. No es necesario que el bucle del juego bifurque y controle los mensajes, simplemente llame a ProcessEvents y continúe.

Bucle de juego en el juego de Microsoft Store direct3D 11

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

Ahora tenemos una aplicación para UWP que configura la misma infraestructura de gráficos básica y representa el mismo cubo colorido, como nuestro ejemplo de DirectX 9.

¿Y ahora qué?

Marque las preguntas más frecuentes sobre migración de DirectX 11.

Las plantillas para UWP de DirectX incluyen una sólida infraestructura de dispositivos Direct3D que está lista para su uso con el juego. Consulta Crear un proyecto de juego de DirectX a partir de una plantilla para obtener instrucciones sobre cómo seleccionar la plantilla correcta.

Visite los siguientes artículos de desarrollo de juegos de Microsoft Store en profundidad: