SmallVR - Virtual Reality Toolkit
Prof. Márcio Sarroglia Pinho
Criação de Cenários

1. Grafo de Cena

Todo o gerenciamento das cenas gráficas usando a SmallVR baseia-se na criação de um grafo de cena.
Neste grafo, os nodos representam os objetos gráficos e os arcos representam  relações entre estes objetos.
Do ponto de vista de programação os nodos do grafo são objetos da classe SmVR_CGeometricObject.
As relações (os arcos) entre os objetos são criadas através do método AddChild desta mesma classe. Este método insere um objeto como "filho" de outro.
O trecho a seguir, por exemplo, cria uma relação entre o objeto Mao e objeto Polegar, onde este último é filho do primeiro.
SmVR_CGeometricObject *Mao, *Polegar;
Mao = new SmVR_CGeometricObject("Mao", DesenhaMao);
Polegar = new SmVR_CGeometricObject("Polegar", DesenhaPolegar);
Mao->AddChild(Polegar); // cria a relação entre os objetos
Para inserir um novo filho no objeto Mao, pode-se usar o trecho a seguir:
SmVR_CGeometricObject *Indicador;
Indicador = new SmVR_CGeometricObject("Indicador", DesenhaIndicador);
Mao->AddChild(Indicador);
A criação destas relações fará com que qualquer transformação geométrica aplicada ao objeto Mao tenha reflexos sobre todos os obejtos que são seus filhos, no caso, os objetos Polegar e Indicador. Entre os objetos Indicador e Polegar há uma relação de irmão.
Note que o uso deste método AddChild não altera posição de nenhum objeto na cena.

Graficamente poderíamos representar o grafo construído acima através do seguinte desenho:

Figura - Exemplo de um grafo de cena

A partir deste momento, quaisquer dos objetos do grafo pode receber novos objetos como filhos, da mesma forma como foi feito com os objetos do exemplo acima.

Para exibir um objeto o programador deve evocar o método Render do objeto em questão. Neste momento, além do objeto, todos os seus filhos serão exibidos. No caso, o comando de exibição da mão seria:

Mao->Render();


2. Inserindo Objetos no Cenário

Para criar um cenário utilizando a biblioteca SmallVR é necessário conhecer algumas Classes e Tipos de Dados Básicos que são fundamentais ao seu funcionamento.
Conforme já foi mencionado, a classe que representa qualquer tipo de objeto gráfico na SmallVR é a SmVR_CGeometricObject. A partir deste objeto é que a biblioteca faz toda a gerência da exibição das cenas.

Podemos definir a geometria dos objetos basicamente de 2 formas. A primeira, criando funções para desenhar o objeto em OpenGL e a segunda lendo os objetos de um arquivo no formato Wavefront OBJ. Nas seções a seguir são apresentadas essas duas alternativas.

2.1 Objetos Lidos de Arquivo

Uma das principais características da construção de ambientes virtuais é a necessiade de utlizar-se objetos definidos em modeladores tridimensionais como Cinema4D, AC3D, Maya, 3DStudio, entre outros.

Na SmallVR a classe SmVR_CObjFromFile  é que representa um objeto a ser lido de arquivo.

A partir desta classe devem ser criadas outras classes derivadas (pelo mecanismo de herança) que fazem de fato a leitura e exibição de objetos nos formatos desejados pelo desenvolvedor.

Juntamente a SmallVR, é disponibilizada a classe "SmVR_COBJLoader"  que carrega objetos do Alias Wavefront  (.obj), criada como uma classe derivada da SmVR_CObjFromFile.

O uso desta classe é feito conforme o exemplo abaixo. 

 
// Cria o objeto SmallVR
SmVR_CGeometricObject *Bola;

// Cria um objeto para carregar o modelo de arquivo
SmVR_COBJLoader *obj1 = new SmVR_COBJLoader(); 
// Executa a carga do objeto
obj1->Load("objetos3d/bola.obj");

// Associa o objeto ligo de arquivo com o objeto SmallVR
// Isto é feito passando o objeto "obj1" na construtora da classe
// do objeto SmallVR
Bola = new SmVR_CGeometricObject("bola1", obj1);

// Adiciona o objeto recém criado ao grafo de cena
RootObject->AddChild();
As informações para obtenção das faces, vértices e outras informações do objeto estão disponiveis aqui.

Para a inclusão de leitores de outros formatos de objetos, deve-se seguir as recomendações apresentadas na página Construindo Novos Leitores de Objetos para a SmalVR.

2.3 Objetos Desenhados em OpenGL

Além de permitir a carga de objetos criados em modeladores geométricos, a SmallVR permite que ser crie um objeto a partir de comando em OpenGL. Isto facilita bastante o porte de aplicações já existentes, aumentando o escopo de utilização da biblioteca.

Para tanto, deve-se criar uma  função (que desenha o objeto) que retornar um valor inteiro (int)  e receba como um parâmetro ponteiro do tipo void *. Feito isto, deve-se cria um objeto da classe SmVR_CGeometricObject e passar como parâmetro para o método construtor a função a ser utilizada para pintura do objeto. Se dispusermos de uma fução de desenho chamada DesenhaTeste, então a criação do objeto geométrico é feita da seguinte forma.

    SmVR_CGeometricObject *obj1;
     obj1 = new SmVR_CGeometricObject("Teste", DesenhaTeste);

Depois isto é necessário adicionar o objeto ao grafo de cena da SmallVR, através do método AddChild. Lembre-se que a raiz do grafo de cena em nosso exemplos se chama RootObject.

    RootObject->AddChild(obj1);

Abaixo temos um exemplo mais completo que mostra como isto é feito.

// função que desenha um objeto com comando OpenGL
int DesenhaTeste(void *p) {
 glBegin (GL_QUADS);
     // Front Face
     glVertex3f(-0.5,-0.5, 0.5);
     glVertex3f( 0.5,-0.5, 0.5);
     glVertex3f( 0.5, 0.5, 0.5);
     glVertex3f(-0.5, 0.5, 0.5);
     // Complete o cubo com as faces que faltam.
 glEnd();
}

int main(int argc, char **argv) {

  // Inicialização da GLUT
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
  glutInitWindowSize(800, 600);
  glutCreateWindow("Teste");

  // Inicializaçõa da SmallVR
  RootObject = SmVR_Init(NULL);
  // criacao do cubo e adicao dele como filho do RootObject
  SmVR_CGeometricObject *obj1 = new SmVR_CGeometricObject("Teste", desenhaCubo);
  // Inclusão
  RootObject->AddChild(obj1);
  glutDisplayFunc(RenderScene); // Especifica a função de desenho
  glutMainLoop();
  return 0;
}

Neste exemplo cria-se um objeto da classe SmVR_CGeometricObject cujo nome é "Teste".
O primeiro parâmetro da construtora da classe representa o nome a ser dado ao objeto, o segundo representa a rotina a ser usada para a exibição deste objeto. No caso, a rotina chama-se DesenhaTeste.

2.3.1 Rotinas para Exibição de Objetos Gráficos

A rotina passada como parâmetro na chamada do método construtor da classe SmVR_CGeometricObject deve sempre retornar um int e possuir um parâmetro do tipo void *.
Dentro desta função podem ser colocados comandos de desenho da bilioteca OpenGL.
Não devem ser usadas, nestas rotinas as funções de transformações geométricas como glTranslate, glRotate, glScale ou funções que  alterem as matrizes de transformação de OpenGL, como glLoadIdentity, glMultMatrix, glLoadMatrix.
Na verdade estas rotinas podem ser usadas, desde que a função inicie com um glPushmatix e termine com um glPopMatrix. Entretanto, esta prática não é recomendada quando se está utilizando a SmallVR pois se estas transformações geométricas não poderão ser alteradas pelos métodos da SmallVR e tão pouco poderão ser usadas para aplicar transformação geométricas aos filhos deste objeto.

IMPORTANTE:  Não faça nenhuma utilização dos objetos da classe SmVR_CGeometricObject dentro da rotina que exibe o objeto.
 

2.3.2 Passando Parâmetros para a Rotina de Exibição de Objetos

Caso seja necessário passar algum tipo de parâmetro para a rotina que exibe um objeto geométrico, isto pode ser feito através do método  SetRenderFunctionData(void *d).
O uso deste parâmetro fica a cargo do programador.

A título de exemplo, podemos sugerir o uso deste parâmetro para a definição a cor de um objeto. No trecho de código a seguir é passado para o método SetRenderFunctionData(void *d) um vetor que contém os valores R, G, e B da cor do objeto.
Note que é necessário aplicar um type cast sobre os dados passados como parâmetro, a fim de adequar os tipos de dados.
IMPORTANTE: A SmallVR não armazena uma cópia dos dados informados pelo método SetRenderFunctionData. Armazena-se apenas um apontador para a área de memória onde está o dado a ser utilizado. Assim,a fim de que o dado passado como parâmetro possa ser de fato utilizado na função de exbição, a variável passada como parâmetro para o método SetRenderFunctionData deve ser global.

int DesenhaTeste(void *p)
{
 if(p)  // verifica se há algum parâmetro válido
    glColor3fv((GLfloat*)p); // Se houver, seta cor do objeto
    // Usa o type cast para GLfloat*

 glBegin (GL_QUADS);
     glVertex3f(-0.5,-0.5, 0.5);
     glVertex3f( 0.5,-0.5, 0.5);
     glVertex3f( 0.5, 0.5, 0.5);
     glVertex3f(-0.5, 0.5, 0.5);
     ...
 glEnd();
}
void main ()
{
..........
........
..........
    GLfloat azul[3] = { 0, 0, 1};

    SmVR_CGeometricObject *obj1 = new SmVR_CGeometricObject("Teste", DesenhaTeste);
    obj1->SetRenderFunctionData(azul); // define o parâmetro da ser usado na
                                       // rotina de exibição do objeto

    RootObject->AddChild(obj1);
}



3. Renderizando Objetos

Para a exibição de um objeto deve ser chamado o método Render da classe SmVR_CGeometricObject na rotina de exibição de objetos gráficos do programa.
void display(void) {
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  PosicUser();
  glMatrixMode(GL_MODELVIEW);
  RootObject->Render();
  glutSwapBuffers();
}

....
....
glutDisplayFunc ( display );
....
....
 
 

O método Render desenha o objeto e todos seus filhos. Portanto se for utilizado um objeto 'root', pai de todos outros objetos, ao chamar o Render desse objeto todo cenário será exibido. Note-se que esta rotina display é a rotian de exibição de objetos definida na GLUT/OpenGL, através da função glutDisplayFunc.


4. Primeiro Programa

Um programa mínimo para usar a SmallVR é descrito a seguir.

Para inicializar a biblioteca SmallVR deve-se chamar a função SmVR_Init. Esta função pode receber como parâmetro o nome de um arquivo com a descrição de uma cena. Na versão atual a leitura das cenas de arquivos ainda não é considerada estável, portanto não deve ser usada. Em face disto, deve-ser passar como parâmetro a constante NULL no parâmetro da função.

Como retorno esta função devolve uma referência (ponteiro) para um objeto que irá representar toda a cena a ser exibida. Em nosso exemplo este objeto será chamado de RootObject. Este objeto representará um apontador para a raiz ou nodo inicial a partir do qual o grafo de cena pode ser percorrido.

SmVR_CGeometricObject *RootObject;
RootObject  = SmVR_Init(NULL);
Todos os demais objetos da cena serão criados como filhos deste RootObject. Assim, a exibição da cena pode ser feita simplesmente chamando o método Render deste objeto, desta forma:
RootObject->Render();
O exemplo a seguir inicializa a SmallVR e desenha um quadrado na tela. No exemplo estão sendo omitidos os detalhes relativos à posicionamento de câmera e à inicialização de outros parâmetros de OpenGL.
O programa-fonte completo pode ser encontrado neste link Cubo.cpp. Este programa exibe um quadrado na tela, conforme a figura abaixo.


Figura - Tela do primeiro programa SmallVR



Exercício 1:   Carregando objetos de arquivo

Conforme foi dito na seção 2.1, a SmallVR permite que sejam carregados objetos no formato Wavefront OBJ.  Para testar esta característica, copie o arquivo LoadObj.cpp,
grave-o no sub-diretório TestFiles, que se encontra no diretório onde você descompactou a SmallVR (se você tiver objetos em outros formatos, como 3DS, VRML, DXF, entre outros, sugerimos usar um conversor como o AccuTrans 3D e converter os objetos para Wavefront OBJ).

Adicione  o arquivo LoadObj.cpp ao projeto.

Este programa-fonte carrega um objeto no formato objeto OBJ e o exibe em frente ao observador. O trecho de código que carrega este objeto está na função main(veja o código abaixo).

         // Cria o objeto SmallVR
    SmVR_CGeometricObject *TestObject;
   
    // Cria um objeto para carregar o modelo de arquivo
    SmVR_COBJLoader *obj1 = new SmVR_COBJLoader();
    // Executa a carga do objeto
    obj1->Load("..//TestFiles//Objetos3D//Couch.obj");
   
    // Associa o objeto ligo de arquivo com o objeto SmallVR
    // Isto é feito passando o objeto "obj1" na construtora da classe
    // SmVR_CGeometricObject
    TestObject = new SmVR_CGeometricObject("Objeto Teste", obj1);
   
    // Adiciona o objeto recém criado ao grafo de cena
    RootObject->AddChild(TestObject);

Para obter o arquivo com o Sofa e outros objetos, copie o arquivo Objetos.zip  e descompacte-o no subdiretório TestFiles/Objetos3DCertifique-se de estar colocando os objetos no diretório correto.

Compile e execute o programa e veja o resultado.  O programa deve carregar um sofá na frente do usuário. Veja na abaixo como deve ficar a tela.


Figura - Objeto Sofa.obj


No  arquivo Objetos.zip há ainda outros objetos tridimensionais, conforme as imagens abaixo:




Extinguisher.obj
Mesa1.obj
Plant.obj
Piso.obj
Soccerball.obj
Figura - Outros Objetos

Experimente trocar o objeto "Couch.obj" por algum dos objetos apresentados acima.


Mudança do Observador

    Neste programa você pode alterar alguns parâmetros, como a posição do observador e seu ângulo de visão. Para tanto, modifique os valores das variáveis que estão na parte superior do fonte (veja o trecho de código abaixo).

// ******************************
// User stuff
//     see "PosicUser" function
//  on how to use these variables
// ******************************
// User position
SmVR_CPoint    User(0,0,2);
// Target position
SmVR_CPoint    Target(0,0,0);

// Root Object to represent the entire scene
SmVR_CGeometricObject *RootObject;

// Viewing angle in degrees
float ViewAngle = 90;

Sistema de Coordenadas OpenGL/SmallVR
       
Lembre-se que o sistema de coordenadas de OpenGL e pro conseqüência, da SmallVR, tem a configuração apresentada na figura abaixo.



Figura - Sistema de Coordenadas de OpenGL


Exercício 2:   Exibindo Objetos em OpenGL
Além de carregar obejtos já prontos, é possível criar objetos em OpenGL e adicioná-los no grafo de cena. O exercçio a seguir tem o objetivo de exemplicar esta característica.

Copie o programa
Cubo.cpp e grave-o no sub-diretório TestFiles, que se encontra no diretório obde você descompactou a SmallVR.
Insira o arquivo no projeto SmallVR Aplication.


5. Localizando Objetos

Para localizar objetos no grafo de cena SmallVR provê, na classe SmVR_CGeometricObject, o método FindChildObject que procura dentre os filhos um objeto com nome igual ao passado como parâmetro e devolve um apontador para o objeto encontrado. Isto é útil para evitar que o programador tenha que guardar ponteiro para todos os objetos. Este método também é utilizado para permitir o acesso aos objetos sem utilizar variáveis globais.

O trecho de código a seguir, por exemplo, permite obter um apontador para o objeto de nome "Test Object", se este for filho do objeto  RootObject.

SmVR_CGeometricObject *temp = RootObject->FindChildObject("Test Object");

6. Aplicando Transformações Geométricas

A aplicação de transformações geométricas sobre os objetos da SmallVR é feita através de métodos específicos para este fim. Não se deve usar as funções da biblioteca OpenGL para tal tarefa.

Quando se utiliza a SmallVR, um aspecto muito importante na aplicação de transformações geométricas a um objeto é a noção de qual sistema de coodenadas (sistema de referência) está sendo usado para calcular a transformação geométrica.  Neste aspceto, há três possibilidades:
(a) aplicação de rotações e escalas no sistema de coordenadas local de um objeto;
(b) aplicação de translações no sistema de coordenadas do pai do objeto;
(c) aplicação de transformações no sistema de coordenadas de um outro objeto.

6.1 Transformações Geométricas no Sitema de Coordenadas do Objeto

Na figura abaixo, pode-se observar o efeito da rotação de um retângulo ao redor do eixo Y, usando como referência seu próprio sistema de coordenadas (também chamado de sistema de coordenadas local - SCL).


Figura - Exemplo de uma rotação no Sistema de Coordenadas Local (SCL) de um Objeto

Para efetuar este tipo de transformação geométrica, a classe SmVR_CGeometricObject possui os apresentados na tabela a seguir.  

Método
Funcionalidade
ScaleBy(float ex, float ey, float ez) aplica uma escala (ex,ey,ez) no objeto usando o SCL do objeto
ScaleBy(SmVR_CPoint p) aplica uma escala no objeto usando o SCL do objeto. As componentes X,Y,Z do ponto 'p' definem os fatores de escala a serem aplicados
RotateBy(float angle, float ax, float ay, float az) aplica uma rotação de "angle" graus ao redor do vetor definido por (ax,ay,az), no SCL do objeto
RotateBy(float angle, SmVR_CPoint p) aplica uma rotação de "angle" graus ao redor do vetor definido por p, no SCL do objeto

As translações, por sua vez, são sempre aplicadas no sistema de coordenadas do pai do objeto, conforme a tabela abaixo.
 
Método
Funcionalidade
TranslateBy(float tx, float ty, float tz) aplica uma translação(tx,ty,tz) no objeto usando como referência o sistema de coodenadas do pai do objeto
TranslateBy(SmVR_CPoint p) aplica uma translação no objeto usando como referência o sistema de coodenadas do pai do objeto. O ponto P funciona como um vetor que define a translação




Exercício 3:  Copie o arquivo CenarioExerc3.cpp para o sub-diretório TestFiles, e adicione o arquivo ao projeto.

A seguir, altere o programa de maneira a modelar uma sala semelhante a da figura abaixo. Procure inserir seu código dentro da rotina CriaCenario().




O trecho de código a seguir exemplifica o posicionamento do sofá e do piso.


void CriaCenario()
{
    //================================================
    // PISO
    //================================================
    // Cria o objeto SmallVR
    SmVR_CGeometricObject *TestObject;

    // Cria um objeto para carregar o modelo de arquivo
    SmVR_COBJLoader *obj1 = new SmVR_COBJLoader();
    // Executa a carga do objeto
    obj1->Load("..//TestFiles//Objetos3D//Piso.obj");
   
    // Associa o objeto ligo de arquivo com o objeto SmallVR
    // Isto é feito passando o objeto "obj1" na construtora da classe
    // do objeto SmallVR
    TestObject = new SmVR_CGeometricObject("Piso", obj1);
   
    // Adiciona o objeto recém criado ao grafo de cena
    RootObject->AddChild(TestObject);
    //================================================
    // SOFÁ
    //================================================
    // Cria um objeto para carregar o modelo de arquivo
    obj1 = new SmVR_COBJLoader();
    // Executa a carga do objeto
    obj1->Load("..//TestFiles//Objetos3D//Couch.obj");
   
    // Associa o objeto ligo de arquivo com o objeto SmallVR
    // Isto é feito passando o objeto "obj1" na construtora da classe
    // do objeto SmallVR
    TestObject = new SmVR_CGeometricObject("Sofa", obj1);

    // Reposiciona o sofá
    TestObject->TranslateBy(0,0.4,-2);
    TestObject->RotateBy(180,0,1,0);
   
    // Adiciona o objeto recém criado ao grafo de cena
    RootObject->AddChild(TestObject);

}


6.2 Transformações Geométricas em Outros Sitemas de Coordenadas

Se as transformações geométricas tomarem como base sistema de coordenadas de um outro objeto o resultado é diferente daquele obtido com transformações no Sistema de Coordenadas do Objeto. Na figura abaixo, por exemplo, pode-se observar a rotação ao retângulo ao redor do eixo Y, do objeto vermelho que aparece na figura.

Figura - Exemplo de uma rotação de um objeto no Sistema de Coordenadas de um outro

 Para efetuar este tipo de transformação geométrica, a classe SmVR_CGeometricObject possui os métodos apresentados na tabela a seguir, nos quais, o último parâmetro é sempre o objeto a ser usado como sistema de referência.
 
Método
Funcionalidade
TranslateByOnOBJCS(float tx, float ty, float tz, SmVR_CGeometricObject *OCS) aplica uma translação(tx,ty,tz) no objeto usando o Sistema de Coordenadas do objeto OCS como referência
TranslateByOnOBJCS(SmVR_CPoint p, SmVR_CGeometricObject *OCS) aplica uma translação usando o o Sistema de Coordenadas do objeto 'OCS' como referência. O ponto P funciona como um vetor que define a translação
ScaleByOnOBJCS(float ex, float ey, float ez, SmVR_CGeometricObject *OCS) aplica uma escala (ex,ey,ez) no objeto, usando o Sistema de Coordenadas do objeto 'OCS' como referência
ScaleByOnOBJCS(SmVR_CPoint p, SmVR_CGeometricObject *OCS) aplica uma escala no objeto, usando o Sistema de Coordenadas do objeto 'OCS' como referência. As componentes X,Y,Z do ponto 'p' definem os fatores de escala a serem aplicados
RotateByOnOBJCS(float angle, float ax, float ay, float az, SmVR_CGeometricObject *OCS) aplica uma rotação de "angle" graus ao redor do vetor definido por (ax,ay,az), no Sistema de Coordenadas do objeto 'OCS'
RotateByOnOBJCS(SmVR_CPoint p, SmVR_CGeometricObject *OCS) aplica uma rotação de "angle" graus ao redor do vetor definido por 'p', no Sistema de Coordenadas do objeto 'OCS'



6.3 Translações Absolutas

As translações apresentadas até este momento são sempre aplicadas de forma relativa à posição corrente do objeto. Caso seja necessário mover um objeto para uma posição específica em relação ao sistema de coordenadas de um objeto, deve-se lançar mão do método de translação absoluta, TranslateToOnOBJCS

void SmVR_CGeometricObject::TranslateToOnOBJCS(float x, float y, float z, SmVR_CGeometricObject *OCS);
void SmVR_CGeometricObject::TranslateToOnOBJCS(SmVR_CPoint p, SmVR_CGeometricObject *OCS);

Este método permite que se mova um objeto O para uma posição X,Y,Z definida no sistema de coordenadas de um objeto OCS, independente da posição corrente de O.


7. Obtendo Pontos em Outros Sistemas de Coordenadas

Em alguns casos é necessário se obter as coordenadas de um ponto relativamente ao sistema de coordenadas de um outro objeto. Um exemplo disto são as rotinas de cálculo de colisão entre objetos.

Para obter as coordenadas de um ponto no sistema de coordenadas de um outro objeto deve-se usar o método

void SmVR_CGeometricObject::GetPointInOCS (SmVR_CPoint *in, SmVR_CPoint *out, SmVR_CGeometricObject *OCS).

Este método recebe como primeiro parâmetro (in) o ponto que se deseja obter, no sistema de coordenadas do objeto usado para evocar o método. O segundo parâmetro (out) receberá o resultado da conversão. O terceiro parâmetro (OCS) especifica o objeto do qual será usado o sistema de coordenadas para obter as coordenadas do ponto in.

O trecho a seguir, por exemplo, obtém as coordenadas do ponto (0,0,0) do objeto TestObject, no sistema de referência da raiz do grafo da cena. Isto serve, por exemplo, para saber a posição do objeto no sistema de coordenadas global.

void keyboard(unsigned char key, int x, int y) {
 SmVR_CGeometricObject *temp1;
 SmVR_CPoint Zero(0,0,0), GlobalPoint;

 temp1 = RootObject->FindChildObject("Teste");
 switch(key) {
 case 27:
  exit(0);
  break;

 case 'p': // get Point
  temp1->GetPointInOCS(&Zero, &GlobalPoint, RootObject);
    printf("X = %f, Y = %f, Z = %f", GlobalPoint.X, GlobalPoint.Y, GlobalPoint.Z);
  break;

 }
}

void main(int argc, char** argv) {
   SmVR_CGeometricObject *obj1;
......
......

// initialize the library
 RootObject = SmVR_Init(NULL);

 // criacao do cubo e adicao dele como filho do RootObject
 TestObject = new SmVR_CGeometricObject("Teste", desenhaCubo);

 // Add the object to the scene
 RootObject->AddChild(TestObject);

 TestObject->TranslateBy(0,0,8); // apply a translation on TestObject

.......
.......
}


8. Outros Métodos da Classe SmVR_CGeometricObject

A seguir apresentam-se algum métodos auxiliares disponíveis na classe SmVR_CGeometricObject.
 
Método
Funcionalidade
void SetVisibility(int status) define se um objeto deve ou não ser exibido. O parâmetro status pode receber os valores 0 (invisível) ou 1 (visível)
void SetName(char *name); define um novo nome para o objeto


9. Outras classes da SmallVR

Classe SmVR_CPoint

Esta classe permite armazenar um ponto tridimensional.

Exemplo de uso:

SmVR_CPoint User(0,6,10); // cria um ponto de coordenadas X = 0; Y = 6, Z = 10
Os campos X,Y e Z desta classe, por questões de eficiência, são declarados como public, podendo desta forma serem acessados diretamente, por exemplo:
printf("X = %f, Y = %f, Z = %f", User.X, User.Y, User.Z);