Вы находитесь на странице: 1из 13

Universidad Nacional Mayor de San Marcos

Facultad de Ingeniería de Sistemas e Informática


E.P. Ingeniería de Sistemas
Departamento Académico de Ciencias de la Computación
Laboratorio de Computación Visual 2018 2
Mapeado de texturas con OpenGL

Laboratorio 08

Mapeado de texturas con


OpenGL

Las texturas enriquecen la


representación gráfica.

Objetivo: El objetivo de esta práctica, es que el alumno conozca y sepa cómo se lleva a cabo el proceso
de mapeado de Texturas, además de conocer las principales funciones de manejo de Texturas con
OpenGL.

Duración de la Práctica: 2 Horas.

Lugar de realización: Laboratorio de cómputo.

El conocimiento requerido para realizar esta práctica es de haber asimilado los conceptos básicos
de C/C++ y OpenGL.

El desarrollo tendrá la siguiente estructura de temas:

1. Mapeado de Texturas
2. Mapa de Bits basado en máscaras
3. Programa ejemplo
4. Texturas basadas en ficheros gráficos
5. Programa ejemplo
6. Ejercicios propuestos
7. Referencias
8. Anexo 1
9. Anexo 2

Mg. Johnny R. Avendaño Q. Pag. No. 1


Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Departamento Académico de Ciencias de la Computación
Laboratorio de Computación Visual 2018 2
Mapeado de texturas con OpenGL

1. MAPEADO DE TEXTURAS

Obtener un buen realismo de nuestras escenas implica un decorado exhaustivo de ellas, para esto
haremos uso de los mapas de bits (definidas por el usuario) y las funciones involucradas pertenecientes
a OpenGL para un manejo adecuado de estas. En una primera instancia estas son usadas para diseñar
caracteres y en otras para rellenar polígonos. También puede emplearse imágenes definidas en
ficheros gráficos y opcionalmente algún algoritmo procedural para minimizar costos computacionales.

2. MAPA DE BITS

Un mapa de bits o bitmap es un arreglo rectangular de 0 y 1 que sirve para representar imagen,
también se le denomina de máscara (de bits), esta permite dibujar (o rellenar) una porción rectangular
o ventana.

Para obtener esto precisamos de las siguientes funciones:

• glbitmap(GLsizei ancho,GLsizei alto,GLfloat origenX, GLfloat origenY, GLfloat disX,


GLfloat disy, GLubyte *bits): dibuja un mapa de bits de ancho por alto, anclado en las
coordenadas (origenX, origenY) con un desplazamiento de (disX, disY) píxeles con respecto
a los valores de (origenX, origenY), y finalmente el punterobits es el mapa de bits que
deseamos dibujar.

• glRasterPos{23}{if}{v}{x,y,y}: especifica la posición actual del raster, las cuales vienen dadas
por (x,y) en el caso glraster2i(x,y). Generalmente sirve para posicionar o desplazar el raster a
una nueva posición.

• glPixelStore{i}(GLenumpnombre, GLintparametro) : permite especificar el almacenamiento


o la lectura de los píxeles, donde pnombre puede ser GL_UNPACK_ALIGNMENT el cual nos
permite seleccionar la alineación de cada línea en la imagen. Mientras de que parametro
puede ser 1, 2, 4 o 8 (numero de bytes), consulte los otros parámetros en las referencias.

alto

(origenX,origenY)
(0,0) (disX,disY)
(12,0)
raster ancho
máscara

Mg. Johnny R. Avendaño Q. Pag. No. 2


Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Departamento Académico de Ciencias de la Computación
Laboratorio de Computación Visual 2018 2
Mapeado de texturas con OpenGL

3. PROGRAMA EJEMPLO

Diseñe el carácter F tres veces (o las necesarias) en la pantalla


(uno a continuación del otro), el cual puede ser definido como se
muestra en la figura Nº 1:

Figura No. 1. Mascara de bits

Para esto, guíese del cuadro adjunto para describir la máscara (de bits) necesaria en hexadecimal.

Para esto implemente el siguiente código:

#include <GL/glut.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

Glint aw,ah;
// arreglo de bits para el caracter F
GLubyte rasters[24] = {
0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00,
0xc0, 0x00, 0xff, 0x00, 0xff, 0x00, 0xc0, 0x00,
0xc0, 0x00, 0xc0, 0x00, 0xff, 0xc0, 0xff, 0xc0};

void myinit(void)
{
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glClearColor(0.0, 0.0, 0.0, 0.0);
}

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 1.0, 1.0);
glRasterPos2i (20.5, 20.5);
glBitmap(10, 12, 0.0, 0.0, 12.0, 0.0, rasters);

Mg. Johnny R. Avendaño Q. Pag. No. 3


Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Departamento Académico de Ciencias de la Computación
Laboratorio de Computación Visual 2018 2
Mapeado de texturas con OpenGL

glBitmap(10, 12, 0.0, 0.0, 12.0, 0.0, rasters);


glBitmap(10, 12, 0.0, 0.0, 12.0, 0.0, rasters);
glFlush();
}

void myReshape(intw,int h)
{
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, w, 0, h, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
}
int main(intargc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (0,0);
glutCreateWindow ("teste");
myinit ();
glutReshapeFunc(myReshape);
glutDisplayFunc(display);
//glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

Modificaciones (sugerencia)

El siguiente mapa de bits ha sido tomado de “OpenGL Superbible”, que consiste en dibujar caritas
felices de forma aleatoria:

Int aw,ah;
GLubyte caritas[] = {
0x03, 0xc0, 0, 0,
0x0f, 0xf0, 0, 0,
0x1e, 0x78, 0, 0,
0x39, 0x9c, 0, 0,
0x77, 0xee, 0, 0,
0x6f, 0xf6, 0, 0,
0xff, 0xff, 0, 0,
0xff, 0xff, 0, 0,
0xff, 0xff, 0, 0,
0xff, 0xff, 0, 0,
0x73, 0xce, 0, 0,
0x73, 0xce, 0, 0,
0x3f, 0xfe, 0, 0,
0x1f, 0xf8, 0, 0, Figura No. 2. Mascaras de bits en
0x0f, 0xf0, 0, 0, posiciones aleatorias
0x03, 0xc0, 0, 0, };

Mg. Johnny R. Avendaño Q. Pag. No. 4


Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Departamento Académico de Ciencias de la Computación
Laboratorio de Computación Visual 2018 2
Mapeado de texturas con OpenGL

Ahora añada esto en la función display:

for(int i=0;i<100;i++)
{glRasterPos2i(rand()%aw,rand()%ah);
glBitmap(16,16,8.0,8.0,0.0,0.0,caritas);
}

y en la función reshape:

aw=w;
ah=h;

Finalmente usted deberá obtener el diseño mostrado líneas arriba.

4. TEXTURAS BASADAS EN FICHEROS GRÁFICOS

¿Qué es una textura?, Imagine un lienzo o una alfombra muy decorada a su gusto, tómela y péguela
a la pared, o mejor aún, cubra toda la pared de su cuarto (ya sea extendiéndola o en mosaico); bien, lo
que ha hecho es justamente un mapeado de texturas, y su lienzo ha sido la textura empleada.
Ignoraremos el hecho usual de que este tipo de operaciones suelen ser muy costosas y lentas en el
renderizado de la respectiva escena, salvo este detalle trataremos de mostrar algunos resultados que
luego pueden ser extendidos a escenas más complicadas.

Para un éxito razonable del uso de texturas comentaremos acerca de las funciones necesarias que
OpenGL proporciona para este efecto:

• glTextImage2D(GLenum target, GLintlevel, GLint componente, GLsizei ancho, GLsizei


altura, GLint borde, GLenum formato, GLenum tipo, constGLvoid *pixels): esta orden nos
permite especificar que imagen va ha ser utilizada como textura en nuestro mapeo.
• target debe ser GL_TEXTURE_2D.
• level indica el nivel de detalle de la textura (ver referencias), habitualmente tiene un
valor 0.
• componente indica el numero de componentes del color, usualmente se usan
componentes RGB y RGBA (texturas semitransparentes: 4 componentes).
• ancho indica el ancho de la imagen de la textura (potencia de 2).
• altura indica el alto de la imagen de la textura (potencia de 2).
• borde indica si se utiliza un borde en la textura (1) o (0), usualmente es 0.
• formato indica el formato del valor de cada píxel, normalmente se utiliza GL_RGB, tipo
indica el tipo de datos usado para cada componente del valor de un píxel, puede ser
uno de los siguientes valores:

• GL_UNSIGNED_BYTE
• GL_BYTE
• GL_BITMAP
• GL_UNSIGNED_SHORT
• GL_SHORT
• GL_UNSIGNED_INT
• GL_INT
• GL_FLOAT

Mg. Johnny R. Avendaño Q. Pag. No. 5


Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Departamento Académico de Ciencias de la Computación
Laboratorio de Computación Visual 2018 2
Mapeado de texturas con OpenGL

• pixels es un puntero al mapa de valores de los píxeles. Recuerde que esta deberá ser
generada por cualquier método de lectura para ficheros gráficos.

• void glTexCoord2f(GLfloat x, GLfloat y):las coordenadas (x,y) indican las posiciones sobre
la textura, el cual se hace antes de indicar las coordenadas de vértice para el polígono
involucrado, por ejemplo:

glNormal3f(0.0f , 0.0f , 1.0f);


glTexCoord2f(0.0f , 0.0f);
glVertex3f(-1.0f , -1.0f , 1.0f) ;
glTexCoord2f(1.0f , 0.0f);
glVertex3f(1.0f , -1.0f , 1.0f);
glTexCoord2f(1.0f , 1.0f);
glVertex3f(1.0f , 1.0f , 1.0f);
glTexCoord2f(0.0f , 1.0f);
glVertex3f(-1.0f , 1.0f , 1.0f);

Observe que nuestra textura está limitada por 0 y 1, piense en un escalamiento por defecto.

• void glTexParameterf(GLenum target, GLenum pname, GLfloat parametro): permite repetir


la textura.

• target debe ser GL_TEXTURE_2D.


• pname puede ser GL_TEXTURE_WRAP_S o GL_TEXTURE_WRAP_T, donde el
primero indica las coordenadas x de la textura y el segundo las coordenadas y.
• parametro indica si queremos que se repita el borde de la textura (GL_CLAMP) o que
se repita la textura completa (GL_REPEAT)

• void glBindTexture(GLenum target, GLuint textura): crea el objeto textura.

• target, debe ser TEXTURE_1D, TEXTURE_2D o TEXTURE_3D, según el tipo de


textura a emplear.
• textura, define la textura en cuestión.

• void glGenTextures(size n, GLuint *texture): permite crear la textura en el respectivo puntero


texture., usualmente se usa cuando se lee un bitmap y la almacenamos en un mapa de píxeles
texture.

• Importante: no olvide activar el Mapeado de texturas con la orden:

void glEnable(GL_TEXTURE_2D)

y claro desactívela la vez que sea necesaria con glDisable.

Mg. Johnny R. Avendaño Q. Pag. No. 6


Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Departamento Académico de Ciencias de la Computación
Laboratorio de Computación Visual 2018 2
Mapeado de texturas con OpenGL

5. PROGRAMA EJEMPLO

Lea con atención y compile el archivo


texture3D.cpp (en el ANEXO 1 al final de esta guía),
para esto precisará de uno o más archivos del tipo
BMP, el cual será leído y almacenado en un mapa de
píxeles; estas definirán nuestras texturas a ser
empleada para cubrir un cubo que está rotando en el
espacio, dicho código ya es conocido en las practicas
anteriores, así que se espera que esta parte no
represente dificultad alguna.

Para conseguir esto es necesario leer el archivo


BMP (las dimensiones del formato deben tener las
dimensiones 2n x 2m), para ello se empleará una
función que realice esto, nosotros tomaremos
prestado un método propuesto por Ramiro Alcocer
(valcoey@hotmail.com), ver también el enlace
http://www.oocities.org/valcoey/Contenido.html Figura No. 3. Cubo con texturas
no olvide mencionar el respectivo copyright@ de
autor, creemos que a usted no le gustaría que le ocurra algo parecido. Esta versión hace uso obligatorio
de la librería glaux, el cuál funciona muy bien en el entorno de Visual C.

Ahora si desea usar exclusivamente glut y no otra librería auxiliar como glaux, entonces disponemos
de un método (ANEXO 2) no muy complicado propuesto por Raquel Viaña (raquel.viana@uah.es) de
la Universidad de Alcalá, el cuál puede verse en http://www2.uah.es/rviana/texturasCuadrado.cpp.

De igual manera R. Wright & M. Sweet (OpenGL Superbible) proponen un algoritmo más eficiente,
el cual se deja al alumno para que lo revise e implemente.

Nuestra aplicación deberá verse como se sugiere en la figura Nº 3.

6. EJERCICIOS PROPUESTOS

Ejercicio 01:

Implemente un programa en el que se vea un cubo con diferentes texturas en cada cara. Haga las
implementaciones necesarias para que una de estas caras involucre un mapeado con patrones.

Ejercicio 02:

Implemente o modifique el programa anterior para manipular diferentes imágenes empleando


menús jerárquicos para escoger la imagen deseada. Use listas de visualización para aminorar el tiempo
de respuesta.

Mg. Johnny R. Avendaño Q. Pag. No. 7


Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Departamento Académico de Ciencias de la Computación
Laboratorio de Computación Visual 2018 2
Mapeado de texturas con OpenGL

Ejercicio 03:

En función del anterior taller, implemente el código necesario para mostrar un gris como base del
terreno y sobre el insertar objetos arqueológicos como pirámides u obeliscos de tal forma que podamos
incorporar texturas de forma apropiada, finamente activarlas o desactivarlas.

7. REFERENCIAS

1. Foley J. D., A.van Dam, S.K.Feiner and J.F. Hughes Computer Graphics. Principles and
Practice (Second Edition). Addison-Wesley. 1990
2. OpenGL Superbible. R. Wright and M. Sweet. Waite Group, Inc 1996
3. The OpenGL Utility Toolkit (GLUT) Programming Interface (API Version 3). Mark J. Kilgard,
Silicon Graphics, Inc 1996
4. The OpenGL Graphics System: A Specification (Version 1.2). Mark segal& Kurt Akeley.
Silicon Graphics, Inc 1998
5. Ramiro Alcocer , enlace: www.geocities.com/valcoey/index.html

8. ANEXO 1

Código del archive texture3D.cpp:

/* texture3D.cpp
Rotación de un Cubo, con la aplicación de Textura
Autor : Ramiro Alcocer
WWW : www.geocities.com/valcoey/index.html
Email : valcoey@hotmail.com
*/
#include <GL/glut.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glaux.h>
#include <stdio.h>
//angulos de rotacion
GLfloatxrot=0.0;
GLfloatyrot=0.0;
GLfloatzrot=0.0;
GLuint texture[1];

Mg. Johnny R. Avendaño Q. Pag. No. 8


Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Departamento Académico de Ciencias de la Computación
Laboratorio de Computación Visual 2018 2
Mapeado de texturas con OpenGL

// unsigned
//parametros de la fuente de luz
GLfloatLightAmbient[]={ 0.5f, 0.5f, 0.5f, 1.0f };
GLfloatLightDiffuse[]={ 1.0f, 1.0f, 1.0f, 1.0f };
GLfloatLightPosition[]={ 1.0f, 1.0f, 1.0f, 0.0f };
AUX_RGBImageRec *LoadBMP(char *Filename) // Loads A Bitmap Image
{
FILE *File=NULL; // File Handle
if (!Filename) // Make Sure A Filename Was Given
{
return NULL; // If Not Return NULL
}
File=fopen(Filename,"r"); // Check To See If The File Exists
if (File) // Does The File Exist?
{
fclose(File); // Close The Handle
return auxDIBImageLoad(Filename); // Load The Bitmap And Return A Pointer
}
return NULL; // If Load Failed Return NULL
}
intLoadGLTextures() // Load Bitmaps And Convert To Textures
{
int Status=FALSE; // Status Indicator
AUX_RGBImageRec *TextureImage[1]; // Create Storage Space For The Texture
memset(TextureImage,0,sizeof(void *)*1); // Set The Pointer To NULL
// Load The Bitmap, Check For Errors, If Bitmap's Not Found Quit
if (TextureImage[0]=LoadBMP("foto.bmp"))
{
Status=TRUE; // Set The Status To TRUE
glGenTextures(1, &texture[0]); // Create The Texture
// Typical Texture Generation Using Data From The Bitmap
glBindTexture(GL_TEXTURE_2D, texture[0]);
glTexImage2D(GL_TEXTURE_2D, 0, 3,
TextureImage[0]->sizeX,
TextureImage[0]->sizeY,
0, GL_RGB, GL_UNSIGNED_BYTE,
TextureImage[0]->data);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
}
if (TextureImage[0]) // If Texture Exists
{
if (TextureImage[0]->data) // If Texture Image Exists
{
free(TextureImage[0]->data); // Free The Texture Image Memory
}
free(TextureImage[0]); // Free The Image Structure
}
return Status; // Return The Status
}
voidinit(void)
{
//Carga la textura
LoadGLTextures();
glEnable(GL_TEXTURE_2D);
glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
glClearDepth(1.0f);

Mg. Johnny R. Avendaño Q. Pag. No. 9


Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Departamento Académico de Ciencias de la Computación
Laboratorio de Computación Visual 2018 2
Mapeado de texturas con OpenGL

glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient);
glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);
//posicion de la fuente de luz
glLightfv(GL_LIGHT1, GL_POSITION,LightPosition);
//activa la luz
glEnable(GL_LIGHT1);
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0.0f,0.0f,-4.5f);
//Rota el cubo
glRotatef(xrot,1.0f,0.0f,0.0f);
glRotatef(yrot,0.0f,1.0f,0.0f);
glRotatef(zrot,0.0f,0.0f,1.0f);
glBindTexture(GL_TEXTURE_2D, texture[0]);
glBegin(GL_QUADS);
// Frente
glNormal3f( 0.0f, 0.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
// parte de Atras
glNormal3f( 0.0f, 0.0f,-1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
// Arriba
glNormal3f( 0.0f, 1.0f, 0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
// Abajo
glNormal3f( 0.0f,-1.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
// lado Derecho
glNormal3f( 1.0f, 0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
// Lado Izquierdo
glNormal3f(-1.0f, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
glEnd();

Mg. Johnny R. Avendaño Q. Pag. No. 10


Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Departamento Académico de Ciencias de la Computación
Laboratorio de Computación Visual 2018 2
Mapeado de texturas con OpenGL

glFlush ();
glutSwapBuffers();
}
void reshape (int width, int height)
{
if (height==0)
{
height=1;
}
glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void keyboard(unsigned char key, int x, int y)
{
switch (key)
{
case 27: exit(0);
break;
}
}
//Incremento los angulos de rotacion
void Idle(void)
{
xrot+=1.0f;
yrot+=1.0f;
zrot+=0.0f;
display();
}
int main(intargc, char** argv)
{
//Inicializar el estado de GLUT
glutInit(&argc, argv);
//Seleccionar el tipo de modo de display Buffer doble y color RGBA
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
//Poner el tamaño y posición de la ventana
glutInitWindowSize (300, 300);
glutInitWindowPosition (0, 0);
glutCreateWindow ("Textura 3D");
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutIdleFunc(Idle);
glutMainLoop();
return 0;
}

Mg. Johnny R. Avendaño Q. Pag. No. 11


Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Departamento Académico de Ciencias de la Computación
Laboratorio de Computación Visual 2018 2
Mapeado de texturas con OpenGL

9. ANEXO 2

Código:

/* Método extraído de
http://www2.uah.es/rviana/texturasCuadrado.cpp
E-mail: raquel.viana@uah.es
*/

int LoadBitmap(char *filename)


{

int i, j=0; //Index variables


FILE *l_file; //File pointer
unsigned char *l_texture; //The pointer to the memory zone in which we will load the texture

// windows.h gives us these types to work with the Bitmap files


BITMAPFILEHEADER fileheader;
BITMAPINFOHEADER infoheader;
RGBTRIPLE rgb;

int num_texture=-1;
num_texture++; // The counter of the current texture is increased

if( (l_file = fopen(filename, "rb"))==NULL) return (-1); // Open the file for reading

fread(&fileheader, sizeof(fileheader), 1, l_file); // Read the fileheader

fseek(l_file, sizeof(fileheader), SEEK_SET); // Jump the fileheader


fread(&infoheader, sizeof(infoheader), 1, l_file); // and read the infoheader

// Now we need to allocate the memory for our image (width * height * color deep)
l_texture = (byte *) malloc(infoheader.biWidth * infoheader.biHeight * 4);
// And fill it with zeros
memset(l_texture, 0, infoheader.biWidth * infoheader.biHeight * 4);

// At this point we can read every pixel of the image


for (i=0; i < infoheader.biWidth*infoheader.biHeight; i++)
{
// We load an RGB value from the file
fread(&rgb, sizeof(rgb), 1, l_file);

// And store it
l_texture[j+0] = rgb.rgbtRed; // Red component
l_texture[j+1] = rgb.rgbtGreen; // Green component
l_texture[j+2] = rgb.rgbtBlue; // Blue component
l_texture[j+3] = 255; // Alpha value
j += 4; // Go to the next position
}

fclose(l_file); // Closes the file stream

glBindTexture(GL_TEXTURE_2D, num_texture); // Bind the ID texture specified by the 2nd


parameter

// The next commands sets the texture parameters


glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // If the u,v
coordinates overflow the range 0,1 the image is repeated

Mg. Johnny R. Avendaño Q. Pag. No. 12


Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Departamento Académico de Ciencias de la Computación
Laboratorio de Computación Visual 2018 2
Mapeado de texturas con OpenGL

glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);


glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // The
magnification function ("linear" produces better results)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_NEAREST); //The minifying function

glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); // We don't combine


the color with the original surface color, use only the texture map.

// Finally we define the 2d texture


glTexImage2D(GL_TEXTURE_2D, 0, 4, infoheader.biWidth, infoheader.biHeight, 0, GL_RGBA,
GL_UNSIGNED_BYTE, l_texture);

// And create 2d mipmaps for the minifying function


gluBuild2DMipmaps(GL_TEXTURE_2D, 4, infoheader.biWidth, infoheader.biHeight, GL_RGBA,
GL_UNSIGNED_BYTE, l_texture);

free(l_texture); // Free the memory we used to load the texture

return (num_texture); // Returns the current texture OpenGL ID


}

Mg. Johnny R. Avendaño Q. Pag. No. 13