No capítulo anterior aprendemos como adicionar luzes ao nosso ambiente.
Você deve ter percebido que, quando alteramos algumas propriedades da OpenGL acontece algumas mudanças na forma de renderizar a cena.

Por exemplo, quando aplicamos a cor Amarela a um objeto, este objeto passa a ser impresso na tela com a cor amarela.
Mais quando incluimos uma textura ou uma luz no ambiente, o objeto amarelo sofre interferência dessas funções e acaba tendo sua cor original trocada.

Neste capitulo iremos aprofundar ainda mais nossos conhecimentos sobre os Materiais de Cores da OpenGL.

Primeiro, nós sabemos que a OpenGL trabalha com o padrão RGBA que faz a mistura de Cores e habilita a transparência.

Basicamente, aprendemos 2 formas de adicionar cor aos nossos objetos.

- A primeira é aplicando cor diretamente sobre objeto.

- A segunda é aplicando cor sobre a superfície do objeto, alterando assim as propriedades da superfície ( conhecido como Material ) através de configurações ou através da incidência de luz.

Um dos problemas que nós iremos encontrar é com relação de cores e luzes.
Por exemplo, se um objeto vermelho for luminado por uma luz azul, esse objeto irá aparecer relativamente preto.
Isso acontece por que o objeto vermelho reflete luz vermelha e não azul e a luz contem luz azul e não vermelho.

Vamos aprender como aplicar uma cor transparente

Os comandos responsáveis por habilitar a transparência são:

glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

glColor4f ( 0.0f, 0.0f, 1.0f, 0.5f );

Exemplo em AllegroGL

Observe que o quadro azul é transparente.
Observe também que nossas cores originais não foram alteradas pela inclusão da função de transparência.

Veja no exemplo abaixo, como usar transparência e textura com AllegroGL

Antes, leia:
Instalação de bibliotecas para texturas
http://www.bdjogos.com/biblioteca_conteudo.php?id=25

Como usar texturas
http://www.bdjogos.com/conteudo.php?link=capitulo_42.php

    glPushMatrix();

    glEnable(GL_TEXTURE_2D);

    glBegin(GL_QUADS);
    glColor4f ( 1.0f, 1.0f, 1.0f, 0.7f );
    glBindTexture ( GL_TEXTURE_2D, 1 );
    glTexCoord2f(0.0f, 0.0f);
    glVertex3f( -0.40, -0.40, 0.00 );
    glTexCoord2f(0.0f, 1.0f);
    glVertex3f( -0.40, 0.40, 0.00 );
    glTexCoord2f(1.0f, 1.0f);
    glVertex3f( 0.40, 0.40, 0.00 );
    glTexCoord2f(1.0f, 0.0f);
    glVertex3f( 0.40, -0.40, 0.00 );
    glEnd();
    glDisable(GL_TEXTURE_2D);
    glPopMatrix();

Usando glColor4f ( 1.0f, 1.0f, 1.0f, 0.7f ); nós obtemos uma textura com as cores originais, adicionando apenas trasnparência para ela...
Eu usei uma textura com as cores vermelho, verde e azul para exemplo.
Veja o resultado do programa.

Bom, o que aconteceria se pegarmos o primeiro exemplo, aonde aplicamos cores e transparência
e aplicarmos iluminação nela ?

No exemplo acima aplicamos uma luz ambiente e uma luz difusa.
Quando executamos o programa temos o horrível resultado:

Nosso render perdeu as cores e a transparência.
Isso acontece por que a luz interfere diretamente nas faces dos objetos.

Para mostrar as cores originais dos objetos, iremos precisar usar 2 funções importantes.

A glMaterial que já vimos e a glNormal.

Toda alteração de cor, transparência ou aplicação de textura é feita sobre as faces em OpenGL.
E quando aplicamos esses valores a essas faces na verdade estamos criando um material e aplicando a face.

Iremos usar a função glNormal por que ela vai indicar para a OpenGL qual é a face que está visível e que precisa ser iluminada.
Iremos usar a função glMaterial para criar um material para cada objeto, fazendo com que a luz não altere sua cor original.

Alem disso ainda iremos usar

glEnable(GL_COLOR_MATERIAL);

Para habilitar as cores dos materiais e

glColorMaterial(GL_FRONT,GL_AMBIENT_AND_DIFFUSE);

Para indicar que as cores serão indicadas na face frontal.

// Aplicando cores, transparência e luz - EXEMPLO completo!! - AllegroGL
// Autor: Adriano Waltrick
// BDJogos
// Data: 13/03/2008
#include <allegro.h>
#include <alleggl.h>

#include <GL/glut.h>

int main()
{
   
   // Iniciações básicas da Allegro
   allegro_init();
   install_keyboard();
   
   // Iniciação da AllegroGL
   install_allegro_gl();
   
   allegro_gl_set(AGL_Z_DEPTH, 8);
   allegro_gl_set(AGL_COLOR_DEPTH, 16);
   allegro_gl_set(AGL_SUGGEST, AGL_Z_DEPTH | AGL_COLOR_DEPTH);
   
   // Setando o Modo Gráfico
   set_gfx_mode(GFX_OPENGL_WINDOWED, 640, 480, 0, 0);
   
   
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   
   // Iniciando a camera
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   glFrustum(-1.0, 1.0, -1.0, 1.0, 1, 60.0);
   
   glShadeModel( GL_SMOOTH );
   
   // Faz a OpenGL aceitar profunidade
   glClearDepth( 1.0f );
   glEnable( GL_DEPTH_TEST );
   glDepthFunc(GL_LEQUAL);
   
   // Maior qualidade nos gráficos
   glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
   
   
   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   
   
   // iniciando um array de luz ambiente
   GLfloat luz_ambiente[] = { 0.1f, 0.1f, 0.1f, 1.0f };
   GLfloat luz_difusa[] = { 1.0f, 1.0f, 1.0f, 1.0f };
   GLfloat luz_posicao[] =   { 0.0f, 0.0f, -15.0f, 1.0f };
   
   // criando a luz ambiente
   glLightfv(GL_LIGHT1, GL_AMBIENT, luz_ambiente);
   glLightfv(GL_LIGHT1, GL_DIFFUSE, luz_difusa);
   glLightfv(GL_LIGHT1, GL_POSITION, luz_posicao);
   
   glEnable( GL_LIGHT1 );
   glEnable( GL_LIGHTING );

   // habilita as cores do material
   glEnable(GL_COLOR_MATERIAL);
   glColorMaterial(GL_FRONT,GL_AMBIENT_AND_DIFFUSE);
   glEnable(GL_NORMALIZE);
   
   glLoadIdentity();
   
   
   // Laço principal
   while( !key[KEY_ESC] )
   {
   
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
      
      glLoadIdentity();
      
      
      glBegin(GL_QUADS);
      
      glNormal3f(0.0, 0.0, 1.0);
      glColor3f ( 0.0, 1.0, 0 );
      glVertex3f( 0.00, 0.00, 0.00 );
      glVertex3f( 0.00, -0.80, 0.00 );
      glVertex3f( -0.80, -0.80, 0.00 );
      glVertex3f( -0.80, 0.00, 0.00 );
      
      glEnd();
      
      
      glBegin(GL_TRIANGLES);
      
      // Face da Frente do triângulo
      glNormal3f(0.0, 0.0, 1.0);
      glColor3f ( 1.0, 0 , 0 );
      glVertex3f( 0.00, 0.00, 0.00 );
      glVertex3f( 0.80, 0.00, 0.00 );
      glVertex3f( 0.40, 0.80, 0.00 );
      
      glEnd();
      
      
      
      glBegin(GL_QUADS);

      glNormal3f(0.0, 0.0, 1.0);
      glColor4f ( 0.0f, 0.0f, 1.0f, 0.5f );
      glVertex3f( -0.40, -0.40, 0.00 );
      glVertex3f( -0.40, 0.40, 0.00 );
      glVertex3f( 0.40, 0.40, 0.00 );
      glVertex3f( 0.40, -0.40, 0.00 );
      
      glEnd();
      
      // imprime tudo
      allegro_gl_flip();
   
   }
   
   allegro_exit();
   
   return 0;
}
END_OF_MAIN();

Agora sim, temos o exemplo de Luzes, Transparências e cores.
Inclusive, se você mudar a posição da luz, para perto, as cores originais vão ficar mais escuras.

Faça o teste:

GLfloat luz_posicao[] =   { 0.0f, 0.0f, -15.0f, 1.0f };

Mude para
GLfloat luz_posicao[] =   { 0.0f, 0.0f, -5.0f, 1.0f };

Pronto.. agora temos um sistema de luzes com cores eficiente.

Brightness = Luminance = Luminosidade

O Termo usado ai em cima representa o quanto uma luz vai iluminar um objeto mudando sua cor original.
Não confunda Brightness com Blend, blending é o canal de transparência.

// Exemplo de Luz com textura, normal, Material e Brightness
// Autor: Adriano Waltrick
// BDJogos
// Data: 13/03/2008
#include <allegro.h>
#include <alleggl.h>

#include <GL/glut.h>
#include "glaux\glaux.h"

#include <stdlib.h>
#include <stdio.h>

void CarregaTextura(char* Filename, GLuint Index);
GLuint texture_id[1] = {0};

int main()
{

   // Iniciações básicas da Allegro
   allegro_init();
   install_keyboard();
   
   // Iniciação da AllegroGL
   install_allegro_gl();
   
   allegro_gl_set(AGL_Z_DEPTH, 8);
   allegro_gl_set(AGL_COLOR_DEPTH, 16);
   allegro_gl_set(AGL_SUGGEST, AGL_Z_DEPTH | AGL_COLOR_DEPTH);
   
   // Setando o Modo Gráfico
   set_gfx_mode(GFX_OPENGL_WINDOWED, 640, 480, 0, 0);
   
   
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   
   // Iniciando a camera
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   glFrustum(-1.0, 1.0, -1.0, 1.0, 1, 60.0);
   
   glShadeModel( GL_SMOOTH );
   
   // Faz a OpenGL aceitar profunidade
   glClearDepth( 1.0f );
   glEnable( GL_DEPTH_TEST );
   glDepthFunc(GL_LEQUAL);
   
   // Maior qualidade nos gráficos
   glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
   
   
   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   
     // carrega textura
   glEnable(GL_TEXTURE_2D);
   glDepthFunc(GL_LEQUAL);
   
     //Carrega os arquivos de texturaC
   CarregaTextura("textura.bmp", texture_id[0] );
   
     // iniciando um array de luz ambiente
   GLfloat luz_ambiente[] = { 0.1f, 0.1f, 0.1f, 1.0f };
   GLfloat luz_difusa[] = { 1.0f, 1.0f, 1.0f, 1.0f };
   GLfloat luz_posicao[] = {0.0f,0.0f,-1.0f,1.0f};
   
   GLfloat luz_especular[] = { 1.0f, 1.0f, 0.0f, 1.0f };
   GLfloat luz_posicao2[] = {3.0f,0.0f,-5.0f,1.0f};
   
   // criando a luz ambiente
   glLightfv(GL_LIGHT1, GL_AMBIENT, luz_ambiente);
   glLightfv(GL_LIGHT1, GL_DIFFUSE, luz_difusa);
   glLightfv(GL_LIGHT1, GL_POSITION, luz_posicao);
   
   glLightfv(GL_LIGHT2, GL_SPECULAR, luz_especular);
   glLightfv(GL_LIGHT2, GL_POSITION, luz_posicao2);
   
   
   glEnable( GL_LIGHT1 );
   glEnable( GL_LIGHT2 );
   glEnable( GL_LIGHTING );
   
   
   // habilita as cores do material
   glEnable(GL_COLOR_MATERIAL);
   glColorMaterial(GL_FRONT,GL_AMBIENT_AND_DIFFUSE);
   glEnable(GL_NORMALIZE);
   
   
   
   glLoadIdentity();

  
     GLfloat Especularidade[]= {1.0f, 1.0f, 0.0f, 1.0f };

   glMateriali( GL_FRONT, GL_SHININESS, 120 );
   glMaterialfv( GL_FRONT, GL_SPECULAR, Especularidade );
   
   
   // Laço principal
   while( !key[KEY_ESC] )
   {
   
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
      
      glLoadIdentity();
      
      
      
      
      glBegin(GL_QUADS);
      glNormal3f(0.0, 0.0, 1.0);
      glColor3f ( 0.0, 1.0, 0 );
      glVertex3f( 0.00, 0.00, 0.00 );
      glVertex3f( 0.00, -0.80, 0.00 );
      glVertex3f( -0.80, -0.80, 0.00 );
      glVertex3f( -0.80, 0.00, 0.00 );
      
      glEnd();
      
      
      glBegin(GL_TRIANGLES);
      
      // Face da Frente do triângulo
      glNormal3f(0.0, 0.0, 1.0);
      glColor3f ( 1.0, 0 , 0 );
      glVertex3f( 0.00, 0.00, 0.00 );
      glVertex3f( 0.80, 0.00, 0.00 );
      glVertex3f( 0.40, 0.80, 0.00 );
      
      glEnd();
      
      
      
      
      glPushMatrix();
      
      glEnable(GL_TEXTURE_2D);
      
      glBegin(GL_QUADS);
      glNormal3f(0.0, 0.0, 1.0);
      glColor4f ( 1.0f, 1.0f, 1.0f, 0.7f );
      glBindTexture ( GL_TEXTURE_2D, 1 );
      glTexCoord2f(0.0f, 0.0f);
      glVertex3f( -0.40, -0.40, 0.00 );
      glTexCoord2f(0.0f, 1.0f);
      glVertex3f( -0.40, 0.40, 0.00 );
      glTexCoord2f(1.0f, 1.0f);
      glVertex3f( 0.40, 0.40, 0.00 );
      glTexCoord2f(1.0f, 0.0f);
      glVertex3f( 0.40, -0.40, 0.00 );
      glEnd();
      glDisable(GL_TEXTURE_2D);
      glPopMatrix();
      
      
      
      
      
      
      // imprime tudo
      allegro_gl_flip();
   
   }
   
   allegro_exit();
   
   return 0;
}
END_OF_MAIN();
   
//Função para Carregar uma imagem .BMP
void CarregaTextura(char* Filename, GLuint Index)
{
   AUX_RGBImageRec *imagemTextura = NULL;
   FILE *FileHandle = NULL;
   
   imagemTextura = auxDIBImageLoad(Filename);
   
   glGenTextures(1, &texture_id[Index]);
   glBindTexture(GL_TEXTURE_2D, texture_id[Index]);
   
   gluBuild2DMipmaps( GL_TEXTURE_2D,       // A textura é 2D
                  3,                       // 3 Significa que é uma textura "RGB"
                  imagemTextura->sizeX,    // Largura do Bitmap
                  imagemTextura->sizeY,    // Altura do Bitmap
                  GL_RGB,                  // O Bitmap está no formato RGB
                  GL_UNSIGNED_BYTE,        // Tipo de dado de cada Pixel é armazenado
                  imagemTextura->data);    // Dados do Bitmap Atual
   
   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
}

Observe que no exemplo acima aplicamos iluminação direcionada amarelada no triangulo vermelho, adicionando brilho amarelo.
As outras cores não foram influenciadas, o que é muito importante.

Contribuidor
Adriano Waltrick
18/03/2008