1

UNIVERSIDAD AUTÓNOMA METROPOLITANA AZCAPOTZALCO

Ciencias Básicas e Ingeniería

Gráficas por computadora.

Práctica 4 .

Grupo: CSI81 Trimestre lectivo: 24P

Profesor:
Alejandro Cruz Sandoval

Fecha de entrega:
Domingo 08 - Septiembre - 2024

Equipo:

Jordy Ariel Ramirez Gómez 2202003390

Vania Alejandra Contreras Torres 2203001309
Maria Elena Ledesma Juarez 2193059980
Miguel Angel Ruiz Ruiz 2202000639
 2

Contenido
Objetivos: ................................................................................................................................................................... 3
Cuestionario ............................................................................................................................................................... 3
Ejercicio 1: Trabajar sobre un proyecto ya creado, solo hay que realizar lo que se pide y si quieren lo pueden
mejorar con algún otro cuerpo geométrico. ............................................................................................................. 6
Ejercicio 2: Modifique la primitiva. Para el usuario. ................................................................................................ 11
Ejercicio 3: Modifique o complemente el código del piso o suelo a cuadros para agregar un carro en 2D. ........... 13
Ejercicio 4: Modifique o complemente el código del piso o suelo a cuadros para agregar una pelota que rebota.
................................................................................................................................................................................. 18
Ejercicio 5.- Esfera dentro de una caja. En este ejercicio, tienen que sacar la pelota ............................................ 23
cunado se abra la tapa de la caja. ............................................................................................................................ 23
Conclusiones individuales ........................................................................................................................................ 26
Ramirez Gomez Jordy Ariel 2202003390 ............................................................................................................. 26
Miguel Angel Ruiz Ruiz 2202000639 ................................................................................................................... 27
Contreras Torres Vania Alejandra 2203001309................................................................................................... 27
Ledesma Juarez Maria Elena 2193059980 .......................................................................................................... 27
Referencias ............................................................................................................................................................... 28
 3

Objetivos:

1. Preparar una ventana Windows para su uso con Opengl.

2. Aprender a manejar el sistema de iluminación de OpenGL.
3. Aprender a caracterizar un material por sus propiedades ópticas.

Cuestionario
1. Investigue y reporte cómo se habilita el sistema de luces de OpenGL. Esto
es, que hacen las subrutinas glEnable() y los argumentos GL_LIGHTING
Y GL_LIGHTxx.

Se usa la función glEnable(). Cuando se desea activar la iluminación general, se utiliza el

argumento GL_LIGHTING. Para habilitar luces específicas, se utiliza GL_LIGHT0,
GL_LIGHT1, etc., hasta GL_LIGHT7. Estas luces se refieren a las distintas fuentes de luz que
pueden ser activadas individualmente en la escena. Por ejemplo:
glEnable(GL_LIGHTING); // Habilita el sistema de iluminación
glEnable(GL_LIGHT0); // Habilita la luz número 0

2. Investigue y reporte el término “luz ambiente y su reflexión difusa”.

● Luz ambiente: Es una luz que no viene de una dirección específica y se dispersa
igualmente por todo el ambiente. Esta luz minimiza las sombras porque ilumina
todos los objetos por igual, sin importar su orientación.
● Reflexión difusa: Es la propiedad de los materiales para reflejar la luz en muchas
direcciones. No depende del punto de vista y es el resultado de la luz
dispersándose en muchas direcciones cuando choca con una superficie rugosa.

3. Investigue y reporte el término “reflexión difusa de la luz”.

La reflexión difusa ocurre cuando la luz choca con una superficie y se dispersa en múltiples
direcciones. Esto hace que la superficie parezca igualmente iluminada desde cualquier ángulo
de visión, característica común en materiales como papel, tela o madera no barnizada.
0. Investigue y reporte el término “reflexión especular de la luz”.
Es lo que se produce cuando la luz se refleja en una superficie lisa y el reflejo depende
del ángulo de visión. Esto crea efectos como el brillo o los destellos en superficies
como metal o agua.
 4

4. Para definir las propiedades de las luces ambiente, difusa y especular, se

recurre a la función glLight(). Investigue y reporte qué argumentos
requiere.

La función glLight() se utiliza para definir las características de una fuente de

luz particular. Sus argumentos son:
● GL_AMBIENT: Define la intensidad de la luz ambiente.
● GL_DIFFUSE: Define la intensidad de la luz difusa.
● GL_SPECULAR: Define la intensidad de la luz especular.
● GL_POSITION: Define la posición de la fuente de luz.
● GL_SPOT_DIRECTION: Dirección del cono de luz para luces tipo foco.
● GL_SPOT_EXPONENT: Intensidad de la distribución de luz dentro del cono.
● GL_SPOT_CUTOFF: Ángulo del cono de luz, fuera del cual no hay luz.
● GL_CONSTANT_ATTENUATION: Factor de atenuación constante de la luz.
● GL_LINEAR_ATTENUATION: Factor de atenuación lineal de la luz.
● GL_QUADRATIC_ATTENUATION: Factor de atenuación cuadrática de la
luz.

5. Investigue y reporte un corto resumen sobre el modelo de iluminación Warn

de atenuación.

Este modelo tiene en cuenta la disminución de la intensidad de la luz con la distancia,

lo cual es especialmente útil para crear efectos más realistas en escenas 3D. Las
fórmulas de atenuación (constante, lineal y cuadrática) ayudan a calcular cómo la luz
disminuye a medida que se aleja de la fuente.

6. Respecto del punto anterior, reporte que significan los argumentos de la

función glLight() siguientes

A. GL_AMBIENT: Define la reflectividad ambiente del material.

B. GL_DIFFUSE: Define la reflectividad difusa del material.
C. GL_SPECULAR: Configura la intensidad de la luz especular.
D. GL_POSITION: Define el brillo del material.
E. GL_SPOT_DIRECTION: Define la dirección de una luz de tipo foco. Se especifica
como un vector de tres componentes.
F. GL_SPOT_EXPONENT: Controla la caída de la luz desde el centro hacia el borde del
cono de un foco. Valores más altos resultan en una luz más concentrada en el centro.
 5

G. GL_SPOT_CUTOFF: Establece el ángulo del cono de luz de un foco. El ángulo se mide

en grados, y un valor típico podría estar entre 0 y 90 grados. Un valor de 180 indica que
no hay corte y la luz se trata como una fuente puntual regular.
H. GL_CONSTANT_ATTENUATION: Factor de atenuación constante que afecta la
intensidad de la luz en función de la distancia.
I. GL_LINEAR_ATTENUATION: Factor de atenuación lineal que reduce la intensidad de
la luz en función de la distancia a la fuente de luz.
J. GL_QUADRATIC_ATTENUATION: Factor de atenuación cuadrática, que disminuye la
intensidad de la luz con el cuadrado de la distancia a la fuente.

7. Investigue y reporte que subrutinas de OpenGL se requieren para definir

un material ambiente y que argumentos necesita (glMaterial).

La función glMaterialfv() se utiliza para definir las propiedades del material que
afectan a cómo se renderiza bajo iluminación.
GLfloat ambient[] = {0.1f, 0.1f, 0.1f, 1.0f}; // Componente RGBA del
material ambiente
glMaterialfv(GL_FRONT, GL_AMBIENT, ambient);
Donde GL_AMBIENT: Define la reflectividad ambiente del material.

8. Investigue y reporte que subrutinas de OpenGL se requieren para definir un

material que presente reflexión difusa de la luz y que argumentos necesita
(glMaterial).

GLfloat diffuse[] = {0.8f, 0.8f, 0.8f, 1.0f}; // Componente RGBA del material
difuso
glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse);
Donde GL_DIFFUSE: Define la reflectividad difusa del material.

9. Investigue y reporte que subrutinas de OpenGL se requieren para definir

un material que presente reflexión especular de la luz y que argumentos
necesita (glMaterial).

GLfloat specular[] = {1.0f, 1.0f, 1.0f, 1.0f}; // Componente RGBA del material
especular
glMaterialfv(GL_FRONT, GL_SPECULAR, specular);
GLfloat shininess = 50.0f; // Brillo del material
glMaterialf(GL_FRONT, GL_SHININESS, shininess);
Donde:
a. GL_SPECULAR: Define la reflectividad especular del material.
b. GL_SHININESS: Define el brillo de los reflejos especulares.
 6

10. Investigue y reporte la función glPolygonMode() y que argumentos necesita.

Especifica el modo de rasterizado de los polígonos. Los argumentos son:
a. face: Puede ser GL_FRONT, GL_BACK o
GL_FRONT_AND_BACK, indicando qué caras de los polígonos se
afectarán.
b. mode: Puede ser GL_POINT, GL_LINE, o GL_FILL, indicando si los
polígonos deben ser rasterizados como puntos, líneas, o rellenos.

11. Investigue y reporte la función glShadeModel() y que argumentos necesita.

Define el modo de sombreado para renderizar. Donde el argumento puede ser:
a. mode: Puede ser GL_FLAT (sombreado plano, un color por primitiva)
o GL_SMOOTH (sombreado suave, los colores son interpolados entre
los vértices).

Ejercicio 1: Trabajar sobre un proyecto ya creado, solo hay que realizar lo que se pide y

si quieren lo pueden mejorar con algún otro cuerpo geométrico.

1.El programa consta de una sección de

a. Variables globales para definir luces y materiales
//Variables que definen luces
GLfloat light_Ambient[4] = { 0.4, 0.4, 0.4, 1.0 };
GLfloat light_Diffuse[4] = { 0.7, 0.7, 0.7, 1.0 };
GLfloat light_Position[4] = { 20.0, 15.0, 10.0, 1.0 };
//Variables que definen materiales
GLfloat material[4] = { 1.0, 0.2, 0.2, 1.0 };
GLfloat RedMaterial[4] = { 1.0, 0.0, 0.0, 1.0 };
GLfloat GreenMaterial[4] = { 0.0, 1.0, 0.0, 1.0 };
GLfloat BlueMaterial[4] = { 0.0, 0.0, 1.0, 1.0 };
GLfloat WhiteMaterial[4] = { 1.0, 1.0, 1.0, 1.0 };

/* los valores de los materiales se van a sumar para tener una totalidad, que antes se
multiplico a la luz
ambiente+difuso + especular*/
//Cuadric
GLUquadricObj* quadobj;
 7

b. Subrutina “luces()” que habilita las ecuaciones de luz de oOpenGL

void luces(void){

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

glLightfv(GL_LIGHT0, GL_AMBIENT, light_Ambient);

glLightfv(GL_LIGHT0, GL_DIFFUSE, light_Diffuse);

glLightfv(GL_LIGHT0, GL_POSITION, light_Position);

}
 8

c. Subrutina “EjesReferencia()” que dibuja los eje4s del sistema de referencia.

void EjesReferencia(){
glBegin(GL_LINES);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, RedMaterial);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(20.0, 0.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, GreenMaterial);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(0.0, 20.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, WhiteMaterial);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(0.0, 0.0, 20.0);
glEnd();
}

d. Subrutina “Cilindro()” que dibuja un cilindro (es posible aún no

entienda el código”.
void cilindro(){
quadobj = gluNewQuadric();
gluQuadricDrawStyle(quadobj, GLU_FILL);
gluQuadricNormals(quadobj, GLU_SMOOTH);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glRotatef(-90, 1.0, 0.0, 0.0);
gluCylinder(quadobj,
2, //GLdouble baseRadius
2, // GLdouble topRadius
3, //GLdouble height
15, //GLint slices
15); //GLint stacks
glPopMatrix();
//Se dibujará un segundo cilindro
//************************************************** /*
/* glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef(-7.0,0.0,-27.0);
glRotatef(-90,1.0,0.0,0.0);
gluCylinder( quadobj,
2, //GLdouble baseRadius,
2, //GLdouble topRadius,
3, // GLdouble height,
15, // GLint slices,
15); // GLint stacks );
glPopMatrix();
 9

gluDeleteQuadric(quadobj);*/
}

e. Subrutina “RenderScene()” que ordena invoca a las subrutinas anteriores

para dibujar la escena.
void RenderScene(void){ /*Borra frame buffer*/
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/*Prepara la luz*/
luces();
/*Prepara ejes de referencia*/
EjesReferencia();
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, material);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

glShadeModel(GL_FLAT); //Localice dentro de la rutina “RenderScene()” la línea

//“glShadeModel(GL_FLAT)” y cambie
// “GL_FLAT” por “GL_SMOOTH”.Construya y ejecute. Reporte la figura
obtenida.
//glShadeModel (GL_SMOOTH);
/*Prepara un cilindro*/
cilindro();
/*Render de las primitivas*/
glFlush();
}

f. Subrutina ”main()” que prepara la ventana Windows para OpenGL.

2.Construya y ejecute.
int main(void) {
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
//NOTE QUE SE ASIGNO
//GLUT_DEPTH utilizar buffer de profundidad
glutInitWindowSize(800, 600);
glutInitWindowPosition(100, 100);
glutCreateWindow("Cilindro 3D en OpenGL");
glutDisplayFunc(RenderScene);
glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
//Habilitando el bufer de produndidad
glEnable(GL_DEPTH_TEST);
//cte GL_DEPTH_TEST HABILITADO //
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// glOrtho(-5,5,-5,5,-10,10);// esta es proyeccion plana
gluPerspective(15, 800 / 600, .1, 1000);
//explicacion abajo
//fov:angulo de apertura de la camara=>35 grados
 10

// //relacion de aspecto 3:4,16:9=>800/600

// //plano de vista cercano. mayor de 0 => .1
// //plano de vista lejano. =>1000.
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(25, 10, 35, 4, 2, -5, 0, 1, 0);
// si pones 5,5,-5 se ve cortado
//camara tiene un ojo, posicion de lente y giro de tripie.No esta en pixeles
//eyex, eyey, eyez: especifica la poisicon de la lente de la camara u ojo.
// centerx, centery, centerz: especifica la posion del punto al que se mira
//upx, upy, upz: especfica el vector de orientacion de la camara
glTranslatef(4, 3, -0.5); //
// glRotated(45,0.0,0.0,1.0);
glutMainLoop();
return 0;
}

3. Reporte la gráfica obtenida

Imagen 1. Presenta el cilindro obtenido para el código anterior.

4 Localice dentro de la rutina “RenderScene()” la línea “glShadeModel

(GL_FLAT)” y cambie “GL_FLAT” por “GL_SMOOTH”. Construya y ejecute.
5. Reporte la figura obtenida.
 11

Imagen 2. La figura muestra el cambio tras modificar la instrucción GL_FLAT por

GL_SMOOTH.

Ejercicio 2: Modifique la primitiva. Para el usuario.

El modelo de iluminación practicado hasta ahora tiene un pequeño defecto. Considere

dos objetos a diferentes distancias de la fuente de luz. El objeto cercano tendrá cierta
iluminación y el objeto lejano deberá estar menos iluminado por lo que se verá oscurecido.
El modelo de iluminación de OpenGL, como está configurado actualmente no toma en cuenta
esta situación. Para habilitar esta característica debe hacer uso de los argumentos
GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION,
GL_QUADRIC_ATTENUATION.

6 . Dentro de la subrutina “Cilindro()” hay código en comentarios que dibuja un

segundo cilindro de iguales dimensiones al primero pero alejado. Retire los comentarios.
Construya y ejecute el programa.
 12

Imagen 3. Tras modificar el codigo anterior, generamos un cilindro extra que parece estar

más al fondo.

7. Dentro de la subrutina “luces()” agregue código para el que programa tome en

cuenta la distancia en su modelo de iluminación
 13

Imagen 4. Tras modificar los argumentos de iluminación, la imagen puede percibirse de

esta manera. El cilindro del fondo aparenta estar más oscuro, pues en teoría está más

alejado.

Ejercicio 3: Modifique o complemente el código del piso o suelo a cuadros para agregar

un carro en 2D.

#include <iostream>
#include <GL/glut.h>

float pos = 0;
int gr = 0;

void rueda_d() {
glPushMatrix();
glColor3f(0, 0, 0);
glTranslatef(1.5f, 0.0f, 0.0f);
glRotatef(gr, 0.0f, 0.0f, 1.0f);
glutSolidSphere(1.0f, 20, 20);
glPopMatrix();
}

void rueda_t() {
glPushMatrix();
glColor3f(0, 0, 0);
glTranslatef(5.5f, 0.0f, 0.0f);
glRotatef(gr, 0.0f, 0.0f, 1.0f);
glutSolidSphere(1.0f, 20, 20);
glPopMatrix();
}

void ventanas() {
glPushMatrix();
glColor3f(0, 0, 0);
glTranslatef(1.2f, 2.0f, 0.01f);
glBegin(GL_TRIANGLES);
glVertex3f(0.0f, 0.0f, 0.0f);
 14

glVertex3f(0.8f, 0.0f, 0.0f);

glVertex3f(0.8f, 0.8f, 0.0f);
glEnd();
glBegin(GL_QUADS);
glVertex3f(0.8f, 0.0f, 0.0f);
glVertex3f(1.7f, 0.0f, 0.0f);
glVertex3f(1.7f, 0.8f, 0.0f);
glVertex3f(0.8f, 0.8f, 0.0f);
glEnd();
glTranslatef(1.9f, 0.0f, 0.0f);
glBegin(GL_QUADS);
glVertex3f(0.0f, 0.0f, 0.0f);
glVertex3f(0.9f, 0.0f, 0.0f);
glVertex3f(0.9f, 0.8f, 0.0f);
glVertex3f(0.0f, 0.8f, 0.0f);
glEnd();
glBegin(GL_TRIANGLES);
glVertex3f(0.9f, 0.0f, 0.0f);
glVertex3f(1.7f, 0.0f, 0.0f);
glVertex3f(0.9f, 0.8f, 0.0f);
glEnd();
glPopMatrix();
}

void techo() {
glPushMatrix();
glTranslatef(1.0f, 2.0f, 0.0f);
glBegin(GL_TRIANGLES);
glVertex3f(1.0f, -1.0f, 0.0f);
glVertex3f(-1.0f, -1.0f, 0.0f);
glVertex3f(1.0f, 1.0f, 0.0f);
glEnd();
glBegin(GL_QUADS);
glVertex3f(1.0f, 0.0f, 0.0f);
glVertex3f(3.0f, 0.0f, 0.0f);
glVertex3f(3.0f, 1.0f, 0.0f);
glVertex3f(1.0f, 1.0f, 0.0f);
glEnd();
glBegin(GL_TRIANGLES);
glVertex3f(3.0f, 0.0f, 0.0f);
glVertex3f(4.0f, 0.0f, 0.0f);
glVertex3f(3.0f, 1.0f, 0.0f);
glEnd();
glPopMatrix();
}
 15

void coche() {
glColor3f(1, 0, 0);
glTranslatef(pos, 1.0f, 0.0f);
glBegin(GL_QUADS);
glVertex3f(0.0f, 0.0f, 0.0f);
glVertex3f(7.0f, 0.0f, 0.0f);
glVertex3f(7.0f, 2.0f, 0.0f);
glVertex3f(0.0f, 2.0f, 0.0f);
glEnd();
}

// Initialization routine.
void setup(void) {
glClearColor(1.0, 1.0, 1.0, 0.0);
glEnable(GL_DEPTH_TEST); // Enable depth testing.
// Turn on OpenGL lighting.
glEnable(GL_LIGHTING);

// Light property vectors.

float lightAmb[] = { 0.0, 0.0, 0.0, 1.0 };
float lightDifAndSpec[] = { 1.0, 1.0, 1.0, 1.0 };
float lightPos[] = { 0.0, 1.0, 0.0, 0.0 };
float globAmb[] = { 0.2, 0.2, 0.2, 1.0 };
// Light properties.
glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDifAndSpec);
glLightfv(GL_LIGHT0, GL_SPECULAR, lightDifAndSpec);
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
glEnable(GL_LIGHT0); // Enable particular light source.
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globAmb); // Global
ambient light.
// Material property vectors.
float matSpec[] = { 1.0, 1.0, 1.0, 1.0 };
float matShine[] = { 50.0 };
// Material properties.
glMaterialfv(GL_FRONT, GL_SPECULAR, matSpec);
glMaterialfv(GL_FRONT, GL_SHININESS, matShine);
// Enable color material mode.
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
// Flat shading to obtain the checkered pattern of the floor.
glShadeModel(GL_FLAT);
 16

// Cull back faces.

glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
}

// Drawing routine.
void drawScene(void)
{
int i;
float z;

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(0.0, 5.0, 30.0, 0.0, 10.0, 0.0, 0.0, 1.0, 0.0);

// Draw floor as a stack of triangle strips.

i = 0;
for (z = 100.0; z > -100.0; z -= 5.0)
{
glBegin(GL_TRIANGLE_STRIP);
for (float x = -100.0; x < 100.0; x += 5.0)
{
if (i % 2) glColor4f(0.0, 0.5, 0.5, 1.0);
else glColor4f(1.0, 1.0, 1.0, 1.0);
glNormal3f(0.0, 1.0, 0.0);
glVertex3f(x, 0.0, z - 5.0);
glVertex3f(x, 0.0, z);
i++;
}
glEnd();
i++;
}

coche();
techo();
ventanas();
rueda_d();
rueda_t();

glutSwapBuffers();
}
 17

// OpenGL window reshape routine.

void resize(int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-5.0, 5.0, -5.0, 5.0, 5.0, 100.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

// Main routine.
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowSize(500, 500);
glutInitWindowPosition(100, 100);
glutCreateWindow("Coche sobre suelo a cuadros");
glutDisplayFunc(drawScene);
glutReshapeFunc(resize);
setup();
glutMainLoop();
return 0;
}
 18

Imagen 5. El código muestra a la salida un auto sobre un suelo a cuadros.

Ejercicio 4: Modifique o complemente el código del piso o suelo a cuadros para agregar

una pelota que rebota.

#include <iostream>
#include <GL/glut.h>
//#include &lt;GL/freeglut.h&gt;
using namespace std;
// Globals.
static float latAngle = 0.0; // Latitudinal angle.
static float longAngle = 0.0; // Longitudinal angle.
static int isAnimate = 0; // Animated?
static int animationPeriod = 70; // Time interval between frames.
// Draw ball flying around torus.

void drawBall(void){
glPushMatrix();
 19

glTranslatef(0.0, 12.0, -15.0);

glRotatef(90.0, 1.0, 0.0, 0.0);
// Begin revolving ball.
glRotatef(longAngle, 0.0, 0.0, 1.0);
glTranslatef(12.0, 0.0, 0.0);
glRotatef(latAngle, 0.0, 1.0, 0.0);
glTranslatef(-12.0, 0.0, 0.0);
glTranslatef(20.0, 0.0, 0.0);
glColor4f(0.0, 0.0, 1.0, 1.0); // High alpha for opacity.
glutSolidSphere(5.0, 20, 20);
// End revolving ball.
glPopMatrix();
}
// Timer function.
void animate(int value)
{
if (isAnimate)
{
latAngle += 5.0;
if (latAngle > 360.0) latAngle -= 360.0;
longAngle += 1.0;
if (longAngle > 360.0) longAngle -= 360.0;
glutPostRedisplay();
glutTimerFunc(animationPeriod, animate, 1);
}
}
// Initialization routine.
void setup(void)
{
glClearColor(1.0, 1.0, 1.0, 0.0);
glEnable(GL_DEPTH_TEST); // Enable depth testing.
// Turn on OpenGL lighting.
glEnable(GL_LIGHTING);
// Light property vectors.
float lightAmb[] = { 0.0, 0.0, 0.0, 1.0 };
float lightDifAndSpec[] = { 1.0, 1.0, 1.0, 1.0 };
float lightPos[] = { 0.0, 1.0, 0.0, 0.0 };
float globAmb[] = { 0.2, 0.2, 0.2, 1.0 };
// Light properties.
glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmb);

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDifAndSpec);

glLightfv(GL_LIGHT0, GL_SPECULAR, lightDifAndSpec);
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
glEnable(GL_LIGHT0); // Enable particular light source.
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globAmb); // Global ambient light.
// Material property vectors.
float matSpec[] = { 1.0, 1.0, 1.0, 1.0 };
float matShine[] = { 50.0 };
// Material properties.
glMaterialfv(GL_FRONT, GL_SPECULAR, matSpec);
glMaterialfv(GL_FRONT, GL_SHININESS, matShine);
// Enable color material mode.
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
// Cull back faces.
 20

glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glEnable(GL_BLEND); // Enable blending.
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Specify blending
parameters.
}
// Drawing routine.
void drawScene(void)
{
int i = 0;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(0.0, 5.0, 25.0, 0.0, 10.0, 0.0, 0.0, 1.0, 0.0);
// Blend checkered plane (the floor) onto the reflection.
glShadeModel(GL_FLAT); // Flat shading to get the checkered pattern.
for (float z = 100.0; z > -100.0; z -= 5.0)
{
glBegin(GL_TRIANGLE_STRIP);
for (float x = -100.0; x < 100.0; x += 5.0)
{
if (i % 2) glColor4f(0.0, 0.0, 0.0, 0.5); // Low alpha for blending.
else glColor4f(1.0, 1.0, 1.0, 0.5); // Low alpha for blending.
glNormal3f(0.0, 1.0, 0.0);
glVertex3f(x, 0.0, z - 5.0);
glVertex3f(x, 0.0, z);

i++;
}
glEnd();
i++;
}
glShadeModel(GL_SMOOTH); // Restore smooth shading.
// Draw real ball and torus.
drawBall();
glutSwapBuffers();
}
// OpenGL window reshape routine.
void resize(int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-5.0, 5.0, -5.0, 5.0, 5.0, 100.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
// Keyboard input processing routine.
void keyInput(unsigned char key, int x, int y)
{
switch (key)
{
case 27:
exit(0);
break;
case ' ':
if (isAnimate) isAnimate = 0;
 21

else
{
isAnimate = 1;
animate(1);
}
break;
default:
break;
}
}
// Callback routine for non-ASCII key entry.
void specialKeyInput(int key, int x, int y)
{
if (key == GLUT_KEY_DOWN) animationPeriod += 5;
if (key == GLUT_KEY_UP) if (animationPeriod > 5) animationPeriod -= 5;
glutPostRedisplay();
}
// Routine to output interaction instructions to the C++ window.
void printInteraction(void)
{
cout << "Interaction" << endl;
cout << "Press space to toggle between animation on and off." << endl
<< "Press the up/down arrow keys to speend up/slow down animation." << endl;
}
// Main routine.
int main(int argc, char** argv)
{
printInteraction();
glutInit(&argc, argv);
//glutInitContextVersion(4, 3);
//glutInitContextProfile(GLUT_COMPATIBILITY_PROFILE);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowSize(500, 500);
glutInitWindowPosition(100, 100);
glutCreateWindow("Pelota rebotando sobre suelo a cuadros");
glutDisplayFunc(drawScene);
glutReshapeFunc(resize);
glutKeyboardFunc(keyInput);
glutSpecialFunc(specialKeyInput);
//glewExperimental = GL_TRUE;
//glewInit();
setup();
glutMainLoop();
}
 22

Imagen 6. Muestra una esfera que simula ser una pelota rebotando sobre un suelo a

cuadros.
 23

Ejercicio 5.- Esfera dentro de una caja. En este ejercicio, tienen que sacar la pelota
cunado se abra la tapa de la caja.

#include <iostream>
#include <GL/glut.h>
using namespace std;

#define ONE_BY_ROOT_THREE 0.57735

// Global variables
static int step = 0; // Steps in open/closing the box lid.
static float spherePosition = 0.0; // Position of the sphere (0.0 means inside the box).

// Box vertex co-ordinate vectors.

static float vertices[] = {
1.0, -1.0, 1.0,
1.0, 1.0, 1.0,
1.0, 1.0, -1.0,
1.0, -1.0, -1.0,
-1.0, -1.0, 1.0,
-1.0, 1.0, 1.0,
-1.0, 1.0, -1.0,
-1.0, -1.0, -1.0
};

// Vertex indices for the box sides

static unsigned char stripIndices0[] = { 5, 4, 1, 0, 2, 3, 6, 7, 5, 4 };
static unsigned char stripIndices1[] = { 0, 4, 3, 7 };
static unsigned char stripIndices2[] = { 6, 5, 2, 1 };

// Box vertex normal vectors

static float normals[] = {
ONE_BY_ROOT_THREE, -ONE_BY_ROOT_THREE, ONE_BY_ROOT_THREE,
ONE_BY_ROOT_THREE, ONE_BY_ROOT_THREE, ONE_BY_ROOT_THREE,
ONE_BY_ROOT_THREE, ONE_BY_ROOT_THREE, -ONE_BY_ROOT_THREE,
ONE_BY_ROOT_THREE, -ONE_BY_ROOT_THREE, -ONE_BY_ROOT_THREE,
-ONE_BY_ROOT_THREE, -ONE_BY_ROOT_THREE, ONE_BY_ROOT_THREE,
-ONE_BY_ROOT_THREE, ONE_BY_ROOT_THREE, ONE_BY_ROOT_THREE,
-ONE_BY_ROOT_THREE, ONE_BY_ROOT_THREE, -ONE_BY_ROOT_THREE,
-ONE_BY_ROOT_THREE, -ONE_BY_ROOT_THREE, -ONE_BY_ROOT_THREE
};

// Initialization routine
void setup(void) {
glClearColor(1.0, 1.0, 1.0, 0.0);
glEnable(GL_DEPTH_TEST); // Enable depth testing.

// Turn on OpenGL lighting

glEnable(GL_LIGHTING);
float lightAmb[] = { 0.0, 0.0, 0.0, 1.0 };
float lightDifAndSpec[] = { 1.0, 1.0, 1.0, 1.0 };
float lightPos[] = { 0.0, 1.5, 3.0, 1.0 };
float globAmb[] = { 0.2, 0.2, 0.2, 1.0 };
glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmb);
 24

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDifAndSpec);

glLightfv(GL_LIGHT0, GL_SPECULAR, lightDifAndSpec);
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
glEnable(GL_LIGHT0); // Enable particular light source
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globAmb); // Global ambient light
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); // Enable two-sided lighting
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); // Enable local viewpoint
}

// Drawing routine
void drawScene(void) {
float matAmbAndDif1[] = { 0.9, 0.0, 0.0, 1.0 };
float matAmbAndDif2[] = { 0.0, 0.9, 0.0, 1.0 };
float matSpec[] = { 1.0, 1.0, 1.0, 1.0 };
float matShine[] = { 50.0 };

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(0.0, 3.0, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

// Draw the box

glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, matAmbAndDif1);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, matSpec);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, matShine);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, vertices);
glNormalPointer(GL_FLOAT, 0, normals);
glDrawElements(GL_TRIANGLE_STRIP, 10, GL_UNSIGNED_BYTE, stripIndices0);
glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, stripIndices1);

// Draw the lid of the box

glPushMatrix();
glTranslatef(0.0, 1.0, -1.0);
glRotatef((float)step, -1.0, 0.0, 0.0);
glTranslatef(0.0, -1.0, 1.0);
glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, stripIndices2);
glPopMatrix();

// Update sphere position based on the lid angle

if (step == 180) {
spherePosition = 2.0; // Move the sphere out of the box when lid is fully open
} else {
spherePosition = 0.0; // Keep the sphere inside the box when lid is closed
}

// Draw the sphere

glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, matAmbAndDif2);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glPushMatrix();
glTranslatef(spherePosition, 0.0, 0.0); // Move the sphere based on its position
glutSolidSphere(1.0, 40, 40);
glPopMatrix();
glDisable(GL_CULL_FACE);
 25

glutSwapBuffers();
}

// OpenGL window reshape routine

void resize(int w, int h) {
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (float)w / (float)h, 1.0, 20.0);
glMatrixMode(GL_MODELVIEW);
}

// Keyboard input processing routine

void keyInput(unsigned char key, int x, int y) {
switch (key) {
case 27: // Escape key
exit(0);
break;
default:
break;
}
}

// Callback routine for non-ASCII key entry

void specialKeyInput(int key, int x, int y) {
if (key == GLUT_KEY_UP) if (step < 180) step++;
if (key == GLUT_KEY_DOWN) if (step > 0) step--;
glutPostRedisplay();
}

// Routine to output interaction instructions to the C++ window

void printInteraction(void) {
cout << "Interaction:" << endl;
cout << "Press up/down arrow keys to open/close the box." << endl;
}

// Main routine
int main(int argc, char** argv) {
printInteraction();
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowSize(500, 500);
glutInitWindowPosition(100, 100);
glutCreateWindow("Esfera dentro una caja");
glutDisplayFunc(drawScene);
glutReshapeFunc(resize);
glutKeyboardFunc(keyInput);
glutSpecialFunc(specialKeyInput);
setup();
glutMainLoop();
return 0;
}
 26

Imagen 7. Muestra

una caja abriéndose para sacar una pelota de color verde.

Conclusiones individuales

Ramirez Gomez Jordy Ariel 2202003390

El manejo de luces y materiales en OpenGL es esencial para la creación de gráficos 3D realistas y

visualmente atractivos. Aquí se presenta una conclusión sobre los conceptos clave y su impacto en el
desarrollo de gráficos:

1. Iluminación Realista
El sistema de iluminación de OpenGL permite simular cómo la luz interactúa con las superficies de los
objetos. Al configurar luces en una escena, los desarrolladores pueden emular diversas condiciones de
iluminación, desde luces direccionales y puntuales hasta luces spot, lo que ayuda a crear una experiencia
visual más inmersiva y realista.

2. Propiedades de Materiales
Los materiales definen cómo un objeto refleja la luz. Las propiedades de materiales, como el color
ambiental, difuso, especular y la brillantez (shininess), controlan cómo la luz se dispersa en la superficie
del objeto. Estos parámetros permiten ajustar cómo se ve un objeto bajo diferentes condiciones de
iluminación y desde diferentes ángulos de visión.

3. Modelado de Luz y Sombra

El sistema de luces en OpenGL permite crear efectos de sombra y resaltar detalles que mejoran la
percepción espacial y la profundidad de la escena. Esto incluye sombras proyectadas, reflexiones y la
interacción entre objetos iluminados y sus entornos.

4. Configuración y Uso de Luces

La configuración de las luces en OpenGL implica definir propiedades como la intensidad, el color y la
posición de las fuentes de luz. Además, OpenGL soporta diferentes modelos de iluminación, como el
modelo de iluminación de Phong, que simula el reflejo especular y difuso, proporcionando una
representación más fiel a cómo los materiales se comportan en el mundo real.
 27

Miguel Angel Ruiz Ruiz 2202000639

Al completar esta práctica, adquirí un entendimiento profundo del sistema de iluminación en OpenGL y
cómo influye en la apariencia de los objetos 3D. Aprendí a configurar luces y definir materiales mediante
las funciones glLight() y glMaterial(), lo que me permitió observar cómo las propiedades ópticas, como
la luz ambiente, difusa y especular, afectan la visualización de las superficies. Implementar la atenuación
de la luz según la distancia fue clave para mejorar el realismo de la escena. Además, la comparación entre
los modos de sombreado GL_FLAT y GL_SMOOTH me permitió entender mejor cómo OpenGL maneja
la interpolación de colores, mientras que los ejercicios prácticos con objetos dinámicos, como la pelota y
el carro, consolidaron mis habilidades para crear entornos 3D más realistas y complejos.

Contreras Torres Vania Alejandra 2203001309

En resumen, OpenGL proporciona poderosas funciones para gestionar la iluminación, color y materiales
en entornos 3D. La capacidad de habilitar la iluminación, establecer colores y definir propiedades de
materiales permite crear representaciones visuales realistas y detalladas en aplicaciones gráficas 3D. Al
comprender y aplicar adecuadamente las sintaxis básicas proporcionadas, los desarrolladores pueden
lograr resultados visuales impresionantes y personalizados en sus proyectos OpenGL.

Ledesma Juarez Maria Elena 2193059980

Durante esta práctica, logré un entendimiento profundo del manejo de iluminación y materiales en
OpenGL. Esta tecnología es fundamental para la creación de escenas 3D realistas. A través de la
configuración de luces y el ajuste de propiedades de los materiales, como la luz ambiente, difusa y
especular, pude observar cómo cada aspecto influye directamente en la representación visual de los
objetos en una escena tridimensional.

Además, la comparación entre los modos de sombreado GL_FLAT y GL_SMOOTH me permitió

comprender mejor cómo OpenGL maneja la interpolación de colores, afectando la suavidad y el detalle
de las figuras. El uso de funciones como glLight() y glMaterial() fue clave para manipular las propiedades
ópticas de los objetos, lo que me dio control sobre la interacción de la luz con las superficies.

En conjunto, estos conocimientos me proporcionan las herramientas necesarias para crear gráficos 3D
más sofisticados y cercanos a la realidad, lo cual me será útil en futuros proyectos. Implementar la
atenuación de luz para objetos cercanos y lejanos fue un reto interesante, ya que permitió visualizar el
impacto que tiene la distancia en la iluminación y mejorar la percepción de profundidad.
 28

Referencias

De Programación, T. (2016, 24 abril). Modelo de Iluminación Phong - Tutorial OpenGL.

acodigo. https://acodigo.blogspot.com/2016/04/modelo-de-iluminacion-phong-tutorial.html