RELATÓRIO TÉCNICO: APLICAÇÃO EM 3D UTILIZANDO OPENGL

Autores: MAIKON ROCHA ANTUNES, AMANDA VIERA FARIAS, RYAN LUCAS SILVA LEMOS,
IAGO VINICIUS SILVA COSTA, WESLEY RODRIGUES DE MATOS, IARA STEFANNY SILVA COSTA,

Introdução

O OpenGL é uma Application Programming Interface (API), termo utilizado para classificar uma biblioteca de funções específicas disponibilizadas para a
criação e desenvolvimento de aplicativos em determinadas linguagens de programação. Ou seja, o OpenGL não é uma linguagem de programação e sim uma
API que utiliza de alguma linguagem, uma das mais utilizadas é C e C++. Ele pode ser utilizado em qualquer sistema operacional, para produzir qualquer tipo
de aplicativo. As aplicações OpenGL variam de ferramentas CAD a programas de modelagem usados para criar personagens para o cinema, tal como um
dinossauro. Além do desenho de primitivas gráficas, tais como linhas e polígonos. Passando pelos games até ferramentas de modelagem 3D ou programas de
processamento de superfícies matemáticas. Atualmente, OpenGL é reconhecida e aceita como um padrão API para desenvolvimento de aplicações gráficas 3D
em tempo real.

A partir do aprendizado de tal ferramenta, foi proposto em sala de aula a criação de um programa que fosse capaz de movimentar um gato e fazendo
a orientação no plano, com o movimento controlado pelo usuário (via teclado). Além disso, o gato deveria dar passos movimentando-se pela tela, bem como as
suas patinhas e o rabo deveriam movimentar-se do mesmo modo. Por fim, o gato deveria fazer uma interação com uma bolinha. Ressaltando que todos os
movimentos deveriam ser controlados via teclado.

Logo, o presente relatório técnico busca caracterizar as principais funções que foram utilizadas para o desenvolvimento da atividade proposta. Vale
ressaltar que para o desenvolvimento da proposta foram utilizados exemplos de código fonte em Linguagem C, disponibilizadas pela Unicamp1.

Função para formar o objeto

void forma_cabeca (){

cabeca = glGenLists(1); //inicializando a cabeca

glNewList(cabeca, GL_COMPILE); //compila a cabeca

glColor3f(0.244, 0.240, 0.232); //cor da cabeça

glutSolidSphere(0.3, 16, 16); //escala da cabeca

glEndList(); // finaliza a lista inicializada}

Utilizando essa função foram geradas as outras formas do objeto corpo, pata, bigode, orelha e rabo, bem como a bola. Sendo assim, fora utilizada
uma função que junta todas as partes feita anteriormente e que no fim gera a estrutura do gato, como segue a seguir:

void forma_gato (){

forma_cabeca();

forma_corpo ();

forma_bigode ();

forma_orelha ();

forma_rabo ();

forma_pata ();

forma_bola ();}

Função para posicionar o objeto

Veremos agora as funções para posicionar o objeto e para rotacionar, de forma que a posição é definida pela função glTranslatef(eixo x, eixo y, eixo z) e a
sua rotação é feita pela função glRotatef(ângulo, eixo x, eixo y, eixo z).

void desenhar_cabeca (){

glPushMatrix();
 glTranslatef(a+0,0,0); // define a posição do objeto, com base nos eixos x, y, z.

glCallList(cabeca); // define que a posição colocada anterior é para esse objeto, ou seja, a cabeca

glPopMatrix();

glPopMatrix(); }

Lembrando que a função citada anteriormente somente posiciona o objeto, não sendo atribuído a ela a rotação, de igual modo as funções para o
corpo e orelha. Já as funções do bigode, rabo, pata e bola posicionam o objeto e fazem a rotação do mesmo, como segue o exemplo da bola:

void desenhar_bola (){

glPushMatrix();

glTranslatef(-1.2,b-1.3,0); // define a posição do objeto, com base nos eixos x, y, z.

bol=70; //variável para determinar o ângulo de rotação do objeto, definida no início como sendo float.

glRotatef(bol, 1.0, 1.0, 1.0); //determina o angulo da rotação e faz o objeto rotacionar em torno dos eixos determinados

glCallList(bola); // define que a posição colocada anterior é para esse objeto, ou seja, a bola

glPopMatrix();

glPopMatrix();}

Aqui também se faz um destaque para a rotação das patas, como segue a figura abaixo. Sendo atribuído para cada pata uma variável de rotação
diferente (pa1, pa2, pa3, pa4), definidas anteriormente como sendo do tipo float e na sua instanciação definido o valor de angulação.

void desenhar_pata (){ //pata fundo 3

//pata frente 1 glPushMatrix();

glPushMatrix(); glTranslatef(a+0.90, -1.0, 0.0);

glTranslatef(a+0.15, -1.0, 0.0); glRotatef(pa3, 1.0, 1.0, 0.0);

glRotatef(pa1, 1.0, 1.0, 0.0); glCallList(pata);

glCallList(pata); glPopMatrix();

glPopMatrix(); glPopMatrix();

glPopMatrix(); //pata fundo 4

//pata frente 2 glPushMatrix();

glPushMatrix(); glTranslatef(a+1.00, -1.0, 0.0);

glTranslatef(a+0.25, -1.0, 0.0); glRotatef(pa4, 1.0, 1.0, 0.0);

glRotatef(pa2, 1.0, 1.0, 0.0); glCallList(pata);

glCallList(pata); glPopMatrix();

glPopMatrix(); glPopMatrix();

glPopMatrix(); }

Logo, de modo semelhante acontece com as outras partes do objeto. E para desenhar todo o objeto chama-se a função:

void desenhar_gato (){

desenhar_cabeca();

desenhar_corpo ();

desenhar_bigode ();
 desenhar_orelha ();

desenhar_rabo ();

desenhar_pata ();

desenhar_bola ();

glFlush (); //força a execução dos comandos enviados ao OpenGL}

Função main

Por fim, a função responsável por estabelecer a comunicação com todas as funções criadas anteriormente. Também se faz presente algumas configurações,
como por exemplo, o tamanho, a posição e o nome da janela. Bem como, a inicialização do openGL e a chamada dos registros dos tratadores de eventos.

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

/* estabelecimento de comunicação com o sistema de janela */

glutInit(&argc, argv);

glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

//define o tamanho, a posição e o nome da janela

glutInitWindowSize (600, 500);

glutInitWindowPosition (100, 100);

glutCreateWindow ("Gato Doente 3D");

init (); // inicializa o openGL

// registra os tratadores de eventos

glutDisplayFunc(display);

glutReshapeFunc(reshape);

glutKeyboardFunc(keyboard);

glutMainLoop(); //entra no modo espera

return 0;}

Conclusão/Conclusões/Considerações finais

Pode-se concluir que o objeto traçado para o desenvolvimento de um gato que interagia com uma bola foi atendido, ficando claro que a questão de estética e
demais detalhes não foram aperfeiçoados devido a distribuição do tempo e a ferramenta utilizada. Para tanto, o trabalho foi enriquecedor, partindo do
pressuposto que muitas funções desconhecidas foram exploradas e a habilidade de desenvolver uma ideia no papel e transferi-la para o computador foi
aprimorada.

Referências bibliográficas

[1] http://www.dca.fee.unicamp.br/courses/IA725/1s2006/program/c/samples/boneco.c

https://www.inf.pucrs.br/~manssour/OpenGL/PrimeiroPrograma.html

https://www.ntu.edu.sg/home/ehchua/programming/opengl/CG_Examples.html

Figura 1: Gato e bola sem e com movimentação

Fonte: Figuras extraídas do software desenvolvido, galeria pessoal.