Menu Introducción primer programa Primitivas y atributos Transformaciones Proyecciones Iluminación Texturización Efectos Todos los Ejemplos

TEXTURAS

Hasta ahora todos los objetos que hemos dibujado tienen un color o varios colores, para darles más realismo lo envolveremos con una o varias imágenes a esto se le llama texturización, en este capitulo veremos como se hace.

Venga manos a la obra!!

Primero de todo tenemos que cargar la textura en memoria, las openGl no tienen ninguna función que se encargué de hacer esto, lo tendremos que hacer nosotros mismos por si tenéis alguna duda de cómo hacerlo lo podréis ver en el ejemplo y si sabéis hacerlo de una manera mas rápida os agradecería que me la explicarais. Antes de cargar la imagen en memoria tenemos que tener algunas restricciones que nos ponen las OpenGl, la primera es que las dimensiones de la imagen tiene que ser de potencia de dos por ejemplo 2x2, 4x64, 128x256, 512x512, y que la imagen sea en RGB, si queremos cargar una imagen GIF primero la tendremos que pagar a RGB. Yo siempre uso BMP para cargar las texturas así me ahorro hacer conversiones.

También es importante guardar las dimensiones de la imagen y sus atributos y en la profundidad que trabaja como trabajaremos en RGB la profundidad es de 24 bits

Bueno ahora tenemos nuestra textura en memoria y se la tenemos que pasar a las opengGL ya que no es capaz de trabajar desde la estructura que nosotros hemos creado para cargar la imagen, esta imagen al pasársela las openggl nos dará un identificador para esta imagen a si posteriormente sabremos que imagen cargar en cada objeto o parte de objeto. La variable que guardara el identificador de la imagen tiene que ser del tipo Gluint

Para que openGl le nos proporcione un identificador o identificadores validos para la textura, usaremos la función glGenTextures(NumeroTextur/as,IdentificadorTextur/as)  le pasamos el numero de texturas que queremos pasarle, un vector donde guardar todos los identificadores de las imágenes si es que hay mas de una y sino simplemente una variable, con esta función las openGL mira cuantas imágenes tiene cargadas y asi nos dará  identificadores validos que no estén repetidos.

Ahora usaremos la función glBindTexture() con la cual asignaremos los identificadores que nos a proporcionado las openGL a la texturas.

Con la función glTexImage2D(TipoTextura, NivelMipMap, FormatoInterno, Ancho, Alto, Borde,Formato) le pasaremos la textura a las OpenGL.

TipoTextura: es el tipo de textura que se esta tratando en nuestro caso es GL_TEXTURE_2D
NivelMipMap: El nivel de MipMapping.
FormatoInterno: El formato que estamos trabajando, por ejemplo RGB el numero de componentes son 3.
Ancho: El ancho de la textura. SIEMPRE potencia de 2.
Alto: El alto de la textura. SIEMPRE potencia de 2.
Borde: El ancho del borde.
Formato: El formato en que esta almacenada la textura en memoria.
Tipo: El tipo de datos que hemos utilizado para guardar la imagen a memoria.
Píxel: La dirección de memoria donde esta guardada la imagen.

Ya tenemos cargada nuestra textura en la Memoria de las OpengGL por lo tanto la textura que nosotros hemos cargado en memoria para luego pasarla a la OpenGL la podemos borrar ya que ya no nos sirve.

Todo esto lo veremos mas en detalle en el ejemplo ahora es para tener claro lo que estamos haciendo en cada paso.

PARAMETROS DE LAS TEXTURAS

En las texturas les podemos poner filtros, para que sirven estos filtros, pues por ejemplo si utilizamos una imagen pequeña no se, de 8x8 y en nuestra aplicación la hacemos aparecer en toda la pantalla pues esta imagen se vera muy pixelada, con los filtros podemos decirle a las OpenGl que utilice interpolación en los píxels para que no se vea tan pixelada. Para pasar parámetros a las texturas utilizaremos la función glTexParameteri()

Que hace si la textura aumenta, y si disminuye, y si quiero que se repita!!!!!!!!!!!!!!!

GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T

RENDERIZANDO CON TEXTURAS

Por ultimo nos queda como colocar la imagen en un polígono de nuestro objeto, vamos a ver como hacerlo. Para ello tenemos que coger puntos de nuestra imagen y asociarla a los puntos del polígono.

 Por ejemplo si tenemos un cuadrado y queremos ponerle una textura escribiríamos el siguiente código:

Primero activamos la texturización.

glEnable GL_TEXTURE_2D

Ahora le indicamos que textura queremos aplicarle, es decir, que en la variable IdentificadorTextura tenemos el valor que la identifica. Esto sirve para cuando tenemos varias texturas pues indicarle las OpenGL cual de ellas queremos aplicar.

glBindTexture GL_TEXTURE_2D, IdentificadorTextura

Ahora ya podemos empezar a dibujar nuestro cuadrado indicándole a cada vértice un punto en concreto de la textura. Como hemos visto en la imagen anterior que para las openGl el valor x=0,y=0 es la parte inferior izquierda de la textura, pues si nuestro cuadro la parte inferior tiene el valor x=-10, y = -10, le diremos que este vértice es el 0,0 de nuestra textura, para ello utilizaremos la función glTexCoord2f(). Quizá esto parezca un poco lioso pero con el siguiente ejemplo quedara bastante claro.

GlBegin GL_QUADS
glTexCoord2f 0,0
glVertex3f -100,-100,0

            glTexCoord2f 1,0
glvertex3f -10,10,0

glTexCoord2f 1,1
glVertex3f 10,10,0

glTexCoord2f 0,1
glVertex3f 10,-10,0

glEnd

Por ultimo desactivamos la texturización.

glDisable GL_TEXTURE_2D

Por cierto recordad que siempre tenéis que asignar los vértices en orden contrario de las agujas del reloj, en caso contrario, la imagen se vería al revés, en algún caso puede que esto nos sea útil.

Para asignar la textura también podríamos haber cogido solo una parte de la imagen por ejemplo si en vez de poner que la parte inferior de la izquierda sea 0,0 le indicamos 0.5, 0.5 pues le asociaría el centro de la imagen.

DESCARGATE AQUI EL EJEMPLO