Capítulo 7: Texture Mapping

Texture Mapping

• El mapeo de texturas permite cubrir objetos (polígonos) con imágenes (texturas).
• Esto entrega una visualización más real en objetos de “menor” complejidad.
• Por ejemplo, se puede construir una muralla de ladrillo utilizando un simple polígono recubierto por una textura de un ladrillo.

Texture Mapping
• Una textura puede ser unidimensional, bidimensional o tridimensional.
• Puede ser aplicada sobre una superficie de diferentes formas:
– Cubrir directamente una superficie (modo DECAL).
– Modular el color de la superficie pintada.
– Mezclar (blend) el color de la textura con el color de la superficie.
• Una textura es un arreglo rectangular de datos: color y valor alpha. Cada elemento se denomina texel.
• En el proceso de mapping una textura es asociada a un polígono.

Proceso de Mapeo de Texturas
1. Crear un objeto de textura y especificar una textura para el objeto.
2. Indicar cómo la textura se aplicará a cada píxel.
3. Habilitar mapeo de texturas.
4. Dibujar la escena, suministrando coordenadas geométricas y de texturas.

Especificación de una Textura
• Para especificar una textura 2D se utiliza el comando glTexImage2D.
void glTexImage2D( GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
– target: GL_TEXTURE_2D or GL_PROXY_TEXTURE_2D.
– level: define múltiples niveles de resoluciones de texturas (para mip mapping).
– internalFormat: formato en que se almacena internamente la textura:
• GL_ALPHA, GL_RGB, GL_RGB8, GL_RGBA8, etc.

Especificación de una Textura
– width: ancho de la textura.
– height: alto de la textura.
– border: ancho del borde la textura (0 = sin borde).
– format: formato de los datos de la imagen:
GL_COLOR_INDEX, GL_RGB, GL_RGBA, GL_RED, GL_GREEN, GL_BLUE,
GL_ALPHA, GL_LUMINANCE, or GL_LUMINANCE_ALPHA.
– type: tipo de datos de la imagen:
GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT,
GL_UNSIGNED_INT, GL_FLOAT, or GL_BITMAP.
– pixels: puntero a los datos de la imagen.

Otras Funciones

• Para escalar el tamaño de una imagen:
– intgluScaleImage( ... );

• Se puede usar información del framebuffer para generar una textura:
– voidglCopyTexImage2D( ... );
• Para reemplazar parte o completamente la actual textura:
– voidglTexSubImage2D( ... );

• Para reemplazar parte o completamente la actual textura utilizando datos de la imagen del framebuffer:
– voidglCopyTexSubImage2D( ... );

Múltiples Niveles de Detalle (LOD)
• Objetos texturizados pueden estar en movimiento, alejándose y/o acercándose hacia observador. Esto implica que el mapeo de la textura en el objeto debe cambiar de tamaño.
• Especialmente cuando un objeto se aleja, las texturas tienen que ser filtrada para reducir el tamaño y no producir actifacts visuales.
• Para evitar actifacts se pueden generar una serie de mapas de texturas prefiltradas en tamaño decreciente, llamada mipmaps.
• Con mipmapping, OpenGL automáticamente determina qué mapa usar basado el tamaño del objeto que está siendo mapeado (ver ejemplo mipmap.c).

Filtros

• Si bien las texturas son rectangulares, es improbable que exista una correspondencia 1:1 entre texels y píxeles.
• Dependiendo de las transformaciones un píxel puede ser una porción de un texel (magnificación) o puede ser un conjunto de varias texels (minificación).
• Para especificar los métodos de magnificación y minificación se utiliza:
• void glTexParameteri(GLenum target, GLenum pname, GLint param);
• target: GL_TEXTURE_2D or GL_TEXTURE_1D.
• pname: especifica el nombre del parámetro:
GL_TEXTURE_MIN_FILTER,
GL_TEXTURE_MAG_FILTER,
GL_TEXTURE_WRAP_S,
GL_TEXTURE_WRAP_T.
• param: especifica el valor de pname (ver tabla).

• Ejemplo:
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

Objetos de Texturas
• A partir de OpenGL 1.1 es posible almacenar un conjunto de objetos de texturas y reutilizarlos cuando sea necesario.
• Pasos a seguir:
1. Generar nombres de texturas.
2. Vincular (crear) objetos de texturas a datos de texturas, incluyendo arreglo de imágenes y propiedades.
3. Si la implementación lo permite, definir un conjunto de texturas de alto-desempeño.
4. Vincular o revincular objetos de texturas, dejándolas disponibles para el rendering de modelos.

Nombres de Objetos de Textura
• Para generar uno mas nombre de texturas se utiliza:
void glGenTextures(GLsizei N, GLuint *textureNames);
N : cantidad de nombres solicitados.
textureNames : puntero a los valores entregados.
• Ejemplo:
static GLuint texName[2];
glGenTextures(2, texName);

Creación y Uso de Objetos de Texturas
• Para crear o seleccionar un objeto de textura se utiliza:
void glBindTexture(GLenum target, GLuint textureName);
target: GL_TEXTURE_1D or GL_TEXTURE_2D.
textureName: identificador de la textura.
• Ejemplo (ver texbind.c):
glGenTextures(2, texName);
glBindTexture(GL_TEXTURE_2D, texName[0]);
...
glBindTexture(GL_TEXTURE_2D, texName[0]);

Borrado de Objetos de Texturas
• Para liberar recursos de objetos de texturas se utiliza:
void glDeleteTextures(GLsizei n, const GLuint *textureNames);
n : cantidad de objetos de texturas.
textureNames: puntero a los nombres de texturas.
• Ejemplo:
glDeleteTextures( 2, texName );

Funciones de Texturas
• Para definir las propiedades de cómo interactúa una textura en el proceso de rendering se utiliza la siguiente función:
void glTexEnv{if}(GLenum target, GLenum pname, TYPE param);
void glTexEnv{if}v(GLenum target, GLenum pname, TYPE *param);
target: GL_TEXTURE_ENV
pname:
Si es igual a GL_TEXTURE_ENV_MODE:
param: GL_DECAL, GL_REPLACE, GL_MODULATE or GL_BLEND.
Si es igual a GL_TEXTURE_ENV_COLOR:
param: es un arreglo de 4 flotantes R,G,B,A. Estos valores se usan si también se ha especificado la función de textura GL_BLEND.

Asignación de Coordenadas de Texturas
• Es el proceso en el que se asignan coordenadas de texturas a los vértices de un objeto.
• Las coordenadas de texturas pueden comprometer 1, 2, 3 o 4 componentes ( s, t, r, q ).
• Usualmente estos valores van entre 0 a 1.
• Para definir las coordenadas de texturas se utiliza:
void glTexCoord{1234}{sifd}(TYPEcoords);
void glTexCoord{1234}{sifd}v(TYPE *coords);
• Para un rectángulo 2D las C.T. son (0,0), (1,0), (1,1), (0,1).
• Ejemplo:
glBegin(GL_QUADS);
glTexCoord2f(0.0, 0.0); glVertex3f(0.0, 0.0, 0.0);
glTexCoord2f(1.0, 0.0); glVertex3f(5.0, 0.0, 0.0);
glTexCoord2f(1.0, 1.0); glVertex3f(5.0, 5.0, 0.0);
glTexCoord2f(0.0, 1.0); glVertex3f(0.0, 5.0, 0.0);
glEnd();

Repetición y Fijación de Texturas
• Es posible repetir una textura cambiando el rango de las coordenadas de texturas y definiendo las propiedades adecuadas.
• Por ejemplo:
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_REPEAT);
....
glBegin(GL_QUADS);
glTexCoord2f(0.0, 0.0); glVertex3f(1.0, -1.0, 0.0);
glTexCoord2f(0.0, 3.0); glVertex3f(1.0, 1.0, 0.0);
glTexCoord2f(3.0, 3.0); glVertex3f(2.41421, 1.0, -1.41421);
glTexCoord2f(3.0, 0.0); glVertex3f(2.41421, -1.0, -1.41421);
glEnd();

Repetición y Fijación de Texturas
• También es posible fijar una textura cambiando en la propiedades e GL_REPEAT por GL_CLAMP.