Criando objetos articulados

Hoje vamos falar um pouco sobre objetos articulados e V-ART. Objetos articulados são aqueles que possuem juntas, compostas por seus graus de liberdade (dofs). Com relação às juntas, as mesmas podem ser uniaxiais (1 dof), biaxiais (2 dofs) ou poliaxiais (3 dofs). Para entender melhor o que é um dof, pensemos em um sistema de coordenadas cartesianas XYZ, os dofs de uma junta são os eixos que esta pode sofrer rotação. Como a maioria das juntas não rotacionam 360 graus em seus respectivos eixos de rotação, os dofs devem possuir limites: ângulos mínimo e máximo de rotação.

Para vermos como gerar um objeto articulado usando V-ART, vamos analisar a aplicação Camera de vigilância. Esta aplicação mostra uma câmera, como essas de vigilância vistas em lojas e nas ruas. Uma imagem da câmera pode ser vista abaixo.

cameraV.png

Temos uma classe chamada clVigilanceCamera, que é a definição da câmera. Esta é composta por um cilindro (Cylinder) chamado base, uma esfera (Sphere) chamada globe, que é filha da transformação (Transform) globeTrans, que por sua vez é filha da base.

A câmera tem uma junta biaxial (BiaxialJoint joint), composta pelos dofs (Dof) flexion (no eixo Z, passando pelo centro do globe, com limites -pi e pi) e aduction (no eixo X, passando pelo centro do globe, com limites 0 e pi/2). Esta junta é filha da esfera globe, e tem como filha a transformação lensTrans, que define as transformações aplicadas no cilindro lens, que é filho de lensTrans.
No VART, para informarmos que um objeto é filho de outro, usamos o método AddChild(SceneNode& child) (exemplo: globeTrans.AddChild(joint)). Já para informarmos que uma junta tem determinados dofs, usamos o método AddDof(Dof *dof) (exemplo: joint.AddDof(&flexion)). A figura abaixo mostra graficamente como é a composição da vigilanceCamera e os arquivos vigilancecamera.h e vigilancecamera.cpp mostram a implementação da câmera).

fluxVigCam.png

A classe main

Na classe main temos o objeto vgCamera da classe clVigilanceCamera que será o objeto a ser renderizado. Este será adicionado à cena com o método AddObject (como visto no blog Primeiro programa usando V-ART). Para testarmos os dofs, vamos criar uma classe para controlarmos o movimento do vgCamera. Ela será da seguinte forma:

class KeyboardHandler : public ViewerGlutOGL::KbHandler
{
public:
KeyboardHandler(clVigilanceCamera* cam) {
ptrCam = cam; -> _o ponteiro ptrCam apontará para cam, que será a vgCamera_
}
virtual void HandleKey(unsigned char key) {
switch (key)
{
case 'j':
ptrCam->Flex(-0.005);
viewerPtr->PostRedisplay();
break;
case 'l':
ptrCam->Flex(0.005);
viewerPtr->PostRedisplay();
break;
case 'i':
ptrCam->Adduct(0.01);
viewerPtr->PostRedisplay();
break;
case 'k':
ptrCam->Adduct(-0.01);
viewerPtr->PostRedisplay();
break;
}
}
private:
clVigilanceCamera* ptrCam;

Essa nova classe é filha da classe ViewerGlutOGL::KbHandler e assim herda as características desta, tais como o términos da execução do programa ao apertar a tecla q. Na classe principal essa classe será utilizada através dos comandos KeyboardHandler kbh(&vgCamera), que cria o objeto da classe, e viewer.SetKbHandler(&kbh), que atacha o objeto kbh ao visualizador.

Não esqueça de executar a aplicação para ver a movimentação da câmera de vigilância.

No próximo blog veremos como usar modelos de objetos mais rebuscados e como gerar animações.

Last edited Aug 3, 2007 at 9:43 PM by araschneider, version 5

Comments

No comments yet.