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

Universidad Nacional Mayor de San Marcos

Facultad de Ingeniería de Sistemas e Informática


E.P. Ingeniería de Sistemas
Laboratorio de Computación Visual 2018 - 2
Manejo de menús jerárquicos con OpenGL

Laboratorio 05

Manejo de menús
jerárquicos con OpenGL
Interacción con el usuario
empleando menús contextuales.

Objetivo: El objetivo de esta práctica, es que el alumno conozca y sepa cómo aplicar los principales
comandos de manejo de menús jerárquicos; también, poder efectuar un despliegue apropiado de las
gráficas con OpenGL, permitiendo al usuario el diseño más transparente y legible, además de
interactuar con la aplicación gráfica.

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. Interacción y animación usando GLUT (segunda parte)


2. Menús jerárquicos
3. Programa ejemplo con OpenGL
4. Ejercicios propuestos
5. Referencias

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
Laboratorio de Computación Visual 2018 - 2
Manejo de menús jerárquicos con OpenGL

1. INTERACCIÓN Y ANIMACIÓN USANDO GLUT (segunda parte)

OpenGL nos proporciona una serie de funciones que pueden ser usadas fácilmente para crear
ventanas con botones, casillas de selección, así como también una serie de menús jerárquicos de
varios niveles; la primera es proporcionada por MUI (Micro User Interface). Nosotros veremos
inicialmente el manejo de los menús jerárquicos y luego pasaremos a la librería mui. Cabe rescatar
que este aporte fue desarrollado por Tom Davis, inicialmente diseñado de manera
independientemente de OpenGL, luego Silicon Graphics la incorporó a GLUT dada su versatilidad y
facilidad de uso.

2. MENÚS JERÁRQUICOS

GLUT nos permite crear menús jerárquicos de muchos niveles, las cuales se pueden activar
mediante la presión de uno de los botones del mouse, el que elijamos (normalmente el derecho), y
cuando estemos sobre la ventana de visualización.
Si lo que queremos son menús que cuelguen de la ventana (típicos de cualquier aplicación
Windows) deberemos recurrir a algo más sofisticado como la MFC 1 del sistema operativo de
Windows.

Las funciones necesarias son las siguientes:

 int glutCreateMenu(void (*func) (int valor)): permite crear un menú al cual se le asocia una
rutina dada por func, que es una función del tipo callback, que se activará cuando se la
invoque.

 void glutAddMenuEntry(char *nombre, int valor): permite desplegar una opción


membretada con la cadena de caracteres nombre, la variable valor es un entero asociado a
esta opción el cuál puede usarse para algún evento en particular.

 void glutAddSubMenu(char *nombre, int valor): permite adicionar un submenú al menú del
nivel superior, este submenú se le llama por nombre y está asociada al entero valor.

 void glutAttachMenu(int boton): indica que evento asociado al mouse será empleado, para
esto, boton puede ser el estado GLUT_RIGHT_BUTTON, GLUT_LEFT_BUTTON o
GLUT_MIDDLE_BUTTON.

Por ejemplo el código:

glutCreateWindow(“Modelo alambrico”);

int submenu=glutCreateMenu(menu2);
// glutAddMenu(“lo que desees”);
glutAddMenuEntry(“cubo”,1);
glutAddMenuEntry(“esfera”,2);
glutAddMenuEntry(“toroide”,3);

// menú para las rotaciones


glutCreateMenu(menu1);;
glutAddSubMenu(“Modelos
alambricos”,submenu);
glutAddMenuEntry(“Eje X”,1);
glutAddMenuEntry(“Eje Y”,2);
glutAddMenuEntry(“Eje Z”,3);
glutAddMenuEntry(“Salir (esc)”,4);

// usaremos el boton derecho del mouse


1
Microsoft Foundation Classes provee un acceso más sencillo a la API de Windows

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
Laboratorio de Computación Visual 2018 - 2
Manejo de menús jerárquicos con OpenGL

glutAttachMenu(GLUT_RIGHT_BUTTON);

permite desplegar ventanas como se muestra en el gráfico superior.

3. PROGRAMA EJEMPLO CON OPENGL

Implemente un programa sobre el Ejercicio 01 del Taller 02 (cubo rotando con respecto a los 3
ejes coordenados), en esta implementación el usuario podrá escoger entre la esfera, el cubo y el
toroide (o algún otro objeto gráfico) usando modelos alámbricos definidos en OpenGL, además podrá
escoger el eje de rotación como se sugiere en el gráfico que se anexa:

#include <stdlib.h>
#include<conio.h>
#include<stdio.h>
#include<math.h>
#include <gl/glut.h>

GLdouble const pi = 3.141592654;


GLdouble angulo=0;
GLint modelo=1;
GLdouble const radio=1.0;
static GLfloat theta[] = {0.0,0.0,0.0};
static GLint axis = 2 ;
GLfloat L=1.5,R,alfa;

void iniciar(void)
{
glClearColor (1.0, 1.0, 1.0, 0.0);
glColor3f (1.0, 0.0, 0.0);
glLineWidth(2.0);
glShadeModel (GL_FLAT);
}

void estructura(void)
{
R=L/sin(M_PI/8);
alfa=45; //M_PI/4;
glScalef(0.25,0.25,0.25);
for(float i=0;i<8;i++)
{
glPushMatrix();
glRotatef(i*alfa,0,0,1);
glTranslatef(R*cos(M_PI/8)+L,0,0);
glutWireCube(2*L);
glPopMatrix();
}
}

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();

gluLookAt(0,0.0,5,0,0.0,4,0,1,0);
glRotatef(theta[0],1.0,0.0,0.0);
glRotatef(theta[1],0.0,1.0,0.0);
glRotatef(theta[2],0.0,0.0,1.0);

switch(modelo){
case 1: glutWireCube(2); break;

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
Laboratorio de Computación Visual 2018 - 2
Manejo de menús jerárquicos con OpenGL

case 2: glutWireSphere(1,10,10); break;


case 3: glutWireTorus(0.2,1.5,10,10); break;
case 4: estructura();break;
}
glFlush();
glutSwapBuffers();
}

void CubeSpin()
{
theta[axis] += 0.1;
if(theta[axis]>360) theta[axis] -= 360.0;
display();
}

void myReshape(int w, int h)


{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluPerspective(60.0, (GLfloat) w/(GLfloat) h,0.1, 30.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

void menu_rotaciones(int opcion)


{
switch(opcion){
case 1: axis = 0; break;
case 2: axis = 1; break;
case 3: axis = 2; break;
case 4 : exit(0); break;
}
}

void menu_modelos_alambricos(int opcion)


{
switch(opcion){
case 1: modelo=4; break;
case 3 : exit(0); break;
}
}

void menu_glut(int opcion)


{
switch(opcion){
case 1: modelo=1; break;
case 2: modelo=2; break;
case 3: modelo=3; break;
}
}

void menu_color(int opcion)


{
switch(opcion){
case 1: glColor3f (1.0, 0.0, 0.0); break;
case 2: glColor3f (0.0, 1.0, 0.0); break;
case 3: glColor3f (0.0, 0.0, 1.0); break;
}
}

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
Laboratorio de Computación Visual 2018 - 2
Manejo de menús jerárquicos con OpenGL

void menu_primi_propia(int opcion)


{
switch(opcion){
case 1: modelo=4; break;
//case 2: modelo=5; break; para el cilindro
}
}

void menu_principal(int opcion)


{
switch(opcion){
//case 1: int i=0;break;
case 4: exit( -1 );
}
}

int main(int argc, char **argv)


{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(500,500);

glutCreateWindow("Modelos Alambricos usando menus jerarquicos con Glut ");

int submenu_glut=glutCreateMenu(menu_glut);
glutAddMenuEntry("cubo",1);
glutAddMenuEntry("Esfera",2);
glutAddMenuEntry("Toroide",3);

int submenu_primi_propia=glutCreateMenu(menu_primi_propia);
glutAddMenuEntry("Estructura",1);
glutAddMenuEntry("Cilindro",2);

int submenu_modelos_alambricos=glutCreateMenu(menu_modelos_alambricos);
glutAddSubMenu("Libreria glut",submenu_glut);
glutAddSubMenu("Libreria propia",submenu_primi_propia);

int submenu_rotaciones=glutCreateMenu(menu_rotaciones);
glutAddMenuEntry("Eje X",1);
glutAddMenuEntry("Eje Y",2);
glutAddMenuEntry("Eje Z",3);

int submenu_color=glutCreateMenu(menu_color);
glutAddMenuEntry("Rojo",1);
glutAddMenuEntry("Verde",2);
glutAddMenuEntry("Azul",3);

int menu=glutCreateMenu(menu_principal);
glutAddSubMenu("Modelos Alambricos",submenu_modelos_alambricos);
glutAddSubMenu("Rotaciones",submenu_rotaciones);
glutAddSubMenu("Colores",submenu_color);
glutAddMenuEntry("Esc",4);

// usaremos el boton derecho del mouse


glutAttachMenu(GLUT_RIGHT_BUTTON);

iniciar();
glutReshapeFunc(myReshape);
glutDisplayFunc(display);
glutIdleFunc(CubeSpin);

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
Laboratorio de Computación Visual 2018 - 2
Manejo de menús jerárquicos con OpenGL

glEnable(GL_DEPTH_TEST);
glutMainLoop();
return 0;
}

4. EJERCICIOS PROPUESTOS

Ejercicio 01:

Modifique el anterior programa modelo insertando menús y ventanas desplegables para que el
usuario pueda cambiar el sentido de la rotación en cada eje para cada grafico (cubo esfera y toroide).

Ejercicio 02:

Modifique el anterior programa (Ejercicio 01) insertando los menús y ventanas desplegables
necesarios de tal manera que además de tener el control de las rotaciones, también se pueda mostrar
otras primitivas geométricas definidas por OpenGL (revise la documentación necesaria, Taller 02).

Ejercicio 03:

Implemente el código necesario para cambiar atributos a una determinada grafica en cualquiera
de los talleres anteriores, estos pueden ser, el color, el grosor del píxel, así como también la
activación de los ejes coordenados o desactivación.

Ejercicio 04:

Implemente el código necesario para mostrar las gráficas de diferentes superficies, las cuáles
puedan ser activadas y desactivadas mediante opciones en un menú jerárquico. Considere como
2 2
mínimo tres superficies diferentes, por ejemplo las gráficas de 𝑧 = 𝑒 −𝑥 −𝑦 , 𝑧 = sen(𝑥) sen(𝑦) ,
y 𝑧 = 𝑥 2 + 𝑦 2 , además de la “silla de montar” y de la “cola de mono”. Como sugerencia, considere
una malla rectangular [−5; 5] × [−5; 5] para los valores de 𝑥 e 𝑦, luego evalúe según la función.
Finalmente puede incorporar transformaciones geométricas en ella.

Observe ambas gráficas, trate de obtener la malla visualmente más apropiada; ambas representan a
la función exponencial. También note que en ambos casos no existe ocultamiento de caras no
visibles.

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
Laboratorio de Computación Visual 2018 - 2
Manejo de menús jerárquicos con OpenGL

Ejercicio 05 (opcional como proyecto):

Una aplicación interesante, sería aquella en la cual el usuario pueda ingresar por consola
(teclado) cualquier función elemental o combinación de ellas, de tal manera que esta se pueda
graficar sin limitación alguna; claro la única restricción sería aquella en donde la función no estuviese
definida y finalmente poder interactuar con ella.

5. REFERENCIAS

 OpenGL Superbible. R. Wright and M. Sweet. Waite Group, Inc 1996

 OpenGL Programming Guide: The Official Guide to Learning OpenGL. D. Sheiner, M.


Wood, J. Neider and T. Davis. Addison Wesley, 2007

 The OpenGL Utility Toolkit (GLUT) Programming Interface (API Version 3). Mark J.
Kilgard, Silicon Graphics, Inc 1996

 The OpenGL Graphics System: A Specification (Version 1.2). Mark segal & Kurt Akeley.
Silicon Graphics, Inc 1998.

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