Transparências em OpenGL

Para exibir objetos transparentes em OpenGL, deve-se utilizar as Funções de Blend (ou de mistura).  Estas funções misturam a cor do objeto que JÁ está na tela com cor do objeto que está sendo desenhado num dado momento.

Assim, como OpenGL trata sempre sobre a imagem que JÁ FOI GERADA, é importante que os objeto transparentes sejam EXIBIDOS DEPOIS de todos os demais.
 

Configurando OpenGL para usar Transparências

Em primeiro lugar é necessário ativar as funções de BLEND. Para tanto, em OpenGL usa-se:
            glEnable(GL_BLEND);

Quando for necessário desenhar um objeto quen não é transparente deve-se desativar o BLEND:
            glEnable(GL_BLEND);
 

Definição do nível de Transparência de um Objeto

Para definir o nível de transparência de um objeto é necessário especificar o ALFA de sua cor. PAra tanto usa-se um quarto parâmetro na função glColor.

glColor4f(1,1,1,alfa);

Este quarto parâmetro alfa pode variar entre 0 e 1, sendo 0 um objeto totalmente transparente e 1 um objeto opaco.

Definição das Funções de Mistura

As funçoes de BLEND definem como é feita a mistura entre as cores do objeto que está sendo desenhado e as imagens que já estão na tela. Esta mistura é feita a partir de uma média ponderada entre o ponto da tela e o ponto do objeto que está sendo desenhado. A função OpenGl para definir este pesos é "glBlendFunc".

Esta função recebe dois parâmetro: o primeiro define o peso da cor do novo ponto e o segundo o peso da cor do ponto que já está na tela. Este pesos, em OpenGL, srão sempre uma função do nível de transparência do objeto, ou seja, de seu alfa.

Por exemplo, a chamada:

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

define que a nova cor do ponto na tela será:

    NovaCorNaTela = CorDoObjeto * AlfaDoObjeto + CorAntigaNaTele * (1-AlfaDoObjeto);

Neste caso, as contantes tem o seguinte sifnificado:
    - GL_SRC_ALPHA: define que o peso da cor do objeto que está sendo desenhado é o próprio alfa de sua cor;
    - GL_ONE_MINUS_SRC_ALPHA: define que o peso da cor que já está na tela é de (1 - Alfa), onde alfa é o nível de transparência do objeto que está sendo desenhado.
 

Exemplo

Veja o exemplo a seguir com objeto transparente e outro opaco:
 
// **********************************************************************
//  void display( void )
// **********************************************************************
void display( void )
{
     glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

     // Desbilita o BLEND par ao primeiro objeto
     glDisable(GL_BLEND);
     glPushMatrix();
          glTranslatef(0,0,-1);
          glRotatef ( xrot, 1.0, 0.0, 0.0 );
          glRotatef ( yrot, 0.0, 1.0, 0.0 );
          glRotatef ( zrot, 0.0, 0.0, 1.0 );

      // habilita remoção de faces traseiras
          glEnable(GL_CULL_FACE);
          glCullFace(GL_BACK);
          DrawCube(0.5);
     glPopMatrix();

 // Habilita o BLEND para ao segundo objeto
 glEnable(GL_BLEND);
 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

 // NovaCorNaTela = CorDoObjeto * AlfaDoObjeto + CorAntigaNaTele * (1-AlfaDoObjeto)

 DesenhaVidro(AlfaVidro);

 xrot+=0.3f;
 yrot+=0.2f;
 zrot+=0.4f;
 glutSwapBuffers();
}

Exercícios


Figura - Exemplos de níveis diferentes de Transparência

Texturas com Transparências

Faço o dowload deste programa e teste o uso de transparências e texturas no mesmo programa.
Para compilá-lo, inclua os dois arquivos .CPP no seu projeto.
No caso de usar o DEV CPP, lembre-se de colocar as opções  -lopengl32 -lglu32 -lglut32  no projeto.
 
 

Veja um exemplo com DOIS Objetos Transparentes