UNIVERSIDADE ESTADUAL DO MARANHÃO – UEMA

CENTRO DE CIÊNCIAS TECNOLÓGICAS – CCT

CURSO DE ENGENHARIA DA COMPUTAÇÃO

SELMO EDUARDO RODRIGUES JÚNIOR - 0993205

COMPUTAÇÃO GRÁFICA

São Luís – MA

2012

Sumário

Introdução........................................................................................................................3

1. Primeiro Código em OpenGL...................................................................................4

2. Sistemas de Referência no OpenGL........................................................................5

3. Projeções..................................................................................................................6

4. Primitivas Gráficas...................................................................................................7

5. Curvas Paramétricas................................................................................................8

6. Translação, Rotação e Escala.................................................................................8

Conclusão......................................................................................................................10

Introdução

Neste trabalho, serão abordados assuntos que foram estudados na disciplina de

Computação Gráfica, relacionando-os às funções da OpenGL. Primeiramente um

código em usando a biblioteca glut.h será analisado. Em seguida, os sistemas de

referência no universo e da tela serão caracterizados.

As funções da OpenGL que realizam projeções, primitivas gráficas e curvas

paramétricas serão descritas nesse trabalho. Por último, as translações, rotações e

escalas serão definidas e suas funções da OpenGL serão especificadas.

3

1. Primeiro Código em OpenGL

O primeiro código em C que será analisado, desenha um triângulo vermelho em

uma tela. Segue abaixo, seu código e análise de cada função:

1 #include<GL/glut.h>2 #include<stdio.h>3 #include<conio.h>45 void Desenha()6 {7 glClearColor(1,1,1,0);8 glClear(GL_COLOR_BUFFER_BIT );9 glColor3f(1,0,0);10 glBegin(GL_TRIANGLES);11 glVertex2f(-0.5,-0.5);12 glVertex2f(0.0,0.5);13 glVertex2f(0.5,-0.5);14 glEnd();15 glFlush();16 }1718 void Teclado(unsigned char key, int x, int y)19 {20 if (key == 27)21 exit(0);22 }2324 void Inicializa()25 {26 glMatrixMode(GL_PROJECTION);27 gluOrtho2D(-1.0,1.0,-1.0,1.0);28 glMatrixMode(GL_MODELVIEW);29 }3031 int main()32 {33 glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);34 glutInitWindowPosition(350,200);35 glutInitWindowSize(600,400);36 glutCreateWindow("Triângulo");37 glutDisplayFunc(Desenha);38 glutKeyboardFunc(Teclado);39 Inicializa();40 glutMainLoop();41 return 0;42 }

4

As três primeiras linhas são comandos da linguagem C que importam arquivos

contendo um conjunto de funções. Nesse código, foi usado três a glut.h, stdio.h e a

conio.h, sendo a primeira de maior importância nesse trabalho. Na quinta linha uma

função desenha é criada. Na linha 7 temos a função glClearColor(), que especifica a

cor de fundo da tela (no caso, branca). Nesse código, o sistema RGB de cores está

sendo utilizado. Em seguida, a função glClear() preenche a tela com a cor escolhida

pela função anterior. A linha 9 escolhe uma cor que será utilizada para fazer o

desenho. No exemplo, a cor será vermelha. Da linha 10 a 14, um triângulo foi

especificado pela primitiva GL_TRIANGLES e pelas funções glVertex(x,y), cuja função

é determinar as coordenadas x e y do triângulo no plano bidimensional, ou seja, os

seus vértices. Na última linha da função Desenha() (linha 15) está a função glFlush(),

que, efetivamente executa as funções citadas anteriormente.

Na linha 18, uma segunda função foi declarada: Teclado(). Essa função

simplesmente encerra o programa caso a tecla Esc seja digitada.

Na função Inicializa(), tem-se as funções da biblioteca glut.h que vão

determinar o s tipos de parâmetros da projeção a ser utilizada. A função gluOrtho2D()

define uma projeção ortográfica paralela ortogonal, isto é, para duas dimensões.

Nesse tipo de projeção, as linhas de projeção são paralelas entre si e perpendiculares

ao plano de projeção.

Por último, temos a função principal. O comando da linha 33 inicializa a GLUT

e define o sistema de cores como RGB. Na linha 34, a posição da janela é definida e

na linha seguinte, seu tamanho é declarado. O comando glCreateWindow() na linha 36

cria a tela com as características descritas pelas funções anteriores e, como

parâmetro da função, é definido o título da tela. As duas próximas funções de cada

linha realizam o que foi descrito pelas funções Desenha() e Teclado(). Finalmente, as

funções da linha 39 e 40 se responsabilizam pelo processamento do programa e o

triângulo vermelho pode ser agora desenhado na tela.

2. Sistemas de Referência no OpenGL

Como referência de descrição dos diversos objetos, o universo é utilizado em

termos das coordenadas utilizadas pelo usuário. Com isso, cada usuário define seu

chamado “universo de trabalho”. Denominamos esse tipo de referência como Sistema

de Referência do Universo (SRU). A OpenGL utiliza esse sistema de referência.

Entretanto, o monitor do computador adota outro tipo de sistema de referência, o SRT

5

(Sistema de Referência da Tela). Essa diferença é perceptível quando comparamos

as origens de ambos os sistemas de origem. No SRT a origem fica no canto superior

esquerdo do monitor, enquanto o SRU é semelhante ao plano cartesiano, com a

origem geralmente no centro. Portanto, para o objeto ser desenhado na tela, precisa-

se fazer um mapeamento. Essa técnica consiste em uma transformação de um

sistema de referência de coordenadas para outro sistema de referência. Com o

mapeamento, os modelos são criados independentes do dispositivo, com as

coordenadas definidas em relação ao sistema de referência adotado.

Como o universo é infinito, precisa-se selecionar uma área que delimite a região

de trabalho do usuário. Denominamos essa área de window. Da mesma forma, é

preciso definir em que parte do monitor deseja-se exibir o conteúdo da window. Essa

área é a chamada viewport. Na OpenGL, utiliza-se duas funções principais para

determinar a window e a viewport:

void glViewport(GLint x, GLint y, GLint widht, GLint height): definição do

viewport. Os dois primeiros parâmetros servem para identificar as coordenadas

do canto inferior esquerdo da janela, enquanto os últimos definem,

respectivamente, a largura e altura da tela;

void gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble

top): definição da window. Essa função já foi citada anteriormente. Seus

parâmetros definem as coordenadas das bordas da janela.

3. Projeções

Quando é necessário trabalhar com objetos em 3D, é necessário fazer um

mapeamento para duas dimensões, representando o objeto na tela. Este operação

para obtenção de representações bidimensionais de representações tridimensionais é

denominada de projeção. Para realizar a projeção, é necessário considerar três

elementos básicos:

Plano de Projeção: é a superfície onde será projetado o objeto;

Raios de Projeção: são as retas que passam pelos pontos do objeto e pelo

centro de projeção;

Centro de Projeção: é o ponto fixo de onde os raios de projeção partem.

Há duas classificações principais de projeções:

6

Projeção Paralela Ortográfica: as projetantes são paralelas entre si e

passam pelos pontos que definem os objetos e interseccionam o

plano com um ângulo de 90o;

Projeção Perspectiva: as projetantes emanam de um único ponto que está

a uma definição finita do plano de projeção e passam pelos pontos que

definem objetos;

Abaixo, algumas funções do OpenGL que realizam as projeções:

void gluPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear,

GLdouble zFar): esta função emprega a projeção pespectiva. O primeiro

parâmetro é utilizado para determinar o ângulo de visualização na direção

y. O parâmetro aspect é a razão de aspecto que determina a área de

visualização na direção x. O terceiro, zNear, corresponde a distância do

observador até o plano frontal. E, por último, o zFar, que corresponde a

distância do observador até o plano de corte em z.

void gluOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble

top, GLdouble near, GLdouble far): função que trabalha com projeção

ortográfica. Os parâmetros left e right especificam os limites máximo e

mínimo no eixo x. Analogamente, bottom e top determinam os limites

máximo e mínimo no eixo y. Os dois últimos parâmetros correspondem aos

valores máximo e mínimo no eixo z.

4. Primitivas Gráficas

As primitivas gráficas consistem em elementos básicos que compõem o desenho.

No código da primeira seção, na linha 10, a função glBegin(GL_TRIANGLES) possui

a primitiva de um triângulo, que terá seus vértices especificados pelas funções

glVertex2f() nas linhas de 11 a 13. Abaixo, algumas das principais primitivas gráficas

do OpenGL:

GL_LINES: para desenhar linhas;

GL_POLYGON: para desenhar polígonos;

GL_TRIANGLES: para desenhar triângulos;

GL_QUADS: para desenhar quadriláteros;

GL_POINTS: para desenhar points.

7

5. Curvas Paramétricas

A forma mais comum de representação de curvas é aquela em que uma das

coordenadas é obtida em função da outra. Ou seja, y = F(x) ou x = F(y)

Esta forma de representação, porém possui alguns inconvenientes quando

estamos trabalhando com modelagem geométrica. Entre estes inconvenientes estão:

é difícil definir a equação de uma curva através de seus pontos e de suas

derivadas neste pontos (o que é bastante útil em modelagem geométrica);

é impossível criar curvas com laços;

é bastante difícil obter uma curva suave que passe por um conjunto de pontos.

A OpenGL implementa diretamente as curvas de Bézier, que é uma curva

polinomial expressa como a interpolação linear entre alguns pontos representativos,

chamados de pontos de controle. Para utilizar um avaliador Bézier, emprega-se a

seguinte função da API:

void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint

order, const GLfloat *points): é uma função que define os pontos de

controle. Os parâmetros u1 e u2 definem o intervalo para variável de

controle u. O stride indica a quantidade de valores que float que existem

entre cada elemento do vetor. O parâmetro order contém a quantidade de

elementos do vetor. Por último, tem-se um ponteiro points, que armazena o

endereço da primeira coordenada do primeiro ponto de controle.

6. Translação, Rotação e Escala

Translação, rotação e escala são os três tipos de fundamentais de transformações

geométricas que permitem a manipulação de um objeto ou cenário, onde a ordem em

que essas transformações são aplicadas influencia o resultado.

6.1. Translação

A translação é usada para definir a posição de um objeto ou cenário.

Matematicamente, essa operação consiste em adicionar constantes de deslocamento

a todas as coordenadas das primitivas gráfica do objeto. A seguir, serão abordadas as

funções utilizadas para aplicar uma translação:

8

void glTranslatef(GLfloat tx, GLfloat ty, GLfloat tz): essa função é usada

para aplicar uma translação em um ou mais objetos de uma cena. Os

parâmetros tx,ty e tz armazenam os valores de translação que devem ser

aplicados aos eixos x, y e z;

void glTranslated(GLdouble tx, GLdouble ty, GLfdouble tz): essa função faz

o mesmo que a anterior. A diferença é que esta lida com parâmetros do tipo

double.

6.2. Rotação

A transformação geométrica de rotação é usada para definir o valor ângulo que

será utilizado como referência para girar o objeto. De acordo com a matemática, esta

operação consiste em aplicar uma composição de cálculos empregando o seno e

cosseno do ângulo de rotação a todas as coordenadas das primitivas gráficas que

compõem um objeto ou cena. As funções do OpenGL utilizadas para realizar a rotação

são:

void glRotatef(GLfloat angulo, GLfloat x, GLfloat y, GLfloat z): função que

aplica a rotação em ou mais objetos. Os parâmetros indicam o ângulo de

rotação e a coordenada do eixo de rotação;

void glRotated(GLdouble angulo, GLdouble x, GLdouble y, GLdouble z):

essa função faz o mesmo que a anterior, sendo a única diferença é que

esta lida com parâmetros do tipo double.

6.3. Escala

A transformação geométrica de escala serve para definir aquela que deve ser

usada para exibir um objeto ou cena. Esta operação consiste em multiplicar um valor

de escala por todas as coordenadas das primitivas gráficas que compõem o objeto ou

cenário no qual será aplicada a escala. As funções OpenGL que aplicam as escalas

são:

void glScalef(GLfloat ex, GLfloat ey, GLfloat ez): função que é utilizada para

aplicar uma escala em um ou mais objetos. Os parâmetros indicam os

valores de escala que devem ser aplicados nos eixos x, y e z;

void glScaled(GLdouble ex, GLdouble ey, GLdouble ez): faz o mesmo que a

anterior, porém esta lida com parâmetros do tipo double.

9

Conclusão

Este trabalho serviu para associarmos os conceitos aprendidos na

disciplina de Computação Gráfica e relacioná-los com a API OpenGL, servindo

como prática e desenvolvimento desses conceitos. Essa API permite uma

visualização que permite que nossas ideias sejam analisadas e estudadas,

obtendo melhores resultados no aprendizado.

10