Silvânia de AssisGuilherme de Melo Moisés Tadeu CardosoIsabela de OliveiraGlauber AtaídeHenrique de Araujo

1

OpenGL e uma biblioteca de funções para desenvolver aplicações gráficas em 2D e

3D, portáteis e interativas, foi desenvolvida em 1992 pela Silicon Graphics .

O OpenGL foi desenvolvido em C, mas e integrável com outras linguagens como

Java, Python e C++ .

2

A utilização do OpenGL pela industria de desenvolvimento de jogos e muito intensa, hoje muitos jogos utilizama biblioteca para seu desenvolvimento, entre eles podemos citar:

Half Life, Medal of Honor, NeverWinter Nights, Unreal Tournament, Alone in the Dark, entre inúmeros outros títulos.

3

As rotinas de exibição de objetos de OpenGL são sempre iguais. O que difere o uso de OpenGl em uma plataforma UNIX ou PC, ou em ferramentas como Delphi, C Builder, Borland C, Visual C ou Visual Basic é a forma de inicializar e integrar a biblioteca OpenGL em cada linguagem e a forma de definir em que janela(ou parte dela) a imagem será exibida.

4

A biblioteca gráfica OpenGL é capaz de trabalhar com 3 tipos de LUZ:

Ambiente, Difusa Especular.

5

Observe como a iluminação é importante para a representação de Objetos 3D:

6

Luz Ambiente Um objeto que não esteja diretamente

iluminado é ainda visível por causa da luz refletida a partir doutras superfícies. Modelada por uma simples fonte de luz ambiente.Em vez de calcular as reflexões nas superfícies dos objetos, especifica-se uma luz ambiente constante para todas as superfíciesDefinida somente pelas intensidades de luz ambiente RGB

7

Exemplo Completo de Luz Difusa:   // As funções "DefineLuz", "DesenhaCubo”

procedure DefineLuz; const // Define a cor da luz ambiente.     LuzAmbient : Array[0..3] of GLfloat = (1.0, 1.0, 1.0, 1.0); begin // Habilita o uso de iluminação     glEnable(GL_LIGHTING); // Ativa o uso da luz ambiente     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, @LuzAmbient); // Ativa o "Color Tracking"     glEnable(GL_COLOR_MATERIAL); end;

procedure DesenhaCubo; begin

glColor3f(0,0,0.5); // Define a de contrasteglBegin(GL_POLYGON); // face 1

glNormal3f(0,0,1); glVertex3f(10.0, 10.0, 10.0); glVertex3f(-10.0, 10.0, 10.0); glVertex3f(-10.0, -10.0, 10.0); glVertex3f(10.0, -10.0, 10.0);

glEnd; glColor3f(0.5,0.5,0); // Define a cor amarela glBegin(GL_POLYGON); // face 2

glNormal3f(0,0,-1); glVertex3f(10.0, 10.0, -10.0); glVertex3f(10.0, -10.0, -10.0); glVertex3f(-10.0, -10.0, -10.0); glVertex3f(-10.0, 10.0, -10.0);

glEnd;

8

Luz difusa responsável pelo efeito de "degradé" nos objetos;

a cor da luz difusa(r,g,b); a posição da luz(x,y,z). Os passos para fazer isso são: definir cor da luz Ambiente, posição e a cor da Luz Difusa, através de constantes

9

const   LuzAmbiente : Array[0..3] of GLfloat = (0.5, 0.5, 0.5, 1.0);

// Cor da Luz Difusa LuzDifusa : Array[0..3] of GLfloat = (0.8, 0.8, 0.8, 1.0); // Posição da Luz Difusa PosicaoLuz : Array[0..3] of GLfloat = (30.0, 30.0, 0.0, 1.0);

Ativar o uso da luz ambiente e o "Color Tracking"(conforme exemplo anterior)

// Habilita o uso de iluminação

    glEnable(GL_LIGHTING);

// Ativa o uso da luz ambiente

    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, @LuzAmbient);

// Ativa o "Color Tracking"

    glEnable(GL_COLOR_MATERIAL); Definir e ativar uma luz Difusa

Em OpenGl podemos ter até 8 pontos de Luz. Cada um deles designado por uma constante(GL_LIGHT0,

GL_LIGHT1, GL_LIGHT2, ...). NoExemplo a seguir definimos as características da luz de número 0(zero).

   glLightfv(GL_LIGHT0, GL_AMBIENT, @LuzAmbiente);    glLightfv(GL_LIGHT0, GL_DIFFUSE, @LuzDifusa );    glLightfv(GL_LIGHT0, GL_POSITION,@PosicaoLuz );    glEnable(GL_LIGHT0);

// Exibe uma linha da posição da luz até (0,0,0)    glBegin(GL_LINES);    glVertex4fv(@PosicaoLuz);    glVertex3f(0,0,0);

10

Uma luz do tipo Especular é a responsável pela geração de pontos de brilho no objeto; o brilho é da cor da luz; há um ponto a partir do qual ela é emitida; seu brilho é emitido indistintamente em todas as direções;

cada tipo de material(objeto) tem um grau de especularidade (que em outras

palavras define a capacidade de brilho do material). a posição da luz(x,y,z). a cor da luz difusa(r,g,b); a cor da luz especular(r,g,b); a cor especular do objeto(r,g,b); o capacidade de brilho do objeto, ou o grau de concentração do brilho(algo

como o grau de polimento do objeto);

11

definir cor da luz Ambiente, a posição e a cor da Luz Difusa e da Luz especular, através de constantes const

LuzAmbiente : Array[0..3] of GLfloat = (0.5, 0.5, 0.5, 1.0); LuzDifusa : Array[0..3] of GLfloat = (0.4, 0.4, 0.4, 1.0); LuzEspecular: Array[0..3] of GLfloat = (1.0, 0.0, 1.0, 1.0); PosicaoLuz : Array[0..3] of GLfloat = (0.0, 20.0, 60.0, 1.0); Especularidade: Array[0..3] of GLfloat = (0.0, 0.0, 0.0, 1.0);

Ativar o uso da luz ambiente e o "Color Tracking"(conforme exemplo anterior) // Habilita o uso de iluminação     glEnable(GL_LIGHTING); // Ativa o uso da luz ambiente     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, @LuzAmbient); // Ativa o "Color Tracking"     glEnable(GL_COLOR_MATERIAL);

Definir e ativar uma luz Especular // Define os parâmetros da Luz número Zero glLightfv(GL_LIGHT0, GL_AMBIENT, @LuzAmbiente); glLightfv(GL_LIGHT0, GL_DIFFUSE, @LuzDifusa ); glLightfv(GL_LIGHT0, GL_SPECULAR, @LuzEspecular ); glLightfv(GL_LIGHT0, GL_POSITION, @PosicaoLuz ); glEnable(GL_LIGHT0);

Definir a cor especular do obejto // Define a reflectancia do material glMaterialfv(GL_FRONT,GL_SPECULAR, @Especularidade);

Definir o grau de especularidade do objeto // Define a concentração do brilho. // Quanto maior o valor do Segundo parametro, mais concentrado será o brilho. // (Valores válidos: de 0 a 128)

glMateriali(GL_FRONT,GL_SHININESS,20);

12

• Possui primitivas geométricas (pontos, linhas, polígonos e imagens) e operações para especificar os objetos geométricos a serem renderizados em duas ou três dimensões.

• Capaz de gerar imagens de alta qualidade.

• Independente de plataforma.

• Objetos complexos devem ser construídos a partir de primitivas geométricas simples.

13

• Uma vez emitido um vértice (glVertex), este é desenhado com as propriedades (cor, material, normal, coordenadas de textura etc) registradas nas variáveis de estado correspondentes.

• Conclusão: Antes de emitir um vértice, assegurar-se que cor, material, normal e etc, têm o valor certo.

14

Valor Significado

GL_POINTS Pontos individuais

GL_LINES Pares de vértices interpretados como segmentos de reta individuais.

GL_LINE_STRIP Serie de segmentos de reta conectados.

GL_LINE_LOOP Igual ao anterior. Ultimo vertice conectado a primeiro

GL_TRIANGLES Triplas de vértices interpretados como triângulos.

GL_TRIANGLE_STRIP Cadeia triângulos conectados.

GL_TRIANGLE_FAN Leque de triângulos conectados.

GL_QUADS Quadrupla de vértices interpretados como quadriláteros.

GL_QUAD_STRIP Cadeia de quadriláteros conectados.

GL_POLYGON Borda de um polígono convexo simples.

15

16

17

18

19

20

• Todos os comandos começam com o prefixo gl (Ex.: glClearColor).

• As palavras nos nome dos comandos começam com letras maiúsculas (Ex.: glColor()).

• O sufixo indica o número e o tipo dos argumentos (Ex.: glVertex2i(1,3)).

• As constantes começam com GL_ (Ex.: GL_COLOR_BUFFER_BIT).

21

glVertex3fv( v )

Número deNúmero decomponentescomponentes2 - (x,y) 3 - (x,y,z)4 - (x,y,z,w)

Tipo de dadoTipo de dadob - byteub - unsigned bytes - shortus - unsigned shorti - intui - unsigned intf - floatd - double

vetorvetoromita o “v” qdo

coords dadas uma a uma

glVertex2f( x, y )

22

• A OpenGL funciona como uma máquina de estados.

• Os estados correntes permanecem ativos até que sejam modificados.

• Exemplo: a cor de desenho corrente é aplicada a qualquer primitiva geométrica até que seja modificada.

23

• Existem vários estados:

– Cor de desenho corrente.– Transformações de visualização e projeção.– Padrões de linhas e polígonos.– Modo de desenho dos polígonos.– Posição e característica das fontes de luz.– Propriedades dos materiais associados aos objetos.– etc.

24

• Vários estados se referem a modos que estão habilitados ou desabilitados.

• Estes estados são modificados através dos comandos:

– glEnable() e glDisable().– Exemplo: glEnable(GL_LIGHTINING).

25

• Alguns comandos para ler um estado:– glGetBooleanv(), glGetDoublev(), glGetFloatv(),

glGetIntegerv(), glPointerv() ou glIsEnabled().

• Comandos para salvar um estado:– glPushAttrib() e glPushClientAttrib().

• Comandos para restaurar um estado:– glPopAttrib() e glPopClientAttrib().

26

• GLU (OpenGL Utility Library)– Parte do padrão OpenGL.– NURBS, trianguladores, quádricas, etc.

• AGL, GLX, WGL– Camadas entre o OpenGL os diversos sistemas de

janelas.

• GLUT (OpenGL Utility Toolkit)– API portátil de acesso aos sistemas de janelas.– Encapsula e esconde as camadas proprietárias.– Não é parte official do OpenGL.

27

• Rendering – processo através do qual um computador gera imagens a partir de um modelo.

• Pixel – menor elemento visível que um dispositivo gráfico pode apresentar. Uma imagem é formada por vários pixels.

• Plano de bits – área de memória que armazena um bit de informação para cada pixel.

• Framebuffer – estrutura que armazena todas as informações necessárias para que o display gráfico possa controlar a intensidade da cor em cada pixel.

28

PixelsPixels

VérticesVértices

Listas deDisplay

AvaliadorPolinomial

Operaçõespor vértice

& Montagemde primitivas

Rasterização

Memória de Textura

Operaçõespor Fragmento

FrameBuffer

Operaçõessobrepixels

29

Baseado no Jogo Metal Gear

30

}

31

32

33

34

35

#include "Nanna.h“#include <iostream>using namespace std;

void Nanna::draw() { glColor3f(1,0,0); glBegin(GL_QUADS); glVertex3f(this->getX(), this->getY(), 0); glVertex3f(this->getX() + this->getLargura(), this->getY(), 0); glVertex3f(this->getX() + this->getLargura(), this->getY() + this->getAltura(), 0); glVertex3f(this->getX(), this->getY() + this->getAltura(), 0); glEnd();

}36