Compartir a través de

Portar el bucle del juego

Resumen

Muestra cómo implementar una ventana para un juego en la Plataforma Universal de Windows (UWP) y cómo integrar el bucle del juego, incluyendo cómo crear un IFrameworkView para controlar un CoreWindow de pantalla completa. Parte 3 del Portar una aplicación sencilla de Direct3D 9 a DirectX 11 y UWP guía.

Creación de 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 mediante DirectX implementa IFrameworkView. Esta interfaz existe para que las aplicaciones y juegos de DirectX se ejecuten directamente en un CoreWindow dentro del contenedor de aplicaciones.

Nota Windows proporciona punteros administrados a recursos como el objeto de aplicación de origen y el CoreWindow. Consulte Operador de Referencia a Objeto (^).

 

La clase "main" debe heredar de IFrameworkView e implementar los cinco métodos IFrameworkView: Initialize, SetWindow, Load, Runy Uninitialize. Además de crear el 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 lo único que main puede hacer es usar la factoría para crear la instancia de IFrameworkView.

Función principal

//-----------------------------------------------------------------------------
// 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 se ubica en el método IFrameworkView::Run (en lugar de en main() ) porque nuestro juego funciona dentro de la clase IFrameworkView.

En lugar de implementar un marco de manejo de mensajes y llamar a PeekMessage, podemos llamar al método ProcessEvents integrado en el CoreDispatcher de nuestra ventana de la aplicación . No es necesario que el bucle del juego se ramifique y controle los mensajes: simplemente llamar a ProcessEvents y continuar.

Bucle de juego en el juego de Microsoft Store en 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.

¿Dónde voy desde aquí?

Añade a favoritos el FAQ sobre la portabilidad 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: