OpenGL. Sumário COMPUTAÇÃO GRÁFICA E INTERFACES. Introdução. Introdução. Carlos Carreto

Transcrição

1 Sumário COMPUTAÇÃO GRÁFICA E INTERFACES OpenGL Carlos Carreto Curso de Engenharia Informática Ano lectivo 2003/2004 Escola Superior de Tecnologia e Gestão da Guarda Introdução Utilização Tipos de dados Nomes das funções Bibliotecas Máquina de estados Estrutura básica de uma aplicação Primitivas de desenho Transformações geométricas Introdução Introdução OpenGL (Open Graphics Library) É uma biblioteca padrão de funções gráficas para desenvolvimento de aplicações 2D e 3D em tempo real. Os seus recursos permitem criar gráficos com qualidade próxima à de um raytracer, mas com muita mais rapidez, além de incluir recursos avançados de animação, tratamento de imagens e texturas. A biblioteca OpenGL foi introduzida em 1992 pela Silicon Graphics, na forma de uma API gráfica, independente dos dispositivos de exibição e dos sistemas operativos. Pipeline da OpenGL Chamadas API OpenGL Buffer de comandos OpenGL Transformações geométricas e Iluminação Rasterização Frame Buffer

2 Utilização OpenGL para Windows A OpenGL foi escrita em C e segue a convenção de chamada da linguagem C. Existem diferentes implementações da OpenGL para diferentes sistemas operativos, por exemplo para Windows e Linux. As várias implementações usam os mesmos tipos de dados e os mesmos nomes de funções. Desse modo um programa escrito para Windows por exemplo, pode também ser compilado para Linux. Utilização OpenGL para Windows Na implementação Windows são fornecidas: -> Bibliotecas opengl32.lib (kernel OpenGL) e glu32.lib (biblioteca GLU); -> Protótipos para todas as funções, tipos de dados e macros OpenGL (gl.h) e para funções utilitárias (glu.h); -> DLLs opengl32.dll e glu32.dll. As DLLs vêm com o próprio Windows e encontram-se na pasta System32 enquanto que as bibliotecas e ficheiros cabeçalho vêm com a linguagem de programação (no caso do C++Builder encontram-se respectivamente nas pastas $(BCB)\LIB\PSDK e $(BCB)\INCLUDE\GL). Tipos de dados Nomes das funções OpenGL para Windows Para tornar o código portátil, foram definidos tipos de dados próprios para OpenGL. Estes tipos de dados são mapeados dos tipos de dados comuns do C, que também podem ser utilizados. Como os vários compiladores e ambientes possuem regras diferentes para determinar o tamanho das variáveis em C, usando os tipos OpenGL é possível isolar o código das aplicações, destas alterações. Tipo de dados OpenGL GLbyte GLshort GLint, GLsizei GLfloat, GLclampf GLdouble, GLclampd GLubyte, GLboolean GLushort GLuint, GLenum, GLbitfield Representação interna 8-bit integer 16-bit integer 32-bit integer 32-bit floating-point 64-bit floating-point 8-bit unsigned integer 16-bit unsigned integer 32-bit unsigned integer Tipo de dado C equivalente signed char short int ou long float double unsigned char unsigned short unsigned long ou unsigned int Sufixo b s i f d ub us ui Os nomes das funções OpenGL seguem uma convenção que indica a que biblioteca pertencem e a quantidade e tipo dos argumentos que contêm. Exemplo: O prefixo gl significa que a função pertence à biblioteca gl glcolor3f A raiz do nome sugere a funcionalidade da função. O sufixo 3f significa que a função possui 3 parâmetros de ponto flutuante.

3 Bibliotecas A OpenGL fornece um conjunto de comandos poderosos, porem de baixo nível. De modo a facilitar a programação com estes comandos, forma desenvolvidas bibliotecas que implementam funções demais alto nível e portanto mais fáceis de usar: -> GLU (OpenGL Utility Library) -> GLUT (OpenGL Utility Toolkit) -> GLX (OpenGL Extension to the X Window System) -> FSG (Fahrenheit Scene Graph) Bibliotecas GLU (OpenGL Utility Library) Contem funções de uso comum que utilizam comandos OpenGL de baixo nível. As funções desta biblioteca usam o prefixo gl. Bibliotecas GLUT (OpenGL Utility Toolkit) Contêm funções para a implementação de interfaces gráficos independentes da plataforma, tais como funções para tratamento de eventos, menus, rato, etc. Esconde a complexidade da gestão de janelas das diferentes plataformas. As funções desta biblioteca usam o prefixo glut. Bibliotecas Instalação da GLUT Obter os ficheiros em: Página Recursos da disciplina Instalação dos ficheiros: glut32.dll -> SYSTEM32 glut32.lib -> $(BCB)\LIB\PSDK glut.h -> $(BCB)\INCLUDE\GL

4 Bibliotecas GLX (OpenGL Extension to the X Window System) Esta biblioteca é vista com um anexo da OpenGL para plataformas que usam o sistema de janelas X Window. As funções GLX usam o prefixo glx. Para Microsoft Windows 95/98/NT, as janelas são fornecidas pelas funções WGL. Todas as funções WGL usam o prefixo wgl. Bibliotecas FSG (Fahrenheit Scene Graph) Constitui um toolkit orientado a objectos baseado em OpenGL. Fornece objectos e métodos para a criação de aplicações gráficas 3D interactivas. A biblioteca foi escrita em C++ e é separada da OpenGL. Para IBM/OS2, a PGL é a Presentation Manager para a interface OpenGL, e suas funções usam o prefixo pgl. Para Apple, a AGL é a interface para sistemas que suportam OpenGL, e as funções AGL usam o prefixo agl Máquina de estados A OpenGL é uma máquina de estados porque é possível colocá-la em vários estados (ou modos) que não são alterados, a menos que uma função seja chamada para isto. Por exemplo, a cor corrente é uma variável de estado que pode ser definida como branco. Todos os objectos são então desenhados com a cor branca, até ao momento em que outra cor corrente seja especificada. A OpenGL mantém uma série de variáveis de estado, tais como estilo de uma linha, posições e características das luzes, propriedades do material dos objectos a desenhar, etc. Muitas delas referem-se a modos que podem ser habilitados ou desabilitados com os comandos glenable() e gldisable(). A configuração básica da OpenGL em C++Builder tem os seguintes passos: -> Obter e configurar um device context e um rendering context para o form; -> Definir a viewport e a projecção a usar cada vez que se altera o tamanho do form; -> Definir a função de desenho da cena; -> Criar um ciclo de rendering.

5 Unit1.h Ficheiros cabeçalho da OpenGL e da GLU. O construtor... #include <gl/gl.h> #include <gl/glu.h>... private: // User declarations HDC hdc; HGLRC hrc; int Pixel_Format; public: // User declarations fastcall TForm1(TComponent* Owner); void fastcall Idle_Loop(TObject*, bool&); void fastcall Configurar_Pixel_Format(); void fastcall Configurar_RC(); void fastcall Desenhar_Cena(); Um handler para o device context do form (TCanvas). Um handler para o rendering context (OpenGL). Um identificador para o Pixel Format. fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) Application->OnIdle = Idle_Loop; Configuração da função a chamar no evento OnIdle. O evento OnIdle acontece sempre que não houver mensagens do sistema para processar. É o momento ideal para redesenhar a cena.... A função Idle_Loop() void fastcall TForm1::Idle_Loop(TObject*, bool &Terminar) Terminar = false; Desenhar_Cena(); SwapBuffers(hdc); Terminar = false para que o ciclo não pare. Chamada à função que desenha a cena. A função Desenhar_Cena() void fastcall TForm1::Desenhar_Cena() glclear(gl_color_buffer_bit GL_DEPTH_BUFFER_BIT); // Limpar o ecrã e buffer de profundidade glloadidentity(); // Limpar matriz de transformações gltranslatef(-1.5f,0.0f,-1.0f); // Translação de 1.5 unidades no eixo XX e -1 unidade do eixo ZZ glbegin(gl_triangles); // Desenhar um triangulo glvertex3f( 0.0f, 1.0f, 0.0f); // Superior glvertex3f(-1.0f,-1.0f, 0.0f); // Inferior esquerdo glvertex3f( 1.0f,-1.0f, 0.0f); // Inferior direito glend(); // Fim do desenho do triangulo gltranslatef(3.0f,0.0f,0.0f); // Translação de 3 unidades no eixo XX Troca de buffers para minimizar o screen flicker. glbegin(gl_quads); glvertex3f(-1.0f, 1.0f, 0.0f); glvertex3f( 1.0f, 1.0f, 0.0f); glvertex3f( 1.0f,-1.0f, 0.0f); glvertex3f(-1.0f,-1.0f, 0.0f); glend(); glflush(); // Desenhar um quadrado // Superior esquerdo // Superior direito // Inferior direito // Inferior esquerdo // Fim do desenho do Quad //Processar os comandos

6 O evento OnCreate void fastcall TForm1::FormCreate(TObject *Sender) hdc = GetDC(Handle); Configurar_Pixel_Format(); hrc = wglcreatecontext(hdc); wglmakecurrent(hdc, hrc); Configurar_RC(); Obter o device context do form. Configurar o Pixel Format. O evento OnDestroy void fastcall TForm1::FormDestroy(TObject *Sender) ReleaseDC(Handle, hdc); wglmakecurrent(hdc, NULL); wgldeletecontext(hrc); Limpeza do device context e rendering context. Criar um rendering context para o device context. Tornar o rendering context corrente. Configurar o rendering context. A função Configurar_Pixel_Format() void fastcall TForm1::Configurar_Pixel_Format() Configuração da estrutura Pixel Format Descriptor com PIXELFORMATDESCRIPTOR pfd = suporte para OpenGL, uso de Double Buffer e formato RGBA. sizeof(pixelformatdescriptor), 1, PFD_DRAW_TO_WINDOW PFD_SUPPORT_OPENGL PFD_DOUBLEBUFFER, PFD_TYPE_RGBA, 24, 0,0,0,0,0,0, 0,0, Criar o device context com as características configuradas no Pixel Format Descriptor. 0,0,0,0,0, 32, 0, 0, PFD_MAIN_PLANE, 0, 0,0,0 ; Pixel_Format = ChoosePixelFormat(hdc, &pfd); SetPixelFormat(hdc, Pixel_Format, &pfd); A função Configurar_RC() void fastcall TForm1::Configurar_Pixel_Format() glclearcolor(1.0f, 1.0f, 1.0f, 1.0f); glclear(gl_color_buffer_bit); glflush(); Configurar a cor de fundo do rendering context. Limpar o ColorBuffercom essa cor.

7 O evento OnResize Viewport do tamanho da área-cliente do form. void fastcall TForm1::FormResize(TObject *Sender) GLfloat Distancia = 200.0f; glviewport(0, 0, ClientWidth, ClientHeight); glmatrixmode(gl_projection); glloadidentity(); As transformações geométrica afectam a câmara. if (ClientWidth <= ClientHeight) glortho(-distancia, Distancia, -Distancia*ClientHeight/ClientWidth, Distancia*ClientHeight/ClientWidth, -Distancia, Distancia); else glortho(-distancia*clientwidth/clientheight, Distancia*ClientWidth/ClientHeight, -Distancia, Distancia, -Distancia, Distancia); Output do programa glmatrixmode(gl_modelview); glloadidentity(); As transformações geométrica afectam os objectos da cena. Configuração de uma projecção ortográfica. glortho(gldouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far) O Repository do C++Builder O repository do C++Builder permite guardar este projecto como um modelo para futuros projectos OpenGL. Para isso basta: -> Seleccionar Projects Add to Repository; -> Escolher um título, por exemplo Estrutura OpenGL ; -> Escolher a página Forms. Para reutilizar o projecto basta seleccionar File New Forms e escolher Estrutura OpenGL. Primitivas de desenho A OpenGL contem um conjunto de primitivas simples, tais como pontos, linhas e polígonos, que podem ser combinadas de várias maneiras para criar estruturas mais complexas. Estas primitivas são formadas por um ou mais vértices. É pois necessário especificar uma lista de vértices, o que é feito através das funções OpenGL: glbegin()... glend() O argumento passado para glbegin() determina qual objecto será desenhado. Por exemplo, para desenhar três pontos vermelhos podemos usar a seguinte sequência de comandos: glbegin(gl_points); glcolor3f(1.0f, 0.0f, 0.0f); glvertex2i(100, 50); glvertex2i(100, 130); glvertex2i(150, 130); glend();

8 Primitivas de desenho Outros argumentos para glbegin(): A função glvertex2i pertence à biblioteca GL e possui dois argumentos inteiros. Existem duas variantes desta função que permitem passar valores de ponto flutuante no lugar de inteiros, e três coordenadas (x,y,z) no lugar de duas: glvertex2d(100.0, 50.0); glvertex3f(50.0, 50.0, 50.0); É também possível definir uma cor diferente para cada vértice. Nesse caso, é feita uma interpolação das cores de cada vértice aquando do desenho do objecto. Primitivas de desenho Outros argumentos para glbegin(): GL_LINES -> desenha uma linha a cada dois comandos glvertex; GL_LINE_STRIP -> desenha uma sequência de linhas conectando os pontos definidos por glvertex; GL_LINE_LOOP -> desenha uma sequência de linhas conectando os pontos definidos por glvertex e no final liga o primeiro como último ponto; GL_POLYGON -> desenha um polígono convexo preenchido, definido por uma sequência de chamadas a glvertex; GL_TRIANGLES -> desenha um triângulo preenchido a cada três pontos definidos por glvertex; GL_TRIANGLE_STRIP -> desenha uma sequência de triângulos baseados no trio de vértices v0, v1, v2, depois, v2, v1, v3, depois, v2, v3, v4 e assim por diante; GL_TRIANGLE_FAN -> desenha uma sequência de triângulos conectados baseados no trio de vértices v0, v1, v2, depois, v0, v2, v3, depois, v0, v3, v4 e assim por diante; GL_QUADS -> desenha um quadrado preenchido conectando cada quatro pontos definidos por glvertex; GL_QUAD_STRIP -> desenha uma sequência de quadriláteros conectados a cada quatro vértices; primeiro v0, v1, v3, v2, depois, v2, v3, v5, v4, depois, v4, v5, v7, v6, e assim por diante. Transformações geométricas A OpenGL implementa as transformações geométricas básicas de translação, escala e rotação através de multiplicação de matrizes. Estas transformações podem ser combinadas numa única matriz, permitindo desse modo a aplicação de várias transformações geométricas através de uma única operação. Isto ocorre porque uma transformação geométrica em OpenGL é armazenada internamente numa matriz. A cada transformação que é aplicada, esta matriz é alterada e usada para desenhar os objectos da cena a partir daquele momento. A cada nova alteração é feita uma composição de matrizes. Este efeito cumulativo traz vantagens, mas também pode ser indesejado. Para o evitar é necessário utilizar as funções glpushmatrix() e glpopmatrix(), que gravam e restauram, respectivamente, a matriz actual de transformação numa pilha interna da OpenGL. Transformações geométricas A translação é feita através da função gltranslatef(tx, Ty, Tz), que pode receber três números float ou double (gltranslated) como parâmetro. Neste caso, a matriz actual é multiplicada por uma matriz de translação baseada nos valores dados. A rotação é feita através da função glrotatef(ângulo, x, y, z), que pode receber quatro números float ou double (glrotated) como parâmetro. Neste caso, a matriz actual é multiplicada por uma matriz de rotação de "Ângulo" graus ao redor do eixo definido pelo vector "x,y,z" no sentido anti-horário. A escala é feita através da função glscalef(ex, Ey, Ez), que pode receber três números float ou double (glscaled) como parâmetro. Neste caso, a matriz actual é multiplicada por uma matriz de escala baseada nos valores dados.