Criando seu primeiro programa usando V-ART
Conforme mencionado no blog anterior, agora vou mostrar como é simples criar uma aplicação usando V-ART.
Vamos então criar uma aplicação que mostra uma esfera na tela. Se pensarmos nisso como algo do mundo real, o que precisariamos para enxergarmos uma esfera? De nossos olhos, da esfera e um local para ela estar, além de uma fonte de luz, certo? Pensando agora em uma aplicação computacional, precisamos de uma cena (local aonde a esfera está, um mundo), de uma câmera (nossos olhos) e de uma iluminação para a cena (fonte de luz).
Usando V-ART teríamos uma aplicação com as seguintes variáveis:
Material lGreyPlastic(Color(R,G,B)) -> material que compõe a esfera. No caso será a cor da mesma.
static Scene scene -> cena
static ViewerGlutOGL viewer -> janela aonde a aplicação será executada
Camera camera(Point4D posição, Point4D foco, Point4D up)-> câmera posicionada em
posição, com foco
foco e vetor up
up.
Sphere sp -> a esfera que será vizualizada.
Precisamos então definir as características da esfera, tais como raio e material. Os comandos abaixo fazem isso:
// Set up the viewer
sp.SetRadius(1.5);
sp.SetMaterial(lGreyPlastic);
Agora podemos construir a cena:
scene.AddObject(&sp) -> adiciona a esfera à cena
scene.AddLight(Light::BRIGHT_AMBIENT())->adiciona uma luz ambiente à cena
scene.AddCamera(&camera) ->adiciona a câmera
Depois disso temos que "avisar" o que será mostrado na janela
viewer.SetScene(scene);
E por fim rodarmos a aplicação:
scene.DrawLightsOGL();
ViewerGlutOGL::MainLoop();
O arquivo
firstProgram.zip é um exemplo da explicação acima. O que você vê ao executá-lo é uma janela conforme a da figura abaixo.
Acrescentando mais funcionalidades
Vamos agora rebuscar mais nossa aplicação. Mas para isso vamos ver alguns conceitos a respeito da estrutura do V-ART.
Temos então uma cena, que é constituída por nodos de cena e câmeras. Estes por sua vez podem ser luzes, geometrias, transformações, conforme visto na figura abaixo.

Bom, esses nodos de cena dispostos de forma ordenada, definindo uma estrutura hierárquica e são "visitados" do primeiro (raiz) até o último (folhas). A estrutura do nosso primeiro programa é então:

Vamos agora renderizar a mesma cena, mas com a esfera transladada. Para isso precisamos aplicar uma transformação (matriz de translação) na esfera. O V-Art trabalha com transformações que devem ser "pais" do objeto que se quer transformar. Mas você pode estar pensando: "Que confuso! Por que não criar a transformação e simplesmente aplicar ao objeto ao invés de colocá-la como nodo da cena?"
Bem, a resposta é: por questões de otimização. É mais lento alterar uma geometria do que alterar uma transformação.
Dito isso, temos que a nova estrutura de nossa cena será:

Para criarmos a aplicação transladando a cena teremos que incluir o arquivo
transform.h nos includes. Teremos também que incluir uma variável do tipo Transform (
Transform spTrans por exemplo). Essa transformação será a matriz de translação que será aplicada ao objeto esfera. Para isso usaremos o comando
spTrans.MakeTranslation(0,0,2.5), que irá preencher spTrans de forma que ela represente uma translação de 2,5 em z. Podemos também acrescentar uma descrição para o objeto spTrans através de
spTrans.SetDescription("spTrans"). Bem, para aplicar essa transformação à esfera, temos que tornar a esfera filha da transformação.
O resultado será:

Você pode pegar a implementação do programa com esta modificação em
main.cpp.
Por hoje é só. Na próxima conversaremos um pouco sobre objetos articulados e V-ART.