Tema 4. Imágenes y texturas

Departamento de Tecnologías de la Información

Tema 4

4.1 Bitmaps

4.2 Pixmaps

4.3 Transformaciones de imágenes

4.4 Definición de texturas

4.5 Aplicación de texturas

4.6 Mipmaps

4.7 Compresión de texturas

4.8 Generación de coordenadas

Tema 4. Imágenes y texturas

Índice

4.1 Bitmaps

4.2 Pixmaps

4.3 Transformaciones de imágenes

4.4 Definición de texturas

4.5 Aplicación de texturas

4.6 Mipmaps

4.7 Compresión de texturas

4.8 Generación de coordenadas

• Un bitmap es una matriz de bits que representan una imagen cuyos píxeles pueden estar en dos estados: on y off.

• Los bitmaps se utilizan como para representar máscaras (stippling) o fuentes de letra.

• Para dibujar un bitmap sobre la imagen se utiliza:

glBitmap(width,height,xorig,yorig,xmove,ymove,bitmap);

• Donde width y height describen el tamaño del bitmap, xorig e yorig la posición de la esquina inferior izquierda, xmove e ymove el desplazamiento a realizar sobre la posición raster y bitmap es un array de GLubyte.

Tema 4. Imágenes y texturas

GLubyte fly[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x01, 0xC0, 0x06, 0xC0, 0x03, 0x60, 0x04, 0x60, 0x06, 0x20, 0x04, 0x30, 0x0C, 0x20, 0x04, 0x18, 0x18, 0x20, 0x04, 0x0C, 0x30, 0x20, 0x04, 0x06, 0x60, 0x20, 0x44, 0x03, 0xC0, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x66, 0x01, 0x80, 0x66, 0x33, 0x01, 0x80, 0xCC, 0x19, 0x81, 0x81, 0x98, 0x0C, 0xC1, 0x83, 0x30, 0x07, 0xe1, 0x87, 0xe0, 0x03, 0x3f, 0xfc, 0xc0, 0x03, 0x31, 0x8c, 0xc0, 0x03, 0x33, 0xcc, 0xc0, 0x06, 0x64, 0x26, 0x60, 0x0c, 0xcc, 0x33, 0x30, 0x18, 0xcc, 0x33, 0x18, 0x10, 0xc4, 0x23, 0x08, 0x10, 0x63, 0xC6, 0x08, 0x10, 0x30, 0x0c, 0x08, 0x10, 0x18, 0x18, 0x08, 0x10, 0x00, 0x00, 0x08};

4.1 Bitmaps

• Los bitmaps se dibujan sobre la imagen a partir de una posición llamada posición raster.

• Para fijar la posición raster se utiliza la función glRasterPos..(). En esta función las coordenadas se interpretan como coordenadas de vértices y, por tanto, son transformadas por las matrices modelview y projection. Este es un ejemplo de la funcion

glRasterPos2i(0,0);

• Para fijar la posición raster en coordenadas de la ventana se utiliza la función

Tema 4. Imágenes y texturas

Índice

4.1 Bitmaps

4.2 Pixmaps

4.3 Transformaciones de imágenes

4.4 Definición de texturas

4.5 Aplicación de texturas

4.6 Mipmaps

4.7 Compresión de texturas

4.8 Generación de coordenadas

• Un pixmap es una matriz de píxeles que representan una imagen. • Los valores de los píxeles pueden estar descritos en varios formatos

y almacenados en distintos tipos de datos.

• Para dibujar un bitmap sobre la imagen se utiliza:

glDrawPixels( width, height, format, type, pixels);

• Donde width y height describen el tamaño del pixmap, format indica el formato en que se describen los valors de los píxeles, type es el tipo de dato utilizado para almacenar el valor de cada pixel y pixels es un array del tipo indicado anteriormente.

Tema 4. Imágenes y texturas

4.2 Pixmaps

Formatos admitidos

GL_COLOR_INDEX GL_STENCIL_INDEX GL_DEPTH_COMPONENT GL_RGB GL_BGR GL_RGBA GL_BGRA GL_RED GL_GREEN GL_BLUE GL_ALPHA GL_LUMINANCE GL_LUMINANCE_ALPHA

Tipos de dato admitidos

•

•

•

•

Tipo Contenido

GL_UNSIGNED_BYTE unsigned 8-bit integer

GL_BYTE signed 8-bit integer

GL_BITMAP single bits in unsigned 8-bit integers

GL_UNSIGNED_SHORT unsigned 16-bit integer

GL_SHORT signed 16-bit integer

GL_UNSIGNED_INT unsigned 32-bit integer

GL_INT 32-bit integer

GL_FLOAT single-precision floating-point

GL_UNSIGNED_BYTE_3_3_2 unsigned 8-bit integer

GL_UNSIGNED_BYTE_2_3_3_REV unsigned 8-bit integer with reversed component ordering

GL_UNSIGNED_SHORT_5_6_5 unsigned 16-bit integer

GL_UNSIGNED_SHORT_5_6_5_REV unsigned 16-bit integer with reversed component ordering

Tema 4. Imágenes y texturas

4.2 Pixmaps

Tipos de dato admitidos (continuación)

•

•

•

•

Tipo Contenido

GL_UNSIGNED_SHORT_4_4_4_4 unsigned 16-bit integer

GL_UNSIGNED_SHORT_4_4_4_4_REV unsigned 16-bit integer with reversed component ordering

GL_UNSIGNED_SHORT_5_5_5_1 unsigned 16-bit integer

GL_UNSIGNED_SHORT_1_5_5_5_REV unsigned 16-bit integer with reversed component ordering

GL_UNSIGNED_INT_8_8_8_8 unsigned 32-bit integer

GL_UNSIGNED_INT_8_8_8_8_REV unsigned 32-bit integer with reversed component ordering

GL_UNSIGNED_INT_10_10_10_2 unsigned 32-bit integer

GL_UNSIGNED_INT_2_10_10_10_REV unsigned 32-bit integer with reversed component ordering

• OpenGL no contiene funciones para leer imágenes a partir de ficheros en formatos estándar (GIF, PNG, JPEG, …). Es responsabilidad del programador obtener la representación de las imágenes como vectores de píxeles.

• Existen bibliotecas de libre distribución que permiten generar pixmaps a partir de ficheros en formatos estándar, por ejemplo, FreeImage.

Tema 4. Imágenes y texturas

4.2 Pixmaps

• Los pixmaps también se pueden leer del color buffer, obteniendo una captura de la imagen generada por OpenGL.

glReadPixels(x, y, width, height, format, type, pixels);

• También se puede copiar un pixmap de una zona del color buffer a otra.

glCopyPixels(x,y,width,height,type);

• En este caso, la posición de destino es la asignada como posición raster. El valor de type puede ser GL_COLOR, GL_DEPTH o GL_STENCIL indicando si los datos a copiar son los valores almacenados en el color buffer, el depth buffer o el stencil buffer.

• Se puede especificar cual es el buffer de color del que van a tomar los datos las funciones glReadPixels() y glCopyPixels().

glReadBuffer(GLenum mode);

• Los valores de mode pueden ser los siguientes: GL_FRONT_LEFT, GL_FRONT_RIGHT, GL_BACK_LEFT, GL_BACK_RIGHT,

GL_FRONT, GL_BACK, GL_LEFT, GL_RIGHT y GL_AUXi (donde i es un número entre 0 y GL_AUX_BUFFERS-1).

• Cuando se utiliza doble buffer, front se refiere al buffer mostrado y back se refiere al buffer de trabajo. Las opciones left y right se refieren a configuraciones de imágenes estereoscópicas.

Tema 4. Imágenes y texturas

4.2 Pixmaps

• También se puede especificar cual es el buffer de color de destino de las funciones glDrawPixels() y glCopyPixels().

glDrawBuffer(GLenum mode);

• Los valores admitidos para mode son los mismos que los utilizados en la función glReadBuffer().

4.1 Bitmaps

4.2 Pixmaps

4.3 Transformaciones de imágenes

4.4 Definición de texturas

4.5 Aplicación de texturas

4.6 Mipmaps

4.7 Compresión de texturas

4.8 Generación de coordenadas

Tema 4. Imágenes y texturas

4.3 Transformaciones de imágenes

• Se pueden configurar transformaciones sobre las imágenes a mostrar con glDrawPixels() y glCopyPixels().

• Por ejemplo, se puede escalar la imagen en dirección X e Y.

glPixelZoom(GLfloat xfactor, Glfloat yfactor);

• También se pueden realizar transformaciones de color por medio de la función

glPixelTransferi(GLenum type, GLint param); glPixelTransferf(GLenum type, GLfloat param);

• Los valores admitidos para el tipo de transformación son:

• Los valores scale y bias describen una transformación lineal de cada color .

Color_Final = Color_Inicial * scale + bias

GL_RED_SCALE GL_RED_BIAS GL_GREEN_SCALE GL_GREEN_BIAS GL_BLUE_SCALE GL_BLUE_BIAS GL_ALPHA_SCALE GL_ALPHA_BIAS GL_DEPTH_SCALE GL_DEPTH_BIAS GL_MAP_COLOR GL_MAP_STENCIL GL_INDEX_SHIFT GL_INDEX_OFFSET

Tema 4. Imágenes y texturas

4.3 Transformaciones de imágenes

• La opción GL_MAP_COLOR sirve para modificar los colores de los pixels por una índice a una tabla de colores. Para poder realizar esta transformación es necesario definir la tabla de colores.

glPixelMapuiv(GLenum map, GLint mapsize, GLuint *values); glPixelMapusv(GLenum map, GLint mapsize, GLushort *values);

glPixelMapfv(GLenum map, GLint mapsize, GLfloat *values);

• Se utiliza un mapa diferente para cada componente. El parámetro map indica que mapa de qué componente se está configurando. Los valores aceptados son:

GL_PIXEL_MAP_R_TO_R GL_PIXEL_MAP_G_TO_G GL_PIXEL_MAP_B_TO_B GL_PIXEL_MAP_A_TO_A

• También se pueden aplicar filtros de convolución sobre las imágenes.

• En primer lugar hay que activar la opción

glEnable(GL_CONVOLUTION_2D);

• A continuación se define el filtro de convolución:

glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type,

Tema 4. Imágenes y texturas

4.3 Transformaciones de imágenes

• target es siempre GL_CONVOLUTION_2D,

• internalFormat indica a que píxeles se les va a aplicar, • width y height son el tamaño del filtro,

• format y type describen la forma en la que se almacena el filtro • image contiene un array que describe el filtro.

• Ejemplo de filtro de convolución: GLfloat filter[3][3] = { { 0.0f, -1.0f, 0.0f}, {-1.0f, 5.0f, -1.0f}, { 0.0f, -1.0f, 0.0f} }; glConvolutionFilter2D(GL_CONVOLUTION_2D, GL_RGB, 3, 3, GL_LUMINANCE, GL_FLOAT, filter); glEnable(GL_CONVOLUTION_2D);

Tema 4. Imágenes y texturas

Índice

4.1 Bitmaps

4.2 Pixmaps

4.3 Transformaciones de imágenes

4.4 Definición de texturas

4.5 Aplicación de texturas

4.6 Mipmaps

4.7 Compresión de texturas

4.8 Generación de coordenadas

• Se denomina textura a la aplicación de una imagen a una primitiva geométrica.

• Los puntos de las texturas se denominan texels. • Tipos de texturas: 1D, 2D, 3D

– Texturas 1D: vector de texels en una dimensión (línea de texels) – Texturas 2D: matriz de texels (imagen en 2 dimensiones)

– Texturas 3D: matriz de tres dimensiones (colección de imágenes o volumen de texels)

• OpenGL identifica el tipo de textura mediante las constantes GL_TEXTURE_1D, GL_TEXTURE_2D y GL_TEXTURE_3D.

Tema 4. Imágenes y texturas

4.4 Definición de texturas

• Para cargar una textura 1D en memoria se utiliza la función

glTexImage1D( GLenum target,

GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type,

• Para cargar una textura 2D en memoria se utiliza la función

glTexImage2D( GLenum target,

GLint level, GLint internalFormat, GLsizei width, Glsizei height, GLint border, GLenum format, GLenum type,

Tema 4. Imágenes y texturas

4.4 Definición de texturas

• Para cargar una textura 3D en memoria se utiliza la función

glTexImage3D( GLenum target,

GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type,

• Los valores de target indican el tipo de textura que se está cargando. • El parámetro level indica el nivel de “mipmap” de la textura cargada

(valor 0 por defecto).

• El parámetro internalFormat indica el formato en el que se va a almacenar la textura. Los más comunes son GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB y GL_RGBA. También pueden indicarse formatos comprimidos.

• Los parámetros width, height y depth indican el tamaño de la textura. En las versiones anteriores a OpenGL 2.0 se exigía que fueran potencias de 2 (1,2, 4, 8, 16, 32, 64, …). En versiones posteriores no se exige, aunque es aconsejable.

Tema 4. Imágenes y texturas

4.4 Definición de texturas

• El parámetro border indica el número de texels de borde. El borde se entiende como una extensión de la textura. Estos texels resultan necesarios para evaluar los píxeles asociados a los extremos de las texturas.

• Los parámetros format, type y data son idénticos a los utilizados para definir pixmaps.

• Además de almacenarlas directamente, las imágenes que forman las texturas se pueden copiar del color buffer

glCopyTexImage1D(GLenum target, GLint level, GLint internalFormat,

GLint x, GLint y,

GLsizei width, GLint border); glCopyTexImage2D(GLenum target, GLint level,

GLint internalFormat, GLint x, GLint y,

GLsizei width, GLsizei height,GLint border);

Tema 4. Imágenes y texturas

4.4 Definición de texturas

• Cargar texturas es un proceso lento. En ocasiones conviene cargar solo un trozo de textura sobre la textura ya existente en vez de realizar una carga completa.

glTexSubImage1D(GLenum target, GLint level, GLint xOffset, GLsizei width,

GLenum format, GLenum type, const GLvoid * data);

glTexSubImage2D(GLenum target, GLint level, GLint xOffset, GLint yOffset,

GLsizei width, GLsizei height,

glTexSubImage3D(GLenum target, GLint level,

GLint xOffset, GLint yOffset, GLint zOffset, GLsizei width, GLsizei height, GLsizei depth,

GLenum format, GLenum type, const GLvoid * data);

• Los valores de xOffset, yOffset y zOffset indican la posición en la que comienza la susitución de la textura existente.

Tema 4. Imágenes y texturas

4.4 Definición de texturas

• También se puede sustituir las texturas con valores tomados desde el color buffer:

glCopyTexSubImage1D(GLenum target, GLint level, GLint xOffset,

GLint x, GLint y, GLsizei width);

glCopyTexSubImage2D(GLenum target, GLint level, GLint xOffset, GLint yOffset,

GLint x, GLint y,

glCopyTexSubImage3D(GLenum target, GLint level, GLint xOffset, GLint yOffset, GLint zOffset, GLint x, GLint y,

GLsizei width, GLsizei height);

• En el caso de las texturas 3D, la copia de la imagen del color buffer se hace en un único nivel de profundidad marcado por zOffset.

Tema 4. Imágenes y texturas

4.4 Definición de texturas

• Las funciones de OpenGL trabajan sobre la textura activa.

• Para trabajar sobre varias texturas sin necesidad de sobreescribir constantemente la textura activa se definen objetos textura. Cada objeto textura se identifica mediante un número.

• Para reservar identificadores de objetos textura se utiliza

glGenTextures(GLsizei n, GLuint* textures);

• Donde n es el número se identificadores a reservar y textures el vector que almacena los identificadores.

• Para saber si un identificador está reservado como textura se utiliza

• Para indicar cual de los objetos textura corresponde a la textura activa se utiliza

glBindTexture(GLenum target, GLuint texture);

• Donde target indica el tipo de textura (GL_TEXTURE_1D, GL_TEXTURE_2D o GL_TEXTURE_3D) y texture el identificador de la textura a activar.

• Para eliminar las texturas se utiliza

glDeleteTextures(GLsizei n, GLuint* textures);

• Para configurar un objeto textura hay que activarlo con glBindTexture() y operar con las funciones ya conocidas.

Tema 4. Imágenes y texturas

Índice

4.1 Bitmaps

4.2 Pixmaps

4.3 Transformaciones de imágenes

4.4 Definición de texturas

4.5 Aplicación de texturas

4.6 Mipmaps

4.7 Compresión de texturas

4.8 Generación de coordenadas

• Para comenzar a utilizar texturas es necesario habilitar la opción

glEnable(GL_TEXTURE_1D); glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_3D);

• En cada momento solo puede estar activo un tipo de textura.

• De igual forma, se puede deshabilitar el uso de texturas con la función glDisable(…).

glDisable(GL_TEXTURE_1D); glDisable(GL_TEXTURE_2D); glDisable(GL_TEXTURE_3D);

Tema 4. Imágenes y texturas

4.5 Aplicación de texturas

• Para identificar un punto en una textura se utilizan coordenadas. OpenGL las denomina (s,t,r,q) con un significado similar a las coordenadas espaciales (q es un factor de escala). Generalmente se utilizan valores en coma flotante, entre 0.0f y 1.0f.

• La coordenada de la textura es una información asociada a los vértices. Para asignarla se utilizan las funciones glTexCoord…().

glTexCoord1f(GLfloat s);

glTexCoord2f(GLfloat s, GLfloat t);

glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);

• Las coordenadas de las texturas pueden ser transformadas multiplicándolas por la matriz GL_TEXTURE, de la misma forma que las coordenadas de los vértices se transforman con las matrices modelview y projection.

• Para modificar esta matriz se utilizan los funciones de manejo de matrices. Para que estas funciones se apliquen a la matriz de texturas hay que indicar glMatrixMode(GL_TEXTURE).

• También existe una pila de matrices de texturas, pero sólo puede almacenar dos elementos. Esto permite utilizar glPushMatrix() y glPopMatrix(), pero solo con un nivel de profundidad.

Tema 4. Imágenes y texturas

4.5 Aplicación de texturas

• El proceso de aplicación de texturas puede configurarse de muchas formas. Para ello se utilizan dos funciones: glTexParameter..(), que permite modificar algunos parámetros del proceso de aplicación de texturas, y glTexEnv..(), que permite configurar el entorno de texturas.

• La función glTexParameter..() tiene las siguientes versiones

glTexParameterf( GLenum target, GLenum pname, GLfloat param); glTexParameteri( GLenum target, GLenum pname, GLint param); glTexParameterfv( GLenum target, GLenum pname, Glfloat* param); glTexParameteriv( GLenum target, GLenum pname, Glint* param);

• target indica el tipo de textura (GL_TEXTURE_1D, …). • pname indica el parámetro a configurar.

Tema 4. Imágenes y texturas

4.5 Aplicación de texturas

• pname puede ser

GL_TEXTURE_MIN_FILTER GL_TEXTURE_MAG_FILTER GL_TEXTURE_BASE_LEVEL GL_TEXTURE_MAX_LEVEL GL_TEXTURE_MIN_LOD GL_TEXTURE_MAX_LOD GL_TEXTURE_LOD_BIAS GL_TEXTURE_WRAP_S GL_TEXTURE_WRAP_T GL_TEXTURE_WRAP_R GL_TEXTURE_COMPARE_FUNC GL_TEXTURE_COMPARE_MODE GL_TEXTURE_SWIZZLE_R GL_TEXTURE_SWIZZLE_G GL_TEXTURE_SWIZZLE_B GL_TEXTURE_SWIZZLE_A GL_DEPTH_STENCIL_TEXTURE_MODE

• La función glTexEnv..() tiene estos formatos

glTexEnvi(GLenum target, GLenum pname, GLint param); glTexEnvf(GLenum target, GLenum pname, GLfloat param);

• target indica el entorno de textura a configurar (GL_TEXTURE_ENV, GL_TEXTURE_FILTER_CONTROL o GL_POINT_SPRITE).

• pname indica el parámetro del entorno a configurar. • param indica el valor asignado al parámetro

Tema 4. Imágenes y texturas

4.5 Aplicación de texturas

• Cuando target es GL_TEXTURE_ENV, pname puede ser

GL_TEXTURE_ENV_MODE GL_TEXTURE_ENV_COLOR GL_COMBINE_RGB GL_COMBINE_ALPHA GL_RGB_SCALE GL_ALPHA_SCALE GL_SRC0_RGB GL_SRC1_RGB GL_SRC2_RGB GL_SRC0_ALPHA GL_SRC1_ALPHA GL_SRC2_ALPHA

• Para aplicar una textura sobre una primitiva geométrica se calculan las coordenadas de textura correspondientes a cada pixel de la primitiva y se busca en la textura el color correspondiente a esas coordenadas. Esto se conoce como texture-filtering.

• Típicamente, el tamaño de la textura y el tamaño de la primitiva serán diferentes y al filtrar tendremos que agrandar la textura o encogerla.

• OpenGL define formas de filtrado independientes para agrandar o encoger las texturas.

Tema 4. Imágenes y texturas

4.5 Aplicación de texturas

• Para configurar el proceso de filtrado se utiliza la función glTexParameter…() con los parámetros GL_TEXTURE_MAG_FILTER y GL_TEXTURE_MIN_FILTER.

• Los valores típicos para los filtros son GL_NEAREST y GL_LINEAR. • El filtro GL_NEAREST se limita a asignar al pixel el color del texel más

cercano a sus coordenadas de textura. Este filtro puede provocar problemas de aliasing. El filtro GL_LINEAR realiza una interpolación lineal entre los cuatro texels vecinos.

• Cuando la primitiva geométrica se observa de manera inclinada, el filtrado lineal (aunque mejor que el nearest) produce un efecto borroso. Eso se debe a que la distancia de los texels se ve afectada por el efecto de la inclinación.

• Para considerar este efecto se puede configurar un filtrado anisotrópico. En realidad esta opción no forma parte del estandar de OpenGL, pero la mayoría de los fabricantes la añaden como extensión.

Tema 4. Imágenes y texturas

4.5 Aplicación de texturas

• Para activar el filtrado anisotrópico hay que verificar que la opción esté soportada y a continuación modificar el nivel de anisotropía del filtrado con el parámetro GL_TEXTURE_MAX_ANISOTROPY_EXT.

if(gltIsExtSupported(“GL_EXT_texture_filter_anisotropic”)) { GLfloat fLargest; glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &fLargest); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest); }

• Las texturas se dimensionan entre 0.0f y 1.0f. Sin embargo, las coordenadas de textura no tienen por qué estar incluidas entre estos límites. Esto puede ocurrir al utilizar la opción GL_LINEAR o al colocar estos valores con glTexCoord..().

• El comportamiento de los filtros de textura más allá de los límites se denomina texture wrapping. OpenGL permite configurar comportamientos diferentes en cada dimensión.

• Para configurarlos se utilizan los parámetros GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T y GL_TEXTURE_WRAP_R.

Tema 4. Imágenes y texturas

4.5 Aplicación de texturas

• Los valores de estos parámetros pueden ser: GL_REPEAT, GL_CLAMP, GL_CLAMP_TO_EDGE o GL_CLAMP_TO_BORDER.

– GL_REPEAT genera una repetición de la textura.

– GL_CLAMP utiliza los texels del borde (si está definido) o el color del borde. El color del borde se puede asignar con el parámetro GL_TEXTURE_BORDER_COLOR.

– GL_CLAMP_TO_EDGE utiliza los texels de los extremos, es decir, repite el último texel en cada dimensión.

• El color final de cada pixel se construye utilizando las propiedades de color (o material) y la textura. La forma de combinar estas propiedades se controla configurando el entorno de textura (GL_TEXTURE_ENV) por medio de la función glTexEnv().

• El parámetro GL_TEXT_ENV_MODE permite configurar el modo en el que se va a combinar la textura con el color de la primitiva (que ya contiene los efectos de iluminación).

Tema 4. Imágenes y texturas

4.5 Aplicación de texturas

GL_ADD obtiene el color final sumando la textura y el material GL_MODULATE obtiene el color final multiplicando la textura y el

material

GL_DECAL mezcla los colores considerarndo el valor alpha de la textura

GL_BLEND mezcla los colores considerando los valores del parámetro de color de la textura

(GL_TEXTURE_ENV_COLOR) GL_REPLACE utiliza solo el color de la textura • Los valores posibles son

• La forma más habitual de combinar los efectos de la iluminación con la textura es GL_MODULATE.

• Esta opción tiene como efecto no deseado que anula las luces especulares, que aumentan la luminosidad del objeto. Esto se debe a que no se puede aumentar la luminosidad mediante la multiplicación por un número menor de 1.0.

• Para resolver este problema hay que tratar la luz especular después de aplicar la textura.

glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);

Tema 4. Imágenes y texturas

Índice

4.1 Bitmaps

4.2 Pixmaps

4.3 Transformaciones de imágenes

4.4 Definición de texturas

4.5 Aplicación de texturas

4.6 Mipmaps

4.7 Compresión de texturas

4.8 Generación de coordenadas

• Cuando la primitiva geométrica resulta mucho más pequeña que el tamaño de la textura se produce un efecto llamado scintillation. El problema es que si el fragmento es pequeño, dos píxeles consecutivos pueden corresponder a texels alejados y el filtrado provoca efectos de aliasing. Este defecto resulta más visible cuando los objetos se encuentran en movimiento.

• Para evitar este problema se utilizan mipmaps. El término mip procede de la expresión latina “multum in parvo” (mucho en poco). La técnica consiste en tener versiones de la textura de tamaños inferiores y aplicar en cada caso el nivel de mipmap adecuado al tamaño del fragmento.

• Cada nivel de mipmap se obtiene dividiendo entre dos cada dimensión de la textura.

Tema 4. Imágenes y texturas

4.6 Mipmaps

• Cada nivel de mipmap se obtiene dividiendo entre dos cada dimensión de la textura del nivel anterior.

• Por ejemplo, si tenemos una textura de 32x16, el nivel 1 tendría un tamaño 16x8, el nivel 2 sería 8x4, el nivel 3 sería 4x2, el nivel 4 sería 2x1 y el nivel 5 sería 1x1. (Esta es la razón por la que los tamaños deben ser potencias de 2)

• El mipmapping supone un gasto adicional en memoria. Para texturas 1D la memoria aumenta un 100%. Para texturas 2D la memoria necesaria es un 33% mayor. Para texturas 3D el aumento es de un 15%. • Los mipmaps se cargan con la funciones glTexImage..() y derivadas,

• Por defecto, para utilizar mipmapping es necesario que todos los niveles de mipmap estén cargados. Se puede indicar un rango de niveles de mipmap obligatorios con los parámetros de textura GL_TEXTURE_BASE_LEVEL y GL_TEXTURE_MAX_LEVEL.

• Por ejemplo, para configurar un mipmapping con los niveles obligatorios de 0 a 4.

glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL , 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 4);

• También se puede configurar los niveles de mipmap (level of detail) que van a ser utilizados realmente con los parámetros GL_TEXTURE_MIN_LOD y GL_TEXTURE_MAX_LOD.

Tema 4. Imágenes y texturas

4.6 Mipmaps

• El uso de mipmaps añade un nuevo aspecto a las opciones de filtrado. Al considerar las componentes de textura de un pixel podemos encontrarnos entre dos niveles de mipmap. En este caso podemos calcular el color final de la textura con el mipmap más cercano o con una interpolación lineal entre los dos mipmaps.

• Las opciones de filtrado pueden ser entonces

GL_NEAREST GL_LINEAR

GL_NEAREST_MIPMAP_NEAREST GL_LINEAR_MIPMAP_NEAREST GL_NEAREST_MIPMAP_LINEAR GL_LINEAR_MIPMAP_LINEAR

• Para utilizar mipmaps es necesario generar la imagen correspondiente a cada nivel. Esto puede realizarse con alguna herramienta de edición de imágenes y cargarse con glTexImage() o generarse de forma automática.

• Una forma de generar los mipmaps de forma automática es usar funciones incluidas en la librería GLU. Estas funciones cargan la imagen base y todos los niveles de mipmap:

gluBuild1DMipmaps(target, internalFormat, width, format, type, data); gluBuild2DMipmaps(target, internalFormat,

width, height, format, type, data); gluBuild3DMipmaps(target, internalFormat,

Tema 4. Imágenes y texturas

4.6 Mipmaps

• A partir de la versión 1.4, OpenGL permite generar automáticamente los mipmaps utilizando aceleración hardware. Para ello hay que activar el parámetro GL_GENERATE_MIPMAP.

glTexParameteri(GL_TEXTURE_2D,

GL_GENERATE_MIPMAP, GL_TRUE);

• Desde la versión 3.0, OpenGL permite generar automáticamente los mipmaps utilizando la función

• OpenGL calcula internamente cual es el mejor nivel de mipmap a aplicar. Este criterio de selección se puede modificar configurando un sesgo en el entorno de textura:

glTexEnvf(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, -1.5);

Tema 4. Imágenes y texturas

Índice

4.1 Bitmaps

4.2 Pixmaps

4.3 Transformaciones de imágenes

4.4 Definición de texturas

4.5 Aplicación de texturas

4.6 Mipmaps

4.7 Compresión de texturas

4.8 Generación de coordenadas

• A partir de la versión 1.3, OpenGL permite almacenar las texturas en formatos comprimidos. Los valores de internalFormat que indican formatos comprimidos son

• Si al cargar una textura se indica que el formato interno es comprimido, OpenGL realiza automáticamente la compresión de los datos.

• Se puede indicar el tipo de método de compresión a utilizar

glHint(GL_TEXTURE_COMPRESSION_HINT, GL_FASTEST); glHint(GL_TEXTURE_COMPRESSION_HINT, GL_NICEST);

GL_COMPRESSED_RGB GL_COMPRESSED_RGBA

GL_COMPRESSED_SRGB GL_COMPRESSED_SRGB_ALPHA GL_COMPRESSED_RED GL_COMPRESSED_RG

Tema 4. Imágenes y texturas

4.7 Compresión de texturas

• Se puede obtener la versión comprimida de la imagen almacenada con la función

glGetCompressedTexImage(GLenum target, GLint lod,

GLvoid * img);

• donde target corresponde a la textura que se pretende leer, lod es el nivel de mipmap e img el puntero a los datos.

• Estos datos se pueden almacenar externamente y cargarlos directamente. En ocasiones esta carga puede crear problemas si el fabricante de la tarjeta gráfica utiliza una versión no estándar del algoritmo de compresión.

• Para cargar directamente los datos ya comprimidos se utilizan las funciones

glCompressedTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLsizei width,

GLint border, GLsizei imageSize, void *data); glCompressedTexImage2D(GLenum target, GLint level,

GLenum internalFormat,

GLsizei width, GLsizei height,

GLint border, GLsizei imageSize, void *data); glCompressedTexImage3D(GLenum target, GLint level,

GLenum internalFormat,

Tema 4. Imágenes y texturas

Índice

4.1 Bitmaps

4.2 Pixmaps

4.3 Transformaciones de imágenes

4.4 Definición de texturas

4.5 Aplicación de texturas

4.6 Mipmaps

4.7 Compresión de texturas

4.8 Generación de coordenadas

• Asignar las coordenadas de textura a los vértices supone una operación de modelado bastante compleja. Generalmente se utilizan herramientas de modelado para generar estas coordenadas de una forma más cómoda.

• OpenGL incluye funciones que permiten generar las coordenadas de textura de forma automática. Para utilizarlas es necesario activar esta opción para cada una de las componentes:

glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glEnable(GL_TEXTURE_GEN_R); glEnable(GL_TEXTURE_GEN_Q);

Tema 4. Imágenes y texturas

4.8 Generación de coordenadas

• Una vez activada esta opción, las llamadas a glTexCoord..() son ignoradas.

• Se puede desactivar la opción con las correspondientes llamadas a glDisable().

• Para configurar el método de generación de coordenadas se utiliza la función glTexGen..().

glTexGeni(GLenum coord, GLenum pname, GLint param); glTexGenf(GLenum coord, GLenum pname, GLfloat param); glTexGenfv(GLenum coord, GLenum pname, GLfloat * params);

• coord se refiere a la coordenada de textura a configurar: GL_S, GL_T, GL_R, GL_Q.

• pname se refiere al parámetro a configurar. Puede ser

GL_TEXTURE_GEN_MODE, GL_OBJECT_PLANE o GL_EYE_PLANE.

• param contiene el valor asignado al parámetro a configurar.

• El método de generación de las coordenadas se configura con el parámetro GL_TEXTURE_GEN_MODE, que puede contener los valores

GL_OBJECT_LINEAR GL_EYE_LINEAR

GL_SPHERE_MAP GL_NORMAL_MAP

Tema 4. Imágenes y texturas

4.8 Generación de coordenadas

• El método GL_OBJECT_LINEAR calcula la coordenada mediante la función

g = p1 · x + p2 · y + p3 · z + p4 · w

• Donde (x,y,z,w) son las coordenadas del vértice (antes de ser multiplicadas por la matriz modelview) y (p1,p2,p3,p4) son las coordenadas de un plano (asignadas mediante el parámetro GL_OBJECT_PLANE). La ecuación supone asignar a la coordenada un valor proporcional a la distancia del vértice al plano.

• El método GL_EYE_LINEAR calcula la coordenada mediante la función

g = p1’ · x + p2’ · y + p3’ · z + p4’ · w (p1’, p2’, p3’, p4’) = (p1, p2, p3, p4) · M-1

• Donde (x,y,z,w) son las coordenadas del vértice en el sistema de referencia del observador (es decir, después de ser multiplicadas por la matriz modelview), M es el contenido de la matriz modelview en el punto de llamada a glTexGen y (p1,p2,p3,p4) son las coordenadas de un plano (asignadas mediante el parámetro GL_EYE_PLANE). • La ecuación supone asignar a la coordenada un valor proporcional a

la distancia del vértice al plano descrito en coordenadas del observador.

Tema 4. Imágenes y texturas

4.8 Generación de coordenadas

• El método GL_SPHERE_MAP utiliza las coordenadas del vértice y las normales para calcular una especie de proyección esférica del modelo.

• Los métodos GL_NORMAL_MAP y GL_REFLECTION_MAP se utilizan con un modelo de textura denominado CubeMap.

• El modelo cube map consiste en utilizar 6 texturas formando un cubo. De esta forma las texturas describen un volumen en lugar de un plano.

• Para cargar las texturas se utilizan como parámetro target los valores

• Para utilizar este modelo de textura hay que activarlo

glEnable(GL_TEXTURE_CUBE_MAP);

GL_TEXTURE_CUBE_MAP_POSITIVE_X GL_TEXTURE_CUBE_MAP_NEGATIVE_X

GL_TEXTURE_CUBE_MAP_POSITIVE_Y GL_TEXTURE_CUBE_MAP_NEGATIVE_Y

Tema 4. Imágenes y texturas

4.8 Generación de coordenadas

• En este modelo de textura, las coordenadas se indican con tres valores (x,y,z) donde alguno de ellos debe ser +1 o -1 indicando la cara del cubo en el que se encuentra la coordenada.

• Los modelos GL_NORMAL_MAP y GL_REFLECTION_MAP generan automáticamente las coordenadas de textura como la proyección del cubo sobre el objeto.

• Este modelo se utiliza habitualmente para generar superficies que reflejan el entorno.