Silicon Graphics OpenGL - Apresentação
• Interface para Programação de Aplicações
Gráficas
O que é?
– 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
Silicon Graphics OpenGL - Apresentação
• Produzir Software que tenha algum
conteúdo gráfico Bi ou Tridimensional
O que é?
– Software para produção de gráficos estatísticos
• Produzir Software visual de Simulação
Para que Serve?
– 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
Silicon Graphics OpenGL - Apresentação
• Define-se a Janela de Contexto
O que é?
– Algumas bibliotecas, como o Glut facilitam essa
operação.
• Define as janelas de Visualização
Para que Serve?
Como Funciona?
– 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
Silicon Graphics OpenGL - Apresentação
• Habilita os estados da máquina de estados
O que é?
Para que Serve?
Como Funciona?
– 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.
• {
Silicon Graphics OpenGL - Apresentação
• Empilha a matriz atual
– Para recuperá-la posteriormente
O que é?
Para que Serve?
Como Funciona?
• 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.
Silicon Graphics OpenGL - Apresentação
O que é?
Para que Serve?
Como Funciona?
Estrutura
• 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.
Silicon Graphics OpenGL - Apresentação
O que é?
Para que Serve?
Como Funciona?
Estrutura
Sufixo Est. Dados
b
Inteiro 8-bits
Em C/C++
signed char
Nome OpenGL
GLbyte
s
Inteiro 16-bits
short
GLshort
i
Inteiro 32-bit
long
GLint, GLsizei
f
ponto flutuante
32-bits
ponto flutuante
64-bits
Inteiro sem
sinal 8-bits
Inteiro sem
sinal 16-bits
Inteiro sem
sinal 32-bits
float
GLfloat, GLclampf
double
GLdouble, GLclampd
unsigned char
GLubyte, GLboolean
d
ub
us
ui
unsigned short GLushort
unsigned long
GLuint, GLenum,
GLbitfield
Silicon Graphics OpenGL - Apresentação
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.
Silicon Graphics OpenGL - Apresentação
• (biblioteca)nomeDaFunção<n>(sufixo)[v]
O que é?
Para que Serve?
Como Funciona?
Estrutura
– 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.
Silicon Graphics OpenGL - Apresentação
Como
O que
Fazer?
é?
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>
Silicon Graphics OpenGL - Apresentação
Como
O que
Fazer?
é?
Para
Variáveis
que Serve?
Como Funciona?
• 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.
Silicon Graphics OpenGL - Apresentação
Como
O que
Fazer?
é?
Para
Variáveis
que Serve?
Como
CallBack?
Funciona?
• 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);
Silicon Graphics OpenGL - Apresentação
• Em Windows a rotina principal chama-se
WinMain que exige, como parâmetros:
Como
O que
Fazer?
é?
Para
Variáveis
que Serve?
Como
CallBack?
Funciona?
WinMain?
–
–
–
–
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;
Silicon Graphics OpenGL - Apresentação
Como
O que
Fazer?
é?
Para
Variáveis
que Serve?
Como
CallBack?
Funciona?
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.
Silicon Graphics OpenGL - Apresentação
Como
OGLInit
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
Silicon Graphics OpenGL - Apresentação
Como
OGLInit
Fazer?
Variáveis
–
–
–
–
–
–
–
–
CallBack?
–
WinMain?
–
–
–
–
Mostra a Janela
Determina
se é em tela cheia
Coloca
• Se for
a janela
inicializa
no topo
as configurações
Coloca
• Tenta
o foco
mudar
doos
teclado
atributos
na janela
de exibição do SO
Atribui o modelo
Inicializa
as projeções
de exibição
do OpenGL
da janela (tela cheia ou
janela):
Tenta Inicializar os Parâmetors (estados) da OpenGL
Tenta
criar
a janela;
Retorna
True
se em todas as tentativas obtiver sucesso
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;
Silicon Graphics OpenGL - Apresentação
Como
OGLInit
Fazer?
Projeções
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.
Silicon Graphics OpenGL - Apresentação
• Ortográfica:
Como
OGLInit
Fazer?
Projeções
Variáveis
CallBack?
WinMain?
– 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:
Silicon Graphics OpenGL - Apresentação
Como
OGLInit
Fazer?
Projeções
Variáveis
Topo
Esq.
Dir.
CallBack?
Direção
do plano de Visão
W
inMain?
Base
Perto
Longe
Silicon Graphics OpenGL - Apresentação
• Ortográfica:
Como
OGLInit
Fazer?
Projeções
Variáveis
CallBack?
WinMain?
– 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.
Silicon Graphics OpenGL - Apresentação
• Perspectiva:
Como
OGLInit
Fazer?
Projeções
Variáveis
CallBack?
WinMain?
– 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:
Silicon Graphics OpenGL - Apresentação
glFrustum(esq.,dir.,base,topo,perto,longe)
Como
OGLInit
Fazer?
Projeções
Variáveis
Topo
Frustum
Esq.
CallBack?
Dir.
WinMain?
Perto
Base
Longe
Silicon Graphics OpenGL - Apresentação
gluPerspective(fovy,aspecto,perto,longe)
Aspecto=l/a
Como
OGLInit
Fazer?
Projeções
Variáveis
CallBack?
fovy
q
a
l
WinMain?
Perto
Longe
Silicon Graphics OpenGL - Apresentação
• Perspectiva:
Como
OGLInit
Fazer?
Projeções
Variáveis
CallBack?
WinMain?
– 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.
Silicon Graphics OpenGL - Apresentação
• Inicialização dos estados da OpenGL
Como
OGLInit
Fazer?
Projeções
Variáveis
CallBack?
MEFInit
WinMain?
– 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.
Silicon Graphics OpenGL - Apresentação
Como
OGLInit
Fazer?
Projeções
Variáveis
CallBack?
MEFInit
Desenhando
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.
Silicon Graphics OpenGL - Apresentação
Como
OGLInit
Fazer?
Projeções
Variáveis
CallBack?
MEFInit
Desenhando
WinMain?
Silicon Graphics OpenGL - Apresentação
Como
OGLInit
Fazer?
Projeções
Variáveis
CallBack?
MEFInit
Desenhando
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;
Silicon Graphics OpenGL - Apresentação
Como
OGLInit
Fazer?
Projeções
Variáveis
CallBack?
MEFInit
Desenhando
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);
• glVertex3fv(*v2);
• glVertex3fv(*v3);
• glEnd();
• ou:
Silicon Graphics OpenGL - Apresentação
Como
OGLInit
Fazer?
Projeções
Variáveis
CallBack?
MEFInit
Desenhando
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.
Silicon Graphics OpenGL - Apresentação
Como
OGLInit
Fazer?
Projeções
Variáveis
CallBack?
MEFInit
Desenhando
WinMain?
E a Cena?
• 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);
Silicon Graphics OpenGL - Apresentação
Como
OGLInit
Fazer?
Projeções
Variáveis
CallBack?
MEFInit
Desenhando
WinMain?
•Transformações
Silicon Graphics OpenGL - Transformações
• Procedimentos utilizados para:
– Modificar o valor de cada vértice de um objeto
Como
O queFazer?
são?
Variáveis
CallBack?
WinMain?
• 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.
Silicon Graphics OpenGL - Transformações
• Translação:
Como
O queFazer?
são?
Quais
Variáveis
São?
CallBack?
WinMain?
– 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.
Silicon Graphics OpenGL - Transformações
Como
O queFazer?
são?
Translação
Quais
Variáveis
São?
Pilha
CallBack?
de Matriz
Como
WinMain?
Fazer
• Definido pela Matriz:
– 1 0 0 Tx
– 0 1 0 Ty
– 0 0 1 Tz
–0001
• 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)
Silicon Graphics OpenGL - Transformações
Como
O queFazer?
são?
Translação
Quais
Variáveis
São?
Rotação
Pilha
CallBack?
de Matriz
Como
WinMain?
Fazer
• 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):
– mm m0
– mm m0
– mm m 0
– 0 0 0 1
– Dado que: M=u.uT+(cos a).(I-u.uT)+(sen a).S
Silicon Graphics OpenGL - Transformações
Como
O queFazer?
são?
Translação
Quais
Variáveis
São?
Rotação
Pilha
CallBack?
de Matriz
Como
WinMain?
Fazer
• 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.
Silicon Graphics OpenGL - Transformações
Como
O queFazer?
são?
Translação
Quais
Variáveis
São?
Rotação
Pilha
CallBack?
de Matriz
Escala
Como
WinMain?
Fazer
• 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.
Silicon Graphics OpenGL - Transformações
Como
O queFazer?
são?
Quais
Variáveis
São?
Pilha
CallBack?
de Matriz
Como
WinMain?
Fazer
• 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.
Silicon Graphics OpenGL - Transformações
Como
O queFazer?
são?
Quais
Variáveis
São?
Pilha
CallBack?
de Matriz
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
Silicon Graphics OpenGL - Transformações
Como
O queFazer?
são?
Quais
Variáveis
São?
Pilha
CallBack?
de Matriz
Como
WinMain?
Fazer
• Quaisquer transformações ou comando para
empilhar matrizes:
• Antes de executar o comando
glBegin(primitiva) e/ou depois do comando
glEnd()
Silicon Graphics OpenGL - Apresentação
Como
OGLInit
Fazer?
Projeções
Variáveis
CallBack?
MEFInit
Desenhando
WinMain?
•Iluminação
Silicon Graphics OpenGL - Iluminação
Para
Como
queFazer?
serve?
Variáveis
CallBack?
WinMain?
• 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.
Silicon Graphics OpenGL - Iluminação
• Observe como a iluminação é importante para a
representação de Objetos 3D:
Para
Como
queFazer?
serve?
Exemplos
Variáveis
CallBack?
WinMain?
Silicon Graphics OpenGL - Iluminação
Para
Como
queFazer?
serve?
Exemplos
Variáveis
CallBack?
Luzes
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.
Silicon Graphics OpenGL - Iluminação
Para
Como
queFazer?
serve?
Exemplos
Variáveis
CallBack?
Luzes
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.
q
q
Silicon Graphics OpenGL - Iluminação
Para
Como
queFazer?
serve?
Exemplos
Variáveis
CallBack?
Luzes
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).
Silicon Graphics OpenGL - Iluminação
• Exemplos de Iluminações:
Para
Como
queFazer?
serve?
Iluminação especular:
Exemplos
Variáveis
CallBack?
Luzes
WinMain?
Cor:
Ambiente+Difusa
Silicon Graphics OpenGL - Iluminação
• Luzes em OpengL:
Para
Como
queFazer?
serve?
Exemplos
Variáveis
CallBack?
Luzes
Representação
WinMain?
– 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.
Silicon Graphics OpenGL - Iluminação
Para
Como
queFazer?
serve?
Exemplos
Variáveis
CallBack?
Luzes
Representação
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);
Silicon Graphics OpenGL - Iluminação
Para
Como
queFazer?
serve?
Exemplos
Variáveis
CallBack?
Luzes
Representação
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.
Silicon Graphics OpenGL - Iluminação
Para
Como
queFazer?
serve?
Exemplos
Variáveis
CallBack?
Luzes
Representação
WinMain?
Como Fazer?
• 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)
Silicon Graphics OpenGL - Apresentação
Para
Como
queFazer?
serve?
Exemplos
Variáveis
CallBack?
Luzes
Representação
WinMain?
Como Fazer?
•Materiais
Silicon Graphics OpenGL - Materiais
Como
O queFazer?
são?
Variáveis
CallBack?
WinMain?
• 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)
Silicon Graphics OpenGL - Materiais
Como
O queFazer?
são?
Funcionamento
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
Silicon Graphics OpenGL - Materiais
Como
O queFazer?
são?
Funcionamento
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
q
q
Silicon Graphics OpenGL - Materiais
Como
O queFazer?
são?
Funcionamento
Variáveis
Representação
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.
Silicon Graphics OpenGL - Materiais
Como
O queFazer?
são?
Funcionamento
Variáveis
Representação
CallBack?
Como
WinMain?
Fazer?
• 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).
Silicon Graphics OpenGL - Materiais
Como
O queFazer?
são?
Funcionamento
Variáveis
Representação
CallBack?
Como
WinMain?
Fazer?
•
•
•
•
•
•
•
•
•
•
•
•
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();}...
Silicon Graphics OpenGL - Transparência
O que são?
Funcionamento
Representação
Como Fazer?
• Transparência (Blending)
Silicon Graphics OpenGL - Transparência
Como
Transparencia?
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;
Silicon Graphics OpenGL - Transparência
Como
Transparencia?
Fazer?
Funcionamento
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.
Silicon Graphics OpenGL - Transparência
• Pensamento natural:
Como
Transparencia?
Fazer?
Funcionamento
Variáveis
CallBack?
WinMain?
– 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.
Silicon Graphics OpenGL - Transparência
Como
Transparencia?
Fazer?
Funcionamento
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.
Silicon Graphics OpenGL - Transparência
Como
Transparencia?
Fazer?
Funcionamento
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.
Silicon Graphics OpenGL - Transparência
Como
Transparencia?
Fazer?
Funcionamento
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.
Silicon Graphics OpenGL - Transparência
• Gerando os Fatores Fonte e Destino:
Como
Transparencia?
Fazer?
Funcionamento
Variáveis
CallBack?
WinMain?
–
–
–
–
–
–
–
–
–
–
–
–
–
–
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
Silicon Graphics OpenGL - Transparência
Como
Transparencia?
Fazer?
Funcionamento
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:
Silicon Graphics OpenGL - Transparência
Como
Transparencia?
Fazer?
Funcionamento
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
Silicon Graphics OpenGL - Transparência
Como
Transparencia?
Fazer?
Funcionamento
Variáveis
Como Fazer?
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.
Silicon Graphics OpenGL - Antialiasing
Como
Transparencia?
Fazer?
Funcionamento
Como Fazer?
•ANTIALIASING
Silicon Graphics OpenGL - Antialiasing
Como O
Fazer?
que é?
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.
Silicon Graphics OpenGL - Antialiasing
Como O
Fazer?
que é?
Funcionamento
• 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.
Silicon Graphics OpenGL - Antialiasing
Como O
Fazer?
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:
Silicon Graphics OpenGL - Antialiasing
Como O
Fazer?
que é?
Funcionamento
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);
Silicon Graphics OpenGL - Antialiasing
• GL_PERSPECTIVE_CORRECTION_HINT
Como O
Fazer?
que é?
Funcionamento
Como Fazer?
– Especifica a qualidade de cores e de
interpolação de coordenadas de textura
desejadas;
Silicon Graphics OpenGL - Neblina
Como O
Fazer?
que é?
Funcionamento
Como Fazer?
•Neblina
Silicon Graphics OpenGL - Neblina
Como O
Fazer?
que é?
• 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.
Silicon Graphics OpenGL - Neblina
Como O
Fazer?
que é?
Funcionamento
• 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];
Silicon Graphics OpenGL - Neblina
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;
Silicon Graphics OpenGL - Neblina
• Os valores padrão são 1,0 e 1,
respectivamente;
Como O
Fazer?
que é?
Funcionamento
• 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:
Silicon Graphics OpenGL - Neblina
Como O
Fazer?
que é?
• Primeiramente habilita-se a máquina de
estados a gerar a neblina com
glEnable(GL_FOG);
Funcionamento
• Ajusta o modo da neblina com glFog(s):
glFogi(GL_FOG_MODE,GL_EXP);
Como Fazer?
• 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)
Silicon Graphics OpenGL - Textura
Como O
Fazer?
que é?
Funcionamento
Como Fazer?
•Mapeamento de
Textura
Silicon Graphics OpenGL - Textura
O que é?
• 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.
Silicon Graphics OpenGL - Textura
O que é?
Funcionamento
• 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.
Silicon Graphics OpenGL - Textura
O que é?
Funcionamento
Especificando
• 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)
Silicon Graphics OpenGL - Textura
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)
Silicon Graphics OpenGL - Textura
• glTexImage2D: Parâmetros:
O que é?
Funcionamento
Especificando
– 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
Silicon Graphics OpenGL - Textura
• glTexImage2D: Parâmetros:
O que é?
Funcionamento
Especificando
– GLvoid *pixels: Contêm os dados da imagemtextura, 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)
Silicon Graphics OpenGL - Textura
• Controle de Filtros:
O que é?
Funcionamento
– 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;
Especificando
– 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.
Silicon Graphics OpenGL - Textura
GL_TEXTURE_MAG_FILTER
• Controle de GL_NEAREST
Filtros:
O que é?
GL_LINEAR
– O Comando OpenGL
para a especificação dos filtros é:
glTexParameteri(GL_Texture2D,filtro,procedimento),
onde
GL_TEXTURE_MIN_FILTER
GL_NEAREST
Funcionamento
– Filtro é GL_TEXTURE_MAG_FILTER
ou
GL_LINEAR
Especificando
– GL_TEXTURE_MIN_FILTER
GL_NEAREST_MIPMAP_NEAREST
– E procedimento
é dado pela tabela:
GL_NEAREST_MIPMAP_LINEAR
GL_LINEAR_MIPMAP_NEAREST
GL_LINEAR_MIPMAP_LINEAR
Silicon Graphics OpenGL - Textura
• Controle de Filtros:
O que é?
Funcionamento
Especificando
– 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;
Silicon Graphics OpenGL - Textura
• Controle de Filtros:
O que é?
Funcionamento
Especificando
– 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;
Silicon Graphics OpenGL - Textura
• Controle de Filtros:
O que é?
Funcionamento
Especificando
– 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;
Silicon Graphics OpenGL - Textura
• Controle de Filtros:
O que é?
Funcionamento
Especificando
– 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)
Silicon Graphics OpenGL - Textura
O que é?
Funcionamento
• Existem 3 funções possíveis para
computar a cor final do objeto a ser
desenhado:
– Usar a cor da textura como cor final;
Especificando
Como Aplicar?
– 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;
Silicon Graphics OpenGL - Textura
• Modulação e Transparência:
O que é?
Funcionamento
Especificando
Como Aplicar?
– 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.
Silicon Graphics OpenGL - Textura
O que é?
Funcionamento
Especificando
Como Aplicar?
Habilitando
• 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;
Silicon Graphics OpenGL - Textura
O que é?
Funcionamento
Especificando
Como Aplicar?
Habilitando
Desenhando
• 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)