|
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.
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 );
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 |
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 |
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.
FIM.