Computação Gráfica - Introdução ao OpenGL

4,062 views

Published on

0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
4,062
On SlideShare
0
From Embeds
0
Number of Embeds
3
Actions
Shares
0
Downloads
127
Comments
0
Likes
2
Embeds 0
No embeds

No notes for slide

Computação Gráfica - Introdução ao OpenGL

  1. 1. Computação Gráfica Aula 5 – Introdução ao OpenGL Prof. Tony Alexander Hild Documento licenciado por Creative Commons - http://creativecommons.org/licenses/by-nc-sa/2.5/br/
  2. 2. Histórico <ul><li>Início da década de 80: </li></ul><ul><ul><li>Cada fabricante de hardware tinha seu próprio conjunto de instruções para desenho de gráficos 2D e 3D;
  3. 3. Construir aplicações que suportassem vários hardwares era um verdadeiro desafio;
  4. 4. Esforço era constantemente duplicado e havia pouco espaço para companhias menores e sem capital para tamanho investimento. </li></ul></ul><ul><li>Meados dos anos 80: </li></ul><ul><ul><li>Um padrão surgiu na indústria;
  5. 5. Chamado PHIGS (sigla de Programmer’s Hierarchical, Graphics System) e começou a ser adotado por grandes fabricantes da época;
  6. 6. Entretanto, embora tenha sido reconhecido por entidades como a ANSI e a ISO, o padrão começou a ser considerado complicado e desatualizado. </li></ul></ul><ul><li>Final dos anos 80: </li></ul><ul><ul><li>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 gráfica. Consideravelmente mais fácil de usar, a API começou a tornar-se um padrão de fato na indústria. </li></ul></ul>
  7. 7. Histórico <ul><li>Entretanto, grandes empresas produtoras da hardware, como a Sun Microsystems e a IBM, ainda eram capazes de fabricar hardware adotando o padrão PHIGS;
  8. 8. 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 hardware pudessem adotá-lo;
  9. 9. A API Iris continha muito código proprietário e portanto não poderia ser aberta;
  10. 10. Também lidava com questões não tão relacionadas ao desenho 2D e 3D, como gerenciamento de janelas, teclado e mouse;
  11. 11. Ainda assim, era do interesse da Silicon Graphics manter os seus antigos clientes comprando seu hardware;
  12. 12. Como um resultado disso, o padrão OpenGL é criado: </li></ul><ul><ul><li>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, Matrox, NVIDIA, Sun e, logicamente, a Silicon Graphics;
  13. 13. O papel desse conselho é manter a especificação e indicar quais recursos serão adicionados a cada versão;
  14. 14. A versão mais atual do OpenGL até hoje é a 2.1. </li></ul></ul>
  15. 15. Histórico <ul><li>Os projetistas do OpenGL sabiam de duas coisas: </li></ul><ul><ul><li>A primeira é que fabricantes de hardware gostariam de adicionar recursos próprios, sem que tivessem que esperar para esses recursos estarem 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 interessantes o suficiente para que outros vendedores de hardware as adotem. Então, quando elas são consideradas suficientemente abrangentes, ou suficientemente importantes, a ARB pode promovê-las para que façam 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 jogos.
  16. 16. 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 incluíram extensões de software, que permitiam emular essas 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. </li></ul></ul>
  17. 17. Arquitetura do OpenGL <ul><li>O OpenGL é um conjunto de funções, que fornecem acesso aos recursos do hardware de vídeo;
  18. 18. Age como uma máquina de estados, que dizem ao OpenGL o que fazer;
  19. 19. Usando as funções da API, você pode ligar ou desligar vários aspectos dessa máquina, tais como: </li></ul><ul><ul><li>A cor atual;
  20. 20. Se transparência será usada
  21. 21. Se cálculos de iluminação devem ser feitos;
  22. 22. Se haverá ou não o efeito de neblina. Etc. </li></ul></ul><ul><li>É 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 incorreta.
  23. 23. 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 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 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 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 ao mesmo tempo cliente e servidor. </li></ul>
  24. 24. Arquitetura do OpenGL <ul><li>Essa decisão de design tem uma conseqüência muito importante: os comandos do OpenGL não são imediatamente enviados para o hardware;
  25. 25. Eles são agrupados para serem enviados mais tarde, o que não só otimiza o uso da rede, mas também abre margem para outras otimizações;
  26. 26. Por conseqüência, um erro comum de muitos programadores é tentar medir o tempo levado pelos comandos de desenho simplesmente adicionando funções antes e depois de um comando (ou conjunto de comandos) o que, nessa arquitetura, certamente gerará resultados inválidos; </li></ul>
  27. 27. Arquitetura do OpenGL <ul><li>Afinal, não há garantias de que os comandos serão imediatamente executados, e, o que acaba sendo medindo com essa estratégia é a velocidade que o OpenGL armazena os comandos para futura execução. Forçar a execução dos comandos também é uma estratégia ruim, já que com isso muitas otimizações são simplesmente desprezadas;
  28. 28. Nessa arquitetura, a forma mais confiável de se medir a performance é através de software especial, que pode ser baixado na própria página do OpenGL. </li></ul>
  29. 29. Rendering Pipeline <ul><li>O núcleo do OpenGL é conhecido como “rendering pipeline”. É importante notar que o OpenGL lida tanto com o desenho na forma vetorial, definidas por vértices, como com mapas de bits, definidos pixel-a-pixel. Os principais elementos desse pipeline estão descritos a seguir: </li></ul>
  30. 30. Rendering Pipeline - Display Lists <ul><li>Display Lists: Todos os dados, sejam de os vértices de geometrias ou pixels, podem ser salvos numa display list para uso atual ou posterior. </li></ul>
  31. 31. Rendering Pipeline - Avaliadores <ul><li>Avaliadores (evaluators): Todas as primitivas geométricas, no OpenGL são descrita por vértices. Curvas e superfícies paramétricas podem ser descritas por fórmulas, que devem ser derivadas, para recaírem nos vértices. Quem faz essa avaliação são os evaluators (avaliadores). </li></ul>
  32. 32. Rendering Pipeline - Operações pré-vértices <ul><li>Operações pré-vértice: Para os dados de vértices, as operações pré-vértice convertem os vértices em primitivas de desenho. Nessa etapa, cada vértice é convertido em matrizes 4×4, então cálculos são realizados para que sejam convertidos do espaço 3D para as coordenadas de tela. Essa etapa ainda realiza operações de cálculos de textura, iluminação, materiais, etc. de acordo com quais estados tenham sido habilitados. </li></ul>
  33. 33. Rendering Pipeline - Operações com Pixels <ul><li>Operações com Pixels: Enquanto os dados geométricos seguem pelo rendering pipeline, os mapas pixels passam por diferentes tipos de transformação. Primeiramente, os pixels são descompactados de acordo com o seu número de componentes, então eles tem sua escala ajustada, seu formato final é calculado, parte de sua área é recortada e então são enviados para o passo chamado rasterization. </li></ul>
  34. 34. Rendering Pipeline - Montagem de texturas <ul><li>Montagem de texturas (texture assembly): Permite a aplicação de imagens como texturas das geometrias, para que elas pareçam mais realistas. Algumas implementações do OpenGL podem ter recursos especiais para acelerar esse passo. </li></ul>
  35. 35. Rendering Pipeline - Rasterization <ul><li>Rasterization: Transforma todos os dados em fragmentos. Cada fragmento é um quadrado que corresponde a pixels no framebuffer. Padrões de linhas e polígonos, largura da linha, tamanho do ponto, shading, cálculos de cobertura e anti-aliasing são todos levados em conta durante essa fase. Cor e valores de profundidade são considerados para cada fragmento. </li></ul>
  36. 36. Rendering Pipeline - Operações sobre fragmentos <ul><li>Operações sobre fragmentos (Fragment Operations): Finalmente, operações finais são aplicadas aos fragmentos, tais como recortes, operações de máscaras de bits (como blending) são aplicadas. Então, os pixels são finalmente calculados e são encaminhados para desenho. </li></ul>
  37. 37. Outras bibliotecas relacionadas ao OpenGL <ul><li>O OpenGL fornece um conjunto poderoso de comandos, mas restrito apenas ao desenho. Várias bibliotecas existem para facilitar a manipulação de outros aspectos da aplicação, como as seguintes: </li></ul><ul><ul><li>OpenGL Utility Library (GLU): Fornece diversas funções para auxiliar na montagem de matrizes de visualização e projeção, desenho de superfícies e imagens 3D. Essa biblioteca é fornecida juntamente com as implementações do OpenGL e todas as rotinas dessa biblioteca tem o prefixo glu;
  38. 38. Cada ambiente de janelas tem uma biblioteca de extensão do OpenGL. Por exemplo, o sistema X possui o glx, enquanto o Windows fornece a extensão wgl;
  39. 39. OpenGL Utility Toolkit (GLUT): É um toolkit que abstrai o sistema de janelas, fornecendo uma interface simples para a criação de uma aplicação OpenGL. </li></ul></ul>
  40. 40. Tao Framework <ul><li>Coleção de bindings (links) que facilitam o desenvolvimento de aplicações de mídia multi-plataforma utilizando .NET e MONO. </li></ul>
  41. 41. Iniciando com OpenGL e C# <ul><li>Crie uma classe com o nome do exemplo: </li></ul>using System; using System.Collections.Generic; using System.Text; using gl = Tao.OpenGl.Gl; using glut = Tao.FreeGlut.Glut; namespace OpenGlExamples { public class GL2D { public GL2D() { } } }
  42. 42. Iniciando com OpenGL e C# <ul><li>Crie o método Init: </li></ul>private static void Init() { //forcece os valores para a limpeza do buffer de cor no modo RGBA. //Seleciona a cor preta para a linha. gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f); gl.glColor3f(0.0f, 0.0f, 0.0f); //seleciona o modo de operação ortogonal. gl.glOrtho(0, 256, 0, 256, -1, 1); }
  43. 43. Iniciando com OpenGL e C# <ul><li>Crie o método Display: </li></ul>private static void Display() { //Limpa toda a janela para a cor do comando glClearColor. gl.glClear(gl.GL_COLOR_BUFFER_BIT); gl.glBegin(gl.GL_LINES); //Fornece as coordenadas do pontos iniciais e finais. gl.glVertex2i(20, 100); gl.glVertex2i(100, 20); gl.glEnd(); gl.glBegin(gl.GL_QUADS); gl.glVertex2i(20, 20); gl.glVertex2i(30, 20); gl.glVertex2i(30, 40); gl.glVertex2i(20, 40); gl.glEnd(); gl.glFlush(); }
  44. 44. Iniciando com OpenGL e C# <ul><li>Crie o método Keyboard para interação: </li></ul>private static void Keyboard(byte key, int x, int y) { switch (key) { case 27: Environment.Exit(Environment.ExitCode); break; default: switch (key) { case 49: gl.glColor3f(255.0f, 255.0f, 0.0f); break; case 50: gl.glColor3f(255.0f, 0.0f, 0.0f); break; case 51: gl.glColor3f(0.0f, 255.0f, 0.0f); break; case 52: gl.glColor3f(0.0f, 0.0f, 255.0f); break; default: gl.glColor3f(0.0f, 0.0f, 0.0f); break; } glut.glutPostRedisplay(); break; } }
  45. 45. Iniciando com OpenGL e C# <ul><li>Faça a inicialização no construtor: </li></ul>public GL2D() { glut.glutInit(); 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); //geração de imagens e cores no modo RGB glut.glutInitWindowSize(400, 400);//Especifica a dimensão da janele em pixels; glut.glutInitWindowPosition(100, 100);//Especifica a coordenada superior esquerda da janela; glut.glutCreateWindow(&quot;Desenha objetos 2D&quot;);//Cria a janela e devolve um identificador único para //a janela. Até que o comando gluMainLoop seja chamado //a janela não será mostrada. Init(); glut.glutDisplayFunc(Display); //Toda vez que o GLUT determinar que a janela //presisa ser desenhada, ele chamará esta função //usando um callback ou ponteiro para a função glut.glutKeyboardFunc(Keyboard); //Determina as funções para ler do teclado. glut.glutCloseFunc(Close); glut.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. }
  46. 46. Referências <ul><li>CONCI , Aura ; Eduardo Azevedo ; LETA, F. R. . Computação Gráfica - Teoria e Prática - Vol. 2. Rio de Janeiro: Campus Elsevier, 2003.
  47. 47. http://pt.wikipedia.org/wiki/OpenGL. </li></ul>

×