UNIVERSIDAD DE LAS FUERZAS ARMADAS - ESPE

INFORME DE INVESTIGACIÓN

PROFESOR GRUPO: NOMBRE DE LA ASIGNATURA

INVESTIGACIÓN
/PRACTICA:
Ing. Nancy Una Persona TEXTURIZADO EN OPENGL COMPUTACION GRAFICA
Jacho

NOMBRES (ALUMNOS)

DAVID ALEJANDRO VARGAS PAREDES CI: 0503950669 FIRMA:

1. INTRODUCCIÓN
El texturizado en OpenGL es un proceso que permite aplicar imágenes a la superficie de
objetos tridimensionales en una escena gráfica. Esto le da a los objetos un aspecto más
detallado y realista, permitiendo que se vean como si tuvieran una textura..
En OpenGL, el texturizado se realiza mediante el uso de texturas, que son imágenes 2D que
se aplican a una superficie 3D. Las texturas se pueden aplicar de muchas maneras diferentes,
incluyendo mapeo planar, mapeo cilíndrico y mapeo esférico.
Además, el texturizado en OpenGL también permite la utilización de múltiples texturas en un
solo objeto, lo que permite crear texturas más complejas y realistas. También se pueden
aplicar efectos de iluminación y sombreado a las texturas para lograr un aspecto más
detallado.
El texturizado también se utiliza para simular diferentes materiales y superficies, como
madera, metal, piedra, entre otros. Esto permite crear una amplia variedad de efectos visuales
y mejora la interacción del usuario con la escena, también se puede utilizar para crear efectos
especiales como reflejos, sombras y transparencias. Todo esto contribuye a mejorar la calidad
de la experiencia de visualización en OpenGL.
En resumen, el texturizado en OpenGL es una herramienta esencial para los desarrolladores
gráficos que buscan crear imágenes y escenas más realistas y detalladas. Con la capacidad
de aplicar texturas y efectos a los objetos

2. OBJETIVO (COMPETENCIA)
Mejorar la apariencia visual de los objetos en una escena 3D, al aplicar una textura a un
objeto, se le agrega detalle y profundidad, haciendo que se vea más realista.

3. FUNDAMENTO

Pág. No. 1 de 8
 UNIVERSIDAD DE LAS FUERZAS ARMADAS - ESPE
INFORME DE INVESTIGACIÓN

● Conceptos entorno a la utilización de librerías gráficas.

● Conceptos entorno al desarrollo de objetos usando OpenGL.

4. DESARROLLO DE LA INVESTIGACIÓN /PRACTICA (INDICAR LOS COMANDOS

O INVESTIGACIÓN UTILIZADOS)
El proceso de cargar texturas no es propio de OpenGL por lo que se deberá hacer de manera
manual, sin embargo, hay que tener en cuenta unas ciertas limitaciones que la librería nos
impone. Por ejemplo, las dimensiones de las texturas que cargaremos deben ser números
pares.
Sea cuál sea el método que escojamos, al final tendremos un puntero a un segmento de
memoria que contiene la imagen, para eso usamos la siguiente línea de código:
unsigned char *textura;
Creando texturas en OpenGL
Para crear una textura, primero OpenGL nos debe proporcionar un identificador para la nueva
textura que necesitamos. Este paso no es necesario, pero es útil si necesitamos usar más
texturas, ya que nos da más control sobre ellas. Para pedir un nuevo identificador hay que
usar el comando:
glGenTextures(n: GLsizei; textures: PGLuint)
Donde n indica el número de identificadores que queremos solicitar, mientras que
textures indica el lugar donde queremos guardar esos identificadores.
Una vez que tenemos un identificador, debemos decirle a OpenGL que la textura que
queremos es una que coincida con el identificador que obtuvimos., esto se lo hace con la
siguiente línea de código:
glBindTexture(target: GLenum; texture: GLuint)
Dónde target nos indica el tipo de textura con la que estamos trabajando, los valores que
puede tomar target son GL_TEXTURE_1D o GL_TEXTURE_2D los cuales indican si se
trata de una textura en 1 o 2 dimensiones, mientras que texture debe ser uno de los
identificadores que solicitamos.
El siguiente paso es especificar qué imagen queremos usar como textura. OpenGL no
contiene comandos para manipular archivos de imagen, tenemos que generar o leer la imagen
de alguna manera y luego pasar esos datos a la textura usando el comando:
glTexImage2D (target: GLenum; level, components: GLint;
width, height: GLsizei; border: GLint;
format, type: GLenum; pixels: Pointer);
Los parámetros de esta función son:
● target: este valor debe ser GL_TEXTURE_2D.
● level: este parámetro se usa solo si se quieren especificar más de un nivel de
detalle para la textura, si solamente se va a utilizar un nivel este valor debe ser 0.
● components: indica la representación interna que queremos que tenga esta textura,
indica si queremos usar el formato RGBA, el número de bits que se quieren, etc. Los
valores permitidos son: GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12,
GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8,
GL_LUMINANCE12.

Pág. No. 2 de 8
 UNIVERSIDAD DE LAS FUERZAS ARMADAS - ESPE
INFORME DE INVESTIGACIÓN

● width,height: indican las dimensiones (en píxeles) de la imagen que estamos

pasando.
● format: indica el formato de los pixeles que estamos pasando.
● type: indica el tipo de datos que estamos pasando, lo valores que puede tomar son:
GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT,
GL_UNSIGNED_INT, GL_FLOAT, o GL_BITMAP
● pixels: es un apuntador a los datos de la imagen que queremos asignar a la
textura.

Parámetros de las texturas

Podemos asignar ciertas propiedades a cada textura. El primero de ellos es el filtro de

visualización. Una textura es un mapa de bits creado a partir de un conjunto de píxeles
dispuestos en un patrón regular. OpenGL escala estos píxeles para que cada texel (pixel de la
textura) ocupe 16 x 12 píxeles en la pantalla.

Esto significa que veremos "cuadrados" de 16x12, cada uno representando un texel de
textura. Visualmente, es muy poco realista ver una textura "pixelada", así que para evitarlo,
aplicamos un filtro. Los más comunes son los "filtros lineales", que se basan en la
interpolación de cada píxel en la pantalla que se está dibujando. Se puede incorporar usando
la siguiente línea de código:

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR);

Con esto estamos parametrizando dos filtros. Uno para cuando la textura se representa más
grande de lo que es en realidad y otro para cuando la textura es más pequeña
respectivamente. En los dos le decimos que haga un filtro lineal, sin embargo, también
podríamos decirle que no aplique ningún filtro usando: GL_NEAREST.

Otro aspecto de las texturas que necesita ser parametrizado es la forma en que se repite la
textura. Al texturizar una escena, el modelador generalmente usa una textura pequeña que se
repite sobre la superficie, por lo que podemos usar menos memoria y sacrificar el realismo.
Podemos decirle a OpenGL que prepare texturas para dibujarlas como "mosaicos" o solo una
vez.

Lo que realmente hace OpenGL es, al dibujar texturas y usar filtros lineales, interpola de borde
a borde con el texel en los bordes opuestos para una apariencia más realista. Si queremos
usar este efecto usamos las siguientes líneas de código:

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

De lo contrario si no queremos usar este efecto:

Pág. No. 3 de 8
 UNIVERSIDAD DE LAS FUERZAS ARMADAS - ESPE
INFORME DE INVESTIGACIÓN

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

Por GL_TEXTURE_WRAP_S y GL_TEXTURE_WRAP_T nos referimos al filtro para las filas y las
columnas, respectivamente.

5. RESULTADOS Y CONCLUSIONES
● Las texturas también se utilizan para emular diferentes materiales y superficies como
madera, metal, piedra, etc. Lo que nos permite crear una amplia gama de efectos
visuales y mejorar la interacción del usuario con la escena, también se puede utilizar
para crear efectos especiales como reflejos, sombras y transparencia. Todo esto
ayuda a mejorar la experiencia de visualización de OpenGL .
● El proceso de texturizado no es propio de OpenGL por lo que debemos cargar las
imágenes que forman el texturizado de manera manual.

6. CUESTIONARIO
● Seleccione la instrucción para parametrizar un filtro cuando la textura se representa
más grande de lo que es en realidad:

o glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR);

o glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_LINEAR);

o glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);

o glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

● Como se declara a un puntero a un segmento de memoria que contiene la imagen:

o glGenTextures(n: GLsizei; textures: PGLuint)
o unsigned char *textura;
o glBindTexture(target: GLenum; texture: GLuint)
o glBind(target: GLenum; texture: GLuint)

7. BIBLIOGRAFÍA
● Rojas, J. T. (2013, April 10). UNIVERSIDAD AUTÓNOMA METROPOLITANA.
Departamento de Ciencias de la Computacion, UAM Iztapalapa. Retrieved

Pág. No. 4 de 8
 UNIVERSIDAD DE LAS FUERZAS ARMADAS - ESPE
INFORME DE INVESTIGACIÓN

February 13, 2023, from

http://mat.izt.uam.mx/mcmai/documentos/tesis/Gen.09-O/Rojas_Cuevas_Tesis
.pdf
● Torres, G. M. (2020, 06 11). Práctica 3. Textura en OpenGL. Cimat. Retrieved
February 13, 2023, from
https://www.cimat.mx/~fory/geocomp/practica3/index.html
● Lopez, A. M. (2022, August 10). ☕️. YouTube. Retrieved February 13, 2023,
from
https://www.researchgate.net/profile/Felix-Sanz/publication/260400848_Motor_
grafico_interactivo_para_la_visualizacion_en_tiempo_real_de_gran_volumen_
de_informacion_vectorial_y_texturizada/links/553f621f0cf23e796bfb3955/
Motor-grafico-interactivo-para-la-vis
●

Desarrollo e Implementación del Programa

El desarrollo e implementación del algoritmo de texturas requiere de una librería adicional

stb_image.h, la cual nos ayudará a abrir la imagen que deseamos poner como textura.

Tabla 1: Código de texturizado.

#include <GL/glut.h>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>

#define STB_IMAGE_IMPLEMENTATION
#include "stb/stb_image.h"

using namespace std;

GLuint texture;

void display() {
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60, 1, 1, 100);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0, 0, 3, 0, 0, 0, 0, 1, 0);

glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture);

glBegin(GL_TRIANGLES);

Pág. No. 5 de 8
 UNIVERSIDAD DE LAS FUERZAS ARMADAS - ESPE
INFORME DE INVESTIGACIÓN

glTexCoord2f(0, 0);
glVertex3f(-1, -1, 0);
glTexCoord2f(1, 0);
glVertex3f(1, -1, 0);
glTexCoord2f(1, 1);
glVertex3f(1, 1, 0);
glTexCoord2f(0, 1);
glVertex3f(-1, 1, 0);
glEnd();

glDisable(GL_TEXTURE_2D);

glutSwapBuffers();
}

void loadTexture() {
int width, height, channels;
unsigned char* image = stbi_load("texture.png", &width, &height, &channels, 0);

glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE,

image);

stbi_image_free(image);
}

int main(int argc, char** argv) {

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(500, 500);
glutCreateWindow("Texturización de Imágenes en OpenGL");
glutDisplayFunc(display);
loadTexture();

glutMainLoop();
return 0;
}

En la Tabla 2, se muestra una de las salidas o corridas de este programa.

Pág. No. 6 de 8
UNIVERSIDAD DE LAS FUERZAS ARMADAS - ESPE
INFORME DE INVESTIGACIÓN

Pág. No. 7 de 8
 UNIVERSIDAD DE LAS FUERZAS ARMADAS - ESPE
INFORME DE INVESTIGACIÓN

Tabla 2: Salida o corrida del programa.

Pág. No. 8 de 8