OpenGL

Computação Gráfica

O que é OpenGL?

• Uma linguagem de programação gráfica de baixo nível

• Projetada para gráfico interativo 2D e 3D• Uma interface para o hardware gráfico• Descendente do GL• Céticos dizem que é GL com variáveis de

nomes mais longos e sem gerenciamento de janela

•Implementações

• Mesa: implementação para Sun Sparcs e Linux PCs (disponível livremente)

• SGIs tem implementações SGI’s ~ 1500% mais rápidas (acesso direto ao hardware).– Não passa pelo SO

Como funciona o Open GL?

• Um conjunto de variáveis de estado – cor, parâmetros de visualização corrente

(matrizes de transformações), largura de linha, final de linha, propriedades de objetos etc...

• Altere o valor das variáveis– Aplica-se a todo comando de desenho seguinte.

• Algumas variáveis possuem valores default no início (ex: Shading = FLAT).

Máquina de estados

• Habilitar ou desabilitar um estado ou predicado– glEnable() or glDisable().

• Saber o estado corrente de uma variável:– glGetBooleanv(), glGetDoublev(), glGetFloatv(),

glGetIntegerv(), glGetPointerv(), ou glIsEnabled()

• Mais específicas (parâmetros de iluminação)– glGetLight*()

O que OpenGL cobre?

• Primitivas OpenGL são pontos, linhas e polígonos• Não faz “windowing” (gerenciamento de janelas e

menus). – Use Xforms, Python, FLTK, TCL-TK, QT4 ou...

• Use a biblioteca Glut que formalmente não faz parte do OpenGL, mas vem com o pacote; ela pode ser usada para gerenciamento de janelas, menus, sliders, controle de mouse, teclado, etc.

Pipeline de renderização

Pipeline

• Dados geométricos (vertices, lines, e polygons) seguem o caminho que inclui evaluators e per-vertex

• Dados raster (pixels, images, e bitmaps) são tratados de forma diferente.

• Ambos tipos seguem os mesmos passos finais (rasterization e per-fragment operations) antes que os dados raster finais sejam escritos no frame-buffer.

Display Lists

• Todos os dados (descrição de geometria ou de pixels) podem ser salvos numa display list para ser usada instantaneamente ou futuramente. Facilita cálculos (aplicação de transformações, textura, etc).

• Quando pronto para renderizar, envia tudo de uma vez.

Evaluators

• Provêem uma maneitra de derivar vértices usados para representar superfícies a partir de pontos de controle (Splines).

• Mapeamento polinomial que produz normal à superfície, coordenadas de textura, cores e coordenadas espaciais a partir de valores em pontos pré-definidos.

Per Vertex Operation

• Converte Vértices em Primitivas (pontos, linhas, polígonos)

• Multiplicação por matrizes para gerar projeção

• Textura

• Iluminação (lighting)

Primitive Assembly

• Clipping

• Resultado: vértices transformados e cortados (clipped) com a respectiva cor, profundidade (Z-Buffer), e, eventualmente, o valor da coordenada de textura associada e outros parâmetros para renderização.

Pixel Operations

• Empacotar no formato devido

• Escalar, guiar, e processar por um pixmap

• Resultado escrito em memória de textura ou enviado para a rasterização

Texture assembly

• Aplicação de texturas

• Resultado é a montagem da textura na cena

Rasterização

• Conversão de ambos dados (geometria e pixels) em fragments.

• Cada fragmento quadrado corresponde a um pixel no framebuffer

• Valores de cor e profundidade são dados a cada fragmento quadrado.

Fragment Operations

• Texturização

• Cálculo de fog (neblina, refração, etc)

• Scissor test, alpha test, stencil test, depth-buffer (Z-Buffer) test

• Blending, dithering, operações lógicas e masking com uma máscara de bits

• Resultado é o pixel a ser finalmente escrito

Acertando uma janela de trabalho

• Coordenadas para os extremos

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

• e.g., glOrtho(0, 100, 0, 100, -1, 1);

• near & far devem ser sempre -1 & 1 (pelo menos por enquanto)

Limpando uma janela

• glClearColor(r, g, b, a);

• a é o canal alpha; coloque em 0.

• glClear(GL_COLOR_BUFFER_BIT);

• glClear pode limpar outros buffers assim também, mas usamos por enquanto apenas o buffer de cor

Estabelecendo uma cor

• Todas as primitivas subsequentes serão desta cor.

• Modelo de cor Red, Green & Blue

• Components são 0-1 (normalizados)

– glColor4f(r,g,b,a);

Sintaxes dos comandos

• Nota: convenção de nomes OpenGL é: – gl<Command>[234][sifd][v] (args... ) – s - short, i - integer, f - float, d- double – v – ponteiro para um array

• Constantes: começam com GL_

SufixosSuf Type C-Language Type OpenGL Type

b 8-bit integer signed char GLbyte

s 16-bit integer short GLshort

i 32-bit integer int or long GLint, GLsizei

f 32-bit fp float GLfloat, GLclampf

d 64-bit fp double GLdouble, GLclampd

Sufixo

ub 8-bit unsigned integer

unsigned char GLubyte, GLboolean

us 16-bit unsigned integer

unsigned short GLushort

ui 32-bit unsigned integer

unsigned int or unsigned long

GLuint, GLenum, GLbitfield

Desenhando um polígono

• glBegin(GL_POLYGON); • Envie então os pontos construindo o polígono• glVertex2f(x0, y0); • glVertex2f(x1, y1); • glVertex2f(x2, y2) ... • Diga que o polígono terminou • glEnd(); • That’s it .

Truques especiais

• No lugar de GL_POLYGON: – GL_POINTS: plot points

– GL_LINES: draw lines

– GL_LINE_LOOP: framed polygon

• Gouraud Shading: – Mude a cor entre cada comando e GL fará um shading suave entre

as cores dos diferentes vértices.

• Fazendo Flush do pipeline : glFlush();

Desenhando uma caixa• MakeWindow("Box", 400, 400); /*Sua rotina de criar janela*/

glOrtho(-1, 1, -1, 1, -1, 1);

glClearColor(0.5, 0.5, 0.5, 1);

glClear(GL_COLOR_BUFFER_BIT);

glColor3f(1.0, 0.0, 0.0);

glBegin(GL_POLYGON);

/* or GL_LINES or GL_POINTS... */

glVertex2f(-0.5, -0.5);

glVertex2f( 0.5, -0.5);

glVertex2f( 0.5, 0.5);

glVertex2f(-0.5, 0.5);

glEnd();

Trabalho de Laboratório

• Implementar diretamente os exemplos, sem modificar, e ver seus efeitos. Tempo estimado: 15 minutos. Comente sucintamente no relatório cada função ou bloco de comandos que voce entender (consulte o manual do red book para isso). Example 1-2 : Simple OpenGL Program Using GLUT: hello.c Example 1-3 : Double-Buffered Program: double.c

• Modificar exemplo 1-3 de modo que o quadrado gire no sentido oposto (tempo estimado: 5 minutos).