---

Prof. Márcio Sarroglia Pinho

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
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: Em CPP Em Python

FIM.