Semana9-Generación y carga de modelos con OpenGL

Vista previa del material en texto

UNIDAD II
COMPUTACIÓN GRÁFICA II
▪ Texturas
▪ Generación y carga de modelos con OpenGL
Semana 9
Al término de la sesión, el estudiante aprende a texturizar y usar modelos OBJ con OpenGL 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)
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
Coordenadas paramétricas
Leyendo texturas externas
Para ajustar la textura a la geometría se recurre a las 
coordenadas de textura:
• A cada vértice se le hacen corresponder las 
coordenadas deseadas de la textura.
• Este proceso puede ser:
• Manual: para casos muy sencillos a través de un 
programa externo.
• Asistido: para casos muy complejos (mapas y 
atlas de texturas).
• Automático: para figuras muy sencillas o donde 
no importan las deformaciones, este método lo 
aplicaremos en nuestro curso.
Manual:
Asistido:
Automático:
Texturas desde mapas de textura BMP
❑ 1.Usaremos la librería RGBimage para leer texturas en formato *.bmp (copiaremos las imágenes y la 
Liberia a la raíz del proyecto), además incluir la llamada: #include "RgbImage.h"
GLuint texture[5]; // declarar el array para almacenar las texturas
void leerTexturasDesdeArchivo(const char* filename, int index){
RgbImage theTexMap(filename); //lee el mapa de textura bmp como un objeto RgbImage
glGenTextures(1,&texture[index]); //genera una array texturas
glBindTexture(GL_TEXTURE_2D,texture[index]);//Todas las texturas de la array son 2D
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT); //Parámetros de envoltura
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);//Opciones de calidad de filtrado
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
// Carga los datos del mapa de texturas en la memoria de OpenGL
glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,theTexMap.GetNumCols(), 
theTexMap.GetNumRows(),0,GL_RGB,GL_UNSIGNED_BYTE,theTexMap.ImageData());
}
❑ Metódo para leerlas texturas
void cargarImagenes(){
leerTexturasDesdeArchivo("Tierra.bmp",0);
..
}
❑ 2.Metódo para cargar diferentes texturas:
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texture[0]);
glBegin(GL_POLYGON);
glTexCoord2f(0,0); glVertex3i(0,0,1);
glTexCoord2f(0,1); glVertex3i(0,1,1);
glTexCoord2f(1,1); glVertex3i(1,1,1);
glTexCoord2f(1,0); glVertex3i(1,0,1);
glEnd();
glDisable(GL_TEXTURE_2D);
❑ 3.Ejemplo de como texturizar un 
polígono:
Pasos
EJEMPLO 3:
DESARROLLA LA SIGUIENTE 
ESCENA CON TEXTURA
Texturas 3D
Leyendo la textura de un fichero *.bmp
Nota:
Cualquier llamada a glTexCoord se ignora Cuando la 
generación de coordenadas de textura está habilitada 
(GL_TEXTURE_GEN_S y GL_TEXTURE_GEN_T ), OpenGL 
calcula las coordenadas de textura para cada vértice por 
usted (usadas en primitivas: teapot, cube, etc):
glPushMatrix();
glEnable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glBindTexture(GL_TEXTURE_2D,texture[0]);
glutSolidTeapot(0.5);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glPopMatrix();
GENERACIÓN Y CARGA DE MODELOS OPENGL
Responder en el foro
MODELOS OPENGL 3D
❑ Son colecciones de puntos conectados en un espacio tridimensional (3D), llamados vértices, que se combinan 
para formar una secuencia de polígonos que se pueden renderizar para representar un objeto en un espacio 
virtual.
❑ Casi todos los objetos 3D que no son primitivas de forma (predefinidos), como los triángulos, pueden 
considerarse modelos OpenGL 3D.
❑ Un modelo completo generalmente incluye texturas, mapas de relieve y para objetos animados, información 
esquelética y pesos de vértices.
❑ Los modelos OpenGL completamente realizados son muy complejos de crear, por lo que casi siempre se 
realizan con un software de modelado con todas las funciones (por ejemplo Blender).
❑ Existen algunas complejidades que pueden surgir al utilizar modelos 3D OpenGL. El más común es el problema de 
leer un archivo, porque no todos los modeladores 3D proporcionan la especificación de cómo se guarda un archivo, 
en ocasiones es suficiente las librerias de Glut, sin embargo otras veces es necesario recurrir a otras librerias.
Formato de archivo .obj
El formato de archivo Wavefront (.obj). es un sencillo formato 
de datos que normalmente representa la geometría 3D de la 
siguiente manera:
❑ La posición de cada vértice X Y Z que se especifican con la 
letra v.
❑ La posición de UV de cada coordenada de textura de vértice, 
que se especifican con las letras vt.
❑ Las normales del vértice, que se especifican con las letras vn 
(Las normales son un vector perpendicular a un polígono, la 
dirección de la normal determina cómo la luz incide en el 
polígono)
❑ Las caras que hacen cada polígono definido como una lista de 
vértices, texturas y normales, que se especifican con la letra f, 
siendo el formato f v1/vt1/vn1 v2/vt2/vn2 v3/vt3/vn3.
Representación .obj
Hablamos de modelo poligonal cuando se utilizan polígonos para describirlo. En general,
el triángulo es la primitiva más utilizada.
Los modelos poligonales representan objetos donde aristas y vértices se comparten
entre diferentes polígonos. A este tipo de modelos se les denomina mallas poligonales.
De esta manera se separa la información de los vértices y la de los triángulos en dos
listas, cada vértice compartido se almacena una única vez y cada triángulo se representa
mediante tres índices a la lista de vértices:
Es importante tener en cuenta esta característica para tratar de reducir el espacio 
de almacenamiento y tiempo de dibujado.
Ejemplos de mallas poligonales
El formato Wavefront OBJ es un formato de archivo utilizado para muchas
aplicaciones de modelado 3D, tales como 3DS Max, Cinema 4D o Maya. Los
modelos producidos y guardados en formato OBJ se componen de polígonos
individuales que se unieron para formar una malla. Estos polígonos son más a
menudo Quads (cuatro lados), pero es preferible tener totalmente polígonos
triangulares. Podemos utilizar Blender, como un conversor a un modelo de
triángulos para luego trabajar en su programa original:
❑ Iniciar la aplicación Blender. Seleccione "Archivo" en el menú
superior y haga clic en "Importar". A partir de las opciones, haga clic
en "Wavefront OBJ." Cargar archivo.
❑ Seleccione "Archivo" en el menú y elegir la opción "Exportar". De
las opciones, elegir la opción "Wavefront OBJ." En la ventana que
aparece, considere hacer check en las siguientes opciones y
finalmente exportar el modelo.
MODELOS OPENGL 3D
Algunos sitios con modelos en formato OBJ y descargas gratuitas:
https://www.turbosquid.com/3d-model
www.cgtrader.com/free-3d-models
https://sketchfab.com/tags/opengl
Modelos free: Link
https://www.turbosquid.com/Search/3D-Models/free?file_type=118%2C119&sort_column=a7&sort_order=desc
MODELOS *OBJ
Ejemplo básico
https://www.turbosquid.com/3d-models/free-orient-stairs-3d-model-1869772#
❑ ¿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/9786074817621
https://elibro-net.eu1.proxy.openathens.net/es/ereader/upnorte/35680?page=2