Material de Auxílio Didático

EA978 - Sistemas de informações gráficas

Primeiro semestre de 2003

DCA/FEEC/Unicamp

1o Projeto

Atividade 1 - Modelagem Geométrica

Objetivo: Gerar o modelo de uma mesa, um vaso, um cálice, uma luminária, uma cadeira e um chão usando somente primitivas do OpenGL.

Modelagem da mesa

A mesa pode ser modelada usando apenas a função glutWireCube da GLUT que gera um cubo unitário na origem. Podem ser utilizadas transformações de escala sobre diferentes cubos para criar o tampo e os pés da mesa. Por exemplo, o pés da mesa são simplesmente cubos alongados no eixo Y. O tampo da mesa é um cubo achatado no eixo Y e alongado no eixo X e Z.

Use o seguinte esqueleto de código para implementar essa tarefa: table.c

Dicas:

Observação: Para visualizar os objetos em wireframe utilize o comando glPolygonMode(GL_FRONT_AND_BACK, GL_LINE). Esse comando também habilita a visualização de polígonos que não estão defrontando o observador.

Através das imagens abaixo pode-se ter uma idéia das dimensões do modelo.
Sinta-se livre para construir um modelo diferente do sugerido.


Mesa (projeção perspectiva)


Mesa vista de frente (projeção ortográfica)


Mesa vista de cima (projeção ortográfica)

Modelagem do vaso

O vaso mostrado abaixo foi construído apenas com funções da GLUT e da GLU. O corpo do vaso foi feito com três cilindros um sobre o outro usando o comando glutCylinder com diâmetros diferentes para o início e fim de cada cilindro. Finalmente, a boca do vaso foi finalizada com um toróide gerado através do comando glutWireTorus. É importante que o vaso seja definido num display list, pois essa estratégia vai facilitar seu posicionamento sobre a mesa no próximo projeto.

Use o seguinte esqueleto de código para implementar essa tarefa: vase.c

Dica: Use o comando glTranslate* para colocar um cilindro sobre o outro. Use também o comando glRotate* para colocar cada cilindro "em pé", uma vez que o comando gluCylinder gera um cilindro deitado, isto é, ao longo do eixo Z na origem. O mesmo se aplica ao toróide.

Através das imagens abaixo pode-se ter uma idéia das dimensões do modelo.
Sinta-se livre para construir um modelo diferente do sugerido.


Vaso (projeção perspectiva)


Vaso visto de frente (projeção ortográfica)


Vaso visto de cima (projeção ortográfica)

Modelagem do cálice

Da mesma forma que na construção do vaso na tarefa anterior, o cálice foi feito com apenas três cilindros. Observe que o comando gluCylinder gera cilindros abertos em cima e em baixo. Para tampar um cilindro podemos utilizar o comando gluDisk, também da GLU. Esse procedimento foi adotado na modelagem da base do cálice (o cilindro achatado). Observe que este cilindro está fechado em cima.

Use o seguinte esqueleto de código para implementar essa tarefa: cup.c

Dica: Use o comando glTranslate* para colocar um cilindro sobre o outro. Use também o comando glRotate* para colocar cada cilindro "em pé", uma vez que o comando gluCylinder gera um cilindro deitado, isto é, ao longo do eixo Z na origem. O mesmo se aplica ao toróide.

Através das imagens abaixo pode-se ter uma idéia das dimensões do modelo.


Cálice (projeção perspectiva)


Cálice visto de frente (projeção ortográfica)


Cálice visto de cima (projeção ortográfica)

Modelagem da luminária

A luminária pode ser modelada a partir do modelo do cálice. Para tanto basta definirmos uma haste mais alongada e, no topo, rotacionarmos o copo de modo que sua boca fique direcionada ao centro da mesa. Além disso, a luminária contém uma esfera que simboliza a lâmpada. A esfera pode ser criada com o comando gluSphere e posicionada no local correto através de chamadas a glTranslate*.

Use o seguinte esqueleto de código para implementar essa tarefa: lamp.c

Através das imagens abaixo pode-se ter uma idéia das dimensões do modelo.


Luminária (projeção perspectiva)


Luminária vista de frente (projeção ortográfica)


Luminária vista de cima (projeção ortográfica)

Modelagem das cadeiras

Na cena que queremos construir, as duas cadeiras são idênticas e apenas diferem entre si por estarem em posições diferentes. Desse modo, podemos modelar apenas uma cadeira, armazená-la num display list e chamar glCallList duas vezes para criar rapidamente as duas cadeiras. A modelagem da cadeira nesse exemplo foi feita usando o comando glutWireCube e uma superfície de Bézier. Os cubos (distorcidos com glScale*) foram utilizados para fazer, por exemplo, os pés da cadeira. A superfície de Bézier foi utilizada na modelagem do estofado. Note que o encosto e o assento da cadeira também são superfícies de Bézier idênticas, com a diferença de que uma está na horizontal e outra na vertical. Basta chamar duas vezes a função glEvalMesh2* e aplicar o comando glRotate* e glTranslate* para posicionar cada superfície no local correto.

Use o seguinte esqueleto de código para implementar essa tarefa: chair.c

Dica: Para gerar a superfície de Bézier utilize o código bezmesh.c descrito nas demonstrações de modelagem geométrica. Nesse exemplo é utilizada uma malha de 4x4 pontos de controle (definido na variável ctrlPoints). Você pode utilizar essa mesma malha e modificar apenas os valores Z de cada ponto de controle de acordo com o aspecto desejado do estofamento. Lembre-se que a componente Z define a altura de cada ponto de controle. Se todos os valores Z forem constantes, a superfície gerada será plana. Lembre-se de ver também as demonstrações didáticas.

Através das imagens abaixo pode-se ter uma idéia das dimensões do modelo. Entretanto, sinta-se livre para construir um modelo diferente do sugerido.


Cadeira (projeção perspectiva)


Cadeira vista de lado (projeção ortográfica)


Cadeira vista de cima (projeção ortográfica)

Modelagem do chão

O chão pode ser uma grade retangular gerada com primitivas GL_TRIANGLES, GL_QUADS, GL_TRIANGLE_STRIP ou GL_QUAD_STRIP do OpenGL. Infelizmente não existem funções da GLUT ou da GLU para geração automática de malhas retangulares. Por outro lado, a criação dessa malha usando as primitivas citadas é relativamente simples e pode ser feita com apenas dois laços aninhados (uma interação em X e outra interação em Z). O chão também pode ser armazenado num display list para facilitar seu posicionamento posterior na cena. Uma imagem do chão feita com primitivas GL_TRIANGLE_STRIP é mostrada abaixo.

Use o seguinte esqueleto de código para implementar essa tarefa: floor.c

Através das imagens abaixo pode-se ter uma idéia das dimensões do modelo.


Chão (projeção perspectiva)


Chão visto de cima (projeção ortográfica)

Demonstrações Didáticas

As demonstrações didáticas abaixo relacionadas auxiliam na compreensão dos conceitos básicos de OpenGL necessários para a implementação dessa e das próximas atividades. Para compilar esses programas nas máquinas do laboratório LE-20, use o seguinte arquivo makefile.
Adicione esse arquivo no mesmo diretório onde estão os programas com extensão .c de cada demonstração. Para compilar todas as demonstrações, digite  "make all" na linha de comando. Para compilar uma demonstração em particular, execute o comando "make" com o parâmetro indicado em cada descrição do programa.

Primeiro Programa em OpenGL [hello.c]
Esse programa demonstra a simplicidade da estrutura básica de um programa em OpenGL usando as funções da GLUT. O objetivo é apenas mostrar um retângulo branco sobre um fundo preto, sem iluminação ou texturas. Apesar da simplicidade dessa demonstração, a estrutura dos próximos programas em OpenGL segue o mesmo formato.
Para gerar o executável digite make hello.
Referência: Capítulo 1 do OpenGL Programming Guide. (Listagem 1.1)
Double buffering e rotação [double.c]
Versão aprimorada do primeiro programa em OpenGL. A exibição do quadrado no framebuffer utiliza o método de double buffering. Nessa estratégia a cena é renderizada num buffer secundário e, somente depois que a cena estiver pronta, o conteúdo desse buffer secundário é transferido para a tela. Dessa forma evita-se o efeito de cintilação da imagem durante uma animação. Essa demonstração também ilustra a rotação do retângulo ativada pelo botão esquerdo do mouse e desativada pelo botão do meio.
Para gerar o executável digite make double.
Referência: Capítulo 1 do OpenGL Programming Guide. (Listagem 1.3)
[Tutorial OpenGL - Formas] Executável Windows
Essa demonstração ilustra como funcionam os diferentes tipos de primitivas disponíveis no OpenGL: POINTS, LINES, LINE_LOOP, LINE_STRIP, TRIANGLES, TRIANGLE_FAN, TRIANGLE_STRIP, QUADS, QUAD_STRIP, POLYGON. Para selecionar um tipo de primitiva use o botão direito do mouse. O código em OpenGL utilizado para mostrar as primitivas é mostrado num painel à direita da tela. Clicando nos argumentos e movendo o mouse é possível modificar os valores das primitivas.
Referência: Capítulo 2 do OpenGL Programming Guide.
Transformação Simples sobre um Cubo [cube.c]
Demonstração de uma transformação geométrica simples sobre um cubo. Inclui uma transformação de escala (transformação de modelagem) e um posicionamento da câmera através da função glLookAt (transformação de visualização).
Para gerar o executável digite make cube.
Referência: Capítulo 3 do OpenGL Programming Guide (Listagem 3.1).
Transformações Geométricas [model.c]
Renderiza um triângulo quatro vezes, cada um com uma transformação geométrica diferente. Um triângulo em aramado sólido é mostrado sem nenhuma transformação. O mesmo triângulo é desenhado novamente, mas transladado e com uma linha tracejada. Outro é desenhado com uma transformação em escala (tracejado longo) e outro ainda é desenhado com as transformações de rotação e escala (linhas pontilhadas).
Para gerar o executável digite make model.
Referência: Capítulo 3 do OpenGL Programming Guide (Listagem 3.2).
Composição de Transformações Geométricas [planet.c]
Demonstração de composição de transformações (translação e rotação) na simulação de um planeta em órbita de uma estrela. Use as teclas 'd' e 'y' para alterar os parâmetros do dia e ano, isto é, rotação do planeta em torno do seu próprio eixo e rotação do planeta em torno da estrela.
Para gerar o executável digite make planet.
Referência: Capítulo 3 do OpenGL Programming Guide (Listagem 3.6).

Sugestão: Experimente adicionar uma lua ao planeta, ou várias luas e novos planetas. Dica: use as funções glPushMatrix e glPopMatrix para salvar e recuperar o estado das transformações geométricas num dado momento. Por exemplo, é preciso salvar o estado das transformações geométricas antes de posicionar cada lua ao planeta e recuperar o estado das transformações depois que cada lua é desenhada. O funcionamento dessas funções é descrito no capítulo 3 do OpenGL Programming Guide.
[Tutorial OpenGL - Transformações] Executável Windows
Demonstra as transformações básicas de rotação, translação e escala em OpenGL. A ordem das transformações pode ser alterada e o resultado é mostrado interativamente. Clique com o botão direito do mouse sobre as janelas para acessar os menus pop-up de configuração.
Quádricas [quadric.c]
Esse programa demonstra o uso das funções gluQuadric* para criação de quádricas disponíveis através da biblioteca GLU. Entre esses objetos estão incluídos o cilindro, esfera, disco e disco parcial (pizza). Note que os cilindros gerados pela GLU não são fechados, isto é, não possuem nem topo nem fundo.
Para gerar o executável digite make quadric.
Referência: Capítulo 6 do GLU Specification.
Curvas de Bézier [bezcurve.c]
Demonstra o uso de avaliadores (evaluatores) do OpenGL para desenhar uma curva de Bézier. A curva de Bézier é descrita apenas por seus pontos de controle. Em tempo real o OpenGL determina automaticamente os pontos da curva através das funções glEvalCoord*. Nessa demonstração a curva é avaliada em 30 pontos e desenhada com GL_LINE_STRIP. Os pontos de controle são mostrados como pontos (GL_POINTS).
Para gerar o executável digite make bezcurve.
Referência: Capítulo 11 do OpenGL Programming Guide (Listagem 11.1).
Superfícies de Bézier [bezmesh.c]
Demonstra a construção de uma superfície de Bézier através do uso de avaliadores do OpenGL. A superfície é descrita como uma malha de 4x4 pontos de controle. Neste exemplo, a coordenada Z de cada ponto especifica a altura do ponto de controle. Se essa coordenada for igual em todos os pontos, a superfície gerada será uma malha retangular plana.
Para gerar o executável digite make bezmesh.
Referência: Capítulo 11 do OpenGL Programming Guide (Listagem 11.3).

Autor: Harlen Costa Batagelo (harlen@dca.fee.unicamp.br)