computação gráfica - introdução ao opengl

Computação GráficaComputação GráficaAula 5 – Introdução ao Aula 5 – Introdução ao

OpenGLOpenGL

Prof. Tony Alexander HildProf. Tony Alexander HildDocumento licenciado por Creative Commons - http://creativecommons.org/licenses/by-nc-sa/2.5/br/

HistóricoHistórico

Início da década de 80: Início da década de 80: Cada fabricante de hardware tinha seu próprio conjunto de instruções para desenho de Cada fabricante de hardware tinha seu próprio conjunto de instruções para desenho de gráficos 2D e 3D;gráficos 2D e 3D;Construir aplicações que suportassem vários hardwares era um verdadeiro desafio;Construir aplicações que suportassem vários hardwares era um verdadeiro desafio;Esforço era constantemente duplicado e havia pouco espaço para companhias menores e Esforço era constantemente duplicado e havia pouco espaço para companhias menores e sem capital para tamanho investimento.sem capital para tamanho investimento.Meados dos anos 80:Meados dos anos 80:Um padrão surgiu na indústria;Um padrão surgiu na indústria;Chamado PHIGS (sigla de Programmer’s Hierarchical, Graphics System) e começou a ser Chamado PHIGS (sigla de Programmer’s Hierarchical, Graphics System) e começou a ser adotado por grandes fabricantes da época;adotado por grandes fabricantes da época;Entretanto, embora tenha sido reconhecido por entidades como a ANSI e a ISO, o Entretanto, embora tenha sido reconhecido por entidades como a ANSI e a ISO, o padrão começou a ser considerado complicado e desatualizado.padrão começou a ser considerado complicado e desatualizado.Final dos anos 80:Final dos anos 80:A Silicon Graphics Inc. (SGI), criou um padrão chamado IRIS GL, que não só começou a A Silicon Graphics Inc. (SGI), criou um padrão chamado IRIS GL, que não só começou a chamar atenção da indústria, como também foi considerado o estado da arte de uma API chamar atenção da indústria, como também foi considerado o estado da arte de uma API gráfica. Consideravelmente mais fácil de usar, a API começou a tornar-se um padrão de gráfica. Consideravelmente mais fácil de usar, a API começou a tornar-se um padrão de fato na indústria.fato na indústria.


Entretanto, grandes empresas produtoras da hardware, como a Sun Entretanto, grandes empresas produtoras da hardware, como a Sun Microsystems e a IBM, ainda eram capazes de fabricar hardware adotando o Microsystems e a IBM, ainda eram capazes de fabricar hardware adotando o padrão PHIGS;padrão PHIGS;Isso levou a SGI a tomar uma decisão para que a adoção de sua API fosse Isso levou a SGI a tomar uma decisão para que a adoção de sua API fosse impulsionada: torná-la um padrão público, para que todos os fabricantes de impulsionada: torná-la um padrão público, para que todos os fabricantes de hardware pudessem adotá-lo;hardware pudessem adotá-lo;A API Iris continha muito código proprietário e portanto não poderia ser A API Iris continha muito código proprietário e portanto não poderia ser aberta;aberta;Também lidava com questões não tão relacionadas ao desenho 2D e 3D, Também lidava com questões não tão relacionadas ao desenho 2D e 3D, como gerenciamento de janelas, teclado e mouse;como gerenciamento de janelas, teclado e mouse;Ainda assim, era do interesse da Silicon Graphics manter os seus antigos Ainda assim, era do interesse da Silicon Graphics manter os seus antigos clientes comprando seu hardware;clientes comprando seu hardware;Como um resultado disso, o padrão OpenGL é criado:Como um resultado disso, o padrão OpenGL é criado:Desde 1992, o padrão é mantido pelo ARB (Architecture Review Board), um conselho Desde 1992, o padrão é mantido pelo ARB (Architecture Review Board), um conselho formado por empresas como a 3DLabs, ATI, Dell, Evans&Sutherland, HP, IBM, Intel, formado por empresas como a 3DLabs, ATI, Dell, Evans&Sutherland, HP, IBM, Intel, Matrox, NVIDIA, Sun e, logicamente, a Silicon Graphics;Matrox, NVIDIA, Sun e, logicamente, a Silicon Graphics;O papel desse conselho é manter a especificação e indicar quais recursos serão O papel desse conselho é manter a especificação e indicar quais recursos serão adicionados a cada versão;adicionados a cada versão;A versão mais atual do OpenGL até hoje é a 2.1.A versão mais atual do OpenGL até hoje é a 2.1.


Os projetistas do OpenGL sabiam de duas coisas:Os projetistas do OpenGL sabiam de duas coisas:A primeira é que fabricantes de hardware gostariam de adicionar recursos A primeira é que fabricantes de hardware gostariam de adicionar recursos próprios, sem que tivessem que esperar para esses recursos estarem próprios, sem que tivessem que esperar para esses recursos estarem oficialmente aceitos no padrão. Para resolver esse problema, eles incluíram oficialmente aceitos no padrão. Para resolver esse problema, eles incluíram uma maneira de extender o OpenGL. Muitas vezes, essas extensões são uma maneira de extender o OpenGL. Muitas vezes, essas extensões são interessantes o suficiente para que outros vendedores de hardware as interessantes o suficiente para que outros vendedores de hardware as adotem. Então, quando elas são consideradas suficientemente abrangentes, adotem. Então, quando elas são consideradas suficientemente abrangentes, ou suficientemente importantes, a ARB pode promovê-las para que façam ou suficientemente importantes, a ARB pode promovê-las para que façam parte do padrão oficial. Praticamente todas as modificações recentes do parte do padrão oficial. Praticamente todas as modificações recentes do padrão começaram como extensões, a grande maioria devido ao mercado de padrão começaram como extensões, a grande maioria devido ao mercado de jogos.jogos.Em segundo lugar, os projetistas também sabiam que muitos hardwares não Em segundo lugar, os projetistas também sabiam que muitos hardwares não seriam poderosos o suficiente para abranger todo o padrão. Por isso, também seriam poderosos o suficiente para abranger todo o padrão. Por isso, também incluíram extensões de software, que permitiam emular essas incluíram extensões de software, que permitiam emular essas funcionalidades. Isso resolvia um problema sério que ocorria com a Iris: O da funcionalidades. Isso resolvia um problema sério que ocorria com a Iris: O da aplicação simplesmente não rodar pela falta de um ou outro recurso.aplicação simplesmente não rodar pela falta de um ou outro recurso.

Arquitetura do OpenGLArquitetura do OpenGL

O OpenGL é um conjunto de funções, que fornecem acesso aos recursos do hardware de O OpenGL é um conjunto de funções, que fornecem acesso aos recursos do hardware de vídeo;vídeo;Age como uma máquina de estados, que dizem ao OpenGL o que fazer;Age como uma máquina de estados, que dizem ao OpenGL o que fazer;Usando as funções da API, você pode ligar ou desligar vários aspectos dessa máquina, Usando as funções da API, você pode ligar ou desligar vários aspectos dessa máquina, tais como:tais como:A cor atual;A cor atual;Se transparência será usadaSe transparência será usadaSe cálculos de iluminação devem ser feitos;Se cálculos de iluminação devem ser feitos;Se haverá ou não o efeito de neblina. Etc.Se haverá ou não o efeito de neblina. Etc.É importante conhecer cada um desses estados, pois não é incomum a obtenção de É importante conhecer cada um desses estados, pois não é incomum a obtenção de resultados indesejados simplesmente por deixar um ou outro estado definido de maneira resultados indesejados simplesmente por deixar um ou outro estado definido de maneira incorreta.incorreta.O OpenGL também foi projetado para funcionar mesmo que a máquina que esteja O OpenGL também foi projetado para funcionar mesmo que a máquina que esteja exibindo os gráficos não seja a mesma que contém o programa gráfico. Pode ser o caso exibindo os gráficos não seja a mesma que contém o programa gráfico. Pode ser o caso dos dois computadores estarem conectados em rede e, sendo que nesse caso o dos dois computadores estarem conectados em rede e, sendo que nesse caso o computador que gera os comandos é chamado cliente, enquanto o que recebe e executa computador que gera os comandos é chamado cliente, enquanto o que recebe e executa os comandos de desenho é chamado de servidor. O formato de transmissão desses os comandos de desenho é chamado de servidor. O formato de transmissão desses comandos (chamado protocolo) também é padronizado, então é possível que duas comandos (chamado protocolo) também é padronizado, então é possível que duas máquinas com sistemas operacionais e hardwares diferentes se comuniquem dessa máquinas com sistemas operacionais e hardwares diferentes se comuniquem dessa forma. Se o OpenGL não está sendo executado numa rede, o computador é considerado forma. Se o OpenGL não está sendo executado numa rede, o computador é considerado ao mesmo tempo cliente e servidor.ao mesmo tempo cliente e servidor.


Essa decisão de design tem uma conseqüência Essa decisão de design tem uma conseqüência muito importante: os comandos do OpenGL não são muito importante: os comandos do OpenGL não são imediatamente enviados para o hardware;imediatamente enviados para o hardware;Eles são agrupados para serem enviados mais Eles são agrupados para serem enviados mais tarde, o que não só otimiza o uso da rede, mas tarde, o que não só otimiza o uso da rede, mas também abre margem para outras otimizações;também abre margem para outras otimizações;Por conseqüência, um erro comum de muitos Por conseqüência, um erro comum de muitos programadores é tentar medir o tempo levado pelos programadores é tentar medir o tempo levado pelos comandos de desenho simplesmente adicionando comandos de desenho simplesmente adicionando funções antes e depois de um comando (ou funções antes e depois de um comando (ou conjunto de comandos) o que, nessa arquitetura, conjunto de comandos) o que, nessa arquitetura, certamente gerará resultados inválidos;certamente gerará resultados inválidos;


Afinal, não há garantias de que os comandos serão Afinal, não há garantias de que os comandos serão imediatamente executados, e, o que acaba sendo imediatamente executados, e, o que acaba sendo medindo com essa estratégia é a velocidade que o medindo com essa estratégia é a velocidade que o OpenGL armazena os comandos para futura OpenGL armazena os comandos para futura execução. Forçar a execução dos comandos execução. Forçar a execução dos comandos também é uma estratégia ruim, já que com isso também é uma estratégia ruim, já que com isso muitas otimizações são simplesmente desprezadas;muitas otimizações são simplesmente desprezadas;Nessa arquitetura, a forma mais confiável de se Nessa arquitetura, a forma mais confiável de se medir a performance é através de software medir a performance é através de software especial, que pode ser baixado na própria página do especial, que pode ser baixado na própria página do OpenGL.OpenGL.

Rendering PipelineRendering Pipeline

O núcleo do OpenGL é conhecido como O núcleo do OpenGL é conhecido como “rendering pipeline”. É importante “rendering pipeline”. É importante notar que o OpenGL lida tanto com o notar que o OpenGL lida tanto com o desenho na forma vetorial, definidas desenho na forma vetorial, definidas por vértices, como com mapas de bits, por vértices, como com mapas de bits, definidos pixel-a-pixel. Os principais definidos pixel-a-pixel. Os principais elementos desse pipeline estão elementos desse pipeline estão descritos a seguir:descritos a seguir:

Rendering Pipeline - Rendering Pipeline - Display ListsDisplay Lists

Display Lists: Todos os dados, sejam Display Lists: Todos os dados, sejam de os vértices de geometrias ou pixels, de os vértices de geometrias ou pixels, podem ser salvos numa display list podem ser salvos numa display list para uso atual ou posterior.para uso atual ou posterior.

Rendering Pipeline - Rendering Pipeline - AvaliadoresAvaliadores

Avaliadores (evaluators): Todas as Avaliadores (evaluators): Todas as primitivas geométricas, no OpenGL são primitivas geométricas, no OpenGL são descrita por vértices. Curvas e descrita por vértices. Curvas e superfícies paramétricas podem ser superfícies paramétricas podem ser descritas por fórmulas, que devem ser descritas por fórmulas, que devem ser derivadas, para recaírem nos vértices. derivadas, para recaírem nos vértices. Quem faz essa avaliação são os Quem faz essa avaliação são os evaluators (avaliadores). evaluators (avaliadores).

Rendering Pipeline - Rendering Pipeline - Operações pré-vérticesOperações pré-vértices

Operações pré-vértice: Para os dados de Operações pré-vértice: Para os dados de vértices, as operações pré-vértice vértices, as operações pré-vértice convertem os vértices em primitivas de convertem os vértices em primitivas de desenho. Nessa etapa, cada vértice é desenho. Nessa etapa, cada vértice é convertido em matrizes 4×4, então cálculos convertido em matrizes 4×4, então cálculos são realizados para que sejam convertidos são realizados para que sejam convertidos do espaço 3D para as coordenadas de tela. do espaço 3D para as coordenadas de tela. Essa etapa ainda realiza operações de Essa etapa ainda realiza operações de cálculos de textura, iluminação, materiais, cálculos de textura, iluminação, materiais, etc. de acordo com quais estados tenham etc. de acordo com quais estados tenham sido habilitados.sido habilitados.

Rendering Pipeline - Rendering Pipeline - Operações com PixelsOperações com Pixels

Operações com Pixels: Enquanto os dados Operações com Pixels: Enquanto os dados geométricos seguem pelo rendering pipeline, geométricos seguem pelo rendering pipeline, os mapas pixels passam por diferentes tipos os mapas pixels passam por diferentes tipos de transformação. Primeiramente, os pixels de transformação. Primeiramente, os pixels são descompactados de acordo com o seu são descompactados de acordo com o seu número de componentes, então eles tem número de componentes, então eles tem sua escala ajustada, seu formato final é sua escala ajustada, seu formato final é calculado, parte de sua área é recortada e calculado, parte de sua área é recortada e então são enviados para o passo chamado então são enviados para o passo chamado rasterization.rasterization.

Rendering Pipeline - Rendering Pipeline - Montagem de texturasMontagem de texturas

Montagem de texturas (texture Montagem de texturas (texture assembly): Permite a aplicação de assembly): Permite a aplicação de imagens como texturas das imagens como texturas das geometrias, para que elas pareçam geometrias, para que elas pareçam mais realistas. Algumas mais realistas. Algumas implementações do OpenGL podem ter implementações do OpenGL podem ter recursos especiais para acelerar esse recursos especiais para acelerar esse passo.passo.

Rendering Pipeline - Rendering Pipeline - RasterizationRasterization

Rasterization: Transforma todos os dados Rasterization: Transforma todos os dados em fragmentos. Cada fragmento é um em fragmentos. Cada fragmento é um quadrado que corresponde a pixels no quadrado que corresponde a pixels no framebuffer. Padrões de linhas e polígonos, framebuffer. Padrões de linhas e polígonos, largura da linha, tamanho do ponto, largura da linha, tamanho do ponto, shading, cálculos de cobertura e anti-shading, cálculos de cobertura e anti-aliasing são todos levados em conta durante aliasing são todos levados em conta durante essa fase. Cor e valores de profundidade são essa fase. Cor e valores de profundidade são considerados para cada fragmento.considerados para cada fragmento.

Rendering Pipeline - Operações Rendering Pipeline - Operações sobre fragmentossobre fragmentos

Operações sobre fragmentos Operações sobre fragmentos (Fragment Operations): Finalmente, (Fragment Operations): Finalmente, operações finais são aplicadas aos operações finais são aplicadas aos fragmentos, tais como recortes, fragmentos, tais como recortes, operações de máscaras de bits (como operações de máscaras de bits (como blending) são aplicadas. Então, os blending) são aplicadas. Então, os pixels são finalmente calculados e são pixels são finalmente calculados e são encaminhados para desenho. encaminhados para desenho.

Outras bibliotecas Outras bibliotecas relacionadas ao OpenGLrelacionadas ao OpenGL

O OpenGL fornece um conjunto poderoso de comandos, mas O OpenGL fornece um conjunto poderoso de comandos, mas restrito apenas ao desenho. Várias bibliotecas existem para restrito apenas ao desenho. Várias bibliotecas existem para facilitar a manipulação de outros aspectos da aplicação, como facilitar a manipulação de outros aspectos da aplicação, como as seguintes:as seguintes:OpenGL Utility Library (GLU): Fornece diversas funções para auxiliar OpenGL Utility Library (GLU): Fornece diversas funções para auxiliar na montagem de matrizes de visualização e projeção, desenho de na montagem de matrizes de visualização e projeção, desenho de superfícies e imagens 3D. Essa biblioteca é fornecida juntamente superfícies e imagens 3D. Essa biblioteca é fornecida juntamente com as implementações do OpenGL e todas as rotinas dessa com as implementações do OpenGL e todas as rotinas dessa biblioteca tem o prefixo glu;biblioteca tem o prefixo glu;Cada ambiente de janelas tem uma biblioteca de extensão do Cada ambiente de janelas tem uma biblioteca de extensão do OpenGL. Por exemplo, o sistema X possui o glx, enquanto o Windows OpenGL. Por exemplo, o sistema X possui o glx, enquanto o Windows fornece a extensão wgl;fornece a extensão wgl;OpenGL Utility Toolkit (GLUT): É um toolkit que abstrai o sistema de OpenGL Utility Toolkit (GLUT): É um toolkit que abstrai o sistema de janelas, fornecendo uma interface simples para a criação de uma janelas, fornecendo uma interface simples para a criação de uma aplicação OpenGL. aplicação OpenGL.

Tao FrameworkTao Framework

Coleção de bindings (links) que Coleção de bindings (links) que facilitam o desenvolvimento de facilitam o desenvolvimento de aplicações de mídia multi-plataforma aplicações de mídia multi-plataforma utilizando .NET e MONO.utilizando .NET e MONO.

Iniciando com OpenGL e Iniciando com OpenGL e C#C#

Crie uma classe com o nome do exemplo:Crie uma classe com o nome do exemplo:

using System;using System;using System.Collections.Generic;using System.Collections.Generic;using System.Text;using System.Text;using gl = Tao.OpenGl.Gl;using gl = Tao.OpenGl.Gl;using glut = Tao.FreeGlut.Glut;using glut = Tao.FreeGlut.Glut;

namespace OpenGlExamplesnamespace OpenGlExamples{{ public class GL2Dpublic class GL2D {{

public GL2D()public GL2D() {{ }} }}}}


Crie o método Init:Crie o método Init:

private static void Init()private static void Init(){{ //forcece os valores para a limpeza do buffer //forcece os valores para a limpeza do buffer

de cor no modo RGBA.de cor no modo RGBA. //Seleciona a cor preta para a linha.//Seleciona a cor preta para a linha.

gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f); gl.glColor3f(0.0f, 0.0f, 0.0f);gl.glColor3f(0.0f, 0.0f, 0.0f); //seleciona o modo de operação ortogonal.//seleciona o modo de operação ortogonal. gl.glOrtho(0, 256, 0, 256, -1, 1);gl.glOrtho(0, 256, 0, 256, -1, 1);}}


Crie o método Display:Crie o método Display:

private static void Display()private static void Display(){{ //Limpa toda a janela para a cor do comando glClearColor.//Limpa toda a janela para a cor do comando glClearColor. gl.glClear(gl.GL_COLOR_BUFFER_BIT);gl.glClear(gl.GL_COLOR_BUFFER_BIT); gl.glBegin(gl.GL_LINES);gl.glBegin(gl.GL_LINES); //Fornece as coordenadas do pontos iniciais e finais.//Fornece as coordenadas do pontos iniciais e finais. gl.glVertex2i(20, 100); gl.glVertex2i(100, 20);gl.glVertex2i(20, 100); gl.glVertex2i(100, 20); gl.glEnd();gl.glEnd();

gl.glBegin(gl.GL_QUADS);gl.glBegin(gl.GL_QUADS);

gl.glVertex2i(20, 20);gl.glVertex2i(20, 20); gl.glVertex2i(30, 20);gl.glVertex2i(30, 20); gl.glVertex2i(30, 40);gl.glVertex2i(30, 40); gl.glVertex2i(20, 40);gl.glVertex2i(20, 40);

gl.glEnd();gl.glEnd(); gl.glFlush();gl.glFlush();}}


Crie o método Keyboard para interação:Crie o método Keyboard para interação:

private static void Keyboard(byte key, int x, int y)private static void Keyboard(byte key, int x, int y){{ switch (key)switch (key) {{ case 27:case 27: Environment.Exit(Environment.ExitCode);Environment.Exit(Environment.ExitCode); break;break; default:default: switch (key)switch (key) {{ case 49:case 49: gl.glColor3f(255.0f, 255.0f, 0.0f);gl.glColor3f(255.0f, 255.0f, 0.0f); break;break; case 50:case 50: gl.glColor3f(255.0f, 0.0f, 0.0f);gl.glColor3f(255.0f, 0.0f, 0.0f); break;break; case 51:case 51: gl.glColor3f(0.0f, 255.0f, 0.0f);gl.glColor3f(0.0f, 255.0f, 0.0f); break;break; case 52:case 52: gl.glColor3f(0.0f, 0.0f, 255.0f);gl.glColor3f(0.0f, 0.0f, 255.0f); break;break; default:default: gl.glColor3f(0.0f, 0.0f, 0.0f);gl.glColor3f(0.0f, 0.0f, 0.0f); break;break; }} glut.glutPostRedisplay();glut.glutPostRedisplay(); break;break; }}}}


Faça a inicialização no construtor:Faça a inicialização no construtor:

public GL2D()public GL2D(){{ glut.glutInit();glut.glutInit(); glut.glutInitDisplayMode(glut.GLUT_SINGLE | glut.GLUT_RGB); //indica que vamos usar um bugger para glut.glutInitDisplayMode(glut.GLUT_SINGLE | glut.GLUT_RGB); //indica que vamos usar um bugger para glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE, glut.GLUT_ACTION_CONTINUE_EXECUTION);glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE, glut.GLUT_ACTION_CONTINUE_EXECUTION); //geração de imagens e cores no modo RGB//geração de imagens e cores no modo RGB glut.glutInitWindowSize(400, 400);//Especifica a dimensão da janele em pixels;glut.glutInitWindowSize(400, 400);//Especifica a dimensão da janele em pixels; glut.glutInitWindowPosition(100, 100);//Especifica a coordenada superior esquerda da janela;glut.glutInitWindowPosition(100, 100);//Especifica a coordenada superior esquerda da janela; glut.glutCreateWindow("Desenha objetos 2D");//Cria a janela e devolve um identificador único paraglut.glutCreateWindow("Desenha objetos 2D");//Cria a janela e devolve um identificador único para //a janela. Até que o comando gluMainLoop seja chamado//a janela. Até que o comando gluMainLoop seja chamado //a janela não será mostrada.//a janela não será mostrada. Init();Init(); glut.glutDisplayFunc(Display); //Toda vez que o GLUT determinar que a janelaglut.glutDisplayFunc(Display); //Toda vez que o GLUT determinar que a janela //presisa ser desenhada, ele chamará esta função//presisa ser desenhada, ele chamará esta função //usando um callback ou ponteiro para a função//usando um callback ou ponteiro para a função glut.glutKeyboardFunc(Keyboard); //Determina as funções para ler do teclado.glut.glutKeyboardFunc(Keyboard); //Determina as funções para ler do teclado. glut.glutCloseFunc(Close);glut.glutCloseFunc(Close); glut.glutMainLoop(); //É o último comando. Ele faz com que as janelas sejam desenhadas. Uma vez queglut.glutMainLoop(); //É o último comando. Ele faz com que as janelas sejam desenhadas. Uma vez que //entramos neste loop, somente saimos quando o programa se encerra. //entramos neste loop, somente saimos quando o programa se encerra. }}

ReferênciasReferências

CONCICONCI, Aura ; Eduardo , Aura ; Eduardo AzevedoAzevedo ; ; LETA, F. R. . LETA, F. R. . Computação GráficaComputação Gráfica - - Teoria e Prática - Vol. 2. Rio de Teoria e Prática - Vol. 2. Rio de Janeiro: Campus Elsevier, 2003.Janeiro: Campus Elsevier, 2003.

http://pt.wikipedia.org/wiki/OpenGL.http://pt.wikipedia.org/wiki/OpenGL.

computação gráfica - introdução ao opengl

Education