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();
}