Farseer Physics : Debugando o seu jogo

Fala filhotes! Hoje vou continuar falando sobre o Farseer então se você quer rever o ultimo post clique aqui. 
Então vamos la!

Bom, um do problemas de se criar um jogo costuma ser a falta de uma maneira fácil de debugar, ou de relatórios em geral ao contrario do asp.net. Por isso vou mostrar como adicionar um debug como esse no jogo:

Com esse debug você vai conseguir ver a quantidade de objetos no jogo, informações de consumo de memória, e performance.
Usarei o mesmo projeto do ultimo artigo, então só mostrarei os códigos para se adicionar o DebugView. Caso você queira, pode baixar os fontes do projeto anterior aqui.

DebugViewXna

O DebugView é uma classe do Farseer para lhe ajudar a debugar os objetos do Farseer. A DebugViewXna foi criada para melhorar o uso da DebugView no XNA, além de poder ser usada de uma maneira simples e descomplicada, ao contrario da DebugView original.

Baixando o DebugViewXNA

Primeiro de tudo baixe o projeto Hello World XNA em ( http://farseerphysics.codeplex.com/releases/view/64108 ) e dentro da solução compile o projeto DebugViewXNA para gerar as DLLs dele. Ou então baixe as DLLs direto daqui.

Agora basta adicionar como referência ao seu projeto.

Usando o DebugViewXNA

Depois de adicionar as DLLs ao seu projeto, temos que executar alguns passos para configurar o DebugView:
Na classe Game1, vamos criar as variáveis necessárias:

    // Projeção de onde estão os objetos
    private Matrix _projection;
    // Visualização dos objetos na tela
    private Matrix _view;
    // Variavel do DebugViewXNA
    private DebugViewXNA _dbgXna;

Agora no final método Initialize:

     // Inicializa o DebugViewXNA passando o WORLD
     _dbgXna = new DebugViewXNA(objWorld);
            
     // Cria a projeção da matriz
     CreateProjection();

E então criamos a função CreateProjection:

/// <summary>
/// Projeção para o debug
/// </summary>
private void CreateProjection()
{
 // Cria uma projeção ortogonal 
 // Lembrando que temos que converter para metros
 _projection = Matrix.CreateOrthographic(ToMeter(graphics.PreferredBackBufferWidth), ToMeter(-graphics.PreferredBackBufferHeight), 0, 1);
 // Nossa view que encaixa o debug na tela
 var campos = new Vector3();            
 campos.X = -(ToMeter(graphics.PreferredBackBufferWidth / 2f));
 campos.Y = -(ToMeter(graphics.PreferredBackBufferHeight / 2f));
 campos.Z = 0;
 var tran = Matrix.Identity;
 tran.Translation = campos;
 _view = tran;

Alterei a função ToMeter para receber float em vez de int:

 /// <summary>
 /// Função que converte um float de pixel para metros
 /// </summary>
 public float ToMeter(float pixel)
 {
    return pixel / PixelInMeter;
 }

Agora no método LoadContent vamos adicionar isso:

 // Carrega o debug
 _dbgXna.LoadContent(GraphicsDevice, Content);

Por padrão o DebugViewXNA já vem ativo, ou seja, mostrando alguns detalhes na tela como a colisão e os corpos. O que limita o que o Debug mostra ou esconde são as Flags, A flag DebugViewFlags.Shape por exemplo mostras as shapes, cada flag tem uma função especifica. Por isso vamos criar a possibilidade de adicionar/remover as flags no debug apertando algumas teclas ( do F2 ao F8 ).

Então no método Update:

   // Pega o estado da tecla 
   newState = Keyboard.GetState();
            
   // Verifica qual tecla foi pressionado
   if (newState.IsKeyDown(Keys.Right))
   // Aplica a rotação
   objBola.ApplyTorque(1f);

   if (newState.IsKeyDown(Keys.Left))
   objBola.ApplyTorque(-1f);

   // Teclas do Debug
   if (KeyPressCheck(Keys.F2))
    EnableDisableFlag(DebugViewFlags.Shape);
   else if (KeyPressCheck(Keys.F3))
    EnableDisableFlag(DebugViewFlags.AABB);
   else if (KeyPressCheck(Keys.F4))
    EnableDisableFlag(DebugViewFlags.PolygonPoints);
   else if (KeyPressCheck(Keys.F5))
    EnableDisableFlag(DebugViewFlags.DebugPanel);
   else if (KeyPressCheck(Keys.F6))
    EnableDisableFlag(DebugViewFlags.ContactNormals);
   else if (KeyPressCheck(Keys.F7))
    EnableDisableFlag(DebugViewFlags.Controllers);
   else if (KeyPressCheck(Keys.F8))
    EnableDisableFlag(DebugViewFlags.PerformanceGraph);

    oldState = newState;

E criamos uma função que checa se a tecla foi pressionada APENAS UMA VEZ:

/// <summary>
/// testa para um clique simples
/// </summary>
/// <param name="key">Tecla a ser testada</param>
/// <returns></returns>
private bool KeyPressCheck(Keys theKey)
{
if (newState.IsKeyUp(theKey) && oldState.IsKeyDown(theKey))
    return true;

return false;
}

E a função que adiciona ou retira uma flag:

/// <summary>
/// Função que habilitada ou desabilita uma flag ao debug
/// </summary>
/// <param name="flag"></param>
void EnableDisableFlag(DebugViewFlags flag)
{
    if (_dbgXna.Flags.HasFlag(flag))
       _dbgXna.RemoveFlags(flag);
    else
        _dbgXna.AppendFlags(flag);
}

Pronto! Só falta adicionar a função para desenhar o debug! Vamos adicionar uma chamada dela no método Draw:

// Função que desenha o debug
DebugDraw();

E criamos a função:

/// <summary>
/// Desenha o debug usando a projeção e a view
/// </summary>
private void DebugDraw()
{
    Matrix mtrx = _projection;
    _dbgXna.RenderDebugData(ref mtrx, ref _view);
}

E pronto! o Debug esta pronto para rodar! bastar executar o seu código normalmente e ir apertando de F2 a F8 para ver os resultados. Lembrando que você pode adicionar outras flags no código.

Se quiser baixar o código, clique aqui!

Bom, por hoje é só! Até mais.