Semana8-texturas (1)

Vista previa del material en texto

UNIDAD II
COMPUTACIÓN GRÁFICA II
▪ Texturas
Semana 8
Al término de la sesión, el estudiante aprende a texturizar objetos para generar una aplicación
gráfica que complemente lo aprendido.
Logro de 
Aprendizaje
¿Texturas?
Responder en el foro
Introducción
Las texturas se pueden combinar, también, con color y luz
con buenos resultados.
Las texturas son una parte vital en computación gráfica
para dar mayor realismo a las escenas y a costos
aceptables.
Es una técnica enormemente importante en computación
gráfica moderna.
Introducción
Texturizar una superficie consiste esencialmente en pintar una imagen sobre ella, un proceso que se puede
utilizar con dos grandes ventajas a la hora de programar gráficos:
Autenticidad
• Representación realista de un objeto.
Ilusión de detalles geométricos
• En lugar de recrear fielmente un objeto 
con primitivas geométricas, pintar una 
imagen de ella en una escena puede 
lograr un resultado realista a una 
fracción del costo en el número de 
polígonos.
Introducción
Los píxeles en una textura se llaman texels, cada uno de ellos almacena valores de
color, como RGB de 24 bits o RGBA de 32 bits.
Hay varias formas de aplicar una textura en OpenGl.
La más común: La textura es una matriz rectangular de píxeles y se aplica a una
superficie poligonal.
Introducción
Los píxeles en una textura se llaman texels, cada uno
de ellos almacena valores de color, como RGB de 24
bits o RGBA de 32 bits (Red, Green, Blue y
Alpha/opacidad).
Hay varias formas de aplicar una textura en OpenGl.
La más común: La textura es una matriz rectangular de píxeles y se aplica a una
superficie poligonal.
Introducción
Textura de procedimiento o Sintética: una textura creada en el programa
mismo.
La textura en sí misma puede ser:
Textura Externa: una imagen externa que se importa a un programa OpenGL.
Una vez cargados, no hay diferencia entre las dos.
Texturas en OpenGL
Una textura, desde el punto de vista de su almacenamiento en memoria es un array
de datos.
Podemos rellenar dicho array bien cargando una imagen desde un fichero, o bien
dándole nosotros los valores de color a cada texel.
Cada uno de los valores de este array lo llamamos textel. Este array de datos
representa una imagen, que utilizaremos para mapearla sobre un polígono.
Podemos tener texturas unidimensionales (un solo pixel de alto o de ancho), bidimensionales (imagen de
tamaño m*n) o tridimensional (con volumen), aunque lo habitual será utilizar las bidimensionales.
Texturas en OpenGL
Los pasos necesarios para mapear texturas sobre polígonos son los siguientes:
Cargar el fichero 
de imagen
Indicar los 
parámetros de 
aplicación de la 
textura y activar 
el mapeado de 
texturas
Especificar la 
textura 
Dibujar la escena
Texturas en OpenGL
Para OpenGL las texturas 1D, 2D o 3D son arraysuni, bi o tri - dimensionales
respectivamente.
En los ejemplos de clase utilizaremos unas funciones de la librería RgbImage.h, estas
funciones permiten cargar fichero en formato BMP.
Texturas 1D
Donde:
Son texturas que solo tienen un Texel de altura y/o un Texel de ancho
Texturas 1D
Ejemplo, para activar el mapeo de texturas 1D:
glEnable (GL_TEXTURE_1D)
Para definir los colores de la textura:
#define Violeta_oscuro{ 0x3f, 0x00, 0x3f }
#define Violeta{ 0x7f, 0x00, 0x7f }
#define Malva{ 0xbf, 0x00, 0xbf }
#define Azul{ 0x00, 0x00, 0xff }
#define Verde{ 0x00, 0xff, 0x00 }
#define Amarillo { 0xff, 0xff, 0x00 }
#define Naranja{ 0xff, 0x7f, 0x00 }
#define Rojo{ 0xff, 0x00, 0x00 }
unsigned char ArcoIris[8][3] = {Violeta_oscuro, Violeta,Malva, Azul, Verde, 
Amarillo, Naranja, Rojo};
Coordenadas de la textura
Para hacer corresponder las coordenadas de la textura con las de la superficie del
objeto, se usa:
glBegin(GL_QUADS);
glTexCoord1f (0.0);
glVertex3f (0, 0, 0);
glTexCoord1f (1.0);
glVertex3f (8, 0, 0);
glTexCoord1f (1.0);
glVertex3f (8, 8, 0);
glTexCoord1f (0.0);
glVertex3f (0, 8, 0);
glEnd();
Donde S: las coordenadas de la textura 1D es 0 ó 1
glTexCoord1f (GLfloat S)
Filtrado en una textura 1d
Al mapear la imagen de textura sobre una superficie, los texels no se van a corresponder exactamente con los pixels:
El área del pixel equivale a una región
de la textura mayor que un texel,
cerca del polígono, llamado
MAGnificación
El área del pixel equivale a una
región de la textura menor que
un texel, alejado del polígono,
llamado MINificación.
Filtrado en una textura 1d
Filtrado en una textura 1d
Para indicar el tipo de filtrado en una textura seria con:
Modos de mapeo en una textura 1d
Para establecer el modo de mapeo: glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GLint valor) 
donde valor puede tomar 3 valores:
– GL_DECAL: el valor del texel se copia directamente al pixel.
– GL_MODULATE: el valor del texel se escala por el color del objeto.
– GL_BLEND: el valor del texel se usa para interpolar entre el color del objeto y un color constante definido 
para la textura, mediante la función: 
EJEMPLO 1:
DESARROLLA LA SIGUIENTE 
ESCENA CON TEXTURA 1D 
(PRUEBA EL PARÁMETRO
GL_NEAREST Y GL_LINEAR)
En Resumen los parámetros de filtrado para las texturas son (en este caso 1D):
// Refresca el búfer para dar color a las líneas
glClear (GL_COLOR_BUFFER_BIT); 
// Habilitamos el mapeo de texturas
glEnable(GL_TEXTURE_1D);
// Indicamos el tipo de filtrado
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
// Creamos la textura //8 puede cambiar de 1 a 8 en 1D
glTexImage1D(GL_TEXTURE_1D,0,3,8,0,GL_RGB,GL_UNSIGNED_BYTE,ArcoIris);
// Indicamos el modo de mapeo, volcar los texels directamente sobre los píxeles
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
Texturas 2D
Donde:
Para definir la textura 2D:
Texturas 2D
Coordenadas de la textura
Para hacer corresponder las coordenadas de la textura con las de la superficie:
Texturas 2D
Coordenadas de la textura
En el polígono
Texturas 2D
Para activar el mapeo de texturas 2D:
glEnable (GL_TEXTURE_2D)
GLubyte Colores[4][4][3] = {
{{64,0,0}, {128,0,0}, {192,0,0}, {255,0,0}}, // Rojos
{{0,64,0}, {0,128,0}, {0,192,0}, {0,255,0}}, // Verdes
{{0,0,64}, {0,0,128}, {0,0,192}, {0,0,255}}, // Azules
{{64,64,0}, {128,128,0}, {192,192,0}, {255,255,0}} // Amarillos
};
glTexImage2D (GL_TEXTURE_2D, 0, 3, 4, 4, 0,GL_RGB, GL_UNSIGNED_BYTE, Colores);
Ejemplo:
Texturas 2D
Coordenadas de la textura:
Para hacer corresponder las coordenadas de la
textura con las de la superficie:
void glTexCoord2f (GLfloat s, GLfloat t)
glBegin(GL_QUADS);
glTexCoord2f (0.0, 0.0);
glVertex3f (0, 400, 0);
glTexCoord2f (1.0, 0.0);
glVertex3f (400, 400, 0);
glTexCoord2f (1.0, 1.0);
glVertex3f (400, 0, 0);
glTexCoord2f (0.0, 1.0);
glVertex3f (0, 0, 0);
glEnd();
Ejemplo:
Tipos de filtrado 2D
EJEMPLO 2:
DESARROLLA LA 
SIGUIENTE ESCENA 
CON TEXTURA 2D En Resumen los parámetros de filtrado para las texturas son (en este caso 2D):// Refresca el búfer para dar color a las líneas
glClear (GL_COLOR_BUFFER_BIT); 
// Habilitamos el mapeo de texturas
glEnable(GL_TEXTURE_2D);
// Indicamos el tipo de filtrado
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
// Creamos la textura //8 puede cambiar de 1 a 8 en 1D
glTexImage2D(GL_TEXTURE_2D,0,3,4,4,0,GL_RGB,GL_UNSIGNED_BYTE,Colores);
// Indicamos el modo de mapeo, volcar los texels directamente sobre los píxeles
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,GL_DECAL);
❑ ¿Qué aprendí?
❑¿Qué necesito reforzar?
¿Preguntas o dudas?
Referencias
Benstead, Luke. (2012) Programación de videojuegos con OpenGL. 
https://upn.vitalsource.com/books/9786074817621.
Bosque, Jose. (2007). Introducción a OpenGL. 
https://elibro-net.eu1.proxy.openathens.net/es/ereader/upnorte/35680?page=2
Donald, Hearn. (2006). Gráficos por computadora con OpenGL: Pearson Educación
https://upn.vitalsource.com/books/9786074817621https://elibro-net.eu1.proxy.openathens.net/es/ereader/upnorte/35680?page=2