Introduo Computao Grfica Open GL Bsico Claudio Esperana

Introdução à Computação Gráfica Open. GL Básico Claudio Esperança Paulo Roma Cavalcanti

Open. GL – O que é? • Uma API para geração de gráficos w 3 D e 2 D w Primitivas vetoriais e matriciais (imagens) w Capaz de gerar imagens de alta qualidade w Comumente implementado de forma a tirar partido da aceleração gráfica (se disponível) w Independente de plataforma w Independente de sistema de janelas

Sistemas de Janela • Principal meio de interação homem/máquina em ambientes de computação modernos • Tela é dividida em janelas (eventualmente superpostas) • Janelas são controladas por aplicações que têm a incumbência de mantê-las sempre atualizadas • Interação do usuário e do próprio sistema de janelas são comunicados à aplicação através de eventos, ex. : w Mouse foi apertado w Janela foi redimensionada • Eventos são tratados por rotinas callback da aplicação. Ex. : w Redesenhar o conteúdo da janela w Mover um objeto de um lado para outro da janela • Cada Sistema de Janelas possui uma API distinta w MS Windows, X, Apple w Portabilidade: Camada de interface com diversos SJ mas com API única (ex. : GLUT)

Arquitetura do Open. GL Avaliador Polinomial CPU Listas de Display Operações sobre pixels Operações por vértice & Montagem de primitivas Rasterização Memória de Textura Operações por Fragmento Frame Buffer

Desenhando com Open. GL • Open. GL funciona como uma máquina de estados • API tem rotinas para w Desenhar primitivas geométricas e imagens w Alterar variáveis de estado (ex. : cor, material, fontes de iluminação, etc) w Consultar variáveis de estado • Open. GL é um padrão em evolução w Mecanismo padronizado de extensões w Novas versões são estabelecidas por um comitê (ARB) de usuários e fabricantes

APIs Relacionadas • GLU (Open. GL Utility Library) w Parte do padrão Open. GL w NURBS, trianguladores, quádricas, etc. • AGL, GLX, WGL w Camadas entre o Open. GL os diversos sistemas de janelas • GLUT (Open. GL Utility Toolkit) w API portátil de acesso aos sistemas de janelas w Encapsula e esconde as camadas proprietárias w Não é parte official do Open. GL

Anatomia de um programa Open. GL/GLUT #include <GL/glut. h> /* Outros headers */ Headers void display (void) {. . . } Rotinas Callback /* Outras rotinas callback */ int main (int argc, char *argv[]) { glut. Init (&argc, argv); glut. Init. Display. Mode( modo ); glut. Create. Window( nome_da_janela ); glut. Display. Func( display ); glut. Reshape. Func( reshape. Callback ); /* Registro de outras rotinas callback */ glut. Main. Loop(); return 0; } Inicialização do GLUT Inicialização da janela Registro de callbacks Laço principal

Headers Open. GL/GLUT #include <GL/glut. h> w Já inclui automaticamente os headers do Open. GL: #include <GL/gl. h> #include <GL/glu. h> • Se GLUT não for usado, os headers Open. GL têm que ser incluídos explicitamente, junto com os de outra camada de interface • Há APIs para construção de interfaces gráficas (GUI) construídas sobre o GLUT cujos headers incluem os do GLUT w Por exemplo, o pacote GLUI requer: #include <GL/glui. h> • (Já inclui glut. h)

GLUT – Registrando Callbacks • Callbacks são rotinas que serão chamadas para tratar eventos. • Para uma rotina callback ser efetivamente chamada ela precisa ser registrada através da função glut. Xxx. Func (callback) w Onde Xxx designa uma classe de eventos e callback é o nome da rotina • Por exemplo, para registrar uma callback de desenho chamada Desenho, usa-se glut. Display. Func (Desenho);

GLUT – Callback de desenho • É a rotina chamada automaticamente sempre que a janela ou parte dela precisa ser redesenhada (ex. : janela estava obscurecida por outra que foi fechada) • Todo programa GLUT precisa ter uma! • Exemplo: void display ( void ) { gl. Clear( GL_COLOR_BUFFER_BIT ); gl. Begin( GL_TRIANGLE_STRIP ); gl. Vertex 3 fv( v[0] ); gl. Vertex 3 fv( v[1] ); gl. Vertex 3 fv( v[2] ); gl. Vertex 3 fv( v[3] ); gl. End(); glut. Swap. Buffers(); /* Usamos double-buffering! */ }

GLUT – Callback de redimensionamento • Chamada sempre que a janela é redimensionada, isto é, teve seu tamanho alterado • Tem a forma void reshape (int width, int height){. . . } w width/height são a nova largura/altura da janela (em pixels) • Se uma rotina de redimensionamento não for especificada, o GLUT usa uma rotina de redimensionamento “default” que simplesmente ajusta o viewport para usar toda a área da janela

GLUT - Callbacks • Outras callbacks comumente usadas void keyboard (unsigned char key, int x, int y) • Eventos de teclado void mouse(int button, int state, int x, int y) void motion(int x, int y) void passive. Motion(int x, int y) • Eventos de mouse void idle (void) • Chamada continuamente quando nenhum outro evento ocorre • Várias outras

Programa Open. GL/GLUT - Inicialização • Inicialização do GLUT glut. Init (int* argc, char** argv) • Estabelece contato com sistema de janelas • Em X, opções de linha de comando são processadas e removidas

Programa Open. GL/GLUT - Inicialização • Inicialização da(s) janela(s) glut. Init. Display. Mode (int modo) • Estabelece o tipo de recursos necessários para as janelas que serão criadas. Modo é um “ou” bit-a-bit de constantes: – – – GLUT_RGB cores dos pixels serão expressos em RGB GLUT_DOUBLE bufferização dupla (ao invés de simples) GLUT_DEPTH buffer de profundidade (z-buffer) GLUT_ACCUM buffer de acumulação GLUT_ALPHA buffer de cores terá componente alfa glut. Init. Window. Position (int x, int y) • Estabelece a posição inicial do canto superior esquerdo da janela a ser criada glut. Init. Window. Size (int width, height) • Estabelece o tamanho (em pixels) da janela a ser criada

Programa Open. GL/GLUT - Inicialização • Criação da(s) janela(s) int glut. Create. Window (char* nome) • Cria uma nova janela primária (top-level) • Nome é tipicamente usado para rotular a janela • O número inteiro retornado é usado pelo GLUT para identificar a janela • Outras inicializações w Após a criação da janela é costumeiro configurar variáveis de estado do Open. GL que não mudarão no decorrer do programa. Por exemplo: • Cor do fundo • Tipo de sombreamento de desejado

Programa Open. GL/GLUT – Laço Principal • Depois de registradas as callbacks, o controle é entregue ao sistema de janelas: glut. Main. Display. Loop (void) • Esta rotina na verdade é o “despachante” de eventos • Ela nunca retorna

Exemplo (do livro vermelho) #include <GL/glut. h> void display(void) { /* Limpar todos os pixels */ gl. Clear (GL_COLOR_BUFFER_BIT); /* Desenhar um polígono branco (retângulo) */ gl. Color 3 f (1. 0, 1. 0); gl. Begin(GL_POLYGON); gl. Vertex 3 f (0. 25, 0. 0); gl. Vertex 3 f (0. 75, 0. 0); gl. Vertex 3 f (0. 25, 0. 75, 0. 0); gl. End(); /* Não esperar! */ gl. Flush (); }

Exemplo (do livro vermelho - cont) void init (void) { /* selecionar cor de fundo (preto) */ gl. Clear. Color (0. 0, 0. 0); /* inicializar sistema de viz. */ gl. Matrix. Mode(GL_PROJECTION); gl. Load. Identity(); gl. Ortho(0. 0, 1. 0, -1. 0, 1. 0); } int main(int argc, char** argv) { glut. Init(&argc, argv); glut. Init. Display. Mode (GLUT_SINGLE | GLUT_RGB); glut. Init. Window. Size (250, 250); glut. Init. Window. Position (100, 100); glut. Create. Window ("hello"); init (); glut. Display. Func(display); glut. Main. Loop(); /* C ANSI requer que main retorne um inteiro */ return 0; }

Resultado do Exemplo

Open. GL com Python • Open. GL também pode ser usado com outras linguagens, como Python, por exemplo • Há pelo menos 2 pacotes (“bindings”) para usar Open. GL em Python w Py. Open. GL (http: //pyopengl. sourceforge. net) w Pyglet (http: //www. pyglet. org) • Uso é muito semelhante ao uso com C w Py. Open. GL usa GLUT para interfacear com sistema de janelas w Pyglet oferece interface própria

Exemplo do livro vermelho com Py. Open. GL #!/usr/bin/python # coding: utf-8 import sys from Open. GLUT import * from Open. GL. GLU import * def display(): # Limpar todos os pixels gl. Clear (GL_COLOR_BUFFER_BIT) # Desenhar um polígono branco (retângulo) gl. Color 3 f (1. 0, 1. 0) gl. Begin(GL_POLYGON); for x, y in [(0. 25, 0. 25), (0. 75, 0. 75), (0. 25, 0. 75)]: gl. Vertex 3 f (x, y, 0) gl. End() gl. Flush()

Exemplo do livro vermelho com Py. Open. GL def init (): # selecionar cor de fundo (preto) gl. Clear. Color (0. 0, 0. 0); # inicializar sistema de viz. gl. Matrix. Mode(GL_PROJECTION) gl. Load. Identity() gl. Ortho(0. 0, 1. 0, -1. 0, 1. 0) glut. Init(sys. argv) glut. Init. Display. Mode (GLUT_SINGLE | GLUT_RGB) glut. Init. Window. Size (250, 250) glut. Init. Window. Position (100, 100) glut. Create. Window ('hello') init () glut. Display. Func(display) glut. Main. Loop()

Open. GL – Primitivas de desenho gl. Begin ( PRIMITIVA ); especificação de vértices, cores, coordenadas de textura, propriedades de material gl. End (); • Entre gl. Begin() e gl. End() apenas alguns comandos podem ser usados. Ex. : w gl. Material w gl. Normal w gl. Tex. Coord • Uma vez emitido um vértice (gl. Vertex), este é desenhado com as propriedades (cor, material, normal, coordenadas de textura etc) registradas nas variáveis de estado correspondentes • Conclusão: Antes de emitir um vértice, assegurar-se que cor, material, normal, etc têm o valor certo

Open. GL – Primitivas de desenho GL_LINES GL_POINTS v 2 v 3 v 5 v 1 v 4 v 1 v 2 v 5 GL_TRIANGLES v 4 GL_LINE_STRIP v 4 v 6 v 1 v 3 v 5 v 2 v 3 v 6 v 2 v 3 v 5 GL_QUADS v 4 v 1 v 5 v 3 v 2 8 v 7 v 4 GL_POLYGON GL_TRIANGLE_FAN v 1 v 4 v 6 v 5 v 2 v 4 v 2 v 1 v 6 v 1 GL_TRIANGLE_STRIP v 6 GL_LINE_LOOP GL_QUAD_STRIP v 5 v 3 v 1 v 3 v 5 v 2 v 4 v 6 v 2 v 3 v 4

Open. GL – Exemplo de desenho simples void draw. Rhombus( GLfloat color[] ) { gl. Begin( GL_QUADS ); gl. Color 3 fv( color ); gl. Vertex 2 f( 0. 0, 0. 0 ); gl. Vertex 2 f( 1. 5, 1. 118 ); gl. Vertex 2 f( 0. 5, 1. 118 ); gl. End(); }

Open. GL – Convenções de Nome gl. Vertex 3 fv( v ) Número de componentes 2 - (x, y) 3 - (x, y, z) 4 - (x, y, z, w) Tipo de dado b ub s us i ui f d - byte unsigned byte short unsigned short int unsigned int float double vetor omita o “v” qdo coords dadas uma a uma gl. Vertex 2 f( x, y )

Open. GL Especificando Cores Poly. CPU Per Vertex Raster DL Frag Texture Pixel color index mode Red Green 1 2 4 8 ww 16 ww Blue 0 1 2 3 24 25 26 Display 123 www 219 74 www RGBA mode FB

Open. GL – Controlando as cores • Cores especificadas diretamente (default) w Usar gl. Color. Index() ou gl. Color() • Computadas a partir de um modelo de iluminação w Ligar a iluminação: gl. Enable (GL_LIGHTING); w Escolher modelo de sombreamento: • Constante por face: gl. Shade. Model (GL_FLAT); • Gouraud (default): gl. Shade. Model (GL_SMOOTH); w Ligar ao menos uma fonte de luz. Ex: gl. Enable(GL_LIGHT 0); w Especificar propriedades da(s) fonte(s) de luz: gl. Light() w Especificar propriedades de material de cada objeto: gl. Material() w Especificar normais de cada face ou de cada vértice: gl. Normal()

Open. GL - Sombreamento constante por face e Gouraud

Open. GL – Exemplo de Inicialização void myinit(void) { GLfloat light_ambient[] = { 0. 0, 1. 0 }; GLfloat light_diffuse[] = { 1. 0, 1. 0 }; GLfloat light_specular[] = { 1. 0, 1. 0 }; GLfloat light_position[] = { 1. 0, 0. 0 }; gl. Lightfv(GL_LIGHT 0, GL_AMBIENT, light_ambient); GL_DIFFUSE, light_diffuse); GL_SPECULAR, light_specular); GL_POSITION, light_position); gl. Enable(GL_LIGHTING); gl. Enable(GL_LIGHT 0); gl. Enable(GL_DEPTH_TEST); gl. Shade. Model (GL_SMOOTH); }