Partilhar via

Fazer a portabilidade do loop do jogo

  • Artigo

Resumo

Mostra como implementar uma janela para um jogo UWP (Plataforma Universal do Windows) e como trazer o loop do jogo, incluindo como criar um IFrameworkView para controlar um CoreWindow de tela inteira. Parte 3 do passo a passo de Portar um aplicativo Direct3D 9 simples para DirectX 11 e UWP .

Criar uma janela

Para configurar uma janela da área de trabalho com um visor do Direct3D 9, tivemos que implementar a estrutura de janelas tradicional para aplicativos da área de trabalho. Tivemos que criar um HWND, definir o tamanho da janela, fornecer um retorno de chamada de processamento de janela, torná-lo visível e assim por diante.

O ambiente UWP tem um sistema muito mais simples. Em vez de configurar uma janela tradicional, um jogo da Microsoft Store usando DirectX implementa IFrameworkView. Essa interface existe para que aplicativos e jogos DirectX sejam executados diretamente em um CoreWindow dentro do contêiner do aplicativo.

Observação O Windows fornece ponteiros gerenciados para recursos como o objeto de aplicativo de origem e o CoreWindow. Consulte Identificador para Operador de Objeto (^).

 

Sua classe "principal" precisa herdar de IFrameworkView e implementar os cinco métodos IFrameworkView: Initialize, SetWindow, Load, Run e Uninitialize. Além de criar o IFrameworkView, que é (essencialmente) onde seu jogo residirá, você precisa implementar uma classe de fábrica que crie uma instância do seu IFrameworkView. Seu jogo ainda tem um executável com um método chamado main(), mas tudo o que main pode fazer é usar a fábrica para criar a instância IFrameworkView .

Função 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;
}

IFrameworkVer fábrica

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

Fazer a portabilidade do loop do jogo

Vejamos o loop de jogo de nossa implementação do Direct3D 9. Esse código existe na função principal do aplicativo. Cada iteração desse loop processa uma mensagem de janela ou renderiza um quadro.

Loop de jogo no jogo de área de trabalho 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();
    }
}

O loop do jogo é semelhante, mas mais fácil, na versão UWP do nosso jogo:

O loop do jogo vai no método IFrameworkView::Run (em vez de main()) porque nosso jogo funciona dentro da classe IFrameworkView.

Em vez de implementar uma estrutura de tratamento de mensagens e chamar PeekMessage, podemos chamar o método ProcessEvents integrado ao CoreDispatcher da janela do aplicativo. Não há necessidade de o loop do jogo ramificar e manipular mensagens – basta chamar ProcessEvents e continuar.

Loop de jogo no jogo Direct3D 11 da 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();
}

Agora temos um aplicativo UWP que configura a mesma infraestrutura gráfica básica e renderiza o mesmo cubo colorido, como nosso exemplo do DirectX 9.

Para onde vou daqui?

Marque as perguntas frequentes sobre a portabilidade do DirectX 11.

Os modelos UWP do DirectX incluem uma infraestrutura de dispositivo Direct3D robusta que está pronta para uso com seu jogo. Consulte Criar um projeto de jogo DirectX a partir de um modelo para obter diretrizes sobre como escolher o modelo certo.

Visite os seguintes artigos detalhados de desenvolvimento de jogos da Microsoft Store: