1-Introdução ao OpenGL

(1)

1-Introdução ao OpenGL

(2)

Bibliografia

A) OpenGL Programming Guide (4ª Edição)

B) Computer Graphics – Principles and

(3)

Programa

• 1- OpenGL (Bibliotecas, Exemplos de Utilização,

Pipelines) (Cap. A1, pág. 1-23)

• 2-Desenho de Objectos Geométricos,

Transformações Geométricas e Animação) (Cap.

A1, pág. 20-25, A2, pág. 29-59, A3)

• 3- Interacção (event-driven input, display-lists,

Menus, Picking) (Cap. B2, pag. 41-44, B4, pag.

188-195, B10, pag. 435-442, A7, pág. 255-270, A13, pag.

531-552)

(4)

Abordagem

• Nesta introdução revisitam-se conceitos

importantes leccionados em CG através da sua

concretização em OpenGL.

• Considerando que a parte prática de MVT é

desenvolvida recorrendo a OpenGL, sempre

que relevante, apresentam-se aspectos

específicos e dão-se alguns exemplos de

aplicações.

(5)

1-OpenGL

(Bibliotecas, Exemplos de Utilização, Pipelines)

1-OpenGL

(6)

O OpenGL

• Interface Procedimental (API, Application

Programming Interface )

Vantagens:

– Norma industrial (mais de 300 empresas)

– Estável

– Portável

– Escalável

– Fácil de Usar

(7)

Pipeline Revisitado

Transf. Modelação e Visualização

Modelos 3D

Projecção

Primitivas 3D

Coordenadas 3D do Modelo

Coordenadas 3D do Mundo

Discretização

Primitivas 2D

Coordenadas 2D Normal.

Criação da Imagem

Quadrículas

Coordenadas 2D

(8)

Pipeline OpenGL Simples

(9)

Pipeline OpenGL

Display List Evaluators Per-Vertex Operations and Primitive Assembly Pixel Operations Rasterization Per-Fragment

Operations Framebuffer Texture Assembly Vertex Data Pixel Data

(10)

Vértices e Quadrículas

São suportados objectos de dois tipos:

– Geométricos (Vértices 3D)

– Imagens (Quadrículas 2D ou pixels)

Existem processadores diferentes para cada

tipo de objectos. As máquinas OpenGL

(11)

Lista de Desenho

• Os objectos (geometria ou quadrículas), por

omissão são imediatamente transformados

numa Imagem (modo imediato).

• Pode ser usada a Lista de Desenho (display

list) para armazenar comandos de desenho

para processamento posterior (modo de

(12)

Avaliadores

• Convertem representações paramétricas de

objectos com Texturas e Cor (a partir das

coordenadas dos pontos de controlo) na

geometria de uma malha de polígonos planares

(facetas) e calculam ainda:

– Normais

– Coordenadas de texturas

– Cor

(13)

Operações sobre vértices

• Conversão dos vértices em Primitivas. Inclui:

– Transformações de Modelação e Visualização;

– Cálculo de coordenadas para mapeamento de

texturas

– Cálculo de iluminação (usando a normal, a posição

da fonte de luz, as propriedades dos materiais);

(14)

Assemblar Primitivas

• São criadas primitivas geométricas completas

(vértices transformados, com cor,

profundidade e coordenada de textura) obtidas

através de:

– Recorte;

(15)

Operações sobre Quadrículas

• As quadrículas sofrem as seguintes operações:

– Desempacotadas (de vários formatos suportados);

– Escaladas, transladadas e aplicadas operações

lógicas;

– Limitadas a um valor máximo;

– Enviadas para a memória de texturas ou para o

andar de discretização.

(16)

Assemblar Texturas

• Várias texturas, descritas através de pixelmaps

podem ser aplicadas a objectos geométricos

3D. Para isso define um bloco de memória

onde são armazenadas as diferentes imagens

de texturas para posterior selecção e

(17)

Discretização

• Corresponde à conversão de geometria em elementos

quadrados designados por fragmentos. Estes têm

correspondência directa com os pixels constituinets

do framebuffer.

• Um fragmento inclui a cor, profundidade e valor da

coordenada de uma textura. O fragmento é obtido

após a aplicação de características como o tipo de

linha, a dimensão do ponto e operações de

(18)

Operações sobre Fragmentos

• Antes de se proceder à visualização podem ser

aplicadas várias operações (por omissão

inactivas) como:

–Aplicação de textura;

–Cálculo de nevoeiro;

–Testes de recorte, alfa, estêncil, remoção de

superfícies ocultas;

(19)

Tipos de Dados OpenGL

Tipo de dado OpenGL Representação interna Tipo de dado C equivalente Sufixo

GLbyte 8-bit integer signed char b

GLshort 16-bit integer short s

GLint, GLsizei 32-bit integer int ou long i GLfloat, GLclampf 32-bit floating-point float f GLdouble, GLclampd 64-bit floating-point double d GLubyte, GLboolean 8-bit unsigned _integer unsigned char ub GLushort 16-bit unsigned _integer unsigned short us GLuint, GLenum,

GLbitfield 32-bit unsigned integer unsigned long ou unsigned int ui

• Portabilidade facilitada com a definição de tipos de dados

OpenGL

(20)

Convenção p/ comandos OpenGL

• <

PrefixoBiblioteca> <ComandoRaiz>

<NúmeroArgumentosOpcional> <TipoArgumentosOpcional>

• Exemplos:

– glColor3f

– glColor3i

– glColor3d

(21)

Bibliotecas

Toolkit de Alto Nível

(Fahrenheit Scene

Graph)

Utility Library

Sistema de Gestão de

Janelas

OpenGL

Utility Toolkit

glu

gl

glut

glx, wgl,agl

(22)

Biblioteca glu

• Especificação de Texturas

• Transformação de Coordenadas (gluLookAt,..)

• Tessellation (triangulação de polígonos)

• Quadráticas

• Nurbs (superfícies paramétricas)

• Gestão de Erros (ocorrência e descrição de

erros)

(23)

Biblioteca glut

• Toolkit independente do Sistema de Gestão de

Janelas o qual suporta:

– Gestão de Janelas (criação, redesenho, posição,

dimensões,..) e Tabela de Cores.

– Funções de Retorno (callback).

– Gestão das Unidades de Entrada de Dados (rato,

teclado).

– Ciclo de Execução (glutMainLoop) e Processo de

Background.

(24)

Biblioteca wgl

• Extensão para Microsoft a qual suporta:

– Formato das quadrículas.

– Acesso a extensões (dependentes do ambiente).

– Gestão de buffers.

– Sincronização (com o pipeline do Windows –

GDI).

(25)

Máquina de Estados

• Vários modos de funcionamento definidos por variáveis de

estado:

– Cor de desenho

– Estilo de desenho de linhas

– Posição e caracteristicas das fontes de luz – Etc.

• Utilização dos comandos glEnable() e glDisable()

• Exemplo:

int luz;

:

glEnable(GL_LIGHTING); //Activa ilumninação

:

luz = glIsEnabled(GL_LIGHTING); // retorna 1 (verdadeiro)

:

glDisable(GL_LIGHTING); //Desactiva iluminação

:

(26)

Demonstração Fog

Usar a aplicação fog para mostrar:

• Sintaxe do OpenGL;

• Vários Tipos de Modelos;

• Desenho de imagens 3D e de texto 2D;

• Tipos de efeitos no cálculo da Imagem;

• Existência de uma hierarquia de Janelas Gráficas;

• Utilização dos Menus;

(27)

Primeiro Programa

#include <windows.h>

#include <GL/glut.h>

void RenderScene(void) // Called to draw scene {

glClear(GL_COLOR_BUFFER_BIT); // Clear the window with current clearing color glFlush(); // Flush drawing commands

}

void Setup(void) // Setup the rendering state {

glClearColor(0.0f, 0.0f, 1.0f, 1.0f); }

// Main program entry point void main(void) { glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutCreateWindow("Simple"); glutDisplayFunc(RenderScene); Setup(); glutMainLoop(); }

(28)

Funções GLUT utilizadas

• void glutInitDisplayMode (unsigned int mode);

Define uma série de propriedades associadas às janelas que venham a ser criadas • int glutCreateWindow (char* name);

Abre uma janela com as características previamente definidas. Devolve o seu identificador

• void glutDisplayFunc (void (*func)(void));

Especifica a função a invocar sempre que o conteúdo de uma janela tem de ser redesenhado (abertura, pop-up, objectos sobrepostos…)

• void glutMainLoop (void);

(29)

2-

Desenho de Objectos Geométricos,

Transformações e Animação

2-

Desenho de Objectos Geométricos,

Transformações e Animação

(Cap. A1, pág. 20-25, Cap. A2, pág.

29-59 e Cap. A3)

(30)

Desenhando uma Primitiva

glBegin (GL_POLYGON); glVertex2f (0.0, 0.0); glVertex2f (0.0, 3.0); glVertex2f (4.0, 3.0); glVertex2f (6.0, 1.5); glVertex2f (4.0, 0.0); glEnd ( ); glBegin (GL_POLYGON); glVertex2f (0.0, 0.0); glVertex2f (0.0, 3.0); glVertex2f (4.0, 3.0); glVertex2f (6.0, 1.5); glVertex2f (4.0, 0.0); glEnd ( );

• glBegin e glEnd marcam o início e fim de uma lista de vértices que descreve a geometria de uma primitiva com o tipo seleccionado em glBegin.

• Para além da função glVertex, que permite definir a geometria de cada vértice, existem outras funções que, de uma forma modal, atribuem diversas características aos vértices:

glColor (), glIndex () definem a côr

glNormal () define o vector normal ao vértice glTextCoord () define uma coordenada de textura

glMaterial () define propriedades ópticas do material

glColor (), glIndex () definem a côr

glNormal () define o vector normal ao vértice glTextCoord () define uma coordenada de textura

(31)

Tipos de

Primitivas Geométricas

Tipos de

Primitivas Geométricas

• GL_POINTS (conjunto de pontos)

• GL_LINES (segmentos de recta)

• GL_LINE_STRIP (linha poligonal)

• GL_LINE_LOOP (linha poligonal fechada)

• GL_TRIANGLES (conjunto de triângulos)

• GL_TRIANGLES_STRIP (conjunto ligado de triângulos)

• GL_TRIANGLES_FAN (conjunto ligado de triângulos)

• GL_QUADS (conjunto de quadriláteros)

• GL_QUADS_STRIP (conjunto ligado de quadriláteros)

• GL_POLYGON (polígono)

(32)

Primitivas Gráficas Simples

v0 v1 v2 v3 v4 GL_POINTS GL_LINES v0 v1 v2 v3 v4 v5 v6 v7 GL_LINE_STRIP v0 v1 v2 v3 v4 GL_LINE_LOOP v0 v1 v2 v3 v4 v0 v1 v2 v3 v4 v5 GL_TRIANGLES v0 v1 v2 v3 v4 v5 GL_TRIANGLE_STRIP GL_TRIANGLE_FAN v0 v1 v2 v3 v4 v0 v1 v2 v3 v4 v5 v6 v7 _v0 v1 v2 v3 v4 v5 v6 v7 _v0 v1 v2 v3 v4

(33)

Restrições à Definição de Polígonos

• Polígonos simples, sem auto-intersecções, ou seja, intersecções entre pares de arestas. • Polígonos Convexos

• Polígonos Simplesmente Conexos (sem “buracos”)

• Polígonos Planares (para que a sua projecção seja sempre convexa, independentemente do ponto de observação)

• Polígonos mais complexos ou irregulares podem ser gerados por união de polígonos simples (Tesselation)

• Polígonos simples, sem auto-intersecções, ou seja, intersecções entre pares de arestas. • Polígonos Convexos

• Polígonos Simplesmente Conexos (sem “buracos”)

• Polígonos Planares (para que a sua projecção seja sempre convexa, independentemente do ponto de observação)

• Polígonos mais complexos ou irregulares podem ser gerados por união de polígonos simples (Tesselation)

Polígonos Válidos

(34)

Gestão de Estado e Atributos Gráficos

Tanto os atributos gráficos mais clássicos ( côr de desenho, côr de preenchimento,

estilo de linha, etc…) como propriedades ou capacidades gráficas (capabilities) que afectam a síntese da cena de uma forma mais abrangente (iluminação, textura, remoção de superfícies, nevoeiro,…), são armazenados em variáveis de estado.

Tanto os atributos gráficos mais clássicos ( côr de desenho, côr de preenchimento,

estilo de linha, etc…) como propriedades ou capacidades gráficas (capabilities) que afectam a síntese da cena de uma forma mais abrangente (iluminação, textura, remoção de superfícies, nevoeiro,…), são armazenados em variáveis de estado.

Existem funções para activar (ON), desactivar (OFF) e interrogar variáveis de estado booleanas: (GL_DEPTH_TEST, GL_FOG, GL_LIGHTING, …)

void glEnable (GLenum capability); void glDisable (Glenum capability); void glIsEnabled (Glenum capability);

Um outro conjunto de funções permite obter o valor corrente de variáveis de estado mais complexas (GL_CURRENT_COLOR, GL_CURRENT_NORMAL, etc..)

void glGetBooleanv (GLenum pname, Glboolean *params); void glGetIntegerv (GLenum pname, GLint *params);

void glGetFloatv (GLenum pname, GLfloat *params); void glGetDoublev (GLenum pname, GLdouble *params);

void glGetBooleanv (GLenum pname, Glboolean *params); void glGetIntegerv (GLenum pname, GLint *params);

void glGetFloatv (GLenum pname, GLfloat *params); void glGetDoublev (GLenum pname, GLdouble *params);

(35)

Alguns Atributos Gráficos

glPointSize: Tamanho de um ponto em pixels

glLineWidth: Espessura de linha em pixels

glLineStipple: Padrão para linhas

glPolygonMode: Modo de desenho do polígono (point, line, fill)

glFrontFace: Sentido de Circulação para Front-Faces e Back-Faces

glCullFace: Escolha de qual o tipo de faces a remover antes da rasterização

glPolygonStipple: Padrão de preenchimento de polígonos

glPointSize: Tamanho de um ponto em pixels glLineWidth: Espessura de linha em pixels glLineStipple: Padrão para linhas

glPolygonMode: Modo de desenho do polígono (point, line, fill)

glFrontFace: Sentido de Circulação para Front-Faces e Back-Faces

glCullFace: Escolha de qual o tipo de faces a remover antes da rasterização glPolygonStipple: Padrão de preenchimento de polígonos

(36)

Vértices

• A cada vértice pode associar-se:

– Cor definida por valor ou como índice de uma

tabela de cores

– Vector normal

– Coordenada de uma textura

– Propriedade do material

– Indicação precede uma aresta de fronteira

• E podem ser definidos através de Arrays.

(37)

Transformações Geométricas

• Vértices e Normais são transformadas pela

matriz de Modelação-Visualização e pela

matriz de Projecção.

• Para facilitar a composição de Matrizes existe

um gestor de stack de matrizes.

• Podem ser usados 6 planos adicionais de

(38)

Desenho de Objectos

• As Primitivas são recortadas:

– 1º Planos de Recorte definidos pela aplicação

– 2º Volume de Recorte:

• E transformadas em coordenadas de ecrã dentro

de um enquadramento o qual é definido por:

– Número de planos

(39)

Rasterização de Linhas

• As funções associadas a linhas permitem

definir:

– Diâmetro do ponto a discretizado, por omissão 1.0.

– Largura das linhas discretizadas, quer tenha ou

não sido aplicado um processamento de

anti-aliasing.

– Padrão de preenchimento de linha e respectivo

factor multiplicativo.

(40)

Rasterização de Polígonos

• As funções associadas a polígonos permitem

definir:

– Padrão de preenchimento de polígono;

– Faces dos polígonos que são traseiras;

– Qual a face da frente do polígono;

(41)

Demonstração shapes

Usar a aplicação shapes para mostrar:

• Tipos de Objectos Geométricos (glBegin);

• O estado Cor (usar o polígono);

• Geometria da malha de triângulos (alterar 2ª e 3ª cor

do Triangle_Strip);

• Polígonos não planares;

(42)

Transformações Geométricas no Pipeline

Numa perspectiva de Câmara Virtual, a definição das transformações necessárias ao posicionamento da câmara (visualização) e disposição dos objectos na cena (modelação) faz-se, geralmente, na seguinte sequência:

1. Posicionar e orientar a câmara dentro do espaço da cena (Transformação de Visualização).

2. Compôr a cena, colocando os objectos constituintes nas posições e orientações com que se pretende que sejam “fotografados” (Transformação de Modelação).

3. Escolher uma lente para a câmara ou ajustar o Zoom (Transformação de Projecção).

4. Determinar as dimensões e posição da “fotografia” final (Transformação de Viewport).

ModelView Matrix

ModelView

Matrix Projection_Matrix Projection

Matrix Perspective_Division Perspective

Division _{Transformation}Viewport Viewport Transformation Vertex Vertex World coordinates World coordinates Eye Coordinates Eye Coordinates Clip Coordinates Clip Coordinates Normalized Device Normalized Device Window Coordinates Window Coordinates

(43)

A Definição de Transformações

1) As matrizes de Modelação e de Visualização ficam concatenadas numa única matriz, designada MODELVIEW.

3) Sempre que é aplicada uma nova matriz de transformação M, essa matriz é multiplicada pela matriz corrente C (glMultMatrix (matrix*)), à sua direita: CM. Deste modelo resulta que

as transformações são aplicadas aos objectos pela ordem inversa daquela por que são definidas. 2) Existe uma função para seleccionar a matriz sobre a qual se pretende efectuar uma alteração.

glMatrixMode ( ) permite comutar entre GL_MODELVIEW (Modelação-Visualização) e GL_PROJECTION (Projecção).

5) Dado que nem sempre se pretende um efeito acumulativo, existem funções para estabelecer um dado valor para a matriz corrente (glLoadMatrix (matriz*)) ou inicializá-la com a matriz identidade (glLoadIdentity ()).

4) Dada a dependência entre visualização e modelação, o programador deve começar por definir a transformação de visualização e só depois as transformações de modelação, para que a

(44)

Transformações de Model. e Vis. Básicas

Transformação de Objectos versus Transformação de Referencial

Quando se pretende aplicar transformações básicas, o openGL fornece funções utilitárias que, face a

glMultMatrix, têm a vantagem de calcular as matrizes a partir dos parâmetros de transformação:

glTranslate (x, y, z); glRotate (angle, x, y, z); glScale (x, y, z); R T R T Objecto: 1º Translação 2º Rotação Referencial: 1º Rotação 2º Translacção x y z x y z

Nota: Quando se aplicam transformações de escala, a visão por referencial pode tornar-se menos intuitiva. Com escalamento não uniforme e rotações, os eixos do referencial

(45)

Definir a Transformação de Visualização

1) Através de Sucessivas Translacções e Rotações

A definição da Transformação de Visualização (posição e orientação da câmara dentro do

espaço da cena) pode ser feita por invocação das funções glTranslate e glRotate. Os parâmetros indicam movimentos dos objectos face a uma câmara estática e os seus valores simétricos

podem ser encarados como movimentos da câmara face aos objectos.

2) Através da Função gluLookAt ():

up vector eye X Y center gluLookAt ( eyex, eyey, eyez,

centerx, centery, centerz, upx, upy, upz );

(46)

Transformação de Projecção

A definição desta transformação assume a câmara posicionada na origem do referencial, a apontar no sentido negativo do eixo dos zz´. A utilização de rotações e translacções para alterar a posição e orientação do volume de visualização é possível mas não recomendada (controlo pouco intuitivo).

1) PERSPECTIVA: Volume de Visualização Especificado por glFrustum ()

Nota: Com esta função é possível definir void glFrustum ( left, right,

bottom, top, near, far ); left right top near far

(47)

Transformação de Projecção (cont.)

2) PERSPECTIVA: Vol. de Visualiz. especificado por gluPerspective ()

void gluPerspective ( fovy, aspect, near, far ); near far w h fovy

fovy: abertura da câmara, medida por um ângulo no plano xoz

aspect = w / h

3) PARALELA (Ortogonal): Vol. de Visualização especificado por glOrtho ()

void glOrtho ( left, right, bottom, top, near, far );

viewpoint right

left top

(48)

Demonstração projection

Usar a aplicação projection para mostrar:

• Vários tipos de projecção;

• Utilização de função do gluLookAt;

• Planos de Recorte;

(49)

Transformação de Viewport

Os objectos gráficos, depois de transformados pelas matrizes MODELVIEW e PROJECTION, e depois de recortados pelos seis planos delimitadores do volume de visualização, devem ser submetidos à Transformação de Viewport:

Define-se a porção da área do dispositivo de saída onde deve ser mapeada a projecção da cena. Essa definição é feita em coordenadas da janela activa (canto inferior esquerdo. largura e altura). Por defeito, o viewport coincide com a totalidade da janela gráfica.

Notas : Se a relação de aspecto do Viewport não fôr a mesma da janela de projecção, a imagem projectada pode sofrer distorção.

A aplicação deve detectar eventos de redimensionamento

da janela gráfica e modificar o viewport de acordo com essa alteração void glViewport (GLint x, GLint y,

(50)

Mapeamento janela-viewport

Calcular a transformação que mapeia a janela de

visualização limitada por Xw

_min

, Xw

_max

, Yw

_min

e Yw

_max

num viewport de limites Xv

_min

, Xv

_max

, Yv

_min

e Yv

_max

.

(consulte secção 5.4 do livro Computer Graphics do

(51)

Desenhando formas geométricas

#include <windows.h> #include <gl/glut.h>

void RenderScene(void) // Called to draw scene

{

glClear(GL_COLOR_BUFFER_BIT); // Clear the window with current clearing color glColor3f(1.0f, 0.0f, 0.0f); // Set current drawing color to red

glRectf(100.0f, 150.0f, 150.0f, 100.0f); // Draw a filled rectangle with current color glFlush(); // Flush drawing commands

}

void Setup(void) // Setup the rendering state

{

glClearColor(0.0f, 0.0f, 1.0f, 1.0f); }

(52)

Desenhando formas geométricas (cont.)

void ChangeSize(GLsizei w, GLsizei h) // Called by GLUT library when the window has changed size

{ // Prevent a divide by zero if(h == 0 h = 1;

glViewport(0, 0, w, h); // Set Viewport to window dimensions glMatrixMode(GL_PROJECTION); // Reset coordinate system glLoadIdentity();

// Establish clipping volume (left, right, bottom, top, near, far)

if (w <= h) glOrtho (0.0f, 250.0f, 0.0f, 250.0f*h/w, 1.0, -1.0); else glOrtho (0.0f, 250.0f*w/h, 0.0f, 250.0f, 1.0, -1.0); glMatrixMode(GL_MODELVIEW);

glLoadIdentity(); }

void main(void) // Main program entry point

{ glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(400,350); glutInitWindowPosition(10,10); glutCreateWindow("GLRect"); glutDisplayFunc(RenderScene); glutReshapeFunc(ChangeSize); Setup();

(53)

Desenhando formas geométricas (cont.)

• void glutReshapeFunc (void (*func)(int width, int height));

Especifica a função a invocar quando a janela é criada, redimensionada ou transladada. (essa função invoca glViewport para redefinir a área de ecrã e redefine a matriz de

projecção). Necessário garantir relações de aspecto iguais entre o viewport e a janela de visualização (definida pelo volume de visualização)

• OpenGL possui dois tipos de Matrizes de Transformação: Projecção (afecta as dimensões do volume de visualização) e Visualização (afecta os objectos da cena) • glMatrixMode – define qual o tipo de matriz a ser utilizada em futuras

transformações

• Função glOrtho não define um volume de visualização mas sim uma matriz de projecção definida pelos seus parâmetros a qual é multiplicada pela matriz de projecção corrente.

(54)

Stacks de Matrizes

void glPushMatrix (void);

Empurra todas as matrizes do stack corrente um nível para baixo e a matriz do nível superior é copiada, de modo que as duas primeiras

matrizes sejam iguais. Demasiadas operações de push podem provocar a ocorrência de um erro. void glPopMatrix (void);

Retira a matriz do topo do stack e destrói o seu conteúdo.

Aquela que era a segunda matriz, passa a ocupar o topo do stack. Esta operação gera um erro quando executada sobre um stack com uma só matriz.

PUSH

POP

glMatrixMode selecciona o stack sobre o qual se pretende efectuar uma operação.

(55)

Utilização do Stack

//alteração ao código que desenhava um rectângulo para

// que este seja escalado

void RenderScene(void)

{

glClear(GL_COLOR_BUFFER_BIT);

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

//Save the current modelview matrix by pushing

// the current transformation on the stack

glPushMatrix( );

// Scale Ex=1.5, Ey=0.5, Ez=1

glScalef(1.5,0.5,1);

glRectf(100.0f, 150.0f, 150.0f, 100.0f);

// Restore the modelview matrix by popping it

// of the matrix stack

glPopMatrix( );

glFlush();

(56)

Animação:um exemplo

• Um simples programa de animação em que um

rectângulo se movimenta no ecrã.

(57)

3-Interacção

(Cap. B2, pag. 41-44, B4, pag. 188-195,

B10, pag. 435-442, A7, pág. 255-270,

(58)

Interacção

• APIs devem possibilitar o desenho de aplicações

gráficas interactivas

• OpenGL não suporta directamente a interacção

• Razão: portabilidade

• Solução: uso do toolkit GLUT que fornece a

funcionalidade mínima

• A GLUT “esconde” as complexidades inerentes às

interacções existentes entre o sistema de janelas, o

gestor de janelas e o sistema gráfico

(59)

Dispositivos de entrada

• Dispositivos físicos: características particulares

• Dispositivos lógicos: propriedades são especificadas em

termos do que eles fazem na perspectiva da aplicação

(abstração de mais alto nível)

• Portanto: Dispositivos lógicos caracterizam-se pela

interface com o programa do utilizador e não pelas suas

características físicas

(60)

Dispositivos físicos de entrada

• Dispositivos tipo apontador: indicam uma posição

no ecrã (ex: rato, trackball, joystick, lightpen, mesa

digitalizadora

• Dispositivos tipo teclado: devolvem um código de

caracteres (como o ASCII) ao programa (ex: teclado

de mesa)

• Os dispositivos tipo apontador podem ser de

posicionamento relativo (ex: rato) ou de

posicionamento absoluto (mesa digitalizadora ou

lightpen)

• Dispositivos 3D: spaceball (seis graus de liberdade),

(61)

Dispositivos lógicos de entrada

• 2 características que descrevem o comportamento

lógico dos dispositivos de entrada (na perspectiva

da aplicação):

– Que medidas são fornecidas à aplicação?

– Em que instante são essas medidas fornecidas?

• 6 classes de dispositivos lógicos definidos pelo

GKS e PHIGS

• OpenGL não segue esta abordagem, uma vez que

nos modernos sistemas de janelas, a entrada de

informação não pode ser sempre dissociada

completamente das propriedades físicas dos

dispositvos de input

(62)

Classes de dispositivos lógicos de entrada

• String: devolve cadeias de caracteres ASCII. Usualmente é

implementado através de um teclado físico. OpenGL não os

distingue

• Locator: devolve uma posição em coord. do Mundo. OpenGL

associa a esta classe um dispositivo tipo apontador. Necessário

converter coord. de ecrã em coord. do Mundo.

• Pick: Devolve um identificador de um objecto. Utiliza-se geralmente

um dispositivo apontador mas com uma interface de software

específica. Em OpenGL utiliza-se o processo selection

• Choice: Seleccionar uma opção entre múltiplas escolhas. Em

OpenGL (GLUT) recorre-se à utilização de widgets tipo menus,

scrollbars e botões. Ex: menu com n opções

• Dial: entrada analógica. Em OpenGL, novamente utiliza-se widgets

como por exemplo as slidebars

• Stroke: Devolve um array de posições. Em OpenGL, isto

implementa-se através da pressão de um botão do rato, durante a

qual se procede à transferência de informação, e da libertação do

referido botão que corresponde ao fim dessa transferência

(63)

Medição e Trigger

• Medida: os dados que o dispositivo gera

• Trigger: propriedade física do dispositivo que é responsável

por enviar um sinal ao computador

• Exemplos:

– Teclado -> medidas: caracteres ASCII; trigger: tecla de enter – Rato -> medidas: posições (x, y), trigger: botão

• Além da informação pretendida a medida pode incluir

informação adicional como, por exemplo, um estado: no caso

de um rato, se a medida for um id de um objecto (pick), há que

contemplar a possibilidade de o utilizador premir o botão sem

ter apontado para um objecto.

(64)

Modos de Entrada

• A medida de um dispositivo pode ser obtida por três

modos distintos

• Um modo é definido pela relação entre o processo

de medida e o trigger. Normalmente a inicialização

de um dispositivo de entrada inicia o processo de

medida, cujos dados são guardados em buffers e

podem ser utilizados ou não pela aplicação

– Modo baseado em pedidos (request)

– Modo baseado em amostragem (sample):

» úteis em situações em que o programa “controla” o utilizador – Modo baseado em eventos: utilizado em situações onde o

(65)

Modos de Entrada (cont.)

(66)

Modos de Entrada (cont.)

• Modo baseado em pedidos (aplicações não-gráficas): a medida

não é devolvida ao programa até ao instante do disparo do

trigger. Ex: o programa detém-se na instrução scanf e aguarda

que o utilizador prima a tecla enter

• Modo baseado em amostragem: assim que a função é

chamada, a medida é enviada à aplicação. Não é necessário o

trigger.

• Os modos anteriores não permitem (ou é extremamente díficil)

gerir aplicações com múltiplas entradas e as quais controlam a

execução do programa (simulador de voo- não sabemos quais

os dispositivos que o piloto irá utilizar em qualquer instante da

simulação)

• Modo baseado em eventos: cada vez que utilizador realiza o

trigger do dispositivo é gerado um evento. Este pode ser

processsado de 2 modos:

– Guardado numa Fila de Eventos (event queue): GKS e Phigs – Associação com uma função callback

(67)

Gestão de Eventos em OpenGL

void glutDisplayFunc (void (*func)(void));

Especifica a função a invocar sempre que o conteúdo de uma janela tem de ser redesenhado. (abertura, pop-up, objectos sobrepostos…)

void glutReshapeFunc (void (*func)(int width, int height));

Especifica a função a invocar quando a janela é redimensionada ou transladada. (essa função invoca glViewport para redefinir a área de recorte e redefine a matriz de projecção)

void glutPostRedisplay (void);

Marca a janela corrente como necessitando de ser redesenhada (invocar glutDisplayFunc logo que possível)

void glutKeyboardFunc (void (*func)(unsigned int key, int x, int y));

(68)

Gestão de Eventos em OpenGL (cont.)

void glutSpecialFunc (void (*func)(unsigned int key, int x, int y));

Estabelece a função callback que é chamada pela GLUT cada vez que uma tecla que gera código não-ASCII é pressionada, tais como Home, End, PgUp, PgDn, F1 e F2. Os valores válidos:

GLUT_KEY_F1, GLUT_KEY_F2, GLUT_KEY_F3, GLUT_KEY_F4, GLUT_KEY_F5, GLUT_KEY_F6, GLUT_KEY_F7, GLUT_KEY_F8, GLUT_KEY_F9, GLUT_KEY_F10,

GLUT_KEY_F11, GLUT_KEY_F12, GLUT_KEY_LEFT, GLUT_KEY_UP, GLUT_KEY_RIGHT, GLUT_KEY_DOWN, GLUT_KEY_PAGE_UP,

GLUT_KEY_PAGE_DOWN, GLUT_KEY_HOME, GLUT_KEY_END, GLUT_KEY_INSERT. void glutMouseFunc (void (*func)(int button, int state, int x, int y));

Especifica a função a invocar quando um dos botões do rato (left, middle, right) é premido ou libertado. Três valores são válidos para o parâmetro button: GLUT_LEFT_BUTTON,

GLUT_MIDDLE_BUTTON e GLUT_RIGHT_BUTTON. O parâmetro state pode ser GLUT_UP ou GLUT_DOWN. Os parâmetros x e y indicam a localização do mouse no momento que o evento ocorreu.

void glutMotionFunc (void (*func)(int x, int y));

(69)

Programa Interactivo: Exemplo

• Neste exemplo foram implementadas as seguintes interações: sempre que o

utilizador pressiona a tecla "R" ou "r", o rectângulo é exibido com a cor vermelha; ao pressionar a tecla "G" ou "g" o retângulo é exibido com a cor verde; cada vez que o utilizador clica com o botão esquerdo do mouse, o tamanho do rectângulo é alterado; e cada vez que as teclas KEY_UP e KEY_DOWN são pressionadas ocorre

zoom-in e zoom-out, respectivamente.

(70)

Listas de Desenho

• Uma Lista de Desenho (Display List) é uma

sequência não editável de comandos GL que têm que

ser armazenados para posterior execução. Quando a

lista é criada os comandos podem ser só armazenados

ou também executados.

• Uma Lista de Desenho pode conter uma chamada a

outra Lista de Desenho (hierarquia de listas).

• Comandos que não possam ser armazenados são

executados imediatamente.

(71)

OpenGL em Modo de Retenção: Display Lists

• Num mesmo programa é possível intercalar comandos openGL a executar em modo imediato e comandos em modo de retenção, encapsulados em objectos gráficos: as display lists.

• Uma display list é um grupo de comandos openGL, registados e organizados de uma forma eficiente, para serem executados mais tarde, provocando o mesmo efeito que se obteria com a sua execução em modo imediato.

• Uma display list regista apenas os comandos openGL invocados entre as chamadas às funções glNewList e glEndList. Coordenadas e outras grandezas, correspondentes a argumentos

de comandos OpenGL, são registadas na display list com o valor que tinham quando a lista estava a ser compilada.

Cada display list é identificada por um índice inteiro fornecido como argumento em

glNewList. Esse mesmo índice deve ser indicado quando se pretende executar uma display list, através da função glCallList.

(72)

Criação e Execução de Display Lists

void glNewList (GLuint list, GLenum mode);

list: valor inteiro positivo que identifica univocamente uma display list

mode: GL_COMPILE: quando não se pretende que os comandos OpenGL sejam executados enquanto são registados na display list

GL_COMPILE_AND_EXECUTE: quanto se pretende que os comandos

OpenGL sejam imediatamente executados ao mesmo tempo que são registados.

void glEndList (void);

Estabelece o fim de uma display list void glCallList (GLuint list);

(73)

Display Lists: alguns aspectos relevantes

1. Optimizações do Desempenho

• Por questões de desempenho, uma display-list é uma cache de comandos e não um objecto numa base de dados. Como consequência, as display-lists não são editáveis.

• Num ambiente distribuido, em que a aplicação se encontra numa máquina cliente e o processo OpenGL reside numa máquina-servidora, as display-lists são armazenadas no servidor, com consequente redução do tráfego da rede e aumento de desempenho.

• Mesmo em modo local, o mecanismo de display-list pode tornar-se mais eficiente dado que os comandos podem ser pré-processados e armazenados da forma mais compatível possível com as características do hardware gráfico de base (ex: cálculo dos coeficientes das matrizes de transformação a partir dos parâmetros de transformação).

• Em certas implementações de OpenGL mais sofisticadas, pode mesmo proceder-se à fusão de comandos adjacentes, como a concatenação de matrizes de transformação.

(74)

Display Lists: alguns aspectos relevantes (cont.)

2. O que se regista numa Display List

e como afecta o estado do sistema

3. Display Lists Hierárquicas

• Os valores registados para os argumentos dos comandos de uma display-list, são os que

vigoravam na altura em que a display-list estava a ser compilada. Mesmo que se trate de uma variável à qual se atribui posteriormente um outro valor, a display-list não é alterada.

• Os valores registados para os argumentos dos comandos de uma display-list, são os que

vigoravam na altura em que a display-list estava a ser compilada. Mesmo que se trate de uma variável à qual se atribui posteriormente um outro valor, a display-list não é alterada.

• Nem todos os comandos OpenGL podem ser registados numa display-list. Comandos que involvam parâmetros por referência ou devolvam um valor, não são registados dado que a lista pode ser executada fora do contexto em que determinadas variáveis foram definidas. Esses comandos são executados como se fossem invocados em modo imediato.

• A execução de uma Display-List pode alterar o valor de variáveis de estado OpenGL e essas alterações persistem após a execução da lista.

• Podem criar-se display-lists hierárquicas, executando outras listas no corpo de uma lista inicial. Se pretendermos memorizar o estado do sistema antes de executar uma sub-lista e repôr esse

(75)

Display Lists: exemplo

#define MY_CIRCLE_LIST 1 void build_circle (void)

{

Glint i,

Glfloat cosine, sine;

glNewList (MY_CIRCLE_LIST, GL_COMPILE); glBegin(GL_POLYGON);

for(i=0, i<100, i++) {

cosine=cos(i*2*PI/100.0); sine=sin(i*2*PI/100.0); glVertex2f(cosine, sine); } glEnd; glEndList(); }

Observações: as funções C não são guardadas. As coordenadas dos pontos são

calculadas e copiadas para a display list (compilação)

(76)

Gestão de Listas e seus Índices

A utilização directa e indiscriminada de índices para as listas a criar pode provocar efeitos indesejados, como o apagamento de uma lista, por utilização indevida do seu índice.

GLuint glGenLists (Glsizei range);

Aloca um número (range) de índices de display-lists contíguos e não utilizados. O valor de retorno corresponde ao índice que marca o início da série.

Posteriores invocações desta função não devolvem os mesmos índices, a menos que tenham sido entretanto apagados.

GLboolean glIsList (Gluint list);

Retorna TRUE se o valor list corresponder a um índice correntemente utilizado e FALSE caso contrário.

Void glDeleteLists (GLuint list, Glsizei range);

(77)

Selecção de Objectos

• Em aplicações interactivas é fundamental que o sistema gráfico de base forneça um qualquer mecanismo de selecção de objectos ou partes de objectos presentes numa cena.

• O OpenGL fornece um mecanismo de selecção que automaticamente identifica os objectos que são desenhados sobre uma determinada região da janela corrente.

• É possível integrar e completar esse mecanismo numa função que permita identificar o objecto ou objectos seleccionados pelo utilizador através de um cursor gráfico (“picking”).

Objectos Objectos Janela de Pick Janela de Pick Cursor Cursor

(78)

• Para utilizar o mecanismo de selecção do OpenGL começa-se por desenhar a cena no

frame-buffer, comutar em seguida para o modo de operação “Selection” e invocar de novo os comandos necessários ao redesenho de toda a cena.

• Em modo “Selection”, o conteúdo do frame-buffer não é alterado, não obstante serem invocadas operações de desenho

• Quando se abandona o modo “Selection”, o sistema devolve um registo de todas as primitivas que teriam intersectado o volume de visualização (definido pelas transformações Projection e pelos planos de recorte adicionais), caso tivessem sido desenhadas.

• Cada primitiva nessas condições gera um “selection hit”. Cada “selection hit” regista um conjunto de nomes (valores inteiros) identificadores da primitiva e outros dados com ela relacionados -“hit record”. Os vários “hit records” são armazenados num mesmo array.

• O conjunto de identificadores inteiros registado para cada primitiva corresponde aos valores que estão presentes num stack de nomes (“name stack”) no instante em que é dada a ordem de

O Modo de Operação “Selection”

(79)

1) Especificar o array a utilizar para o registo dos “selection hits”

void glSelectBuffer (GLsizei size, GLuint *buffer);

size: número máximo de valores que podem ser armazenados buffer: ponteiro para um array de “unsigned integers”

2) Activar o modo “Selection” por invocação da função glRenderMode com o valor GL_SELECT

GLint glRenderMode (GLenum mode); /* por defeito GL_RENDER */ Quando se comuta de GL_SELECT para GL_RENDER o valor devolvido pela função indica o número de “selection hits” que foram registados.

Passos para a activação do Modo de Selecção

(80)

3) Inicializar o stack de nomes recorrendo às funções glInitNames e glPushName void glInitNames (void);

Cria um Stack de Nomes vazio void glPushName (Gluint name);

Através de uma operação de push, acrescenta uma entrada ao stack, com o valor “name”.

Convém efectuar uma operação de push logo na fase de inicialização para que haja pelo menos uma entrada cujo valor pode depois ser redefinido por glLoadName.

4) Definir o Volume de Visualização (“View Volume”) que se pretende utilizar para efeitos de selecção

Sendo geralmente diferente do volume que se utiliza para efeitos de visualização, o estado das transformações deve ser gravado e reposto antes e depois do processo de selecção,

Passos para a activação do Modo de Selecção (cont.)

(81)

Passos para a activação do Modo de Selecção (cont.)

5) Alternar comandos de desenho de primitivas com comandos de manipulação do stack de nomes.

/* Com um só nível hierárquico */ glInitNames ( ); glPushName (-1); …… glLoadName (1); drawOneObject (); glLoadName (2); drawAnotherObject (); glLoadName (3); drawYetAnotherObject ();

Os comandos glPushName, glPopName e glLoadName são ignorados se não se estiver em modo de selecção. O mesmo código de desenho pode ser usado para “Rendering” ou “Selection”

6) Abandonar o Modo “Selection” e processar a informação armazenada no array de “Selection Hits”. Cada “hit” regista os seguintes ítens:

• O número de nomes presentes no stack de nomes na altura em que o “hit” aconteceu

• Valores mínimo e máximo em z de todos os vértices da primitiva que intersectou o view-volume • Todos os valores contidos no stack de nomes na altura em que se deu o “hit”, começando pelo

(82)

Operação de Pick com base no Mecanismo de Selecção

Utilizar uma Matriz de Picking, em conjugação com a matriz de projecção para restringir a selecção de primitivas a uma pequena região do viewport, tipicamente centrada na posição indicada por um cursor.

Regras a considerar:

1) A rotina que define a Matriz de Pick deve ser invocada antes da definição da Projecção 2) A operação de pick é geralmente despoletada a partir de um evento proveniente de um

dispositivo de interacção de tipo locator.

void gluPickMatrix (GLdouble x, GLdouble y, GLdouble width, GLdouble height, GLint viewport [4] );

x, y: centro da região de pick em coordenadas da janela (posição do cursor) width, height: dimensões da região de pick em coordenadas do ecrã (sensibilidade)

(83)

Transformações Inversas

• Para efectuar o pick é necessário obter, a partir

de coordenadas 2D da imagem de um vértice, a

respectiva localização 3D. Com algumas

restrições (por exemplo matriz que não se pode

inverter) a função gluUnProject efectua essa

operação.

(84)

4-Cor e Iluminação

(85)

Definição de Cor

• Modelo RGB e A (transparência) sendo

possível interrogar o número de planos

existentes para cada canal (R,G,B,A).

• Pode ser definida cor de modo directo ou

indexado (entrada numa Tabela de Cores).

(86)

Propriedades Materiais

• Pode definir-se propriedades das faces dianteiras

e traseiras (ou de ambas) dos polígonos através

dos seguintes parâmetros:

– Cores ambiente e difusa;

– Cor especular e respectivo expoente de brilho;

– Cor de emissão (fonte de energia luminosa).

(87)

Modelos de Sombreamento

• Podem ser definidos os Modelos de

Sombreamento

– Constante

(88)

Cálculos de Iluminação

• Descreve-se a luz proveniente das fontes e a iluminação da superfície dos objectos com base num modelo cromático RGB.

• A côr de uma fonte de luz é definida pela percentagem (0 a 1) de luz vermelha, verde e azul que emite.

• Os materiais constituintes das superfícies a iluminar são caracterizados pela percentagem de luz vermelha, verde e azul recebida, que voltam a reflectir segundo variadas direcções.

• Uma mesma cena pode ser iluminada por mais que uma fonte de luz. Cada uma dessas fontes pode ser activada ou desactivada independentemente das restantes.

• Parte da luz provêm directamente das fontes de luz, de uma direcção e posição definidas, e parte provêm de direcção indefinida, como resultado de múltiplas reflexões da luz, proveniente das fontes, sobre os objectos da cena (luz ambiente).

• Pode definir-se uma componente de luz ambiente global, para a qual não é possível identificar sequer a fonte de origem.

(89)

As Várias Componentes de Luz

Luz Emitida:

Luz Especular: Luz Ambiente:

Luz Difundida:

Luz emitida pela própria superfície do objecto, não afectada por qualquer fonte de luz.

Luz proveniente de todas as direcções (devido a múltiplas reflexões na cena) e reflectida pela superfície em todas as direcções.

Luz proveniente de uma direcção bem definida e reflectida igualmente segundo todas as direcções. A quantidade de luz reflectida depende do ângulo de incidência da luz na superfície. O brilho da superfície não depende da direcção de observação.

Luz proveniente de uma direcção bem definida e que tende a reflectir-se em torno de uma direcção preferencial. O brilho da superfície depende da direcção de observação.

(90)

Conjugação das Propriedades das Fontes e dos Materiais

• As Fontes de Luz

Embora uma fonte real emita luz numa só distribuição de frequências, o OpenGL considera valores de R G B diferentes para as componentes ambiente, difusa e especular (valores LR, LG, LB no intervalo [0, 1] ).

• Os Materiais

Para os materiais definem-se valores de R, G, B (MR, MG, MB no intervalo [0,1]), um conjunto para cada uma das componentes de luz reflectida: ambiente, difusa e especular.

• A Luz Reflectida por Componente

A luz reflectida por um objecto, em cada uma das diferentes componentes, é dada pelo produto entre os correspondentes valores de R, G, B da fonte de luz e do material:

(LR * MR, LG * MG, LB * MB)

• A Iluminação Total

A iluminação de um objecto, ou seja, a totalidade da luz que nele se reflecte e atinge a vista do observador obtém-se somando entre si os valores R G B de cada componente de reflexão.

(R1+R2 + … + Rn, G1 + G2 + … + Gn, B1 + B2 + … + Bn )

(91)

Representação de uma Cena com Iluminação

Para obter, em openGL, a representação de uma cena com cálculos de iluminação, há que efectuar, necessariamente, os seguintes passos:

1) Definir, para todos os objectos presentes na cena, os vectores normais a cada um dos seus vértices.

2) Criar, posicionar e seleccionar uma ou mais fontes de luz.

3) Definir os parâmetros do modelo de iluminação (características, como o

nível de luz ambiente global e a localização efectiva do ponto de observação).

3) Definir os parâmetros do modelo de iluminação (características, como o

nível de luz ambiente global e a localização efectiva do ponto de observação).

4) Definir, para todos os objectos presentes na cena, as propriedades ópticas dos respectivos materiais.

(92)

Criação e Activação de Fontes de Luz

1) Sucessivas invocações da função glLight*() permitem estabelecer diferentes características para uma dada fonte de luz

glLight{if}[v] (Glenum light, Glenum pname, TYPE param);

light: índice da fonte a parametrizar (GL_LIGHT0, GL_LIGHT1, …, GL_LIGHT7)

pname: indicação da característica que se pretende definir param: valor a atribuir à característica seleccionada

glLight{if}[v] (Glenum light, Glenum pname, TYPE param);

light: índice da fonte a parametrizar (GL_LIGHT0, GL_LIGHT1, …, GL_LIGHT7) pname: indicação da característica que se pretende definir

param: valor a atribuir à característica seleccionada

2) Deve preparar-se o sistema para executar cálculos de iluminação

2) Deve preparar-se o sistema para executar cálculos de iluminação glEnable (GL_LIGHTING); glEnable (GL_LIGHTING);

3) Deve activar-se uma ou mais fontes de luz previamente parametrizadas

3) Deve activar-se uma ou mais fontes de luz previamente parametrizadas glEnable (lightIndex);

glEnable (lightIndex);

4) Os cálculos de iluminação devem ser complementados com cálculos de remoção de superfícies

(93)

Propriedades de uma Fonte de Luz

• GL_AMBIENT: valores RGBA para a intensidade da luz ambiente

• GL_DIFFUSE: valores RGBA para a intensidade da luz difusa

• GL_SPECULAR: valores RGBA para a intensidade da luz especular

• GL_POSITION: (x, y, z, w) se w = 0, fonte de luz direccional: posição infinita e direcção dada por (x, y, z)

se w = 1, fonte de luz posicional, com posição dada por (x, y, z) em coord. de objecto. Raios divergentes.

• GL_POSITION: (x, y, z, w) se w = 0, fonte de luz direccional: posição infinita e direcção dada por (x, y, z)

se w = 1, fonte de luz posicional, com posição dada por (x, y, z) em coord. de objecto. Raios divergentes.

• GL_SPOT_DIRECTION: • GL_SPOT_DIRECTION: • GL_SPOT_EXPONENT: • GL_SPOT_EXPONENT: • GL_SPOT_CUTOFF: • GL_SPOT_CUTOFF: • GL_CONSTANT_ATTENUATION (Kc): • GL_CONSTANT_ATTENUATION (Kc): • GL_LINEAR_ATTENUATION (Kl): • GL_LINEAR_ATTENUATION (Kl): direction direction cutoff cutoff cos (θ)

cos (θ)exponentexponent

attenuation factor =

attenuation factor = 11

Kc + Kl.d + Kq.d2

(94)

Fontes de Luz e Transformações

• O openGL trata a posição e direcção de uma fonte de luz da mesma forma que trata a informação geométrica das primitivas gráficas.

• Os valores da posição e direcção de uma fonte, estabelecidos através da função glLight (), são transformados por aplicação da Transformação ModelView corrente e guardados em

coordenadas de vista (eye coordinates).

• Os valores da posição e direcção de uma fonte, estabelecidos através da função glLight (), são transformados por aplicação da Transformação ModelView corrente e guardados em

coordenadas de vista (eye coordinates).

• Assim, a posição e direcção de uma fonte de luz pode ser manipulada por alteração da matriz ModelView.

• Para criar uma fonte de luz que se mova com o ponto de observação, basta definir a posição e orientação da fonte antes de estabelecer a transformação de visualização. Assim, os parâmetros ficam directamente definidos em coordenadas de vista (a posição relativa da fonte e da câmara não muda)