MD3DM: Como desenhar um triângulo usando o Smartphone Emulator - Parte 2

Publicado por Marcos Dell Antonio em 22/02/2007 | .NET, Direct3D, Mobilidade

Num post anterior descrevi como desenhar um triângulo no Smartphone Emulator usando o Managed Mobile Direct3D.

A técnica usada naquele exemplo foi a mais simples possível: três vértices do tipo TransformedColored.

Por que a mais simples? Ora pois… É a mais simples porque usa coordenadas já transformadas, ou seja, todas as posições (x, y, z) dos vértices são dadas de acordo com o espaço da tela (scree space, para os íntimos).

Para os leigos, o que isso significa? Simples: a tela do seu emulador mede 150 x 150 (suponhamos). Então você manda desenhar um ponto (x, y, z) em (75, 75, 0) e o que teremos será um ponto exatamente no meio da tela. Capiche? Estas são as coordenadas da tela do próprio emulador, ou como dito anteriormente, screen space.

Esta técnica, sem dúvida, só serve para demonstrações, pois na prática é muito limitada. O que vou mostrar hoje é como desenhar um triângulo utilizando o conceito de world space, ou seja, coordenadas de mundo.

Para ficar mais claro, veja um trecho do livro Managed DirectX 9 Kick Start: Graphics and Game Programming que descreve o que é o world space:

You can think of world space as an infinite three-dimensional Cartesian space. You can place your objects anywhere in this “world” you want to.

Tradução: você pode imaginar o world space como um plano cartesiano 3D infinito. Você pode posicionar seus objetos em qualquer lugar deste mundo.

Uma complementação de minha autoria:

Depois de posicionados, você verá os objetos que quiser, como se fosse uma câmera apontada para frente, para o lado, para cima ou para baixo. Somente vemos o que está naquele local, mas existem vários outros objetos ao nosso redor.

E então, qual a diferença entre screen space e world space? No screen space você vê tudo o que existe. No world space você pode ver tudo o que existe ou somente uma parte, dependendo da posição que você está olhando (a tal da câmera que falei acima).

Chega de papo furado e vamos ao exemplo.

Para trabalhar no world space usaremos os vértices do tipo PositionColored. Veja abaixo o que muda em relação ao post anterior.

- Inicialização

Anteriormente era criado um buffer de vértices que suportava objetos do tipo TransformedColored. A única coisa que muda é o tipo suportado por este buffer. Agora será PositionColored. Assim:

 1 private void InitializeGraphics()
 2 {
 3     try
 4     {
 5         PresentParameters presentParams = new
 6             PresentParameters();
 7 
 8         presentParams.Windowed = true;
 9         presentParams.SwapEffect =
10             SwapEffect.Discard;
11 
12         _device = new Device(0,
13                              DeviceType.Default,
14                              this,
15                              CreateFlags.None,
16                              presentParams);
17 
18         _device.RenderState.Lighting = false;
19 
20         _vertexBuffer = new VertexBuffer(
21             typeof(CustomVertex.PositionColored),
22             3,
23             device,
24             0,
25             CustomVertex.PositionColored.Format,
26             Pool.SystemMemory);
27 
28         _vertexBuffer.Created +=
29             new EventHandler(OnVertexBufferCreate);
30 
31         OnVertexBufferCreate(_vertexBuffer, null);
32     }
33     catch (Exception ex)
34     {
35         MessageBox.Show("Erro na inicialização: " +
36             ex.Message);
37     }
38 }

Como mencionado anteriormente, a única alteração está na criação do VertexBuffer, que agora suporta vértices do tipo PositionColored.

- Carregando o buffer

A principal alteração fica por conta deste método. No exemplo anterior era usado um array de vértices do tipo TransformedColored e cada item desse array era posicionado conforme o screen space (veja que o código anterior usa o Width e o Height da tela para calcular as coordenadas).

O que deve ser feito é o seguinte:

 1 private void OnVertexBufferCreate(object sender, EventArgs e)
 2 {
 3     VertexBuffer buffer = (VertexBuffer)sender;
 4 
 5     CustomVertex.PositionColored[] verts =
 6         new CustomVertex.PositionColored[3];
 7 
 8     verts[0] = new CustomVertex.PositionColored(
 9         0.0f,
10         0.5f,
11         -0.0f,
12         Color.Red.ToArgb());
13 
14     verts[1] = new CustomVertex.PositionColored(
15         0.5f,
16         -0.5f,
17         -0.0f,
18         Color.Red.ToArgb());
19 
20     verts[2] = new CustomVertex.PositionColored(
21         -0.5f,
22         -0.5f,
23         -0.0f,
24         Color.Red.ToArgb());
25 
26     buffer.SetData(verts, 0, LockFlags.None);
27 }

Ao invés de criarmos três vértices do tipo TransformedColored foram criados três do tipo PositionColored. Veja que suas coordenadas são baseadas no world space, que por enquanto possui os limites -1 até 1 para os três eixos (x, y, z). Essa é a definição default do MD3DM e tem relação com a câmera comentada anteriormente.

- Resultado final

É isso ae! Por hoje é só. Apesar de estar longe de alcançar a meta proposta para o TCC, isso já é um bom começo.

Até +.