Silicon Graphics OpenGL - Apresentação Interface para Programação de Aplicações Gráficas –Fornece métodos para programação grãfica –Realiza a interface

Silicon Graphics OpenGL - Apresentação

• Interface para Programação de Aplicações Gráficas– Fornece métodos para programação grãfica

– Realiza a interface entre Software e as chamadas de acesso ao hardware pelo SO.

• Máquina de Estados– A cada estado produz um resultado diferente

– Deve-se habilitar os estados para tal efeito

• Renderizador– Resultado final é uma imagem

O que é?


• Produzir Software que tenha algum conteúdo gráfico Bi ou Tridimensional– Software para produção de gráficos estatísticos

• Produzir Software visual de Simulação– Simuladores de Carro ou de Avião para teste de

performance e qualidade

• Produzir Jogos e Animações– Mercado que vem crescendo desde o surgimento

das áreas

• Outros

O que é?

Para que Serve?


• Define-se a Janela de Contexto– Algumas bibliotecas, como o Glut facilitam essa

operação.

• Define as janelas de Visualização – Caso nenhuma janela de visualização esteja

definida, a janela de contexto será a janela de visualização.

• Define o tipo de Projeção a ser usado– Ortográfica ou

– Perspectiva

O que é?

Para que Serve?

Como Funciona?


• Habilita os estados da máquina de estados– Operações como teste de profundidade,

antialiasing, mapeamento de textura 1D, 2D ou 3D, iluminação, sombras, etc.

• Carrega a matriz Identidade – Para garantir que a matriz do mundo possa ser

recuperada.

• Posiciona a Câmera– De modo a visualizar objetos corretamente.

• {

O que é?

Para que Serve?

Como Funciona?


• Empilha a matriz atual– Para recuperá-la posteriormente

• Realiza transformações ({Rotação, Escala, Translado, Multiplicação de Matriz})

• Realiza processo de renderização– (Aplica Textura)– (Aplica transparência)– (aplica reflexao)– Desenha primitivas

– Recupera matriz do mundo• } • e Desenha na Tela.

O que é?

Para que Serve?

Como Funciona?


• A OpenGL define suas próprias estruturas de dados. Muitas delas são compatíveis com as das linguagens de programação que utiliza sua API, porém apresentaremos as estruturas e a estrutura de nomenclatura das funções da OpenGL:

• Dados primitivos:– os dados primitivos da OpenGL iniciam

com GL e o tipo. • Segue uma tabela com os tipos de dados da

OpenGL e os valores que podem assumir.

O que é?

Para que Serve?

Como Funciona?

Estrutura

Sufixo Est. Dados Em C/C++ Nome OpenGL

b Inteiro 8-bits signed char GLbyte

s Inteiro 16-bits short GLshort

i Inteiro 32-bit long GLint, GLsizei

f ponto flutuante32-bits

float GLfloat, GLclampf

d ponto flutuante64-bits

double GLdouble, GLclampd

ub Inteiro semsinal 8-bits

unsigned char GLubyte, GLboolean

us Inteiro semsinal 16-bits

unsigned short GLushort

ui Inteiro semsinal 32-bits

unsigned long GLuint, GLenum,GLbitfield


O que é?

Para que Serve?

Como Funciona?

Estrutura


• Com os tipos básicos de dados definidos fica fácil reconhecer funções e quais são os tipos de parâmetros de funções da OpenGL.

• As funções OpenGL tem a seguinte estrutura de nomenclatura:

• (biblioteca)nomeDaFunção<n>(sufixo)[v], onde:– biblioteca indica a qual biblioteca a

função pertence, por exemplo, uma função pura da OpenGL inicia com o prefixo gl..., uma da Glu com glu..., etc.

O que é?

Para que Serve?

Como Funciona?

Estrutura


• (biblioteca)nomeDaFunção<n>(sufixo)[v]

– nomeDaFunção é o nome da função a ser usada. Exemplo: gluPerspective, o que indica que é a função perspectiva va biblioteca Glu (GL utility library).

– n indica quantos dados serão passados como parâmetro e

– Sufixo é um dos sufixos dos tipos de dados básicos da openGL, indicando se é Glbyte, Glint, etc. confira a tabela noamente para saber os sufixos possíveis

– o terminador v é opcional e indica que o argumento é um vetor com n componentes do tipo definido.

O que é?

Para que Serve?

Como Funciona?

Estrutura


• Utilizando Visual C++ 6• Inicie novo projeto: Win32 Application• No Menu Project->Settings

– No Tab: “Link”, no campo “Object/Library Modules”, adicione: “OpenGL32.lib”, “Glu32.lib”, “Glaux.lib”

• Adicione um arquivo C++ source ao projeto.• O arquivo deve incluir os seguintes

cabeçalhos:– “windows.h”, “gl/gl.h”, “gl/glu.h”, “gl/glaux.h”,

entre <>, ex: #include <gl/gl.h>

O que é?

Para que Serve?

Como Funciona?

Estrutura

Como Fazer?


• Como trabalharemos sem o auxílio da GLUT, necessita-se de um pouco de conhecimento sobre programação em Windows:

• Declara-se as variáveis globais que o Windows necessita para a definição da Janela de Contexto:– HDC hDC=NULL; //Dispositivo de cont. privado– HGLRC hRC=NULL;/ /Cont. permanente de renderização– HWND hWnd=NULL; // Instância da janela– HINSTANCE hInstance; // Instância da Aplicação

• Quaisquer outras variáveis necessárias para a sua aplicação.

O que é?

Para que Serve?

Como Funciona?

Como Fazer?

Variáveis


• Para que o Programa possa referenciar uma função é necessário definir um protótipo da função em C para referências em qualquer parte do programa.

• Define-se o protótipo da função para tratamento de mensagens do Windows.– LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

O que é?

Para que Serve?

Como Funciona?

Como Fazer?

Variáveis

CallBack?


• Em Windows a rotina principal chama-se WinMain que exige, como parâmetros:– HINSTANCE hInstance, // Instância– HINSTANCE hPrevInstance, // Instância prévia– LPSTR lpCmdLine,// Parâmetros de linha de comando – int nCmdShow // Estado de Exibição da janela

• Com exceção do parâmetro de linha de comando, os outros parâmetros são automaticamente preenchidos pelo Sistema Operacional.

• A primeira coisa a se fazer é declarar a variável que armazenará a estrutura de mensagens do windows: MSG msg;

O que é?

Para que Serve?

Como Funciona?

Como Fazer?

Variáveis

CallBack?

WinMain?


• A rotina principal tem as seguintes obrigações:– Definir o contexto de renderização;– Relizar o loop para:

• Recuperar as mensagens que o SO envia para a janela/aplicação e

• realizar os procedimentos necessários de acordo com a mensagem recebida.

• Estamos prontos para iniciar a configuração da janela de renderização (contexto) e habilitar a OpenGL a realizar os procedimentos para o programa.

O que é?

Para que Serve?

Como Funciona?

Como Fazer?

Variáveis

CallBack?

WinMain?

Como Fazer?

Variáveis

CallBack?

WinMain?


• Inicializaremos a janela de Renderização com o procedimento OGLInit que possuirá os parâmetros:

– String Título

– int largura,

– int altura

– int profundidade de cores (1,2,8,16,32,... E

– bool telacheia

• O Processo de criação do contexto de renderização é de difícil entendimento, porém, segue os seguintes passos:

– Define-se o estilo da janela através de um objeto da classe janela

– Nomeia a classe e tenta registrá-la

OGLInit

Como Fazer?

Variáveis

CallBack?

WinMain?


– Determina se é em tela cheia

• Se for inicializa as configurações

• Tenta mudar os atributos de exibição do SO

– Atribui o modelo de exibição da janela (tela cheia ou janela):

– Tenta criar a janela;

– Define o descritor do formato de pixel para dizer ao Windows como desenhar;

– Tenta recuperar um contexto de dispositivo (para gerenciamento de exibição dependendo do seu monitor)

– Procura um formato de pixel compatível com o descritor;

– Tenta atribuir o descritor de formato de pixel encontrado ao Windows;

– Tenta criar o contexto de renderização;

– tenta ativar o contexto de renderização;

OGLInit

– Mostra a Janela

– Coloca a janela no topo

– Coloca o foco do teclado na janela

– Inicializa as projeções do OpenGL

– Tenta Inicializar os Parâmetors (estados) da OpenGL

– Retorna True se em todas as tentativas obtiver sucesso

Como Fazer?

Variáveis

CallBack?

WinMain?


• As inicializações das projeções serão efetuadas no procedimento ResizeGL() para manter a taxa de aspecto.

• Dois tipos de projeções:– Ortográfica: Preserva Paralelismo entre

retas, não fornece sensação de profundidade e

– Perspectiva: Retas paralelas convergem em um ponto no infinito, retira o paralelismo das retas, fornece sensação de profundidade.

OGLInit

Projeções

Como Fazer?

Variáveis

CallBack?

WinMain?


• Ortográfica:– Verifica se altura=0 (para efeito de prevenção de divisão

por 0). Se for atribua 1 a ela.

– Defina a Viewport (janela de visualização) com o comando: glViewport(0,0,largura,altura);

– Ajuste o modo de definição da matriz para matriz de projeção com o comando: glMatrixMode(GL_PROJECTION);

– com o comando: glLoadIdentity(); definimos a matriz de projeção como sendo a identidade.

– Defina a projeção ortográfica com o comando glOrtho(esq., dir., base, topo, perto longe), onde esses valores definem o volume de visão como na figura a seguir:

OGLInit

Projeções

Como Fazer?

Variáveis

CallBack?

WinMain?


OGLInit

Projeções Esq.

Dir.

Base

Topo

Perto

Longe

Direção do plano de Visão

Como Fazer?

Variáveis

CallBack?

WinMain?


• Ortográfica:– Determinado o Volume de visualização muda-se o modelo

da matriz para o Modelo/Visão, que define os objetos do mundo, com o comando: glMatrixMode(GL_MODELVIEW);

– Recarrega a matriz identidade com o comando glLoadIdentity();

– Retorna do procedimento.

OGLInit

Projeções

Como Fazer?

Variáveis

CallBack?

WinMain?


• Perspectiva:– Verifica se altura=0 (para efeito de prevenção de divisão

por 0). Se for atribua 1 a ela.

– Defina a Viewport (janela de visualização) com o comando: glViewport(0,0,largura,altura);

– Ajuste o modo de definição da matriz para matriz de projeção com o comando: glMatrixMode(GL_PROJECTION);

– com o comando: glLoadIdentity(); definimos a matriz de projeção como sendo a identidade.

– Defina a projeção perspectiva com um dos comandos abaixo:

• glFrustum(esq., dir., base, topo, perto longe)

• gluPerspective(fovy,aspect,zPerto,zLonge), onde esses valores definem o volume de visão como na figura a seguir:

OGLInit

Projeções

Como Fazer?

Variáveis

CallBack?

WinMain?


OGLInit

Projeções Frustum

Esq.Dir.

Base

Topo

Perto Longe

glFrustum(esq.,dir.,base,topo,perto,longe)

Como Fazer?

Variáveis

CallBack?

WinMain?


OGLInit

Projeções

gluPerspective(fovy,aspecto,perto,longe)

Perto Longe

fovy a

l

Aspecto=l/a

Como Fazer?

Variáveis

CallBack?

WinMain?


• Perspectiva:– Determinado o Volume de visualização muda-se o modelo

da matriz para o Modelo/Visão, que define os objetos do mundo, com o comando: glMatrixMode(GL_MODELVIEW);

– Recarrega a matriz identidade com o comando glLoadIdentity();

– Retorna do procedimento.

OGLInit

Projeções

Como Fazer?

Variáveis

CallBack?

WinMain?


• Inicialização dos estados da OpenGL– Habilita os estados da OpenGL para efeitos de

renderização.

– Os comandos são:

– GLShadeModel(modelo), para determinar o tipo de sombreamento usado para iluminação.

– glEnable(GL_Estado), Habilita a OpenGL a realizar os cálculos de renderização para o estado definido. O Estado especifica iluminação, teste de profundidade, transparência, luzes (caso a iluminação esteja habilitada), materiais, textura, etc.

– glClearColor(f,f,f), determina com que cor limpar a tela;

– glClearDepth(f) determina qual a profundidade do buffer de profundidade a ser limpa;

– glHint(chave, valor) determina miscelânea para renderização, tais como cálculo de perspectiva.

OGLInit

Projeções

MEFInit

Como Fazer?

Variáveis

CallBack?

WinMain?


• A qualquer momento, dentro do programa, pode-se desenhar um objeto na tela.

• O procedimento para desenho encontra-se entre os comandos:

– glBegin(tipoDePrimitiva) e glEnd().

• Antes de determinar como se desenha na tela do computador usando a OpenGL precisaremos introduzir as primitivas gráficas suportadas pela OpenGL. São elas:

• Pontos, Linhas, polígonos (não côncavos), triângulos, quadriláteros, malha de linhas, malha de linhas conectadas, malha de triângulos, triânculos centrados e malha de quadriláteros.

• A seguir encontra-se uma figura de como são esses objetos e o s seus nomes para passar como parâmetro para a OpenGL.

OGLInit

Projeções

MEFInit

Desenhando

Como Fazer?

Variáveis

CallBack?

WinMain?


OGLInit

Projeções

MEFInit

Desenhando

Como Fazer?

Variáveis

CallBack?

WinMain?


• Entre os métodos glBegin e glEnd existem apenas um conjunto de funções da OpenGL que são permitidas. São eles:

– glVertex*() - atribui a coordenada do vértice;

– glColor*() - atribui uma cor ao vértice

– glIndex*() - atribui o índice de cor (apenas se trabalharmos com o modo indexado de cores)

– glNormal*() - Atribui uma normal ao vértice (ou ao plano)

– glEvalCoord*() - calcula coordenadas

– glCallList() glCallLists() - executa listas de exibição

– glTexCoord*() atribui coordenadas de textura

– glEdgeFlag*() - controla desenho de bordas

– glMaterial*() - atribui propriedades de reflexão

• * significa que o método possui n parâmetros ,sufixo e pode possuir o terminador v;

OGLInit

Projeções

MEFInit

Desenhando

Como Fazer?

Variáveis

CallBack?

WinMain?


• Portanto, caso desejemos desenhar um triângulo vermelho cujos vértices estão definidos pelos vetores (matrizes linha) v1,v2 e v3 e cuja normal é definida pelo vetor n procederíamos de uma das seguintes formas:

• glBegin(GL_TRIANGLE);

• glColor3f(1.0f,0.0f,0.0f);

• glNormal3fv(*n);

• glVertex3fv(*v1);



• glEnd();

• ou:

OGLInit

Projeções

MEFInit

Desenhando

Como Fazer?

Variáveis

CallBack?

WinMain?


• glBegin(GL_TRIANGLE);

• glColor3f(1.0f,0.0f,0.0f);

• glNormal3f(n[0],n[1],n[2]);

• glVertex3f(v1[0],v1[1],v1[2]);

• glVertex3f(v2[0], v2[1], v2[2]);

• glVertex3f(v3[0], v3[1], v3[2]);

• glEnd();

• repare que como as funções chamadas terminam em 3f os vetores devem ser do tipo Glfloat e possuir três elementos.

• Entre os comandos glBegin e glEnd podem vir quaisquer outros comandos que a linguagem de programação permitir.

OGLInit

Projeções

MEFInit

Desenhando

Como Fazer?

Variáveis

CallBack?

WinMain?


• Para visualizar efetivamente a Cena deve-se especificar a posição e orientação da câmera hipotética que irá registrá-la.

• Isso é realizado especificando a posição da câmera, ou seja, do plano de visão;

• A direção para onde a câmera aponta e

• O vetor que indica a direção de cima (upVector) da câmera.

• Em OpenGL define-se a câmera em qualquer parte do código (exceto entre glBegin() e glEnd()) co mo comando:

• gluLookAt(Xc,Yc,Zc,Xd,Yd,Zd,Xu,Zu,Du);

OGLInit

Projeções

MEFInit

Desenhando

E a Cena?

Como Fazer?

Variáveis

CallBack?

WinMain?


•Transformações

OGLInit

Projeções

MEFInit

Desenhando

Como Fazer?

Variáveis

CallBack?

WinMain?

Silicon Graphics OpenGL - Transformações

• Procedimentos utilizados para:

– Modificar o valor de cada vértice de um objeto

• V’=Mtn.Mtn-1.(...).Mt2.Mt1.V

– Modificar o Valor da matriz de exibição do mundo

– Objetivo: Posicionar os objetos no mundo de maneira a compor a cena desejada.

O que são?

Como Fazer?

Variáveis

CallBack?

WinMain?


• Translação:

– Move linearmente um vértice de uma posição a outra do espaço cartesiano

• Rotação:– Rotaciona (translada de maneira circular)

um ponto em torno de um eixo na angulação desejada

• Escala: – Altera o tamanho de um objeto por

transladar os vértices do mesmo de maneira desigual.

O que são?

Quais São?

Como Fazer?

Variáveis

CallBack?

WinMain?


• Definido pela Matriz:– 1 0 0 Tx– 0 1 0 Ty– 0 0 1 Tz– 0 0 0 1

• No OpenGL glTranslate(s)[v](Tx,Ty,Tz) ou:– 1 0 0 0– 0 1 0 0– 0 0 1 0– Tx Ty Tz 1 e pelo comando

glMultMat{f,v}(const TIPO *mat)

O que são?

Quais São?

Pilha de Matriz

Como Fazer

Translação

Como Fazer?

Variáveis

CallBack?

WinMain?


• Definido por Matriz:– Seja v=(x,y,z)T e u=v/||v||=(x’,y’,z’).– Seja também S, a matriz:– 0 -z’ y’– z’ 0 -x’– -y’ x’ 0– A matriz de Rotação R será (m representam os

elementos de M):– m m m 0– m m m 0– m m m 0– 0 0 0 1– Dado que: M=u.uT+(cos a).(I-u.uT)+(sen a).S

O que são?

Quais São?

Pilha de Matriz

Como Fazer

Translação

Rotação

Como Fazer?

Variáveis

CallBack?

WinMain?


• No OpenGL utiliza-se o comando:

– glRotate(s)[v](a,x,y,z) ou o comando

– glMultMatriz{f,d}(const TIPO mat*), onde *mat é o vetor bidimensional contendo a transposta da matriz R previamente apresentada.

O que são?

Quais São?

Pilha de Matriz

Como Fazer

Translação

Rotação

Como Fazer?

Variáveis

CallBack?

WinMain?


• Definido pela Matriz E=:– Sx 0 0 0– 0 Sy 0 0– 0 0 Sz 0– 0 0 0 1

• No OpenGL glScale(s)[v](Tx,Ty,Tz) ou:• glMultMat{f,d}(const TIPO *mat), onde

mat é um vetor bidimensional da matriz transposta de E fornecida acima.

O que são?

Quais São?

Pilha de Matriz

Como Fazer

Translação

Rotação

Escala

Como Fazer?

Variáveis

CallBack?

WinMain?


• Ao executar os comandos gl(Rotate,Translate,Scale)* a OpenGL modifica a matriz do Mundo e o resultado final da cena será:

• R=Mm.Mp.Objeto• Para recuperar a matriz do Mundo prévia à

operação realizada existem 2 procedimentos:– Multiplicar a matriz do mundo pela

matriz inversa da operação realizada ou– Empilhar a matriz do mundo atual,

realizar as operações desejadas e desempilhá-la novamente.

O que são?

Quais São?

Pilha de Matriz

Como Fazer

Como Fazer?

Variáveis

CallBack?

WinMain?


• Manipulando a pilha de matrizes:– Comandos:

• glPushMatrix(): empilha a matriz do Mundo

• glPopMatriz(): Desempilha a matriz do mundo

• OpenGL suporta até 32 matrizes de ordem 4 e inicia com 2 matrizes de ordem 4, uma sendo a matriz de projeção e outra sendo a matriz inicial do mundo

O que são?

Quais São?

Pilha de Matriz

Como Fazer?

Variáveis

CallBack?

WinMain?


• Quaisquer transformações ou comando para empilhar matrizes:

• Antes de executar o comando glBegin(primitiva) e/ou depois do comando glEnd()

O que são?

Quais São?

Pilha de Matriz

Como Fazer

Como Fazer?

Variáveis

CallBack?

WinMain?


•Iluminação

OGLInit

Projeções

MEFInit

Desenhando

Como Fazer?

Variáveis

CallBack?

WinMain?

Silicon Graphics OpenGL - Iluminação

• Criar a sensação de Profundidade

– Sem iluminação Objetos parecem planos

• Adicionar Realismo à cena

– A sensação de profundidade provê mais realismo

• Deixar a cena mais bonita.

Para que serve?

Como Fazer?

Variáveis

CallBack?

WinMain?


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

Para que serve?

Exemplos

Como Fazer?

Variáveis

CallBack?

WinMain?


• Criadas através de Fontes de luz:

– Um ponto no Infinito (ex: o Sol)

– Um ponto próximo (ex: uma lâmpada incandescente)

– Uma fonte de luz distribuída (ex: lâmpadas de Neon ou de Gás)

• Alteram um dos 3 Modelos de Iluminação:

– Luz Ambiente: modelo básico de iluminação (padrão no OpenGL), o objeto não é iluminado diretamente pela fonte de luz, mas pela luz refletida de outros objetos. É uma aproximação do efeito global de iluminação difusa.

Para que serve?

Exemplos

Luzes

Como Fazer?

Variáveis

CallBack?

WinMain?


– Reflexão Difusa: Iluminação constante sobre a superfície independente da direção do espectador. A quantidade fracional de luz incidente que é difusamente refletida pode ser ajustada pelo parâmetro Kd=[0,1] (coeficiente de reflexão difusa)

– O raio de luz reflete de acordo com a angulação relativa á normal do plano tangente à superfície atingida.

Para que serve?

Exemplos

Luzes

Como Fazer?

Variáveis

CallBack?

WinMain?


– Reflexão Especular: Iluminação não constante sobre a superfície. A quantidade fracional de luz incidente pode ser totalmente refletida, causando o efeito do Ponto Brilhante no objeto. (ex: maçã, metais, vidros, etc.)

– O raio de luz reflete de acordo com a angulação relativa á normal do plano tangente à superfície atingida, porém sua intensidade não é constante (como na reflexão difusa).

Para que serve?

Exemplos

Luzes

Como Fazer?

Variáveis

CallBack?

WinMain?


• Exemplos de Iluminações:

Para que serve?

Exemplos

LuzesCor: Ambiente+Difusa

Iluminação especular:

Como Fazer?

Variáveis

CallBack?

WinMain?


• Luzes em OpengL:– Vetores quadridimensionais representando os

valores R,G,B e alfa.

– GLfloat Luz[]={ 0.5f,0.5f,0.5f,1.0f };

– No OpenGL a luz ambiente iluminará toda a cena, pois ela não é proveniente de um ponto específico.

– Declara-se a luz ambiente da seguinte forma:

– glLightfv(GL_LIGHT1, GL_AMBIENT, Luz)

– Onde: Light1 é a variável interna da OpenGL que armazenará os atributos para a luz.

– GL_AMBIENT é a constante que identifica o tipo de iluminação e Luz é a cor da iluminação.

Para que serve?

Exemplos

Luzes

Representação

Como Fazer?

Variáveis

CallBack?

WinMain?


– Para a luz difusa :

– Ilumina todo e qualquer objeto que esteja no raio de iluminação

– Para isso, precisa-se de uma posição para a fonte de luz:

– glFloat Posicao=(x,y,z,p), onde p indica se a luz é posicional ou se ela é direcional(está no infinito)

– Defina a luz: glLightfv(GL_LIGHT1, GL_DIFFUSE, Luz);

– e a posição: glLightfv(GL_LIGHT1, GL_POSITION,posicao);

Para que serve?

Exemplos

Luzes

Representação

Como Fazer?

Variáveis

CallBack?

WinMain?


• Onde definir?

• As luzes devem ser definidas fora do escopo glBegin(...) e glEnd(), pois os comandos glEnable e glLight(s)[v]não são permitidos dentro desse escopo.

• A OpenGL permite até 8 luzes definidas no ambiente.

• A luz especular é definida de maneira idêntica à ambiente, com a exceção de que a variável do modelo de iluminação é GL_SPECULAR

• Leitura Recomendada: OpenGL RedBook para maiores informações sobre Iluminação.

Para que serve?

Exemplos

Luzes

Representação

Como Fazer?

Variáveis

CallBack?

WinMain?


• As declarações de iluminação serão, em nosso exemplo, realizadas dentro do procedimento MEFInit, responsável por ajustar a máquina de estados da OpenGL no estado inicial para os procedimentos de desenho.

• Considerando que os vetores de definição das cores da luz e do posicionamento da luz difusa já estão definidos declara-se os seguintes comandos:

• glLightfv(GL_LIGHTn, GL_AMBIENT,Luz1)• glLightfv(GL_LIGHTn, GL_DIFFUSE,Luz2)• glLightfv(GL_LIGHTn, GL_POSITION,pos)• E habilita-se a luz GL_LIGHTn com os comandos:• glEnable(GL_LIGHTn)• e glEnable(GL_LIGHTING)

Para que serve?

Exemplos

Luzes

Representação

Como Fazer?

Como Fazer?

Variáveis

CallBack?

WinMain?


•Materiais

Para que serve?

Exemplos

Luzes

Representação

Como Fazer?

Como Fazer?

Variáveis

CallBack?

WinMain?

Silicon Graphics OpenGL - Materiais

• Estruturas que indicam como o objeto refletirá a luz– O quanto de cada componente da luz é

refletido,– como a luz será refletida e– Luz emitida (pelo próprio objeto)

O que são?

Como Fazer?

Variáveis

CallBack?

WinMain?


• Idêntico ao definido pela física óptica (exceto a refração)

• Objetos sob luz branca refletirão a componente do material atribuído ao objeto

• Cada tipo de iluminação tem uma cor a ser refletida

• A intensidade da cor pode ser modificada pelo coeficiente de reflexão especular

O que são?

Funcionamento

Como Fazer?

Variáveis

CallBack?

WinMain?


• Cor de reflexão difusa do material=(Rm,Gm,Bm)=(255,0,0)

• Cor da luz emitida pela fonte de luz=(Re,Ge,Be)=(0,255,255)

• Cor da luz refletida (pela iluminação difusa) (Id) = (min(Rm,Re),min(Gm,Ge),min(Bm,Be))= (0,0,0)

• Cor do objeto a ser desenhado na tela=Ia+Id+Ie

• Cor do pixel a ser desenhado na tela=Ia+Id+Is

O que são?

Funcionamento

Como Fazer?

Variáveis

CallBack?

WinMain?


• O material é definido pelas cores de reflexão ambiente, difusa, especular e de emissão e pelo coeficiente de brilho (Shininess).

• As cores são definidas através de um vetor quadridimensional representando os coeficientes R,G,B e alfa da cor (assim como é feito para as luzes).

• O coeficiente de Brilho é um valor escalar e indica o expoente especular do material.

O que são?

Funcionamento

Representação

Como Fazer?

Variáveis

CallBack?

WinMain?


• Os materiais são definidos internamente no OpenGL através do comando:

• glMaterial(s)[v](FRONT,Modelo,Dado), onde:

• Modelo=GL_AMBIENT,GL_DIFFUSE, GL_SPECULAR, GL_EMISSION ou GL_SHININESS e

• Dado é o dado de definição de cor do material ou o coeficiente exponencial para a reflexão especular (expoente especular).

O que são?

Funcionamento

Representação

Como Fazer?

Como Fazer?

Variáveis

CallBack?

WinMain?


• Glfloat mat=(1.0f,0.0f,0.0f,1.0f);

• GLfloat bri=50.0f;

• ...

• (Rotina de desenho)

• glPushMatrix()

• glMaterialfv(FRONT,GL_AMBIENT,mat);

• glMaterialfv(FRONT,GL_DIFFUSE,mat);

• glMaterialfv(FRONT,GL_SPECULAR,mat);

• glMaterialfv(FRONT,GL_EMISSION,mat);

• glMaterialfv(FRONT,GL_AMBIENT,bri);

• glBegin;...

• glEnd();}...

O que são?

Funcionamento

Representação

Como Fazer?

C:\My Documents\Tutors\lightmaterial.exe

Silicon Graphics OpenGL - Transparência

• Transparência (Blending)

O que são?

Funcionamento

Representação

Como Fazer?

Como Fazer?

Variáveis

CallBack?

WinMain?


• Método para deixar objetos transparentes;

• Combina cores de objetos que já estão no buffer de profundidade com os objetos (transparentes) desenhados;

• Cria efeitos visuais avançados;

• Não funciona para partes de objetos, apenas para objetos inteiros;

Transparencia?

Como Fazer?

Variáveis

CallBack?

WinMain?


• Utiliza o valor Alfa da cor do objeto para cálculo da transparência;

• Ocorre após a rasterização da cena, mas antes da plotagem dos pixels;

• O valor Alfa pode ser usado no alpha test para aceitar ou rejeitar um fragmento baseado no valor alfa;

• Sem o blending os objetos são desenhados considerando Opacidade plena.

• Com o Blending controla-se o quanto da cor existente deve ser combinada com o novo fragmento.

Transparencia?

Funcionamento

Como Fazer?

Variáveis

CallBack?

WinMain?


• Pensamento natural:

– RGB=cor, Alfa=opacidade– Visão se um objeto através de um vidro

verde:• Parte verde, proveniente do vidro,

• Parte outra cor, proveniente de objetos

• A porcentagem varia dependendo da propriedade de transmissão do vidro

• Se o vidro transmite 80% da luz que incide nele (opacidade de 20%), então 20% será verde (cor do vidro) e 80% será a cor do objeto que se vê através do vidro.

Transparencia?

Funcionamento

Como Fazer?

Variáveis

CallBack?

WinMain?


• Resultado final depende dos fatores Fonte e Destino;

– Durante o blending:• valores do fragmento em processo

(fonte) e • valores de cor do pixel armazenado

(destino)• São combinados através de um

processo de 2 estágios.

Transparencia?

Funcionamento

Como Fazer?

Variáveis

CallBack?

WinMain?


• Especifica-se como computar os fatores Fonte e Destino;

• Tais fatores são quádruplas RGBA que são multiplicados por cada componente RGBA da fonte e do destino, respectivamente;

• Os resultados são, então, adicionados.

Transparencia?

Funcionamento

Como Fazer?

Variáveis

CallBack?

WinMain?


• Matematicamente:– Sejam os fatores de blending da

fonte e do destino: (Sr,Sg,Sb,Sa) e (Dr,Dg,Db,Da) respectivamente;

– Seja os valores RGBA da fonte e destino: (Rs,Gs,Bs,As) e (Rd,Gd,Bd,Ad) respectivamente;

– O valor RGBA final será:(RsSr+RdDr,GdDg+GsSg,BsSb+BdDb,AsSa+AdDa)Cada componente dessa quádrupla será limitado ao

intervalo [0,1] e modificado se necessário.

Transparencia?

Funcionamento

Como Fazer?

Variáveis

CallBack?

WinMain?


• Gerando os Fatores Fonte e Destino:– através da função glBlendFunc(Glenum sf,Glenum df)– Glenum é um vetor com quatro elementos (R,G,B,A).– OpenGL define alguns fatores padrão:– GL_ZERO=(0,0,0,0)– GL_ONE=(1,1,1,1)– GL_DST_COLOR=cor do píxel destino– GL_SRC_COLOR=Cor do pixel fonte– GL_ONE_MINUS_DST_COLOR– GL_ONE_MINUS_SRC_COLOR– GL_SRC_ALPHA– GL_ONE_MINUS_SRC_ALPHA– GL_DST_ALPHA– GL_ONE_MINUS_DST_ALPHA– GL_SRC_ALPHA_SATURATE

Transparencia?

Funcionamento

Como Fazer?

Variáveis

CallBack?

WinMain?


• Cada fator tem um Fator relevante a ser usado na função glBlendFunc;

• Nem todas as combinações dos fatores fonte e destino fazem sentido;

• Alguns usos práticos para os fatores serão vistos no slide seguinte;

• A tabela a seguir demonstra os fatores relevantes para cada variável definida no slide anterior:

Transparencia?

Funcionamento

Como Fazer?

Variáveis

CallBack?

WinMain?


• Desenha figura composta metade de um objeto, metade de outro: – Source=GL_ONE, – desenhe a imagem fonte; – Source e Destiny=GL_SRC_ALPHA e– Desenhe a 2a. Imagem com alfa=0.5.

• Desenhar 3 imagens igualmente: • source=GL_ONE, • desenhe, e • as seguintes proceda da mesma maneira que

anteriormente, com alfa=0.3333333

Transparencia?

Funcionamento

Como Fazer?

Variáveis

CallBack?

WinMain?


• Habilite o BLEND em qualquer parte do programa (exceto no escopo do glBegin() e glEnd()) com o comando glEnable(GL_BLEND);

• Desabilite a máscara de profundidade: glDepthMask(GL_FALSE);

• Defina como ocorrerá o blend com a função glBlendFunc(srcfctr,dstfctr)

• Desenhe;• Habilite a máscara de profundidade e

desabilite o blend.

Transparencia?

Funcionamento

Como Fazer?

Como Fazer?

Silicon Graphics OpenGL - Antialiasing

•ANTIALIASING

Transparencia?

Funcionamento

Como Fazer?

Como Fazer?

Variáveis

CallBack?

WinMain?


• Método para eliminar o efeito “escada” de linhas com inclinação no intervalo |(0o,90o)|

• Ocorre devido aos pixels serem um método discreto de desenho.

O que é?

Como Fazer?


• Calcula-se qual a porcentagem da reta contida no pixel (p)

• Realiza um Blending com a cor do pixel de acordo com a porcentagem calculada.

O que é?

Funcionamento

Como Fazer?


• Em OpenGL pode-se implementar um algoritmo que faça o antialiasing utilizando Blending ou

• Habilitar a Máquina de Estados para realizar o trabalho automaticamente.

• Usa-se os comandos:– void glHint(GLenum target,

GLenum hint); e– glEnable(GL_POINT_SMOOTH)

ou glEnable(GL_LINE_SMOOTH)• Onde os parâmetros target e hint são:

O que é?

Funcionamento

Como Fazer?

Como Fazer?


• GL_POINT_SMOOTH_HINT, GL_LINE_SMOOTH_HINT, GL_POLYGON_SMOOTH_HINT

– Especifica a qualidade de amostragem de pontos, linhas ou pol~igonos desejada durante a operação de antialiasing;

• GL_FOG_HINT– Especifica se os cálculos para geração de

neblina serão feitos por pixel (GL_NICEST) ou por vértice (GL_FASTEST);

O que é?

Funcionamento

Como Fazer?

Como Fazer?


• GL_PERSPECTIVE_CORRECTION_HINT

– Especifica a qualidade de cores e de interpolação de coordenadas de textura desejadas;

O que é?

Funcionamento

Como Fazer?

Como Fazer?

Silicon Graphics OpenGL - Neblina

•Neblina

O que é?

Funcionamento

Como Fazer?

Como Fazer?


• Um método para fazer objetos desaparecerem de acordo aom a distância em uma dada direção;

• Produz cenas mais realistas;

• é um termo geral usado para descrever efeitos atmosféricos similares;

• pode ser usado para simular neblina, fumaça ou poluição;

• É muito utilizado em aplicações de simulação visual, onde a visibilidade limitada precisa ser aproximada.

O que é?

Como Fazer?


• Combina a cor da neblina com a cor do objeto a ser desenhado de acordo com o fator de blending da neblina;

• Esse fator, f, é computado por uma das 3 equações a serem mostradas e limitado ao intervalo [0,1];

O que é?

Funcionamento


• Onde z é a distância entre o ponto de visão e o centro do fragmento;

• Os valores para density, start e end são especificados no comando glFog(GLenum pname, TIPO param);

• caso pname seja GL_FOG_MODE, a variável param deve ser GL_EXP, GL_EXP2 ou GL_LINEAR;

• se pname for GL_FOG_DENSITY, GL_FOG_START ou GL_FOG_END, param é (ou aponta para) o valor de density, start ou end na equação;

O que é?

Funcionamento

Como Fazer?


• Os valores padrão são 1,0 e 1, respectivamente;

• Se pname for GL_FOG_COLOR, então param é (ou aponta para) o conjunto de valores que especifica a cor da neblina;

• A figura a seguir demonstra o gráfico das funções de visibilidade GL_EXP, GL_EXP2 e GL_LINEAR:

O que é?

Funcionamento

Como Fazer?


• Primeiramente habilita-se a máquina de estados a gerar a neblina com glEnable(GL_FOG);

• Ajusta o modo da neblina com glFog(s): glFogi(GL_FOG_MODE,GL_EXP);

• aplica a cor da neblina com glFog(s)[v]: glFogfv(GL_FOG_COLOR,*cor);

• determina a densidade da neblina: glFogf(GL_FOG_DENSITY,0.35f);

• determina como será o cálculo da neblina: glHint(GL_FOG_HINT,GL_DONT_CARE)

O que é?

Funcionamento

Como Fazer?

Como Fazer?

Silicon Graphics OpenGL - Textura

•Mapeamento de Textura

O que é?

Funcionamento

Como Fazer?


• Método para se aplicar uma imagem a um objeto geométrico;

• Reduz complexidade de construção de cenas;

• Um muro pode ser formado com diversas primitivas (paralelepípedos) representando os tijolos ou

• Com um único paralelepípedo e uma textura de Tijolos aplicada a ele.

O que é?


• Especifica-se uma imagem ao OpenGL;– Imagem=Matriz bidimensional com

valores de cores (pixels);• Indica como a imagem será aplicada a

cada pixel renderizado;• Habilita mapeamento de Textura e• Desenha a cena especificando ambas

as coordenadas geométricas e de textura.

O que é?

Funcionamento


• OpenGL não possui métodos para carregar imagens, deve ser implementado pelo programador;

• Através de MipMapping especifica-se uma única textura em muitas resoluções diferentes evitando aplicar uma textura com resolução completa a um fragmento distante do ponto de visão (aumentando performance)

O que é?

Funcionamento

Especificando


• Existem 2 comandos para especificar a textura com os dados carregados na memória:

– glTexImage2D, para texturas bidimensionais (imagens)

– glTexImage1D, para texturas unidimensionais (funções)

O que é?

Funcionamento

Especificando


• glTexImage2D: Parâmetros:– GLenum target: reservado para uso futuro;– Glint nível: usado se for especificado múltiplas

resoluções para cálculo de MipMapping (LOD)– Glint Componentes: inteiro de 1 a 4 indicando

qual dos componentes (R,G,B ou A) será usado para modulação ou transparência;

– GLsizei width, GLsizei height: Respectivamente: :Largura e altura da imagem;

– Glint Borda: Indica a largura da borda (geralmente zero)

– GLenum Formato, GLenum Tipo: Descrevem o formato e o tipo de dados dos dados da imagem da textura

O que é?

Funcionamento

Especificando


• glTexImage2D: Parâmetros:– GLvoid *pixels: Contêm os dados da imagem-

textura, que descreve a imagem em si.

– Supondo que carregamos uma imagem na memória e que seus pixels estão definidos no formato RGBA, especificamos uma textura da seguinte forma:

– glTexImage2D(GL_TEXTURE_2D,0,3,32,32,0,GL_RGBA,GL_UNSIGNED_BYTE,&imagem)

O que é?

Funcionamento

Especificando


• Controle de Filtros:– Após especificarmos a imagem precisamos

especificar como ela será tratada, pois as imagens são retangulares e podem ser aplicadas a objetos não retangulares;

– Existem 2 classes de filtros para texturas:

• Filtro de Magnificação, caso a porção da imagem mapeada seja maior que a porção definida e

• Filtro de Minificação, caso a porção da imagem mapeada seja menor que a porção definida.

O que é?

Funcionamento

Especificando


• Controle de Filtros:– O Comando OpenGL para a especificação dos filtros é:

glTexParameteri(GL_Texture2D,filtro,procedimento), onde

– Filtro é GL_TEXTURE_MAG_FILTER ou

– GL_TEXTURE_MIN_FILTER

– E procedimento é dado pela tabela:

O que é?

Funcionamento

Especificando

GL_TEXTURE_MAG_FILTER GL_NEAREST

GL_LINEAR

GL_TEXTURE_MIN_FILTER GL_NEAREST

GL_LINEAR

GL_NEAREST_MIPMAP_NEAREST

GL_NEAREST_MIPMAP_LINEAR

GL_LINEAR_MIPMAP_NEAREST

GL_LINEAR_MIPMAP_LINEAR


• Controle de Filtros:– Métodos:

• GL_NEAREST: Utiliza o texel cujas coordenadas se aproxima do centro do Pixel, pode causar aliasing;

• GL_LINEAR: Utiliza uma função linear para combinar os texels envolvidos no processo, produz resultados visivelmente melhores;

• GL_NEAREST_MIPMAP_NEAREST: Procura o MipMap cujo texel cujas coordenadas se aproximam do centro do Pixel de maneira mais eficiente;

• GL_NEAREST_MIPMAP_LINEAR: Procura o MipMap cujo texel cujas coordenadas se aproximam do centro do Pixel de maneira mais eficiente e calcula a contribuição dos outros texels para o cálculo da cor a ser aplicada no pixel;

O que é?

Funcionamento

Especificando


• Controle de Filtros:– Métodos:

• GL_LINEAR_MIPMAP_NEAREST: Procura o MipMap cujo texel cujas coordenadas se aproximam do centro do Pixel de maneira mais eficiente e calcula, de acordo com os outros MipMaps (anterior ou posterior) as contribuições do texel para o pixel;

• GL_LINEAR_MIPMAP_LINEAR: Procura o MipMap cujo texel cujas coordenadas se aproximam do centro do Pixel de maneira mais eficiente e calcula , de acordo com outros MipMaps (anterior ou posterior) a contribuição dos outros texels vizinhos para o cálculo da cor a ser aplicada no pixel;

O que é?

Funcionamento

Especificando


• Controle de Filtros:– Definindo método de aplicação:

• A textura é definida através de uma imagem bidimensional com dimensões x e y;

• Ao se aplicar a textura em um objeto, pode ocorrer que coordenadas de texels estejam fora do limite da imagem;

• Define-se o comportamento da textura para quando isso ocorre através da função glTexParameter(i,f)[v](target,pname,param),

• Onde Target deve sempre ser GL_TEXTURE_1D ou GL_TEXTURE_2D;

O que é?

Funcionamento

Especificando


• Controle de Filtros:– glTexParameter(i,f)[v](target,pname,param), :

• Pname pode ser: GL_TEXTURE_WRAP_S, para o comportamento no eixo S (Largura) ou

• GL_TEXTURE_WRAP_T, para o comportamento no eixo T (altura);

• Param é o valor assumido e pode ser:• GL_REPEAT (repete a textura) ou• GL_CLAMP (Copia a última linha ao longo

do resto da textura)

O que é?

Funcionamento

Especificando


• Existem 3 funções possíveis para computar a cor final do objeto a ser desenhado:

– Usar a cor da textura como cor final;

– Modular a cor da textura de acordo com a cor do material do objeto ou

– Combinar a cor da textura com a cor do fragmento a ser desenhado;

O que é?

Funcionamento

Especificando

Como Aplicar?


• Modulação e Transparência:– Especifica como a textura será aplicada à

geometria;

– É obtida através da função glTexEnv(i,f)[v](Target,pname,param)

– Target deve sempre ser GL_TEXTURE_ENV;

– Se pname for GL_TEXTURE_ENV_MODE, param pode ser:

• GL_DECAL: Simplesmente aplica a textura e a cor do pixel será a cor do texel da textura atribuido a ele;

• GL_MODULATE: Modula a cor da textura de acordo com o material do objeto ou

• GL_BLEND: Aplica transparência à textura permitindo transparência seletiva na textura.

O que é?

Funcionamento

Especificando

Como Aplicar?


• Para habilitar o mapeamento de textura utiliza-se a função glEnable com um dos dois parâmetros:

– GL_TEXTURE_1D: para texturas unidimensionais ou

– GL_TEXTURE_2D: para texturas bidimensionais;

O que é?

Funcionamento

Especificando

Como Aplicar?

Habilitando


• Entre o glBegin e glEnd e para cada vértice utiliza-se a função:

• glTexCoord(1,2)(f,d)[v](dado) para especificar qual coordenada de textura (texel) aplicar àquele vértice.

• Ou, Deixar a OpenGL calcular as coordenadas automaticamente.

• (Trabalho para graduação)

O que é?

Funcionamento

Especificando

Como Aplicar?

Habilitando

Desenhando