Mapeamento de Texturas

No contexto de Computação Gráfica, o mapeamento de texturas consiste na "aplicação de uma imagem sobre as faces de um objeto 3D.

O uso de texturas requer a execução de dois passos distintos: a CARGA e a APLICAÇÃO da textura.

Em OpenGL cada textura recebe um número de identificação através da função glGenTextures. Por exemplo:

Sempre que for necessário trabalhar com um textura (para carga ou aplicação) deve-se chamar a função glBindTexture que permite  definir a textura corrente. Esta definição é feita atavés do número de identificaçõa da textura.
 

Carga de uma textura

Para realizar a tarefa de CARGA de uma textura é necessário seguir os seguintes passos:
 // Habilitar o uso de texturas
 glEnable ( GL_TEXTURE_2D );

 // Definir a forma de armazenamento dos pixels na textura (1= alinhamento por byte)
 glPixelStorei ( GL_UNPACK_ALIGNMENT, 1 );

 // Definir quantas texturas serão usadas no programa
 GLuint texture_id[MAX_NO_TEXTURES]; // vetor com os números das texturas
 glGenTextures (1, texture_id);  // 1 = uma textura;
                                 // texture_id = vetor que guarda os números das texturas

 // Definr o número da textura do cubo.
 texture_id[0] = 1001;

 // Define a textura corrente
 glBindTexture ( GL_TEXTURE_2D, texture_id[0] );
             // GL_TEXTURE_2D ==> define que será usada uma textura 2D (bitmaps)
             // texture_id[CUBE_TEXTURE]  ==> define o número da textura

 // carrega a uma imagem TGA
 image_t temp_image;
 tgaLoad  ( "TCG1.tga", &temp_image, TGA_FREE | TGA_LOW_QUALITY );
 

Aplicação de uma Textura

Para a aplicação da textura é preciso criar uma relação entre os vértives da textura e os vértices dos polígonos sobre os quais se desenha mapear a textura escolhida.
Na figura a seguir as letras A, B, C e D definem os vértices da textura e os vértices A1, B1, C1 e D1 os vértices de polígono 3D onde deve ser mapeada esta textura.
O processo de mapeamento de texturas em OpenGL consiste em "aplicar" a imagem 2D sobre o polígono 3D de forma que os pontos A, B, C e D sejam encaixados sobre os pontos A1, B1, C1 e D1.
 
 

Para permitir a construção desta correspondência entre a imagem 2D e o polígono 3D usa-se a função glTexCoord2f antes da definição do ponto 3D.
Por exemplo,
 

  glTexCoord2f(0.0f, 0.0f);
  glVertex3f(1.0f,  -1.0f, 1.0f);


define que o ponto (0.0, 0.0) da textura 2D corresponde ao ponto (1.0,  -1.0,  1.0) do polígono 3D.

O sistema de coordenadas da textura tem como (0,0) o ponto inferior esquerdo da imagem e como (1,1) o ponto superior direito. Ou seja, na imagem acima temos as seguintes coordenadas para os pontos A, B, C e D.
 
 

Vértice da 
Textura
Coordenada
A
(0,1)
B
(1,1)
C
(1,0)
D
(0,0)

Supondo que o polígono 3D é a face lateral direita de um cubo de aresta 2 com o centro no ponto (0,0,0) teremos as seguintes coordenadas:
 
 

Vértice do
Polígono 3D
Coordenada
A1
1.0,  1.0,  1.0
B1
1.0,  1.0, -1.0
C1
1.0, -1.0, -1.0
D1
1.0, -1.0,  1.0

O mapeamento da textura sobre o polígono se dá através do seguinte trecho de código:
 
 

   // Define a textura corrente
   glBindTexture ( GL_TEXTURE_2D, texture_id[0] );
             // GL_TEXTURE_2D ==> define que será usada uma textura 2D (bitmaps)
             // texture_id[CUBE_TEXTURE]  ==> define o número da textura

  // associa cada vértice do polígono a um ponto da textura
  glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
  glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
  glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
  glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);

É importante lembrar ainda que para definir qual a textura a ser usada em um certo polígono é preciso defini-la antes como a textura corrente através da função glBindTexture.

Programas-Exemplo

Para compilar estes exemplos é necessário "linkar" as seguintes bibliotecas com os fontes: OpenGL32.lib, GLU32.lib, GLUT32.lib.
 
Exemplo 1 (Visual C++) Exemplo 1 (DEVCPP)
Exemplo 2 (Visual C++) Exemplo 2 (DEVCPP)
Exemplo para Carga de JPG