UNIVERSIDADE ESTADUAL DO MARANHÃO M ARANHÃO – UEMA CENTRO DE CIÊNCIAS TECNOLÓGICAS – CCT CURSO DE ENGENHARIA DA COMPUTAÇÃO COMPUTAÇÃO
SELMO EDUARDO RODRIGUES JÚNIOR - 0993205
COMPUTAÇÃO GRÁFICA
São Luís – MA 2012
Sumário Introdução Introdução............................... ................................................ .................................. .................................. ................................. ................................. ..................... 3 1.
Primeiro Código em OpenGL ................... ......... ................... ................... ................... .................. ................... ................... ............... ...... 4
2.
Sistemas de Referência no OpenGL................... ......... ................... ................... ................... .................. .................. .............. ..... 5
3. Projeções Projeções................. .................................. .................................. ................................. ................................. ................................. ........................... ........... 6 4. Primitivas Gráficas ................... .......... ................... ................... .................. ................... ................... ................... ................... .................. ............ ... 7 5.
Curvas Paramétricas .................. ......... ................... ................... ................... ................... .................. ................... ................... .................. ......... 8
6. Translação, Rotação e Escala .................. ......... ................... ................... ................... ................... .................. ................... .............. .... 8 Conclusão 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 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
#include #include #include void Desenha() { glClearColor(1,1,1,0); glClear(GL_COLOR_BUFFER_BIT ); glColor3f(1,0,0); glBegin(GL_TRIANGLES); glVertex2f(-0.5,-0.5); glVertex2f(0.0,0.5); glVertex2f(0.5,-0.5); glEnd(); glFlush(); } void Teclado(unsigned Teclado(unsigned char key, int x, int y) { if (key == 27) exit(0); } void Inicializa() { glMatrixMode(GL_PROJECTION); gluOrtho2D(-1.0,1.0,-1.0,1.0); glMatrixMode(GL_MODELVIEW); } int main() { glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowPosition(350,200); glutInitWindowSize(600,400); glutCreateWindow("Triângulo"); glutDisplayFunc(Desenha); glutKeyboardFunc(Teclado); Inicializa(); glutMainLoop(); return 0; }
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). (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). 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, precisase fazer um mapeamento. 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. 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. 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 90 o; 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 GLdouble far): função que 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 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 de 11 a 13. Abaixo, algumas algumas das principais primitivas gráficas 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 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. 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. 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 coordenadas das primitivas gráfica do objeto. A seguir, serão abordadas as funções utilizadas para aplicar uma translação:
8
6.2.
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 valores de translação que devem ser 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.
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 f unções do OpenGL utilizadas para realizar a rotação são:
6.3.
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.
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
