A OC-Zone decidiu aprender um pouco de OpenGl e divertir-se as custas desta biblioteca que a maioria das placas gráficas suportam. Contudo criamos este Artigo para que os nossos leitores e principiantes da programação em C++, aprendam a utilizar e a criar pequenos cenários utilizando algumas figuras geométricas.

O Software utilizado para programar C++ foi o Borlan C++ Builder 6, no entanto, também funciona em Visual Studio C++. O processo é o mesmo portanto fica ao inquérito dos nossos leitores.

Introdução ao OpenGL

A OpenGL (Open Graphics Library), é uma biblioteca padrão de funções gráficas para o desenvolvimento de aplicações gráficas interactivas 2D e 3D com qualidade profissional e de alta performance, tendo sido criada em 1992 pela Silicon Graphics (actual SGI – www.sgi.com), na forma de uma API (Application Programming Interface), gráfica, independente dos dispositivos de exibição e dos sistemas operativos.
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.

A OpenGL não contem funções especificas para interacção com os modernos sistemas de janelas (Windows, X Window etc), pelo que as tarefas comuns de uma aplicação, como criar janelas, gerir eventos provenientes do rato e do teclado, assim como apresentação de menus, ficam a cargo de bibliotecas próprias de cada ambiente de programação. Existe no entanto uma extensão da biblioteca OpenGL conhecida por GLUT (OpenGL ToolKit), que contem funções para a gestão de janelas e eventos e pode ser usada para o desenvolvimento de aplicações gráfica sem OpenGL, independentes do sistema de gestão de janelas dos sistemas operativos.

A OpenGL transformou-se num padrão extensamente utilizado pela indústria. O desenvolvimento desta biblioteca está hoje em dia a cargo de um consórcio formado pelas principais empresas de software e hardware do mundo (www.opengl.org).

A OpenGL promove a inovação e acelera o desenvolvimento de aplicações incorporando um grande conjunto de funções de renderização, de texturas, de efeitos especiais, e de outras poderosas funções de visualização.

1.1 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 isso. Por exemplo, a cor de desenho é uma variável de estado que pode ser definida como branca. Todos os objectos são então desenhados com a cor branca, até ao momento em que outra cor de desenho seja especificada. A OpenGL mantém uma série de variáveis de estado, tais como estilo de linhas, posições e características das luzes, propriedades do material dos objectos a desenhar, etc.

Muitas delas referem-se a modos que podem ser activados ou desactivados com os comandos glEnable() e glDisable().

1.2 O Pipeline da OpenGL

Os comandos da biblioteca OpenGL seguem uma série de estágios de processos ao serem executados a que chamamos Pipeline de Renderização da OpenGL. A sequencia dos processos desse pipeline é mostrada no diagrama da figura 1.

Figura 1 – Pipeline de Renderização da OpenGL

1.3 Funções gráficas da OpenGL

As funções gráficas da biblioteca OpenGL podem ser agrupadas de acordo com a função que desempenham. Segue-se a descrição genérica desses grupos de funções.

Buffer de acumulação: Trata-se de um buffer no qual múltiplos frames renderizados podem ser compostos para produzir uma única imagem. Este buffer é usado para efeitos tais como a profundidade de campo, “blur” de movimento, e de anti-aliasing da cena.

Alfa Blending: Proporciona mecanismos para criar objectos transparentes. Usando

a informação alfa, é possível escolher se um objecto é definido como algo totalmente transparente até algo totalmente opaco.

Anti-aliasing: Um método de renderização utilizado para suavizar linhas e curvas.

Esta técnica calcula a média da cor dos pixels junto à linha. Tem o efeito visual de suavizar a transição dos pixels na linha e daqueles junto à linha, gerando assim uma aparência mais suave.
Modo “Color-Index”: Buffer de Cores que armazena índices de cores das componentes vermelhas, verdes, azuis, e alfa das cores (RGBA), de modo a criar uma paleta de cores especifica.

Display Lists: Uma lista nomeada de comandos de OpenGL. As funções inseridas numa Display list podem ser pré-processadas de modo a serem executadas mais eficientemente do que se fossem executadas no modo imediato.

Double buffering: Usado para fornecer uma animação suave dos objectos. Cada cena sucessiva de um objecto em movimento pode ser construída em “background” ou no buffer “invisível” e então apresentada. Isto permite que somente as imagens completas sejam sempre apresentadas no ecrã.

FeedBack: Um modo onde OpenGL retornará a informação geométrica processada (cores, posições do pixel, e assim por diante), à aplicação. Gouraud Shading: Interpolação suave das cores através de um segmento de polígono ou de linha. As cores são atribuídas em vértices e linearmente interpoladas através da primitiva para produzir uma variação relativamente suave na cor.

Modo Imediato: A execução de comandos OpenGL quando eles são chamados, possui resultado melhor do que os “Display Lists”. Iluminação e sombreamento de materiais: A habilidade de computar exactamente a cor de algum ponto da superfície de um objecto dado as propriedades materiais para essa superfície.

Operações de pixel: Armazena, transforma, traça e processa aumento e redução de imagens.

Executores polinomiais: Para suportar as NURBS (non-uniform rational Bsplines). Primitivas: Um ponto, uma linha, um polígono, um bitmap, ou uma imagem. Primitivas da rasterização : bitmaps e retângulos de pixels.

Modo RGBA: Buffers de cores armazenam componentes vermelhos, verdes, azuis, e alfa da cor.

Selecção e colheita: Trata-se de um modo no qual a OpenGL determina se certa primitiva identificada do gráfico é renderizada numa dada região no buffer de frame.

Planos do stencil: Um buffer que é usado para mascarar pixels individuais no buffer de frame de cores.

Mapeamento de Texturas: O processo de aplicar uma imagem a uma primitiva gráfica. Esta técnica é usada para gerar imagens com realismo.

Transformações: A habilidade de mudar a rotação, o tamanho, e a perspectiva de um objecto no espaço 3D.

Z-buffering: O Z-buffer é usado remover as superfícies escondidas.

1.4 Sintaxe de comandos da OpenGL

Os comandos da biblioteca OpenGL obedecem a um padrão bem definido para especificação dos nomes de funções e constantes. A grande maioria dos nomes das funções contêm o prefixo “gl” em letras minúsculas e todos os nomes de constantes começam com as iniciais “GL_”, em letras maiúsculas, e usam um “underscore” para separar as palavras que formam o nome

(Ex. GL_COLOR_BUFFER_BIT ). Existem algumas funções para a plataforma Windows (evidenciados pelo prefixo "wgl") que facilitam a criação de um espaço de renderização numa janela comum Windows.

Os nomes de algumas funções contêm um sufixo formado por um algarismo e uma ou duas letras (Ex. glColor3f e glVertex3fv). O algarismo indica o número de argumentos da função e a letra indica o tipo desses argumentos. Este formato para o nome das funções ajuda a lidar com o grande número de variantes que uma dada função pode ter. A figura 2 ilustra o formato do nome das variantes para a função glVertex…().

Figura 2 - Variantes do nome da função glVertex…().

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. A tabela 1 apresenta os sufixos das funções e os tipos de dados para os argumentos das funções.

Tab. 1 - Sufixos e tipos de dados para os argumentos das funções da OpenGL.

2 Instalação da OpenGL no Windows XP

2.1 C++ Builder e no Visual Studio C++

A implementação da biblioteca para uma dada plataforma e sistema operativo é composta por dois grupos de ficheiros: os ficheiros que formam a biblioteca propriamente dita e os ficheiros de interface com a biblioteca. No caso da implementação da biblioteca para o sistema operativo Windows, os ficheiros que forma a biblioteca são opengl32.dll (kernel OpenGL) e glu32.dll (biblioteca GLU) e fazem parte da distribuição desse sistema operativo (encontram-se na pasta System32). Os ficheiros de interface com a biblioteca vêm normalmente com o ambiente de desenvolvimento da linguagem de programação que quisermos usar. No caso do C++Builder, os ficheiros de interface são opengl32.lib (interface para o kernel OpenGL) e glu32.lib (interface para a biblioteca GLU) e os ficheiros de cabeçalho gl.h (com os protótipos para o kernel OpenGL) e glu.h (com os protótipos para a biblioteca GLU). Estes ficheiros encontram-se respectivamente nas pastas $(BCB)LIBPSDK e $(BCB)INCLUDEGL.

No caso do Visual C++, tanto os ficheiros de interface como os ficheiros de cabeçalho são os mesmos mencionados anteriormente, no entanto esses encontra-se respectivamente nas pastas $(VC++)LIBPSDK e $(VC++)INCLUDEGL.

Existem versões da biblioteca OpenGL para outros sistemas operativos e ambientes de programação. Os ficheiros correspondentes podem ser obtidos no site oficial da OpenGL (www.opengl.org).

2.1 Primeiros passos

Segue-se o desenvolvimento de uma pequena aplicação que exemplifica a instalação e o uso da biblioteca OpenGL em C++Builder. Os gráficos produzidos pelos comandos da biblioteca OpenGL podem ser visualizados em qualquer componente para o qual se possa obter um device context. No exemplo que se segue, usaremos um componente TPanel para esse efeito.

Crie um novo projecto e adicione um componente TPanel ao formulário principal. Altere o nome do painel para PanelGL e elimine o texto na sua propriedade Caption. Altere as dimensões do painel para que fique apenas um pouco menor do que o formulário e centre-o em relação a este. Declare as seguintes variáveis na secção private da classe do formulário, no ficheiro Unit.h:

private:
HDC hdc;
HGLRC hrc;
int pixel_format;

A primeira variável é o handle para o device context do componente TPanel. A segunda guardará um handle para a janela de renderização OpenGL e a terceira é um identificador do “formato de pixel” que teremos que configurar. Declare as seguintes funções na secção public da classe do formulário:

void __fastcall Configurar_Pixel_Format();
void __fastcall Idle_Loop(TObject*, bool &Terminar);
void __fastcall Desenhar_Cena();

Inclua no ficheiro Unit.cpp os ficheiros cabeçalho necessários para usar a biblioteca OpenGL:

#include <gl/gl.h>
#include <gl/glu.h>

Crie a função Configurar_Pixel_Format() que configura o device context do componente PanelGL para que possa ser usado para renderizar as imagens geradas pela OpenGL:

void __fastcall TForm1::Configurar_Pixel_Format()
{
//Configuração da estrutura Pixel Format Descriptor com
//suporte para OpenGL, uso de Double Buffer e formato RGBA.
PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
24,
0,0,0,0,0,0,
0,0,
0,0,0,0,0,
32,
0,
0,
PFD_MAIN_PLANE,
0,
0,0,0
};
//Cria o device context do painel com as características
//configuradas no Pixel Format Descriptor.
pixel_format = ChoosePixelFormat(hdc, &pfd);
SetPixelFormat(hdc, pixel_format, &pfd);
}

Crie a função Idle_Loop() que será chamada automaticamente no evento OnIdle da aplicação e que implementa o ciclo de renderização da OpenGL:

void __fastcall TForm1::Idle_Loop(TObject*, bool &Terminar)
{
Terminar = false;
Desenhar_Cena();
SwapBuffers(hdc);
}

Acrescente o seguinte código ao construtor do formulário para configurar o evento OnIdle:

__fastcall TForm1::TForm1(TComponent* Owner):TForm(Owner)
{
Application->OnIdle = Idle_Loop;
}

Acrescente o seguinte código ao evento OnCreate para configurar o device context do painel e o rendering context da OpenGL:

void __fastcall TForm1::FormCreate(TObject *Sender)
{
hdc = GetDC(PanelGL->Handle);
Configurar_Pixel_Format();
hrc = wglCreateContext(hdc);
wglMakeCurrent(hdc, hrc);
//Configuração inicial do rendering context da OpenGL
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glFlush();
}

Acrescente o seguinte código ao evento OnDestroy para eliminar o device context e o rendering context:

void __fastcall TForm1::FormDestroy(TObject *Sender)
{
ReleaseDC(Handle, hdc);
wglMakeCurrent(hdc, NULL);
wglDeleteContext(hrc);
}

Acrescente o seguinte código ao evento OnRecize para configurar a viewport e a projecção a usar na renderização:

void __fastcall TForm1::FormResize(TObject *Sender)
{
glViewport(0, 0, PanelGL->Width, PanelGL->Height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

A função glViewport(0, 0, PanelGL->Width, PanelGL->Height) define a viewport de visualização, isto é, a área rectangular dentro do componente TPanel onde as imagens serão renderizadas. O protótipo desta função é: void glViewport(GLint x, GLint y, GLsizei width, GLsizei height).

Os seus parâmetros especificam o canto inferior esquerdo da viewport (x e y), dentro da área do painel, e a sua largura e altura em pixels (width e height). Neste caso os parâmetros usados fazem com que a viewport coincida com a própria área do painel, mas é possível usar outros valores e definir uma área mais pequena (ou mais grande), do que a área do componente. Também é possível definir mais do que uma viewport permitindo assim renderizar mais do que uma cena, ou mais doq que uma vista da mesma cena.

A função glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0) é usada para definir o volume de visualização e em consequência o tipo de projecção, que será usada para renderizar as imagens.

O protótipo desta função é: void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GL double zNear, GLdouble zFar).

Os parâmetros left e right especificam os limites mínimo e máximo no eixo X; analogamente, bottom e top especificam os limites mínimo e máximo no eixo Y; zNear e zFar, por sua vez, especificam a coordenada mais próxima e mais distante do observador, respectivamente, no eixo de profundidade Z. Estes parâmetros definem um volume de visualização com a forma de um paralelepípedo rectangular como o mostrado na figura 1. Este volume de visualização é também designado por volume de recorte, pois só será renderizado aquilo que estiver dentro deste volume. A projecção definida pela função é uma projecção ortográfica ou paralela.

Figura 3 – Volume de visualização da projecção ortográfica.