Modelos de Iluminação e sombreamento - OpenGL. - Unisinos

Iluminação em OpenGL
Iluminação em OpenGL
Dicas de Implementação
Prof. Christian Hofsetz
• Iluminação ambiente, difusa e especular são suportados
pelo OpenGL
• Usuários devem definir pesos e valores
– posição, tipo, cor
• Usuários também definem material
– Pode ser diferente para a parte de trás do polígono
Luzes em OpenGL
GLfloat lightA_position[ ] = {1.0, 1.0, 1.0, 0.0};
GLfloat lightB_position[ ] = {1.0, 2.0, 3.0, 1.0};
glLightfv(GL_LIGHT0, GL_POSITION, lightA_position);
glLightfv(GL_LIGHT1, GL_POSITION, lightB_position);
Acima definimos uma fonte de luz direcional vindo da
direção (1, 1, 1), e uma fonte de luz posicional vindo do
ponto (1, 2, 3) nas coordenadas do universo.
OpenGL Lights
• Podemos especificar até 8 luzes em OpenGL
GL_LIGHT0 .. GL_LIGHT7
• Para verificar o número máximo de luzes que podemos usar em uma
implementação específica:
glGetIntegerv(GL_MAX_LIGHTS, GLint *num_lights);
• Devemos habilitar cada luz que quisermos usar *E* habilitar
iluminação em OpenGL (disabled by default):
glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); …
glEnable(GL_LIGHTING);
glLight*()
Spotlight
• glLight{if}(GLenum light, GLenum pname, TYPE param)
glLight{if}v(GLenum light, GLenum pname, TYPE *param)
• light pode ser GL_LIGHT0 .. GL_LIGHT7
• pname pode ser:
– GL_POSITION: posição da luz
– GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR : cor da luz
– GL_SPOT_DIRECTION, GL_SPOT_EXPONENT, GL_SPOT_CUTOFF:
parâmetros da luz do tipo “spot” (spotlight)
– GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION,
GL_QUADRATIC_ATTENUATION: parâmetros para atenuação
Cutoff
Direction
1

glLight*()
GLfloat light0_ambient[ ] = {0.0, 0.1, 0.0, 1.0};
GLfloat light0_diffuse[ ] = {0.0, 0.0, 1.0, 1.0};
GLfloat light0_specular[ ] = {1.0, 1.0, 1.0, 1.0};
GLfloat light0_position[ ] = {1.0, 2.0, 3.0, 1.0};
glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light0_specular);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
Materiais
• Cores dos objetos iluminados são calculados pela multiplicação da
cor das luz com a cor do material (por canal R, G e B)
• Assim como definimos as cores das luzes em ambiente, difusa e
especular, as cores dos materiais também são definidas da mesma
forma.
• Podemos definir cores de materiais que emitem luz:
– Neste caso, as luzes não influenciam a cor final do material
– As luzes emitidas por objetos que emitem luz não são computadas pelo
OpenGL nos outros objetos
glMaterial*()
• glMaterial{if}(GLenum face, GLenum pname, TYPE param)
glMaterial{if}v(GLenum face, GLenum pname, TYPE *param)
• face pode ser: GL_FRONT, GL_BACK, GL_FRONT_AND_BACK
• pname pode ser:
– GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION: cores
do material
– GL_SHININESS: expoente de iluminação do modelo Phong
glMaterial*()
GLfloat mat0_ambient[ ] = {0.2, 0.2, 0.2, 1.0};
GLfloat mat0_diffuse[ ] = {0.7, 0.0, 0.0, 1.0};
GLfloat mat0_specular[ ] = {1.0, 1.0, 1.0, 1.0};
GLfloat mat0_shininess[ ] = {5.0};
glMaterialfv(GL_FRONT, GL_AMBIENT, mat0_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat0_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat0_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat0_shininess);
glColorMaterial()
• Se vamos apenas modificar uma propriedad do material, é
mais eficiente utilizarmos glColorMaterial( )
• glColorMaterial( ) especifica qual cor modificar
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_DIFFUSE);
glColor3f(0.2, 0.5, 0.8); // altera a cor difusa do material
Desenhar objetos aqui
glColorMaterial(GL_FRONT, GL_SPECULAR);
glColor3f(0.9, 0.0, 0.2); // altera a cor especular do material
Desenhar objetos aqui
glDisable(GL_COLOR_MATERIAL);
Renderizando Polígonos
• Flat Rendering
• Goraud Shading
– Uses Phong Reflectance
• Phong Shading
2

Flat Rendering
• Uma normal por triângulo
• Cor constante no triângulo
– Calculada de acordo com o modelo de reflexão
• Melhor para superfícies realmente planas
• Simples e rápido
Gouraud Shading
• Uma normal por vértice
• Calcula a cor por vértice
• Cores por pixels são interpoladas
– para cada canal R, G, B
• Resultados aceitáveis para superfícies curvas
Phong Shading
• Uma normal por vértice
• Normal é interpolada por pixel
– Interpola-se cada componente da normal e, depois, normaliza-se
Como interpolamos normais? Uma normal é um vetor
unitário. Não podemos apenas interpolar os valores x,y,z da
normal – o vetor resultante não será unitário. Veja este
exemplo:
N1 = (0, .436, -.9). N2 = (0, -.436,.9)
Se fizermos a média destes vetores, obteremos (0,0,.9),
cujo tamanho obviamente não é unitário. Ele deve ser
normalizado para obtermos (0,0,1).
• Calcula a equação de iluminação por pixel
• Bons resultados para superfícies curvas e
• Não disponível ainda em OpenGL
Gouraud vs. Phong
• Gouraud é mais rápido
– Apenas um valor a ser interpolado
– Não precisamos normalizar
– Não é necessário calcular a equação de iluminação para cada
ponto
• Phong produz resultados melhores
– Especialmente quando os efeitos de iluminação mudam
rapidamente com a normal da superfície (e.g., pontos de alta
reflexão especular)
– É o melhor para objetos brilhantes
– É o melhor para cálculo de sombras
3

OpenGL Shading
• OpenGL suporta flat shading e Gouraud shading.
Não há suporte ainda para Phong shading.
• glShadeModel(GL_FLAT)
– Flat shading
• glShadeModel(GL_SMOOTH)
– Gouraud shading
• Lembre-se de fornecer as normais corretamente, caso contrário a
iluminação não irá funcionar.
Discussão
• Fonte de luz e/ou observador no infinito simplificam os
cálculos, mas o resultado é menos realista
Referências
• http://www.cs.umd.edu/~djacobs/CMSC427/Shadi
ng_web.ppt
• Algumas vezes precisamos normalizar ou truncar as cores
para evitar estouro (R = R/(R + G + B) , .... )
4