domingo, 30 de septiembre de 2007

Reporte Practica 5 (LABORATORIO)

1.- ¿Qué es diseño orientado a eventos?

La programación dirigida por eventos es un paradigma de programación en el que tanto la estructura como la ejecución de los programas van determinados por los sucesos que ocurran en el sistema o que ellos mismos provoquen.

Para entender la programación dirigida por eventos, podemos oponerla a lo que no es: mientras en la programación secuencial (o estructurada) es el programador el que define cuál va a ser el flujo del programa, en la programación dirigida por eventos será el propio usuario --o lo que sea que esté accionando el programa-- el que dirija el flujo del programa. Aunque en la programación secuencial puede haber intervención de un agente externo al programa, estas intervenciones ocurrirán cuando el programador lo haya determinado, y no en cualquier momento como puede ser en el caso de la programación dirigida por eventos.

El creador de un programa dirigido por eventos debe definir los eventos que manejará su programa y las acciones que se realizarán al producirse cada uno de ellos, lo que se conoce como el manejador de evento. Los eventos soportados estarán determinados por el lenguaje de programación utilizado, por el sistema operativo e incluso por eventos creados por el mismo programador. En la programación dirigid a por eventos, al comenzar la ejecución del programa se llevarán a cabo las inicializaciones y demás código inicial y a continuación el programa quedará bloqueado hasta que se produzca algún evento. Cuando alguno de los eventos esperados por el programa tenga lugar, el programa pasará a ejecutar el código del correspondiente manejador de evento. Por ejemplo, si el evento consiste en que el usuario ha hecho click en el botón de play de un reproductor de películas, se ejecutará el código del manejador de evento, que será el que haga que la película se muestre por pantalla.

2.- ¿Qué utilidad tiene el manejo de eventos en el desarrollo de aplicaciones gráficas?

Dan la libertad al usuario --o lo que sea que esté accionando el programa-- que dirija el flujo del programa

3.- Escriba un programa en el cual: - Al hacer click en la ventana se toman las coordenadas del mouse y se dibuja un punto. - Cada dos puntos acumulados se dibuja una linea. - Cada tres puntos acumulados se dubuja un triángulo. - Cada cuatro puntos acumulados dibuja un cuadrilatero. - Cada 5 o más puntos acumulados, dibuja un poligono. - El botón izquierdo del mouse limpia la ventana. OJO: checar la funcion glViewport para ajustar escalas dentro de la ventana.


Código:

/*laB. COMPUTACION GRÁFICA SEM, 20081
XImena Gutiérrez Vasques... Programa que dibuja figuras geometricas sencillas
según el número de clicks que detecte.. el boton izquierod dibuja, el boton derecho borra*/


#include
#include

float Ang=0;
int contador=0;
void Idle(void);
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}

void processMouse(int boton, int estado, int x, int y) ///manejar al mouse evento dle mouse cuando se da click
{
switch (boton){ //Boton izquierdo
case GLUT_RIGHT_BUTTON:
switch (estado){
case GLUT_DOWN: //al presionarlo se reinicia el contador de clicks, se borra la pantalla
contador=0;
glutPostRedisplay ();
break;
}
break;
case GLUT_LEFT_BUTTON:// Boton derecho
switch (estado){
case GLUT_DOWN: // Al presionarlo imprime las coordenadas y dibuja una figura según el num. de clicks
printf("Posicion X: %d Posicion Y: %d",x,y);

contador++;

glutPostRedisplay ();

break;

}

break;
}

}


void display(void)
{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glColor3f (1.0, 0.0, 0.0); /* clear the matrix */

gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glScalef (1,1,1); /* modeling transformation */


if (contador==1) //1 click, dibuja un punto
{

glBegin(GL_POINTS);

glVertex2f(2,2) ;
glEnd();
}


if (contador==2) //2 click, dibuja unA LINEA
{

glBegin(GL_LINE_LOOP);
glVertex2f(0,0);
glVertex2f(0,1);


glEnd();

}

if (contador==3) //3 click, dibuja unA TRIANGULO
{
glBegin(GL_LINE_LOOP);
glVertex2f(0,0);

glVertex2f(1,0);

glVertex2f(0.5,1);



glEnd();
}

if (contador==4) //4 click, dibuja un CUADRITO
{
glBegin(GL_LINE_LOOP);
glVertex2f(0,0);
glVertex2f(0,1);
glVertex2f(1,1);
glVertex2f(1,0);

glEnd();
}

if (contador>=5) //5 click, dibuja un POLIGONO
{
glBegin(GL_POLYGON);

glVertex2f(0,0);
glVertex2f(0,1);
glVertex2f(1,3);
glVertex2f(1,0);
glEnd();
}


glutSwapBuffers();
glFlush ();

}

void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
//glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}

/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27: //esc
exit(0);
break;
}
}


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

glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);

glutInitWindowSize (700, 700);

glutInitWindowPosition (100, 100);
glutCreateWindow ("Reporte 5 ...XimenA");
init ();
glutDisplayFunc(display);
// glutDisplayFunc(Render);
//glutIdleFunc(Idle);
glutReshapeFunc(reshape);

//llamadas a eventos para manejar el mouse
glutMouseFunc(processMouse);

glutKeyboardFunc(keyboard);

glutMainLoop();
return 0;
}

void Idle(void)
{
Ang++;
display();
}













miércoles, 26 de septiembre de 2007

Tarea 5 (TEORÍA)

Investigue la expresión matricial de la transformación Window-Viewport




Investigar proyección Ortográfica y de Perspectiva.


proyección ortogonal: Una proyección ortogonal define un volumen de la vista de tipo paralelepipédico tal y como se muestra en la siguiente figura. La principal característica de esta proyección es que el tamaño de los objetos es independiente de la distancia a la que estén del observador, por ejemplo, dos cilindros del mismo tamaño, uno a cinco unidades y el otro a diez unidades de distancia del observador se proyectarán con el mismo tamaño.




proyección ortogonal: La proyección ortogonal no da sensación de profundidad porque el tamaño de los objetos no depende de su distancia al observador. Para conseguir este efecto necesitamos definir una proyección perspectiva. Esta proyección define un volumen de la vista que es una prisma truncado de base rectangular, como el de la siguiente figura


Reporte Practica 4 (LABORATORIO)

1.- Describa las ventajas de construir de manera jerárquica escenas

-AL contruir jerarquicamente, podemos descomponer una escena compleja en objetos sencillos lo que nos permitirá hacer construcciones y operaciones eficientes. Otra ventaja que se puede mencionar es la reutilización de código.

2.-
Escriba un programa que construya de manera jerárquica una escena en la que:

código:

/*Construcción de escena con humanoides y pilar de adoracion
LAb. computación g´rafica, Ximena Gutiérrez Vasques*/


#include
#include

float Ang=0;
void Idle(void);


void reshape(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-12,12, -12, 12, 0.001, 100);
glMatrixMode(GL_MODELVIEW);
}

void cubo(void) //construcción del cubo , cara por cara
{
glBegin(GL_QUADS);

glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(-0.5f,0.5f,0.5f);
glVertex3f(-0.5f,-0.5f,0.5f);
glVertex3f(0.5f,-0.5f,0.5f);

glEnd();
glBegin(GL_QUADS);

glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f( 0.5f,0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);

glEnd();
glBegin(GL_QUADS);

glVertex3f(-0.5f,0.5f,0.5f);
glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,0.5f);

glEnd();
glBegin(GL_QUADS);

glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(0.5f,-0.5f,0.5f);
glVertex3f( 0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,0.5f,-0.5f);
glEnd();
glBegin(GL_QUADS);

glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,0.5f,0.5f);
glVertex3f(0.5f,0.5f,0.5f);
glVertex3f( 0.5f,0.5f,-0.5f);
glEnd();
glBegin(GL_QUADS);

glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,0.5f);
glVertex3f(0.5f,-0.5f,0.5f);

glEnd();
}


void triangulo()
{

glBegin(GL_POLYGON);

glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(-0.5f,0.5f,0.5f);
glVertex3f(-0.5f,-0.5f,0.5f);

glEnd();
}


void columna(void) /*columna de adoracion*/
{
glPushMatrix();
glScalef(2,6,2);
cubo();
glPushMatrix();

}
//cosntruccion jerarquica de humanoides
void palma ()
{
glPushMatrix();
glScalef(2,2,0);
cubo();
glPopMatrix();
}

void dedo (void)
{
glPushMatrix();
glScalef(0.5,0.5,0);
cubo();
glPopMatrix();

glPushMatrix();
glScalef(0.5,0.5,0);
glTranslatef(0,1,0);
cubo();
glPopMatrix();

glPushMatrix();
glScalef(0.5,0.5,0);
glTranslatef(0,2,0);
cubo();
glPopMatrix();
}
void dedoGordo (void) //dedo flexioando de la mano
{
glPushMatrix(); //primera parte
glScalef(0.4,0.6,0);
glRotatef(30,0,0,1);
cubo();
glPopMatrix();

glPushMatrix(); //segunda parte
glRotatef(10,0,0,1);
glScalef(0.4,0.6,0);
glTranslatef(-0.2,1.2,0);
cubo();
glPopMatrix();


glPushMatrix(); //rcera parte
glRotatef(-30,0,0,1);
glScalef(0.4,0.6,0);
glTranslatef(-1.9,2.0,0);
cubo();
glPopMatrix();
}

void manoRobot()
{
glPushMatrix();
palma();
glTranslatef(-0.75,1.25,0);
dedo();
glPopMatrix();

glPushMatrix();
palma();
glTranslatef(-0.25,1.25,0);
dedo();
glPopMatrix();

glPushMatrix();
palma();
glTranslatef(0.25,1.25,0);
dedo();
glPopMatrix();

glPushMatrix();
palma();
glTranslatef(0.75,1.25,0);
dedo();
glPopMatrix();

glPushMatrix();
palma();
glTranslatef(-1.3,-0.75f,0);
dedoGordo();
glPopMatrix();

}

void robot()
{
//construcción de humanoide :
glPushMatrix();
glPushMatrix();// caja central
glScalef(1.2,0.8,0.5);
glColor3f(0,.5,.9);
cubo();


glPushMatrix();//segunda caja central
glScalef(1.2,0.2,0.5);
glColor3f(0,.5,.3);
cubo();
glPopMatrix();


glPushMatrix(); //cabeza
glTranslatef(0.0,1.0,0.0);
glScalef(0.6,0.9,0.8);
glColor3f(0,.5,.2);
cubo();
glPopMatrix();
glPushMatrix(); //brazo der. parte1
glTranslatef(0.8,0.4,0.0);
glScalef(0.7,0.2,0.5);
cubo();
glPushMatrix(); //brazo der. parte 2
glTranslatef(1.0,0.0,0.0);
glScalef(1.0,1.5 ,0.5);
cubo();
glPushMatrix();
glTranslatef(0.8,0.0,0.0);
glScalef(0.8,0.6,0.5);
cubo();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();//brazo izq. parte1
glTranslatef(-0.8,0.4,0.0);
glScalef(0.7,0.2,0.5);
cubo();
glPushMatrix();////brazo der. parte2
glTranslatef(-1.0,0.0,0.0);
glScalef(1.0,1.5,0.5);
cubo();
glPushMatrix();
glTranslatef(-0.8,0.0,0.0);
glScalef( 0.8,0.6,0.5);
cubo();
glPopMatrix();
glPopMatrix();
glPopMatrix();



glPushMatrix();//pie derecho parte 1
glTranslatef(0.35,-0.7,0.0);
glScalef(0.3,0.4,0.5);
cubo();
glPushMatrix();
glTranslatef(0.0,-1.0,0.0); //pie derecho parte 2
glScalef(1.2,1.0,0.5);
cubo();
glPushMatrix();
glTranslatef(0.5,-0.6,0.0); //pie derecho parte 3
glScalef(1.2,0.4,0.5);
cubo();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();//pie izq parte 1
glTranslatef(-0.35,-0.7,0.0);
glScalef(0.3,0.4,0.5);
cubo();
glPushMatrix();
glTranslatef(0.0,-1.0,0.0); //pie izq parte 2
glScalef(1.2,1.0,0.5);
cubo();
glPushMatrix();
glTranslatef(- 0.5,-0.6,0.0); //pie izq parte 3
glScalef(1.2,0.4,0.5);
cubo();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix(); //fin del humanoide

glPopMatrix();
}


void brazoConTenaza(void) //CONSTRUCCION DE BRAZO CON TENAZAS
{
glColor3f(1,0,0);
glPushMatrix();
glPushMatrix();
glRotatef(-30,0,0,1);
glTranslatef(0,1.5,0);
glPushMatrix();
glScalef(0.5,3.0,0.5);
cubo();
glPopMatrix();

glTranslatef(0,1.5,0);
glRotatef(-30,0,0,1);
glTranslatef(0,1,0);

glPushMatrix();
glScalef(0.5,2.0,0.5);
cubo();
glPopMatrix();


glPushMatrix();
glTranslatef(0,2,0);
glRotatef(-30,-4,-2,0);
glScalef(0.2,0.9,0.2);
glColor3f(0,1,0);
cubo();
glPopMatrix();

glTranslatef(.3,2,0);
glRotatef(-30,-4,-2,5);
glScalef(0.2,0.9,0.2);
glColor3f(0,1,0);
cubo();
glPopMatrix();

glPopMatrix();

glPopMatrix();
}


void esferaConTenazas(void) //esfera con muchos brazos de tenazas
{
glPushMatrix();
glutSolidSphere(.6,100,4);
glPopMatrix();

glPushMatrix();
glScalef(0.5,0.5,0.5);
brazoConTenaza();
glPopMatrix();

glPushMatrix();
glTranslatef(0.6,0,0);
glRotatef(-30,0,0,1);
glScalef(0.5,0.5,0.5);
brazoConTenaza();
glPopMatrix();

glPushMatrix();
glTranslatef(-0.6,0,0);
glRotatef(30,0,0,1);
glScalef(0.5,0.5,0.5);
brazoConTenaza();
glPopMatrix();


glPushMatrix();
glTranslatef(.4,-0.5,.3);
glRotatef(-60,0,0,1);
glScalef(0.5,0.5,0.5);
brazoConTenaza();
glPopMatrix();


glPushMatrix();
glTranslatef(-.4,-0.5,.3);
glRotatef(-200,1,0,0);
glRotatef(60,0,0,1);
glScalef(0.5,0.5,0.5);
brazoConTenaza();
glPopMatrix();


}


void escena() //construccion de la escena
{
glPushMatrix(); // piso triangular
glScalef(25,14,19);
glTranslatef(0,0,-.5);
glRotatef(90,1,0,0);
triangulo();
glPopMatrix();



glPushMatrix(); //alto y flaco
glScalef(2,3,1);
glTranslatef(-1.1,0,5);
robot();
glPopMatrix();

glPushMatrix(); //chaparro y regordete
glScalef(1,2,3);
glTranslatef(3,-4,-2);
glRotatef(30,0,1,0);
robot();
glPopMatrix();

glPushMatrix(); //normal
glScalef(2,2,2);
glTranslatef(2,0,-3);
robot();
glPopMatrix();



esferaConTenazas(); //esfera a la que adoran

glPushMatrix(); //pilar de adoracion
glTranslatef(0,-4.7,0);
columna();

glPopMatrix();

}


void display() //llamada de la escena
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0,100,4);
glLoadIdentity();
gluLookAt (6.0, 2.0, 4.0, .0, 0.0, 0.0, 0.0, 1.0, 0.0);
//glRotatef(Ang,0.0f,1.0f,0.0f);

glPushMatrix();
escena();
glPopMatrix();


glFlush();
}





lunes, 24 de septiembre de 2007

Previo 6 (LABORATORIO)

1.- ¿Cómo se dibuja texto con GLUT?

-Se puede utilizar la función de GLUT: glutBitmapCharacter
glutBitmapCharacter renderiza un caracter usando OpenGL. Permite mostrar en la pantalla un caracter con algún tipo de fuente que se le asigne. · void glutBitmapCharacter(void *font, int character); font Tipo de Fuente para el caracter que se va a utilizar character Caracter a renderizar. Las Fuentes disponibles para glutBitmapCharacter son: GLUT_BITMAP_8_BY_13 -misc-fixed-medium-r-normal--13-120-75-75-C-80-iso8859-1 GLUT_BITMAP_9_BY_15 -misc-fixed-medium-r-normal--15-140-75-75-C-90-iso8859-1 GLUT_BITMAP_TIMES_ROMAN_10 -adobe-times-medium-r-normal--10-100-75-75-p-54-iso8859-1 GLUT_BITMAP_TIMES_ROMAN_24
GLUT_BITMAP_HELVETICA_10 -adobe-helvetica-medium-r-normal--10-100-75-75-p-56-iso8859-1 GLUT_BITMAP_HELVETICA_12 -adobe-helvetica-medium-r-normal--12-120-75-75-p-67-iso8859-1 GLUT_BITMAP_HELVETICA_18 -adobe-helvetica-medium-r-normal--18-180-75-75-p-98-iso8859-1 La representación de un caracter que no existe no tiene ningún efecto.


2.- ¿Cambia el dibujo de texto en FreeGLUT y OpenGLUT? ¿Por qué?

Si puede cambiar debido a que OpenGLUT hereda un número muy pequeño de fuentes estándar de FreeGLUT y GLUT. Algunas son "bitmapped" otras son del tipo "stroked". Algunas usan posicionamiento de ancho ajustado, otras no. Las fuentes tipo "stroked" son dibujadas en als coordeandas del modelo del espacio.

Las fuentes son:
GLUT_STROKE_ROMAN (ancho no ajustado)
GLUT_STROKE_MONO_ROMAN (ancho ajsutado)

3.- Cómo funcionan y cuántos son los parametros de los comandos:

glutBitmapCharacter();

void glutBitmapCharacter(void *font, int character)

font Tipo de Fuente para el caracter que se va a utilizar character Caracter a renderizar.
GLUT_BITMAP_8_BY_13 GLUT_BITMAP_9_BY_15 GLUT_BITMAP_TIMES_ROMAN_10 GLUT_BITMAP_TIMES_ROMAN_24 GLUT_BITMAP_HELVETICA_10 GLUT_BITMAP_HELVETICA_12GLUT_BITMAP_HELVETICA_18
void glutStrokeCharacter(void *font, int character);
font Fuente a usar
character Carácter a renderizar

Las Fuentes disponibles para esta función son las siguientes: GLUT_STROKE_ROMAN Roman Simple Espaciada Proporcionadamente. El máximo alto de los caracteres en esta fuente es de 119.05 unidades. GLUT_STROKE_MONO_ROMAN Roman Simple monoespaciada. El máximo alto de los caracteres en esta fuente es de 119.05 unidades. Cada caracter es de 104.76 unidades de ancho.

¿En que se diferencian?
Usando glutStrokeCharacter se pueden aplicar transformaciones a los caracteres


4.-Escriba un programa que dibuje su nombre y numero de cuenta en la pantalla.

Código:

//Declaracion de fuentes
void *font = GLUT_BITMAP_HELVETICA_18;
void *fonts[] =
{
GLUT_BITMAP_9_BY_15,
GLUT_BITMAP_TIMES_ROMAN_10,
GLUT_BITMAP_TIMES_ROMAN_24
};


void output(int x, int y, char *string) //funcion que despliega la cadena
{
int len, i;

glRasterPos2f(x, y);
len = (int) strlen(string);
for (i = 0; i <>
glutBitmapCharacter(font, string[i]);
}
}

void display(void) //desplegado de nombre y numero de cuenta
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0, 0.0, 1.0);
//Aqui cambio el color de la fuente
output(250, 270, "Señora X.");
output(580, 270, "Aki sta el num de cuenta.");
glutSwapBuffers();
}

void
reshape(int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, w, h, 0);
glMatrixMode(GL_MODELVIEW);
}

int
main(int argc, char **argv)
{
int i, msg_submenu, color_submenu;

glutInit(&argc, argv);
for (i = 1; i <>
if (!strcmp(argv[i], "-mono")) {
font = GLUT_BITMAP_9_BY_15;
}
}
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(800, 600);
glutInitWindowPosition (50, 100);
glutCreateWindow("Previo 6");
glClearColor(0.0, 0.0, 0.0, 1.0);
glutDisplayFunc(display);
glutReshapeFunc(reshape);

glutMainLoop();
return 0;
}

martes, 18 de septiembre de 2007

Previo 5 (LABORATORIO)

1.- Escriba una aplicación que usando la librería gluut detecte que se ha realizado un click con el botón derecho del mouse sobre la ventana principal e imprima las coordenadas del mouse en la salida estándar.

-cuando se haga click con el botón izquierdo, cierre la aplicación. Nota: usar getMopuseFunc()

código:

void Idle(void);
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}

void processMouse(int boton, int estado, int x, int y) ///manejar al mouse evento dle mouse cuando se da click
{
switch (boton){ //Boton izquierdo
case GLUT_LEFT_BUTTON:
switch (estado){
case GLUT_DOWN: //al presionarlo se sale de la aplicacion
exit(0);
break;
}
break;
case GLUT_RIGHT_BUTTON:// Boton derecho
switch (estado){
case GLUT_DOWN: // Al presionarlo imprime las coordenadas
printf("Posicion X: %d Posicion Y: %d",x,y);
break;

}
break;
}
glutPostRedisplay ();
}

void display(void) //no se dibuja nada
{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();

glutSwapBuffers();
glFlush ();

}

void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
//glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}

/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27: //esc
exit(0);
break;
}
}

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

glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);

glutInitWindowSize (700, 700);

glutInitWindowPosition (100, 100);
glutCreateWindow ("0");
init ();
glutDisplayFunc(display);
// glutDisplayFunc(Render);
//glutIdleFunc(Idle);
glutReshapeFunc(reshape);

//llamadas a eventos para manejar el mouse, en est eprograma solo s eusa la primera
glutMouseFunc(processMouse);

glutMotionFunc(processMouseActiveMotion);
glutPassiveMotionFunc(processMousePassiveMotion);
glutEntryFunc(processMouseEntry);
glutKeyboardFunc(keyboard);



glutMainLoop();
return 0;
}

void Idle(void)
{
Ang++;
display();
}

2.- Escriba una aplicación que cada 5 segundos abra una nueva ventana y como título ponga en tiempo en que se creó.

Al apretar el botón izquierdo del mouse, para le contador

Al apretar el botón derecho reinicia el contador

Al apretar la tecla ESC cierra kla palicacion

Nota:usar glutimerfunc glutmousefunc y glutkeyboardfuunc

Código:

char buffer [30];
int titulo=1;
int contador=0;
int bandera=0;
void Idle(void);
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}

void processMouse(int boton, int estado, int x, int y) ///manejar al mouse evento dle mouse cuando se da click
{
switch (boton){ //Boton izquierdo
case GLUT_LEFT_BUTTON:
switch (estado){
case GLUT_DOWN: //al presionarlo se para el contador

bandera=1; //para parar el contador
break;
}
break;
case GLUT_RIGHT_BUTTON:// Boton derecho
switch (estado){
case GLUT_DOWN: // Al presionarlo imprime las coordenadas
printf("Posicion X: %d Posicion Y: %d",x,y);
contador=0; //al presioanrlo se resetea el contador
bandera=0; //al presioanrlo se inicia el contador si e sque estaba detenido
break;

}
break;
}
glutPostRedisplay ();
}

void display(void)
{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glutSwapBuffers();
glFlush ();

}

void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
//glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}

/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27: //esc
exit(0);
break;
}
}

void TimerFunction()
{
if (bandera==1) //si dan click izquierdo se detiene no hace nada (detiene el contador)
{
}
else{
contador=contador+5000; //se incremeenta el contador cada 5 seg
glutInitWindowPosition(200,200);
glutReshapeFunc(reshape);
glutCreateWindow(itoa(contador,buffer,10)); //la nueva ventana lleva el nombre del contador
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(processMouse); //para que detecte botones del mouse
glutKeyboardFunc(keyboard); //para que detecte teclado
}
//printf("contador:%d",contador);
glutTimerFunc(5000, TimerFunction, 28317); //llamadaa recursiva a la funcion
}

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

glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);

glutInitWindowSize (700, 700);

glutInitWindowPosition (100, 100);
glutCreateWindow ("0");
init ();
glutDisplayFunc(display);
// glutDisplayFunc(Render);
//glutIdleFunc(Idle);
glutReshapeFunc(reshape);

//llamadas a eventos para manejar el mouse, en est eprograma solo s eusa la primera
glutMouseFunc(processMouse);

glutMotionFunc(processMouseActiveMotion);
glutPassiveMotionFunc(processMousePassiveMotion);
glutEntryFunc(processMouseEntry);
glutKeyboardFunc(keyboard);

glutTimerFunc(5000, TimerFunction, 28317);

glutMainLoop();
return 0;
}


3.- ¿qué comando para manejo de eventos nos proporciona GLUT? Describa cada uno de estos

  • void glutButtonBoxFunc (void (*func)(int button, int state)): el glutButtonBoxFunc fija el servicio repetido del botón de la caja del dial y del botón para la ventana actual.

    glutButtonBoxFunc


  • void glutDialsFunc (void (*func)(int dial, int value)): el glutDialsFunc fija el servicio repetido de los diales de la caja del dial y del botón para la ventana actual.

  • void glutDisplayFunc (void (*func)(void)): el glutDisplayFunc fija el servicio repetido de la exhibición para la ventana actual.

  • void glutEntryFunc (void (*func)(int state)) el glutEntryFunc fija el ratón entra/el servicio repetido de la licencia para la ventana actual.

  • void glutIdleFunc (void (*func)(void)) el glutIdleFunc fija el servicio repetido ocioso global.

  • void glutKeyboardFunc (void (*func)(unsigned char key, int x, int y)) el glutKeyboardFunc fija el servicio repetido del teclado para la ventana actual.

  • void glutMenuStatusFunc (void (*func)(int status, int x, int y)) fija el servicio repetido global del estado del menú. glutMenuStatusFunc

  • void glutMotionFunc (void (*func)(int x, int y)) :el glutMotionFunc y el glutPassiveMotionFunc fijaron el movimiento y los servicios repetidos pasivos del movimiento respectivamente para la ventana actual.

  • void glutMouseFunc (void (*func)(int button, int state, int x, int y)) el glutMouseFunc fija el servicio repetido del ratón para la ventana actual.

  • void glutOverlayDisplayFunc (void (*func)(void)): el glutOverlayDisplayFunc fija el servicio repetido de la exhibición del recubrimiento para la ventana actual.

  • void glutReshapeFunc (void (*func)(int width, int height)): el glutReshapeFunc fija el servicio repetido de la nueva formación para la ventana actual.

  • void glutSpaceballButtonFunc (void (*func)(int button, int state)): el glutSpaceballButtonFunc fija el servicio repetido del botón de Spaceball para la ventana actual.

  • void glutSpaceballMotionFunc (void (*func)(int x, int y, int z)): el glutSpaceballMotionFunc fija el servicio repetido del movimiento de Spaceball para la ventana actual.

  • void glutSpaceballRotateFunc (void (*func)(int x, int y, int z)):el glutSpaceballRotateFunc fija el servicio repetido de la rotación de Spaceball para la ventana actual.

  • void glutSpecialFunc (void (*func)(int key, int x, int y)):el glutSpecialFunc fija el servicio repetido especial del teclado para la ventana actual.

  • void glutTabletButtonFunc (void (*func)(int button, int state, int x, int y)): el glutTabletButtonFunc fija el servicio repetido especial del teclado para la ventana actual.

  • void glutTabletMotionFunc (void (*func)(int x, int y)): el glutTabletMotionFunc fija el servicio repetido especial del teclado para la ventana actual.

  • void glutTimerFunc (unsigned int msecs, void (*func)(int value), value): el glutTimerFunc coloca un servicio repetido del contador de tiempo que se accionará en un número especificado de
  • milisegundos.

  • void glutVisibilityFunc (void (*func)(int state)): glutVisibilityFunc dispone la función de visibilidad dentro de la ventana actual. Esta función es llamada cuando la visibilidad en una ventana ha cambiado. El parámetro estado puede ser GLUT_NOT_VISIBLE o GLUT_VISIBLE dependiendo en la la visibilidad actual de la ventana.

domingo, 16 de septiembre de 2007

Previo 4 (LABORATORIO)

1 ¿Qué es una escena?
-Una escena se puede entender como composiciones geométricas en la cual intervienen varios objetos predefinidos.

2,.-¿Cómo podemos definir una escena jerarquicamente?
-Realizando un desglose de todas las partes que conforman la escena (construir el árbol del modelo) definiendo todos los componentes que forman a cada objeto.

3.-Describa el funcionamiento y parámetros de la función
glutSwapBuffers()
glutKeyboardFunc()
glutIdleFunc()

glutSwapBuffers()
Realiza un intercambio de buffer en la capa en uso para la ventana actual. Específicamente, hace
que el contenido del buffer trasero de la capa en uso se convierta en contenido del buffer frontal.
En este paso el contenido del buffer trasero se considera cono undefined o indefinido. La
actualización usualmente se realiza durante el re-trazado vertical del monitor, en vez de ser
realizado inmediatamente después de llamar a la función glutSwapBuffers. Antes de retornar,
esta función realiza un glFlush. Los comandos subsecuentes de OpenGL pueden ser ordenados
inmediatamente después de llamar a la función, pero no son ejecutados hasta que el intercambio
de buffers se complete.

glutKeyboardFunc()

Dispone la función de teclado para la ventana actual. Cuando el usuario teclea en la ventana,
cada tecla presionada genera un carácter ASCII el cual generará una función de teclado. El
parámetro tecla es el carácter ASCII generado. El estado de teclas modificadoras como Shift no
pueden ser determinadas directamente; su único efecto será al regresar un dato ASCII los
parámetros x y y indican la posición de mouse en coordenadas relativas dentro de la ventana
cuando la tecla fue presionada. Cuando una nueva ventana es creada, no hay ninguna función de
teclado asignada, y todos los caracteres ASCII creados en la ventana serán ignorados.

glutIdleFunc()

Coloca el callback de inactividad global para ser func para que así un programa GLUT pueda
realizar procesos continuos de animación cuando el los eventos de sistema de ventana no estén
siendo recibidos. Si se habilita, el callback de inactividad se llama continuamente cuando no
haya eventos recibidos. La rutina de callback no tiene parámetros. La ventana actual y el menú
actual no serán cambiados antes del callback de inactividad. Los programas con ventanas o
menús múltiples deben colocar explícitamente la ventana y/o el menú actual y no deberán confiar en su configuración actual.

4.-¿Que es el doble buffer (buffer doble)? ¿Para qué sirve? ¿Como se declara con GLUT?
El buffer doble nos permite terminar de dibujar antes de que nuestra imagen sea enviada a la pantalla, previniendo el parpadeo. Es necesario definir nuestra ventana con doble buffer, esto se logra reemplazando los parámetros
de glutInitDisplayMode por GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB

5. ¿Que es un "function callback" (llamada a función) Pista: Sirve para manejos de eventos.
Una función callback esuna función que el programa automaticamente llama en caso de que suceda algún evento en específico, por ejemplo operaciones con el teclado, mouse, cambio del tamaño de la ventana. Ejemplos de funciones callback importantes:

glutKeyboardFunc()
glutMouseFunc()
glutReshapeFunc()
glutDisplayFunc()
glutIdleFunc()
glutTimerFunc()


6. Escriba código que cada que detecte un evento de teclado (glutKeyboardFunc()).
Al apretar "a" incremente el valor de una variable global float fHombro
Al apretar "A" decremente el valor de fHombro
Al apretar "b" incremente el valor de una variable global float fcodo
Al apretar "B" decremente el valor de fcodo
Al apretar "c" incremente el valor de una variable global float fnudillo
Al apretar "C" decremente el valor de fnudillo.
Y después redibuje la pantalla mostrando el brazo robot con tenazas actualizado con los
nuevos valores.
Nota: Usar doble buffer.


Código:

/*LAboratorio de computación gráfica sem 20081
Ximena gutiérrez VAsques,
Porgrama que mueve un brazo de robot:
con A/a: se mueve el hombro
con B/b: el codo
con c/C : las tenazas*/


#include

#include

float Ang=0;
float fNudillo=-30; //variables globales que iran cambiando, se inicializan con 30 grados
float fCodo=-30;
float fHombro=-30;

void Idle(void);
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}


void cubo(void) //construcción del cubo , cara por cara
{
glBegin(GL_LINE_LOOP);

glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(-0.5f,0.5f,0.5f);
glVertex3f(-0.5f,-0.5f,0.5f);
glVertex3f(0.5f,-0.5f,0.5f);

glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f( 0.5f,0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);

glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(-0.5f,0.5f,0.5f);
glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,0.5f);

glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(0.5f,-0.5f,0.5f);
glVertex3f( 0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,0.5f,-0.5f);
glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,0.5f,0.5f);
glVertex3f(0.5f,0.5f,0.5f);
glVertex3f( 0.5f,0.5f,-0.5f);
glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,0.5f);
glVertex3f(0.5f,-0.5f,0.5f);

glEnd();
}


void brazoConTenaza(void) //CONSTRUCCION DE BRAZO CON TENAZAS
{
glColor3f(1,0,0);
glPushMatrix();
glPushMatrix();
glRotatef(fHombro,0,0,1); //va cambiando el grado de rotacion
glTranslatef(0,1.5,0);
glPushMatrix();
glScalef(0.5,3.0,0.5);
cubo();
glPopMatrix();

glTranslatef(0,1.5,0);
glRotatef(fCodo,-4,-2,0); //va cambiando el grado de rotacion
glTranslatef(0,1,0);

glPushMatrix();
glScalef(0.5,2.0,0.5);
cubo();
glPopMatrix();


glPushMatrix();
glTranslatef(0,2,0);
glRotatef(fNudillo,-4,-2,0); //va cambiando el grado de rotacion
glScalef(0.2,0.9,0.2);
glColor3f(0,1,0);
cubo();
glPopMatrix();

glTranslatef(.3,2,0);
glRotatef(fNudillo,-4,-2,5); //va cambiando el grado de rotacion
glScalef(0.2,0.9,0.2);
glColor3f(0,1,0);
cubo();
glPopMatrix();

glPopMatrix();

glPopMatrix();
}



void display(void) //llamada al brazo de robot
{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glColor3f (1.0, 0.0, 0.0); /* clear the matrix */

gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glScalef(0.5,0.5,0.5);
glPushMatrix();
brazoConTenaza();
glPopMatrix();

glutSwapBuffers();
glFlush ();

}

void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
//glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}

/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27: //esc
exit(0);
break;

case 'a': //teclas que se utilizan para mover el brazo
fHombro++;
glutPostRedisplay();
break;

case 'A':
fHombro--;
glutPostRedisplay();
break;

case 'b':
fCodo++;
glutPostRedisplay();
break;

case 'B':
fCodo--;
glutPostRedisplay();
break;

case 'c':
fNudillo++;
glutPostRedisplay();
break;

case 'C':
fNudillo--;
glutPostRedisplay();
break;

}
}


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

glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);

glutInitWindowSize (700, 700);

glutInitWindowPosition (100, 100);
glutCreateWindow ("previo 4...eventos con teclado..XImeNA");
init ();
glutDisplayFunc(display);
// glutDisplayFunc(Render);
//glutIdleFunc(Idle);
glutReshapeFunc(reshape);

glutKeyboardFunc(keyboard); //manejo del teclado

glutMainLoop();
return 0;
}

void Idle(void)
{
Ang++;
display();
}



sábado, 15 de septiembre de 2007

Tarea 4 (TEORÍA)

  • Cödigo del modelado del puerco en glut:
//MODELADO DE CADA PARTE\\\

void torax() //cilindro central
{
glPushMatrix();
glRotatef(90, 0.0f, 1.0f, 0.0f);
glTranslatef(0.0f, 0.0f, -4.0f);
cilindro();
glPopMatrix();
}


void cuadro()
{
glBegin(GL_LINE_LOOP);
glVertex3f(-0.5,0.5,-0.5);
glVertex3f(-0.5,-0.5,-0.5);
glVertex3f(0.5,-0.5,-0.5);
glVertex3f(0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,-0.5);
glEnd();
}


void cilindro()
{
glPushMatrix();
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_FILL);
gluCylinder(qobj, 3.0, 3.0, 8.0, 25, 25);
glPopMatrix();
}



void pesuna()
{
glPushMatrix();
glRotatef(90, 0.0f, 0.0f, 1.0f);
glPushMatrix();
glRotatef(90, 0.0f, 1.0f, 0.0f);
glTranslatef(0.0f, 0.0f, 0.0f);
glScalef(0.28f, 0.28f, 0.06f);
cilindro();
glPopMatrix();
glPopMatrix();
}

void patas() //las 4 patas de harry-Plopper
{
glPushMatrix();
glTranslatef(-2.5f, -4.0f, 1.0f);
glPushMatrix();
glRotatef(90, 0.0f, 0.0f, 1.0f);
glPushMatrix();
glRotatef(90, 0.0f, 1.0f, 0.0f);
glTranslatef(0.0f, 0.0f, 0.0f);
glScalef(0.4f, 0.4f, 0.25f);
cilindro();
glPopMatrix();
glPopMatrix();
glPopMatrix();


glPushMatrix();
glTranslatef(2.5f, -4.0f, 1.0f);
glPushMatrix();
glRotatef(90, 0.0f, 0.0f, 1.0f);
glPushMatrix();
glRotatef(90, 0.0f, 1.0f, 0.0f);
glTranslatef(0.0f, 0.0f, 0.0f);
glScalef(0.4f, 0.4f, 0.25f);
cilindro();
glPopMatrix();
glPopMatrix();
glPopMatrix();

glPushMatrix();
glTranslatef(-2.5f, -4.0f, -1.0f);
glPushMatrix();
glRotatef(90, 0.0f, 0.0f, 1.0f);
glPushMatrix();
glRotatef(90, 0.0f, 1.0f, 0.0f);
glTranslatef(0.0f, 0.0f, 0.0f);
glScalef(0.4f, 0.4f, 0.25f);
cilindro();
glPopMatrix();
glPopMatrix();
glPopMatrix();


glPushMatrix();
glTranslatef(2.5f, -4.0f, -1.0f);
glPushMatrix();
glRotatef(90, 0.0f, 0.0f, 1.0f);
glPushMatrix();
glRotatef(90, 0.0f, 1.0f, 0.0f);
glTranslatef(0.0f, 0.0f, 0.0f);
glScalef(0.4f, 0.4f, 0.25f);
cilindro();
glPopMatrix();
glPopMatrix();
glPopMatrix();
}


void pezunas() //las 4 pezuñas
{
glPushMatrix();
glTranslatef(-2.5f, -4.5f, 1.0f);
pesuna();
glPopMatrix();
glPushMatrix();
glTranslatef(2.5f, -4.5f, 1.0f);
pesuna();
glPopMatrix();
glPushMatrix();
glTranslatef(-2.5f, -4.5f, -1.0f);
pesuna();
glPopMatrix();
glPushMatrix();
glTranslatef(2.5f, -4.5f, -1.0f);
pesuna();
glPopMatrix();
}
void rabito()
{
glPushMatrix();
glTranslatef(-6.0f, 0.0f, -1.0f);
glRotatef(90, 0.0f, 1.0f, 0.0f);
glPushMatrix();
glTranslatef(0.0f, 0.0f, 0.0f);
glScalef(0.18f, 0.18f, 0.25f);
cilindro();
glPopMatrix();
glPopMatrix();
}
void cabeza()
{
glPushMatrix();
glTranslatef(5.5,0.0,0.0);
glPushMatrix();
glTranslatef(0.0,0.0,0.0);
glutSolidSphere(2.3, 20, 20);
glPopMatrix();
glPopMatrix();
}
void trompa()
{
glPushMatrix();
glTranslatef(7.2f, -1.2f, 0.0f);
glRotatef(90, 0.0f, 1.0f, 0.0f);
glPushMatrix();
glTranslatef(0.0f, 0.0f, 0.0f);
glScalef(0.35f, 0.35f, 0.10f);
cilindro();
glPopMatrix();
glPopMatrix();
}
void ojos()
{
glPushMatrix();
glTranslatef(7.7,0.3,-0.8);
glPushMatrix();
glTranslatef(0.0,0.0,0.0);
glutWireSphere(0.7, 30, 30);
glPopMatrix();
glPopMatrix();
glPushMatrix();
glTranslatef(7.7,0.3,0.8);
glPushMatrix();
glTranslatef(0.0,0.0,0.0);
glutWireSphere(0.7, 30, 30);
glPopMatrix();
glPopMatrix();
}
void fleco()
{
glPushMatrix();
glTranslatef(7.7,1.8,0.0);
glPushMatrix();
glScalef(2.4f, 0.5f, 0.8f);
glutSolidCube(1.0);
glPopMatrix();
glPopMatrix();
}
void orejas()
{
glPushMatrix();
glTranslatef(5.2,1.4,1.8);
glRotatef(-45, 1.0f, 0.0f, 0.0f);
glutSolidCone(0.8, 1.5,20,20);
glPopMatrix();
glPushMatrix();
glTranslatef(5.2,1.4,-1.8);
glRotatef(-135, 1.0f, 0.0f, 0.0f);
glutSolidCone(0.8, 1.5,20,20);
glPopMatrix();
}

//dESPLIEGUE Y CONSTRUCCION DEL PUERCO\\

void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1,1,0);
glLoadIdentity();
gluLookAt (6.0, 2.0, 4.0, .0, 0.0, 0.0, 0.0, 1.0, 0.0);
glRotatef(Ang,0.0f,1.0f,0.0f);


/*COnstruccion del puerco*/

glPushMatrix();
torax();
glPushMatrix();
glColor3f(1,1,1);
cabeza();
glPushMatrix();
glColor3f(1,0,1);
trompa();
glPopMatrix();
glPushMatrix();
orejas();
glPushMatrix();
glPushMatrix();
ojos();
glPopMatrix();
glPushMatrix();
glColor3f(1,0,0);
fleco();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glColor3f(0.9,0.5,0.4);
rabito();
glPopMatrix();
glPushMatrix();
patas();
glPushMatrix();
pezunas();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glFlush();
}
void init()
{
glClearColor(0,0,0,0);
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(100, 100);
glutInitWindowSize(500, 500);
glutCreateWindow("HArry Plopper");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(Idle);
glutMainLoop();
return 0;
}






martes, 11 de septiembre de 2007

Reporte de la práctica 3

1.- Escriba el código para dibuajr un mano:

void cubo(void) //construcción del cubo , cara por cara
{
glBegin(GL_LINE_LOOP);

glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(-0.5f,0.5f,0.5f);
glVertex3f(-0.5f,-0.5f,0.5f);
glVertex3f(0.5f,-0.5f,0.5f);

glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f( 0.5f,0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);

glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(-0.5f,0.5f,0.5f);
glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,0.5f);

glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(0.5f,-0.5f,0.5f);
glVertex3f( 0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,0.5f,-0.5f);
glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,0.5f,0.5f);
glVertex3f(0.5f,0.5f,0.5f);
glVertex3f( 0.5f,0.5f,-0.5f);
glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,0.5f);
glVertex3f(0.5f,-0.5f,0.5f);

glEnd();
}

void palma (void)
{
glPushMatrix();
glScalef(2,2,0);
cubo();
glPopMatrix();
}
void dedo (void)
{
glPushMatrix();
glScalef(0.5,0.5,0);
cubo();
glPopMatrix();

glPushMatrix();
glScalef(0.5,0.5,0);
glTranslatef(0,1,0);
cubo();
glPopMatrix();

glPushMatrix();
glScalef(0.5,0.5,0);
glTranslatef(0,2,0);
cubo();
glPopMatrix();
}
void dedoGordo (void) //dedo flexioando de la mano
{
glPushMatrix(); //primera parte
glScalef(0.4,0.6,0);
glRotatef(30,0,0,1);
cubo();
glPopMatrix();

glPushMatrix(); //segunda parte
glRotatef(10,0,0,1);
glScalef(0.4,0.6,0);
glTranslatef(-0.2,1.2,0);
cubo();
glPopMatrix();


glPushMatrix(); //terrcera parte
glRotatef(-30,0,0,1);
glScalef(0.4,0.6,0);
glTranslatef(-1.9,2.0,0);
cubo();
glPopMatrix();
}

// Funcion que dibuja la mano:
void manoRobot()
{
glPushMatrix();
palma();
glTranslatef(-0.75,1.25,0);
dedo();
glPopMatrix();

glPushMatrix();
palma();
glTranslatef(-0.25,1.25,0);
dedo();
glPopMatrix();

glPushMatrix();
palma();
glTranslatef(0.25,1.25,0);
dedo();
glPopMatrix();

glPushMatrix();
palma();
glTranslatef(0.75,1.25,0);
dedo();
glPopMatrix();

glPushMatrix();
palma();
glTranslatef(-1.3,-0.75f,0);
dedoGordo();
glPopMatrix();

}

2.- El código de brazoRobotConTenazas() parametricelo para que pueda modificarse la apertura de las articualciones, Por ejemplo
brazoRobotConTenazas(float fHombro,fCodo,fNudillo)


void brazoRobotConTenazas(float fhombro, float fcodo, float fnudillo)
{
glPushMatrix();
glRotatef(-fhombro,0,0,1);
glTranslatef(0,1.5,0);
glPushMatrix();
glScalef(0.5,3.0,0.5);
cubo();
glPopMatrix();

glTranslatef(0,1.5,0);
glRotatef(-fcodo,0,0,1);
glTranslatef(0,1,0);

glPushMatrix();
glScalef(0.5,2.0,0.5);
cubo();
glPopMatrix();


glPushMatrix();
glTranslatef(0,2,0);
glRotatef(-fnudillo,-4,-2,0);
glScalef(0.2,0.9,0.2);
glColor3f(0,1,0);
cubo();
glPopMatrix();

glTranslatef(.3,2,0);
glRotatef(-fnudillo,-4,-2,5);
glScalef(0.2,0.9,0.2);
glColor3f(0,1,0);
cubo();
glPopMatrix();

glPopMatrix();

}



3.-Agregue la mano al modelo del humanoide, creando uan nueva función humanoideConManos()

void cubo(void) //construcción del cubo , cara por cara
{
glBegin(GL_LINE_LOOP);

glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(-0.5f,0.5f,0.5f);
glVertex3f(-0.5f,-0.5f,0.5f);
glVertex3f(0.5f,-0.5f,0.5f);

glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f( 0.5f,0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);

glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(-0.5f,0.5f,0.5f);
glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,0.5f);

glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(0.5f,-0.5f,0.5f);
glVertex3f( 0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,0.5f,-0.5f);
glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,0.5f,0.5f);
glVertex3f(0.5f,0.5f,0.5f);
glVertex3f( 0.5f,0.5f,-0.5f);
glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,0.5f);
glVertex3f(0.5f,-0.5f,0.5f);

glEnd();
}



void dedo (void)
{
glPushMatrix();
glScalef(0.5,0.5,0);
cubo();
glPopMatrix();

glPushMatrix();
glScalef(0.5,0.5,0);
glTranslatef(0,1,0);
cubo();
glPopMatrix();

glPushMatrix();
glScalef(0.5,0.5,0);
glTranslatef(0,2,0);
cubo();
glPopMatrix();
}
void dedoGordo (void) //dedo flexioando de la mano
{
glPushMatrix(); //primera parte
glScalef(0.4,0.6,0);
glRotatef(30,0,0,1);
cubo();
glPopMatrix();

glPushMatrix(); //segunda parte
glRotatef(10,0,0,1);
glScalef(0.4,0.6,0);
glTranslatef(-0.2,1.2,0);
cubo();
glPopMatrix();


glPushMatrix(); //rcera parte
glRotatef(-30,0,0,1);
glScalef(0.4,0.6,0);
glTranslatef(-1.9,2.0,0);
cubo();
glPopMatrix();
}

void manoRobot()
{
glPushMatrix();
palma();
glTranslatef(-0.75,1.25,0);
dedo();
glPopMatrix();

glPushMatrix();
palma();
glTranslatef(-0.25,1.25,0);
dedo();
glPopMatrix();

glPushMatrix();
palma();
glTranslatef(0.25,1.25,0);
dedo();
glPopMatrix();

glPushMatrix();
palma();
glTranslatef(0.75,1.25,0);
dedo();
glPopMatrix();

glPushMatrix();
palma();
glTranslatef(-1.3,-0.75f,0);
dedoGordo();
glPopMatrix();

}

void robot()
{
//construcción de humanoide :

glPushMatrix();// caja central
glScalef(1.2,0.8,0.5);
cubo();


glPushMatrix();//segunda caja central
glScalef(1.2,0.2,0.5);
cubo();
glPopMatrix();


glPushMatrix(); //cabeza
glTranslatef(0.0,1.0,0.0);
glScalef(0.6,0.9,0.8);
cubo();
glPopMatrix();
glPushMatrix(); //brazo der. parte1
glTranslatef(0.8,0.4,0.0);
glScalef(0.7,0.2,0.5);
cubo();
glPushMatrix(); //brazo der. parte 2
glTranslatef(1.0,0.0,0.0);
glScalef(1.0,1.5 ,0.5);
cubo();
glPushMatrix();
glTranslatef(0.8,0.0,0.0);
glScalef(0.8,0.6,0.5);
cubo();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();//brazo izq. parte1
glTranslatef(-0.8,0.4,0.0);
glScalef(0.7,0.2,0.5);
cubo();
glPushMatrix();////brazo der. parte2
glTranslatef(-1.0,0.0,0.0);
glScalef(1.0,1.5,0.5);
cubo();
glPushMatrix();
glTranslatef(-0.8,0.0,0.0);
glScalef( 0.8,0.6,0.5);
cubo();
glPopMatrix();
glPopMatrix();
glPopMatrix();



glPushMatrix();//pie derecho parte 1
glTranslatef(0.35,-0.7,0.0);
glScalef(0.3,0.4,0.5);
cubo();
glPushMatrix();
glTranslatef(0.0,-1.0,0.0); //pie derecho parte 2
glScalef(1.2,1.0,0.5);
cubo();
glPushMatrix();
glTranslatef(0.5,-0.6,0.0); //pie derecho parte 3
glScalef(1.2,0.4,0.5);
cubo();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();//pie izq parte 1
glTranslatef(-0.35,-0.7,0.0);
glScalef(0.3,0.4,0.5);
cubo();
glPushMatrix();
glTranslatef(0.0,-1.0,0.0); //pie izq parte 2
glScalef(1.2,1.0,0.5);
cubo();
glPushMatrix();
glTranslatef(- 0.5,-0.6,0.0); //pie izq parte 3
glScalef(1.2,0.4,0.5);
cubo();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix(); //fin del humanoide




}


void display(void)
{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
//glColor3f (1.0, 0.0, 0.0); /* clear the matrix */
/* viewing transformation */


gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glScalef (0.5, 0.8, 0.2); /* modeling transformation */

//glRotatef(Ang,0.0f,1.0f,0.0f);


//se manda construye el robot con sus manos;




robot();
glPushMatrix();
glTranslatef(3,0.3,0.0);
glRotatef(-90,0,0,1);
glScalef (0.2, 0.2, 0.0);
manoRobot();
glPopMatrix();

robot();
glPushMatrix();
glTranslatef(-3,0.3,0.0);
glRotatef(-270,0,0,1);
glScalef (0.2, 0.2, 0.0);
manoRobot();
glPopMatrix();


glutSwapBuffers();
glFlush ();

}

lunes, 10 de septiembre de 2007

Tarea 3 (Teoría)

Modelar jerarquicamente la hormiga, construir el árbol del modelo, implementarlo.




Programa que dibuja a la hormiga jerarquicamente en OPenGL:

#include

#include

float Ang=0;
void Idle(void);
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}

void cubo(void) //construcción del cubo , cara por cara
{
glBegin(GL_LINE_LOOP);

glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(-0.5f,0.5f,0.5f);
glVertex3f(-0.5f,-0.5f,0.5f);
glVertex3f(0.5f,-0.5f,0.5f);

glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f( 0.5f,0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);

glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(-0.5f,0.5f,0.5f);
glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,0.5f);

glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(0.5f,-0.5f,0.5f);
glVertex3f( 0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,0.5f,-0.5f);
glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,0.5f,0.5f);
glVertex3f(0.5f,0.5f,0.5f);
glVertex3f( 0.5f,0.5f,-0.5f);
glEnd();
glBegin(GL_LINE_LOOP);

glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,0.5f);
glVertex3f(0.5f,-0.5f,0.5f);

glEnd();
}

void pataHormiga(void)
{
glPushMatrix(); //parte 1
glScalef (0.3, 0.1, 0.3);
cubo();
glPopMatrix();

glPushMatrix(); //parte 2
glTranslatef(0.3,0,0);
glScalef (0.3, 0.1, 0.3);
cubo();
glPopMatrix();

glPushMatrix(); //parte 3
glTranslatef(0.6,0,0);
glScalef (0.3, 0.1, 0.3);
cubo();
glPopMatrix();

glPushMatrix(); //parte 4
glTranslatef(0.9,0,0);
glScalef (0.3, 0.1, 0.3);
cubo();
glPopMatrix();



}







void display(void)
{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
//glColor3f (1.0, 0.0, 0.0); /* clear the matrix */
/* viewing transformation */


gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glScalef (0.5, 0.8, 0.2); /* modeling transformation */


glRotatef(Ang,1.0f,1.0f,1.0f);


glPushMatrix(); //caja central de la hormiga
glScalef (0.8, 0.5, 0.5);
cubo();
glPopMatrix();

glPushMatrix(); //cabeza
glTranslatef(0,0.4,0);
glScalef (0.3, 0.3, 0.5);
cubo();
glPopMatrix();

glPushMatrix(); //torzo
glTranslatef(0,-0.7,0);
glScalef (0.3, 0.8, 0.5);
cubo();
glPopMatrix();

glPushMatrix(); //pata 1 derecha
glTranslatef(0.3,-0.4,0);
pataHormiga();
glPopMatrix();

glPushMatrix(); //pata 1 izq
glTranslatef(-1.2,-0.4,0);
pataHormiga();
glPopMatrix();

glPushMatrix(); //pata 2 derecha
glTranslatef(0.3,-0.6,0);
pataHormiga();
glPopMatrix();

glPushMatrix(); //pata 2 izquierda
glTranslatef(-1.2,-0.6,0);
pataHormiga();
glPopMatrix();

glPushMatrix(); //pata 3 derecha
glTranslatef(0.3,-0.8,0);
pataHormiga();
glPopMatrix();

glPushMatrix(); //pata 3 izquierda
glTranslatef(-1.2,-0.8,0);
pataHormiga();
glPopMatrix();


glPushMatrix(); //caja final de la hormiga
glTranslatef(0,-1.3,0);
glScalef (0.8, 0.4, 0.5);
cubo();
glPopMatrix();







glutSwapBuffers();
glFlush ();

}

void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
//glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}

/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize (700, 700);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
// glutDisplayFunc(Render);
glutIdleFunc(Idle);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

void Idle(void)
{
Ang++;
display();
}