martes, 25 de septiembre de 2007

Previo Práctica 6

1.-¿Cómo se dibuja texto con Glut?¿Cambia el dibujo de texto en FreeGlut y OpenGL?¿por qué?
R: complicada ya que la biblioteca GL sólo proporciona funciones muy primitivas para trazado de bitmaps que obligan a disponer de una librería propia de bitmaps para los caracteres. GLUT va un poco más allá y dispone de unas pocas funciones que permiten renderizar texto en pantalla.

glutBitmapCharacter(void * font, int character)
Permite escribir texto carácter a carácter pasándole sólo la fuente del texto y el carácter a imprimir.
Tipos de fuentes en Glut:

GLUT_BITMAP_9_BY_15
GLUT_BITMAP_8_BY_13

GLUT_BITMAP_TIMES_ROMAN_10

GLUT_BITMAP_TIMES_ROMAN_24

GLUT_BITMAP_HELVETICA_10

GLUT_BITMAP_HELVETICA_12

GLUT_BITMAP_HELVETICA_18

freeglut está pensado para ser un clon en código abierto y 100% compatible de la librería GLUT. GLUT es un entorno de herramientas independiente del sistema de ventanas para escribir programas OpenGL, implementando una API simple de creación de ventanas, que hace muy secillo el aprendizaje y la exploración de la programación OpenGL.

2.-Cómo funcionan y cuáles son los parámetros de los comandos:


glutBitmapCharacter()


Uso
void glutBitmapCharacter(void *font, int character);
font .- Tipo de Fuente para el caracter que se va a utilizar
carácter.- Caracter a renderizar.

Descripción
Renderiza un caracter usando OpenGL. Permite mostrar en la pantalla un caracter con algún tipo de fuente que se le asigne.
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
-adobe-times-medium-r-normal--24-240-75-75-p-124-iso8859-1
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 carácter que no existe no tiene ningún efecto.

glutStrokeCharacter()


Uso
void glutStrokeCharacter(void *font, int character);
font.- Fuente a utilizar
character.- Caracter a renderizar.

Descripción
Renderiza un Stroke Caracter(Caracter de tipo a mano alzada). 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 diferencian?

La diferencia está en el tipo de fuentes que utilizan, unas ya son definidas y en la otra son a mano alzada.

3.-Escriba un programa que dibuje su nombre y número de cuenta en la pantalla.

#include
#include


void *font = GLUT_BITMAP_HELVETICA_18;
void *fonts[] =
{
GLUT_BITMAP_9_BY_15,
GLUT_BITMAP_HELVETICA_18,
GLUT_BITMAP_HELVETICA_18
};

void
output(int x, int y, char *string)
{
int len, i;
glRasterPos2f(x, y);
len = (int) strlen(string);
for (i = 0; i < len; i++) {
glutBitmapCharacter(font, string[i]);
}
}

void
display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 1.0, 1.0);

output(50, 80, "Adrian Quintanar Mondragon");
output(55, 110, "Num. de cuenta 301212735");
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 < argc; i++) {
if (!strcmp(argv[i], "-mono")) {
font = GLUT_BITMAP_9_BY_15;
}
}
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(350, 200);
glutInitWindowPosition (150, 150);
glutCreateWindow("Mi nombre y núm. de cuenta");
glClearColor(0.4, 0.4, 0.4, 0.4);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

Reporte Práctica 5

1.- ¿Que es diseño orientado a objetos?
R: Es el diseño de aplicaciones en las que el flujo de los procesos es determinado por acciones del usuario o mensajes generados por otros programas.

2.-¿Que utilidad tiene el manejo de eventos en el desarrollo de aplicaciones gráficas?
R: Nos permite recibir en tiempo real retroalimentación visual a la cual el usuario responderá con otros eventos. Esto es importante ya que generalmente en el ambiente gráfico el usuario está en constante interacción con este tipo de eventos.

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 dibuja una línea.
-cada tres puntos acumulados dibuja un triángulo.
-cada cuatro puncumulados dibuje un cuadrlátero.
-cada cinco puntos acumulados dibuje un polígono.
-el botón izquierdo del mouse limpia la ventana.

#include
#include
#define maxVer 10

typedef struct { float x; float y; }vertice;
vertice Vertices[maxVer];
static int contador = 0;
static int i,j,k;

void display(void) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
for(i = 0; i <= contador; i++){
glColor3f(0.0,1.0,0.0);
glPointSize( 15 );
glBegin(GL_POINTS);
glVertex2f(Vertices[i].x,Vertices[i].y);
glEnd();
}
if(contador > 0) {
glColor3f(0.0,0.5,0.8);
glLineWidth(5.0);
glBegin(GL_LINE_LOOP);
for(j = 0; j <= contador; j++) {
glVertex2f(Vertices[j].x,Vertices[j].y);
}
glEnd();
}
glPopMatrix();
glutSwapBuffers();
}
void guia(int x,int y){
if(contador < maxVer)
{
Vertices[contador].x = x;
Vertices[contador].y = k-y;
glutPostRedisplay();
}}
void idle(void) {
glutPostRedisplay();
}
void mouse(int boton,int estado,int x,int y) {
if(estado == GLUT_DOWN) {
switch(boton) {
case GLUT_LEFT_BUTTON:
if(contador < maxVer) {
Vertices[contador].x = x;
Vertices[contador].y = k-y;
contador++;
Vertices[contador].x = x;
Vertices[contador].y = k-y;
glutPostRedisplay();
}
break;
case GLUT_RIGHT_BUTTON:
contador = 0;
i=0;
Vertices[contador].x = x;
Vertices[contador].y = k-y;
glutPostRedisplay();
break;
}}}

void reshape ( int width , int height ) {
if (height==0) {
height=1;
}
k = height;
glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, width, 0,height,-10,10);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void init(){
glClearColor(0.5f, 0.7f, 0.9f, 1.0f);
}
int main( int argc, char** argv ) {
glutInit(&argc,argv);
glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH );
glutInitWindowSize(600,600);
glutInitWindowPosition(400,100);
glutCreateWindow("Dibujo de puntos, líneas, triángulos, cuadrados y polígonos" );
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutPassiveMotionFunc(guia);
glutIdleFunc(idle);
glutMainLoop();
return 0;
}





Práctica 5

1.-Compile y ejecute el código del previo.

2.-Escriba un programa en el cuál:
la ventana creada tenga 500 x500 pixeles en sus dimensiones.
-Divida en cuadrantes y :
-al hacer click en el primer cuadrante abre otra ventana. en la salida estándar imprime "primer cuadrante"
-al pasar el mouse por el segundo cuadrante, sin apretar ningún botón de éste imprima en salida estándar
las coordenadas del apuntador del mouse.
-al hacer click en el tercer cuadrantye y mantener presionado el botón derecho, imprima las coordenadas
del punto en donde se empezó a presionar el botón y las coordenadas donde se liberó.
-al hacer click con el botón derecho en el cuarto cudrante empiece un contador que imprima se cuenta en la
salida estándar.

martes, 18 de septiembre de 2007

Previo Práctica 5

1. Escriba una aplicación que usando la libreria GLUT detecte que se ha realizado un click con el boton derecho
del mouse sobre la ventana principal e imprima las coordenadas del mouse en la salida estandar.
Cuando se haga click con el botón izquierdo, cierra la aplicación.
Nota: Usar glutMouseFunc().

#include
#include

void init()
{
glClearColor(0,0,0,0);
glEnable(GL_DEPTH_TEST);

}


void reshape(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0f, (GLfloat)width/(GLfloat)height, 1.0f, 20.0f);

glMatrixMode(GL_MODELVIEW);
}

void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(1,0,0);
glLoadIdentity();


glFlush();

glutSwapBuffers();


}

void idle()
{
display();
}


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

}

void processMouse(int boton, int estado, int x, int y)
{
switch (boton)
{
case GLUT_LEFT_BUTTON:
switch (estado)
{
case GLUT_DOWN:
exit(0);
break;
}

break;

case GLUT_RIGHT_BUTTON:
switch (estado)
{
case GLUT_DOWN:
printf("Posicion X: %d \nPosicion Y: %d \n\n",x,y);
break;

}
break;
}

}


int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowPosition(100, 100);
glutInitWindowSize(300, 200);
glutCreateWindow("Utilización del ratón");

init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);

glutMouseFunc(processMouse);

glutMainLoop();

return 0;
}

2. Escriba una aplicación que cada 5 segundos abra una ventana y como titulo le ponga el tiempo en el que se creó.
Al apretar el boton izquierdo del mouse para el contador.
Al apretar el boton derecho del mouse reinicia el contador.
Al apretar la tecla "ESC" cierra la alicación.
NOta: Usar glutTimerFunc, glutMouseFunc, glutKeyboardFunc.

#include

#include


// Variables globales auxiliares.

int titulo=1;
int contador=0;
int stop=0;
char cadena [50];

void init()
{
glClearColor(0,0,0,0);
glEnable(GL_DEPTH_TEST);

}


void reshape(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0f, (GLfloat)width/(GLfloat)height, 1.0f, 20.0f);

glMatrixMode(GL_MODELVIEW);
}

void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(1,0,0);
glLoadIdentity();

glFlush();

glutSwapBuffers();
}

void idle()
{
display();
}


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

}

void processMouse(int boton, int estado, int x, int y)
{
switch (boton)
{
case GLUT_LEFT_BUTTON:
switch (estado)
{
case GLUT_DOWN:
stop=1;
break;
}
break;

case GLUT_RIGHT_BUTTON:
switch (estado)
{
case GLUT_DOWN:
contador=0;
stop=0;
break;
}
break;
}
glutPostRedisplay ();
}

void TimerFunction()
{
if (stop==1)
{

}

else
{
contador=contador+5000;
glutInitWindowPosition(200,200);
glutReshapeFunc(reshape);
glutCreateWindow(itoa(contador,cadena,10));
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(processMouse);
glutKeyboardFunc(keyboard);
}

glutTimerFunc(5000, TimerFunction, 28317);
}

int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowPosition(100, 100);
glutInitWindowSize(300, 200);
glutCreateWindow("0");

init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);

glutMouseFunc(processMouse);

glutKeyboardFunc(keyboard);

glutTimerFunc(5000, TimerFunction, 28317);

glutMainLoop();

return 0;
}



3. ¿Que comandos para manejo de cuentos nos proporciona GLUT?
Describa cada uno de éstos
glut____Func().
  • 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.
  • 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.


Reporte Práctica 4

1.Describa las ventajas y desventajas de construir de manera jerarquica escenas.
Las escenas jerárquicas son útiles cuando se asocian transformaciones geométricas, ya que sería
demasiado complicado rotar, trasladar y escalar una y otra vez algunos objetos que están
emparentados, en vez de esto es más fácil encontrar la relación que existe entre dichos objetos y
solo tener que hacer pocas transformaciones para lograr los resultados deseados.

2. Escriba un programa que construya de manera jeraquica una escena en la que :
- Hagan 3 humanoides:
- 1 Alto y largo
- 1 normal
- 1 chaparro y regordete.

#include
#include

GLUquadricObj *quadratic;
float ang_hombro;
void reshape(int width, int height){
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);
glMatrixMode(GL_MODELVIEW);
}
void init(){
glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.3f, 0.3f, 0.0f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
}
void cubo(){
glBegin(GL_QUADS);
glColor3f(1.0f,1.0f,1.0f);
glVertex3f( 1.0f, 1.0f,-1.0f);glVertex3f(-1.0f, 1.0f,-1.0f);
glVertex3f(-1.0f, 1.0f, 1.0f);glVertex3f( 1.0f, 1.0f, 1.0f);
glVertex3f( 1.0f,-1.0f, 1.0f);glVertex3f(-1.0f,-1.0f, 1.0f);
glVertex3f(-1.0f,-1.0f,-1.0f);glVertex3f( 1.0f,-1.0f,-1.0f);
glColor3f(1.0f,0.0f,0.0f);
glVertex3f( 1.0f, 1.0f, 1.0f);glVertex3f(-1.0f, 1.0f, 1.0f);
glVertex3f(-1.0f,-1.0f, 1.0f);glVertex3f( 1.0f,-1.0f, 1.0f);
glColor3f(1.0f,0.0f,0.0f);
glVertex3f( 1.0f,-1.0f,-1.0f);glVertex3f(-1.0f,-1.0f,-1.0f);
glVertex3f(-1.0f, 1.0f,-1.0f);glVertex3f( 1.0f, 1.0f,-1.0f);
glColor3f(1.0f,0.0f,0.0f);
glVertex3f(-1.0f, 1.0f, 1.0f);glVertex3f(-1.0f, 1.0f,-1.0f);
glVertex3f(-1.0f,-1.0f,-1.0f);glVertex3f(-1.0f,-1.0f, 1.0f);
glColor3f(1.0f,0.0f,0.0f);
glVertex3f( 1.0f, 1.0f,-1.0f);glVertex3f( 1.0f, 1.0f, 1.0f);
glVertex3f( 1.0f,-1.0f, 1.0f);glVertex3f( 1.0f,-1.0f,-1.0f);
glEnd();
}
void cabeza(){
glPushMatrix();
glColor3f(1.0f,0.64f,0.52f);
glutSolidSphere(1,20,20);
glPopMatrix();
}
void cuello(){
glPushMatrix();
glRotatef(90,1,0,0);
glColor3f(1.0f,0.64f,0.52f);
quadratic=gluNewQuadric();
gluCylinder(quadratic,0.40f,0.40f,0.30,10,10);
glPopMatrix();
}
void dorzo(){
glPushMatrix();
glRotatef(90,1,0,0);
glColor3f(1.0f,0.0f,0.0f);
quadratic=gluNewQuadric();
gluCylinder(quadratic,2.0f,1.5f,4.0,10,10);
glPopMatrix();
}
void hombro(){
glPushMatrix();
glColor3f(1.0f,0.0f,0.0f);
glutSolidSphere(0.6,20,20);
glPopMatrix();
}
void antebrazo(){
glPushMatrix();
glRotatef(90,1,0,0);
glColor3f(1.0f,0.64f,0.52f);
quadratic=gluNewQuadric();
gluCylinder(quadratic,0.6f,0.4f,2.0,10,10);
glPopMatrix();
}
void codo(){
glPushMatrix();
glColor3f(1.0f,0.64f,0.52f);
glutSolidSphere(0.5,20,20);
glPopMatrix();
}
void brazo(){
glPushMatrix();
glRotatef(90,1,0,0);
glColor3f(1.0f,0.64f,0.52f);
quadratic=gluNewQuadric();
gluCylinder(quadratic,0.5f,0.3f,1.5,10,10);
glPopMatrix();
}
void mano(){
glPushMatrix();
glColor3f(1.0f,0.64f,0.52f);
glutSolidSphere(0.6,20,20);
glPopMatrix();
}
void cadera(){
glPushMatrix();
glRotatef(90,0,1,0);
glColor3f(0.0f,0.0f,0.6f);
quadratic=gluNewQuadric();
gluCylinder(quadratic,0.5f,0.5f,3.0,10,10);
glPopMatrix();
}
void muslo(){
glPushMatrix();
glRotatef(90,1,0,0);
glColor3f(0.0f,0.0f,0.6f);
quadratic=gluNewQuadric();
gluCylinder(quadratic,0.8f,0.6f,1.8,10,10);
glPopMatrix();
}
void rodilla(){
glPushMatrix();
glColor3f(0.0f,0.0f,0.6f);
glutSolidSphere(0.7,20,20);
glPopMatrix();
}
void espinilla(){
glPushMatrix();
glRotatef(90,1,0,0);
glColor3f(0.0f,0.0f,0.6f);
quadratic=gluNewQuadric();
gluCylinder(quadratic,0.6f,0.45f,2.0,10,10);
glPopMatrix();
}
void zapato(){
glPushMatrix();
glColor3f(0.8,0.8,0.8);
glScalef(0.4,0.5,1.5);
cubo();
glPopMatrix();
}
void brazo_completo(float ang_hombro){
glPushMatrix();
hombro();
glRotatef(ang_hombro,0,0,1);
glPushMatrix();
antebrazo();
glPushMatrix();
glTranslatef(0.0,-2.0,0.0);
codo();
glPushMatrix();
brazo();
glPushMatrix();
glTranslatef(0.0,-2.1,0.0);
mano();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();
}
void pierna_completa(){
glPushMatrix();
muslo();
glPushMatrix();
glTranslatef(0.0,-2.2,0.0);
rodilla();
glPushMatrix();
glTranslatef(0.0,-0.4,0.0);
espinilla();
glPushMatrix();
glTranslatef(0.0,-2.6,0.5);
zapato();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();
}
void humanoide(){
glPushMatrix();
dorzo();
glPushMatrix();
glPushMatrix();
glTranslatef(0.0,0.25,0.0);
cuello();
glPushMatrix();
glTranslatef(0.0,0.9,0.0);
cabeza();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glTranslatef(2.0,-0.6,0.0);
brazo_completo(25.0);
glPopMatrix();
glPushMatrix();
glTranslatef(-2.0,-0.6,0.0);
brazo_completo(-25.0);
glPopMatrix();
glPushMatrix();
glTranslatef(-1.5,-4.75,0.0);
cadera();
glPushMatrix();
glTranslatef(2.2,-0.5,0.0);
pierna_completa();
glPopMatrix();
glPushMatrix();
glTranslatef(0.7,-0.5,0.0);
pierna_completa();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();
}
void humanoide_1(){
glPushMatrix();
glScalef(0.2,0.2,0.2);
humanoide();
glPopMatrix();
}
void prisma_rectangular(){
glPushMatrix();
glScalef(1.0,2.0,1.0);
glBegin(GL_QUADS);
glColor3f(0.3f,0.3f,0.3f);
glVertex3f( 1.0f, 1.0f,-1.0f);glVertex3f(-1.0f, 1.0f,-1.0f);
glVertex3f(-1.0f, 1.0f, 1.0f);glVertex3f( 1.0f, 1.0f, 1.0f);
glVertex3f( 1.0f,-1.0f, 1.0f);glVertex3f(-1.0f,-1.0f, 1.0f);
glVertex3f(-1.0f,-1.0f,-1.0f);glVertex3f( 1.0f,-1.0f,-1.0f);
glVertex3f( 1.0f, 1.0f, 1.0f);glVertex3f(-1.0f, 1.0f, 1.0f);
glVertex3f(-1.0f,-1.0f, 1.0f);glVertex3f( 1.0f,-1.0f, 1.0f);
glVertex3f( 1.0f,-1.0f,-1.0f);glVertex3f(-1.0f,-1.0f,-1.0f);
glVertex3f(-1.0f, 1.0f,-1.0f);glVertex3f( 1.0f, 1.0f,-1.0f);
glVertex3f(-1.0f, 1.0f, 1.0f);glVertex3f(-1.0f, 1.0f,-1.0f);
glVertex3f(-1.0f,-1.0f,-1.0f);glVertex3f(-1.0f,-1.0f, 1.0f);
glVertex3f( 1.0f, 1.0f,-1.0f);glVertex3f( 1.0f, 1.0f, 1.0f);
glVertex3f( 1.0f,-1.0f, 1.0f);glVertex3f( 1.0f,-1.0f,-1.0f);
glEnd();
glPopMatrix();
}
void esfera(){
glPushMatrix();
glColor3f(0.4f,0.6f,0.9f);
glutSolidSphere(2.0,20,20);
glPopMatrix();
}
void robot_antebrazo(){
glPushMatrix();
glRotatef(90,0,1,0);
glColor3f(1.0f,1.0f,1.0f);
quadratic=gluNewQuadric();
gluCylinder(quadratic,0.6f,0.45f,4.0,10,10);
glPopMatrix();
}
void robot_codo(){
glPushMatrix();
glColor3f(0.4f,0.6f,0.9f);
glutSolidSphere(0.6,20,20);
glPopMatrix();
}
void robot_brazo(){
glPushMatrix();
glRotatef(90,0,1,0);
glColor3f(1.0f,1.0f,1.0f);
quadratic=gluNewQuadric();
gluCylinder(quadratic,0.4f,0.3f,4.0,10,10);
glPopMatrix();
}
void robot_dedo1(){
glPushMatrix();
glRotatef(90,0,1,0);
glColor3f(0.4f,0.6f,0.9f);
quadratic=gluNewQuadric();
gluCylinder(quadratic,0.15f,0.15f,0.8,10,10);
glPopMatrix();
}
void brazo_robot_completo(){
glPushMatrix();
glTranslatef(-5.0f, 0.0f, 0.0f);
glRotatef(-20, 0.0f, 0.0f, 1.0f);
robot_antebrazo();
glPushMatrix();
glTranslatef(3.8f, 0.0f, 0.0f);
glRotatef(0, 0.0f, 0.0f, 1.0f);
robot_codo();
glPushMatrix();
glTranslatef(0.5f, 0.0f, 0.0f);
glRotatef(20, 0.0f, 0.0f, 1.0f);
robot_brazo();
glPushMatrix();
glTranslatef(4.0f, 0.2f, 0.0f);
glRotatef(40, 0.0f, 0.0f, 1.0f);
robot_dedo1();
glPushMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glTranslatef(4.0f, -0.2f, 0.0f);
glRotatef(-40, 0.0f, 0.0f, 1.0f);
robot_dedo1();
glPushMatrix();
glTranslatef(0.8f, 0.0f, 0.0f);
glRotatef(40, 0.0f, 0.0f, 1.0f);
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();
}
void esfera_brazos(){
glPushMatrix();
esfera();
glPushMatrix();
glTranslatef(4.0,0.0,0.0);
glScalef(0.5,0.5,0.5);
brazo_robot_completo();
glPopMatrix();
glPushMatrix();
glTranslatef(-4.0,0.0,0.0);
glRotatef(-180, 0.0f, 1.0f, 0.0f);
glScalef(0.5,0.5,0.5);
brazo_robot_completo();
glPopMatrix();
glPushMatrix();
glTranslatef(0.0,0.0,4.0);
glRotatef(-90, 0.0f, 1.0f, 0.0f);
glScalef(0.5,0.5,0.5);
brazo_robot_completo();
glPopMatrix();
glPushMatrix();
glTranslatef(0.0,0.0,-4.0);
glRotatef(90, 0.0f, 1.0f, 0.0f);
glScalef(0.5,0.5,0.5);
brazo_robot_completo();
glPopMatrix();
glPopMatrix();
}
void triangulo(){
glPushMatrix();
glScalef(10.0,10.0,10.0);
glBegin(GL_TRIANGLES);
glColor3f(0.0f,1.0f,0.0f);
glVertex3f( -1.0f, 0.0f, 0.0f);
glVertex3f(1.0f,0.0f, 0.0f);
glVertex3f( 0.0f,0.0f, -1.71f);
glEnd();
glPopMatrix();
}
void display(){
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt (11.0, 10.0, 1.0, 3.0, 0.0, -10.0, 0.0, 1.0, 0.0);
glTranslatef(0,-3.0,-10.0);
glPushMatrix();
triangulo();
glPopMatrix();
glPushMatrix();
glTranslatef(0,2.25,-6.0);
prisma_rectangular();
glTranslatef(0,2.25,0.0);
esfera_brazos();
glPopMatrix();
glPushMatrix();
glTranslatef(-8.0,2.2,-1.0);
humanoide_1();
glPopMatrix();
glPushMatrix();
glTranslatef(8.0,2.8,-1.0);
glScalef(1.3,1.3,1.3);
humanoide_1();
glPopMatrix();
glPushMatrix();
glTranslatef(0.0,2.2,-15.0);
humanoide_1();
glFlush();
glutSwapBuffers();
}
void idle(){
display();
}
int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(400, 100);
glutInitWindowSize(500, 400);
glutCreateWindow("Escena jerárquica con thulhn");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutMainLoop();
return 0;
}

Práctica 4


1. Complie y corra el código que generó en el cuestionario previo.

#include

GLfloat brazo = 0.0f;
GLfloat antebrazo = 0.0f;
GLfloat dedo1 = 0.0f;
GLfloat dedo2 = 0.0f;

void reshape(int width, int height){
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0f, (GLfloat)width/(GLfloat)height, 1.0f, 20.0f);
glMatrixMode(GL_MODELVIEW);
}

void cuadrado(){
glBegin(GL_LINE_STRIP);
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 cubo(){
cuadrado();
glPushMatrix();
glTranslatef(0.0f, 0.0f, 1.0f);
cuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(-90, 1.0f, 0.0f, 0.0f);
cuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(90, 1.0f, 0.0f, 0.0f);
cuadrado();
glPopMatrix();
}

// antebrazo
void fun_antebrazo(){
glPushMatrix();
glTranslatef(1.0f, 0.0f, 0.0f);
glScalef(2.0f, 2.0f, 1.0f);
cubo();
glPopMatrix();
}
// brazo.
void fun_brazo(){
glPushMatrix();
glTranslatef(2.0f, 0.0f, 0.0f);
glScalef(4.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
}
// dedo.
void fun_dedo(){
glPushMatrix();
glTranslatef(0.5f, 0.0f, 0.0f);
glScalef(1.0f, 0.25f, 1.0f);
cubo();
glPopMatrix();
}
//brazo_robot
void brazo_robot(float antebrazo, float brazo, float dedo1, float dedo2){
glPushMatrix();
glTranslatef(0.0f, 0.0f, 0.0f);
glRotatef(antebrazo, 0.0f, 0.0f, 1.0f);
fun_antebrazo();
glPushMatrix();
glTranslatef(1.7f, 0.0f, 0.0f);
glRotatef(brazo, 0.0f, 0.0f, 1.0f);
fun_brazo();
glPushMatrix();
glTranslatef(3.8f, 0.25f, 0.0f);
glRotatef(dedo1, 0.0f, 0.0f, 1.0f);
fun_dedo();
glPopMatrix();
glPushMatrix();
glTranslatef(3.8f, -0.25f, 0.0f);
glRotatef(dedo2, 0.0f, 0.0f, 1.0f);
fun_dedo();
glPopMatrix();
glPopMatrix();
glPopMatrix();
}

void display(){
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(.9,0.8,0.8);
glLoadIdentity();
gluLookAt (0.0, 1.0, -11.0, 2.0, 0.0, 5.0, 0.0, 2.0, 0.0);
glTranslatef(0.0f, 0.0f, 0.0f);
brazo_robot(antebrazo,brazo,dedo1,dedo2);
glFlush();
glutSwapBuffers();
}
void init(){
glClearColor(0.5,0.2,0.1,0.5);
glEnable(GL_DEPTH_TEST);
}
void idle() {
display();
}
// eventos del teclado.
void keyboard(unsigned char key, int x, int y){
switch(key)
{
case 'a':
antebrazo=antebrazo+1;
reshape(500,500);
break;
case 's':
antebrazo=antebrazo-1;
reshape(500,500);
break;
case 'd':
brazo=brazo+1;
reshape(500,500);
break;
case 'f':
brazo=brazo-1;
reshape(500,500);
break;
case 'g':
dedo1=dedo1+1;
reshape(500,500);
break;
case 'h':
dedo1=dedo1-1;
reshape(500,500);
break;
case 'j':
dedo2=dedo2+1;
reshape(500,500);
break;
case 'k':
dedo2=dedo2-1;
reshape(500,500);
break;
}
}
int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(350, 100);
glutInitWindowSize(300, 300);
glutCreateWindow("Brazo Robot");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}


2. Construya una escena en la cual haga:
- 2 braxoz con teneza
- 2 manos
- 4 cubos
- 3 humanoides
A cada objeto aplique juegos diferentes de transformaciones.

#include

void reshape(int width, int height){
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(55.0f, (GLfloat)width/(GLfloat)height, 0.1, 0);
glMatrixMode(GL_MODELVIEW);
}
void cuadrado(){
glBegin(GL_LINE_STRIP);
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 cubo(){
cuadrado();
glPushMatrix();
glTranslatef(0.0f, 0.0f, 1.0f);
cuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(-90, 1.0f, 0.0f, 0.0f);
cuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(90, 1.0f, 0.0f, 0.0f);
cuadrado();
glPopMatrix();
}
// Partes del Humanoide
void cabeza(){
glPushMatrix();
glTranslatef(0.0f, 6.75f, 0.0f);
glScalef(2.0f, 1.5f, 2.0f);
cubo();
glPopMatrix();
}
void cuello(){
glPushMatrix();
glTranslatef(0.0f, 5.75f, 0.0f);
glScalef(1.0f, 0.5f, 0.5f);
cubo();
glPopMatrix();
}
void torax(){
glPushMatrix();
glTranslatef(0.0f, 4.0f, 0.0f);
glScalef(6.0f, 3.0f, 4.0f);
cubo();
glPopMatrix();
}
void brazos_completos(){
glPushMatrix();
glTranslatef(4.0f, 4.0f, 0.0f);
glScalef(2.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();

glPushMatrix();
glTranslatef(6.0f, 4.0f, 0.0f);
glScalef(2.0f, 1.5f, 1.0f);
cubo();
glPopMatrix();

glPushMatrix();
glTranslatef(7.25f, 4.0f, 0.0f);
glScalef(0.5f, 0.5f, 1.0f);
cubo();
glPopMatrix();

glPushMatrix();
glTranslatef(-4.0f, 4.0f, 0.0f);
glRotatef(180, 0.0f, 0.0f, 1.0f);
glScalef(2.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
// Codo Izquierdo
glPushMatrix();
glTranslatef(-6.0f, 4.0f, 0.0f);
glRotatef(180, 0.0f, 0.0f, 1.0f);
glScalef(2.0f, 1.5f, 1.0f);
cubo();
glPopMatrix();
// Nudillo Izquierdo
glPushMatrix();
glTranslatef(-7.25f, 4.0f, 0.0f);
glRotatef(180, 0.0f, 0.0f, 1.0f);
glScalef(0.5f, 0.5f, 0.5f);
cubo();
glPopMatrix();
}
void piernas_completas()
{
// Muslo Derecho
glPushMatrix();
glTranslatef(2.0f, -1.5f, 0.0f);
glScalef(1.0f, 2.0f, 1.5f);
cubo();
glPopMatrix();
// Muslo Izquierdo
glPushMatrix();
glTranslatef(-2.0f, -1.5f, 0.0f);
glScalef(1.0f, 2.0f, 1.5f);
cubo();
glPopMatrix();
// Pierna Derecha
glPushMatrix();
glTranslatef(2.0f, -4.5f, 0.0f);
glScalef(1.4f, 4.0f, 1.5f);
cubo();
glPopMatrix();
// Pierna Izquierda
glPushMatrix();
glTranslatef(-2.0f, -4.5f, 0.0f);
glScalef(1.4f, 4.0f, 1.5f);
cubo();
glPopMatrix();
// Pie Derecho
glPushMatrix();
glTranslatef(2.0f, -7.25f, 0.0f);
glScalef(2.75f, 1.5f, 2.0f);
cubo();
glPopMatrix();
// Pie Izquierdo
glPushMatrix();
glTranslatef(-2.0f, -7.25f, 0.0f);
glScalef(2.75f, 1.5f, 2.0f);
cubo();
glPopMatrix();
}
void cadera(){
glPushMatrix();
glTranslatef(0.0f, 0.0f, 0.0f);
glScalef(6.0f, 1.0f, 3.0f);
cubo();
glPopMatrix();
}
void columna(){
glPushMatrix();
glTranslatef(0.0f, 1.5f, 0.0f);
glScalef(1.0f, 2.0f, 1.0f);
cubo();
glPopMatrix();
}
void humanoide(){
cabeza();
cuello();
torax();
brazos_completos();
columna();
cadera();
piernas_completas();
}
// Mano
void palma(){
glPushMatrix();
glScalef(4.0f, 4.0f, 1.0f);
cubo();
glPopMatrix();
}
void dedo(){
glPushMatrix();
glTranslatef(1.5f, 2.4f, 0.0f);
glScalef(0.80f, 0.80f, 0.5f);
cubo();
glTranslatef(0.0f, 1.0f, 0.0f);
cubo();
glPopMatrix();
}
void dedos_mano(){
glPushMatrix();
dedo();
glTranslatef(-1.0f, 0.0f, 0.0f);
dedo();
glTranslatef(-1.0f, 0.0f, 0.0f);
dedo();
glTranslatef(-1.0f, 0.0f, 0.0f);
dedo();
glPopMatrix();
}
void dedo_gordo(){
glPushMatrix();
glScalef(0.80f, 0.80f, 0.7f);
cubo();
glTranslatef(-0.60f, 0.60f, 0.0f);
cubo();
glTranslatef(-0.60f, 0.60f, 0.0f);
cubo();
glTranslatef(-0.60f, 0.60f, 0.0f);
cubo();
glPopMatrix();
}
void mano(){
glPushMatrix();
palma();
glPopMatrix();
glPushMatrix();
dedos_mano();
glPopMatrix();
glPushMatrix();
glTranslatef(-2.0f, 0.0f, 0.0f);
dedo_gordo();
glPopMatrix();
}
// Brazo Robot
void hombro_robot(){
glPushMatrix();
glScalef(2.0f, 2.0f, 1.0f);
cubo();
glPopMatrix();
}
void brazo_robot(){
glRotatef(25, 0.0f, 0.0f, 1.0f);
glPushMatrix();
glTranslatef(2.85f, 0.0f, 0.0f);
glScalef(4.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
}
void dedos_robot(){
glPushMatrix();
glTranslatef(5.25f, 0.25f, 0.0f);
glScalef(1.0f, 0.25f, 1.0f);
cubo();
glTranslatef(0.0f, -2.0f, 0.0f);
cubo();
glPopMatrix();
}

void brazo_robot_tenaza(){
glRotatef(-45, 0.0f, 0.0f, 1.0f);
hombro_robot();
brazo_robot();
dedos_robot();
}
void display(){
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.7,0.7,0.7);
glLoadIdentity();
gluLookAt (4.0, 2.0, 20.0, .0, 0.0, 0.0, 0.0, 1.0, 0.0);
// Cubo 1
glPushMatrix();
glTranslatef(-10.0,8.0,0.0);
glScalef (2.0, 2.0, 2.0);
glRotatef(45, 1.0f, 0.0f, 0.0f);
cubo();
glPopMatrix();
// Cubo 2
glPushMatrix();
glTranslatef(-10.0,5.0,0.0);
glScalef (1.5, 1.5, 1.5);
glRotatef(90, 1.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
// Cubo 3
glPushMatrix();
glTranslatef(-10.0,2.0,0.0);
glScalef (1.0, 1.0, 1.0);
glRotatef(135, 1.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
// Cubo 4
glPushMatrix();
glTranslatef(-10.0,-1.0,0.0);
glScalef (1.8, 1.8, 1.8);
glRotatef(180, 1.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
// Humanoide 1
glPushMatrix();
glTranslatef(6.5,4.0,0.0);
glScalef (0.45, 0.45, 0.45);
glRotatef(-10, 0.0f, 0.0f, 1.0f);
humanoide();
glPopMatrix();
// Humanoide 2
glPushMatrix();
glTranslatef(2.0,2.0,0.0);
glScalef (0.25, 0.25, 0.25);
glRotatef(0, 0.0f, 0.0f, 1.0f);
humanoide();
glPopMatrix();
// Humanoide 3
glPushMatrix();
glTranslatef(-3.0,4.0,-0.0);
glScalef (0.50, 0.50, 0.50);
glRotatef(10, 0.0f, 0.0f, 1.0f);
humanoide();
glPopMatrix();
// Mano 1
glPushMatrix();
glTranslatef(-10.0,-6.0,-0.0);
glScalef (0.5, 0.5, 0.5);
glRotatef(20, 0.0f, 0.0f, 1.0f);
mano();
glPopMatrix();
// Mano 2
glPushMatrix();
glTranslatef(-4.0,-4.0,-0.0);
glScalef (0.8, 0.8, 0.8);
glRotatef(15, 0.0f, 1.0f, 0.0f);
mano();
glPopMatrix();
// BrazoRobot 1
glPushMatrix();
glTranslatef(1.0,-4.0,-0.0);
glScalef (0.8, 0.8, 0.8);
glRotatef(-20, 0.0f, 0.0f, 1.0f);
brazo_robot_tenaza();
glPopMatrix();
// BrazoRobot 2
glPushMatrix();
glTranslatef(6.0,-2.0,-0.0);
glScalef (0.6, 0.6, 0.6);
glRotatef(15, 0.0f, 0.0f, 1.0f);
brazo_robot_tenaza();
glPopMatrix();
glFlush();
}
void init(){
glClearColor(0.2,0.4,0.1,0.1);
}

int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(350, 100);
glutInitWindowSize(500, 400);
glutCreateWindow("Escenario");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

martes, 11 de septiembre de 2007

Previo Práctica 4

1.¿Que es una escena?
R:- Ensambles de primitivas
-Superficie: Color, Textura, Normales y Normales “truchas”
-Fondo o Ambiente
- Luces: Modelos de iluminación
- Cámara: Proyección

2.¿Como podemos definir una escena jerarquicamente?
R: consiste en dar movimiento a todos los objetos que se encuentren en la escena.

3.¿Describa el funcionamiento y parametros de la funcion
glutSwapBuffers()

void glutSwapBuffers(void);

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

Uso

void glutKeyboardFunc(void (*func)(unsigned char tecla, int x, int y));

func.- la nueva función de teclado

Descripción

glutKeyboardFunc dispone la función de telado para la ventan actual. Cuando el usuario teclea en la ventana, cada tecla presionada genera un carácter ASCII el cual generará un 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()

Uso: void glutIdleFunc(void (*func)(void));
 
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 que sirve? ¿Como se declara con GLUT?

R: La animación se logra usando doble buffer, se dibuja algo en el buffer secundario, el que no se ve en pantalla, y luego se intercambia por el de la pantalla, si se hacen pequeños cambios, se logra ver una animación.

Es necesario definir nuestra ventana con doble buffer, esto se logra reemplazando los parámetros de glutInitDisplayMode por GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB , o sea, cambiar el buffer single por un buffer doble.

En la función dibujar, hemos limpiado el buffer de la pantalla, ahora debemos limpiar el buffer depth, el buffer secundario, para que no tenga cosas previamente dibujadas. Esto se logra usando glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) en la función dibujar.

Y para finalizar, al final de nuestra función dibujar hay que intercambiar los buffer, del secundario al primario, esto se logra con glutSwapBuffers();

5.¿Que es un "function callback" (llamada a funcion) Pista: Sirve para manejos de eventos.

R: Una función Callback será llamada por GLUT para hacer alguna operación específica cada vez que se produzca un evento.


Reporte Práctica 3

Escriba el código para dibujar una mano

#include
void reshape(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-6,4, -3, 5, 0.5, 80);
glMatrixMode(GL_MODELVIEW);
}
void cuadrado()
{
glBegin(GL_LINE_STRIP);
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 cubo()
{
cuadrado();
glPushMatrix();
glTranslatef(0.0f, 0.0f, 1.0f);
cuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(-90, 1.0f, 0.0f, 0.0f);
cuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(90, 1.0f, 0.0f, 0.0f);
cuadrado();
glPopMatrix();
}
void palma()
{
glPushMatrix();
glScalef(4.0f, 4.0f, 1.0f);
cubo();
glPopMatrix();
}
void dedo()
{
glPushMatrix();
glTranslatef(1.5f, 2.4f, 0.0f);
glScalef(0.80f, 0.80f, 0.5f);
cubo();
glTranslatef(0.0f, 1.0f, 0.0f);
cubo();
glPopMatrix();
}
void dedos_mano()
{
glPushMatrix();
dedo();
glTranslatef(-1.0f, 0.0f, 0.0f);
dedo();
glTranslatef(-1.0f, 0.0f, 0.0f);
dedo();
glTranslatef(-1.0f, 0.0f, 0.0f);
dedo();
glPopMatrix();
}
void dedo_gordo()
{
glPushMatrix();
glScalef(0.80f, 0.80f, 0.7f);
cubo();
glTranslatef(-0.60f, 0.60f, 0.0f);
cubo();
glTranslatef(-0.60f, 0.60f, 0.0f);
cubo();
glTranslatef(-0.60f, 0.60f, 0.0f);
cubo();
glPopMatrix();
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(3,1,1);
glLoadIdentity();
gluLookAt (0.0,0.0,5.0,0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glPushMatrix();
palma();
glPopMatrix();
glPushMatrix();
dedos_mano();
glPopMatrix();
glPushMatrix();
glTranslatef(-2.0f, 0.0f, 0.0f);
dedo_gordo();
glPopMatrix();
glFlush();
}
void init()
{
glClearColor(0,0,0,0);
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(300, 80);
glutInitWindowSize(400, 400);
glutCreateWindow("Mano Robot");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

Práctica 3


1.- Compile y ejecute el código que escribió en el reporte previo.

/*Humanoide parametrizado*/
#include

void init(void){
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}
void cubod(void)
{
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);
glEnd();
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);
glEnd();
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);
glEnd();
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);
glEnd();
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);
glEnd();
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);
glEnd();
}
/*Rotaciones del brazo derecho*/
static int brazderrot = 0;
static int angbrazder = 0;
static int codderrot = 0;
static int angcododer = 0;
/*cabeza*/
void cabeza (float x){
glPushMatrix();
glTranslatef(0.0,2.0,0.0);
glRotatef(x,0.0,0.1,0.0);
cubohueco();
glPopMatrix();
}
/*Torso.*/
void tronco (float x, float y, float z){
glTranslatef(x,y,z);
glRotatef((GLfloat)torsorot,0.0,1.0,0.0);
glPushMatrix();
glScalef (2.0, 3.0, 1.0);
cubod();
glPopMatrix();
}
/*brazo derecho*/
void brazoder (int y, int z){
glPushMatrix();
glTranslatef(2.0,1.25,0.0);
glTranslatef(-1.0,0.0,0.0);
/*eje en el cual va a girar el brazo.*/
switch(y){
case 0:
glRotatef((GLfloat)angbrazder, 1.0, 0.0, 0.0);
break;
case 1:
glRotatef((GLfloat)angbrazder, 0.0, 1.0, 0.0);
break;
case 2:
glRotatef((GLfloat)angbrazder, 0.0, 0.0, 1.0);
break;
default:
break;
}
glPushMatrix();
glTranslatef(1.0,0.0,0.0);
glScalef(2.0,0.5,1.0);
cubod();
glPopMatrix();
/*antebrazo derecho*/
glTranslatef(3.0,0.0,0.0);
glTranslatef(-1.0,0.0,0.0);
/*eje sobre el cuál girará el antebrazo derecho*/
switch(z){
case 0:
glRotatef((GLfloat)angcododer, 1.0, 0.0, 0.0);
break;
case 1:
glRotatef((GLfloat)angcododer, 0.0, 1.0, 0.0);
break;
case 2:
glRotatef((GLfloat)angcododer, 0.0, 0.0, 1.0);
break;
default:
break;
}
glPushMatrix();
glTranslatef(1.0,0.0,0.0);
glScalef(2.0,1.0,1.0);
cubod();
glPopMatrix();
/*mano derecha*/
glTranslatef(2.25,0.0,0.0);
glPushMatrix();
glScalef(0.5,0.5,1.0);
cubod();
glPopMatrix();
glPopMatrix();
}
void brazoizq (float x, int y){
glPushMatrix();
glTranslatef(-2.0,1.25,0.0);
/*eje sobre el cuál girará el brazo izquierdo*/
switch(y){
case 0:
glRotatef((GLfloat)angbrazizq, 1.0, 0.0, 0.0);
break;
case 1:
glRotatef((GLfloat)angbrazizq, 0.0, 1.0, 0.0);
break;
case 2:
glRotatef((GLfloat)angbrazizq, 0.0, 0.0, 1.0);
break;
default:
break;
}
glPushMatrix();
glScalef(2.0,0.5,1.0);
cubod();
glPopMatrix();
/*antebrazo izquierdo*/
glTranslatef(-2.0,0.0,0.0);
glPushMatrix();
glScalef(2.0,1.0,1.0);
cubod();
glPopMatrix();
/*mano izquierdo*/
glTranslatef(-1.25,0.0,0.0);
glPushMatrix();
glScalef(0.5,0.5,1.0);
cubod();
glPopMatrix();
glPopMatrix();
}
void pierder (float x, int y){
glPushMatrix();
glTranslatef(0.6,-2.25,0.0);
/*giro de la pierna derecha*/
switch(y){
case 0:
glRotatef((GLfloat)angpierder, 1.0, 0.0, 0.0);
break;
case 1:
glRotatef((GLfloat)angpierder, 0.0, 1.0, 0.0);
break;
case 2:
glRotatef((GLfloat)angpierder, 0.0, 0.0, 1.0);
break;
default:
break;
}
glPushMatrix();
glScalef(0.75,1.5,1.0);
cubod();
glPopMatrix();
/*pantorrilla derecha*/
glTranslatef(0.0,-1.5,0.0);
glPushMatrix();
glScalef(0.6,1.5,1.0);
cubod();
glPopMatrix();
/*pie derecho*/
glTranslatef(0.25,-0.85,0.0);
glPushMatrix();
glScalef(1.5,0.25,1.0);
cubod();
glPopMatrix();
glPopMatrix();/*pierna derecha completa*/
}
void pierizq (float x, int y){
glPushMatrix();
glTranslatef(-0.6,-2.25,0.0);
/*Switch que indica sobre qué eje va a girar la pierna izquierda.*/
switch(y){
case 0:
glRotatef((GLfloat)angpierizq, 1.0, 0.0, 0.0);
break;
case 1:
glRotatef((GLfloat)angpierizq, 0.0, 1.0, 0.0);
break;
case 2:
glRotatef((GLfloat)angpierizq, 0.0, 0.0, 1.0);
break;
default:
break;
}
glPushMatrix();
glScalef(0.75,1.5,1.0);
cubod();
glPopMatrix();
/*pantorrilla izquierda*/
glTranslatef(0.0,-1.5,0.0);
glPushMatrix();
glScalef(0.6,1.5,1.0);
cubod();
glPopMatrix();
/*pie izquierdo*/
glTranslatef(-0.25,-0.85,0.0);
glPushMatrix();
glScalef(1.5,0.25,1.0);
cubod();
glPopMatrix();
glPopMatrix();/*pierna izquierda completa*/
}
void display (void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity (); /* clear the matrix */
gluLookAt (0.0, 0.0, 9.5, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glPushMatrix();
/*torso*/
tronco(0.0,1.5,0.0);
/*cara*/
cabeza(cuellorot);
/*brazo derecho*/
brazoder(brazderrot, codderrot);
/*brazo izquierdo*/
brazoizq(angbrazizq,brazizqrot);
/*muslo derecho*/
pierder(angpierder,pierderrot);
/*muslo izquierdo*/
pierizq(angpierizq,pierizqrot);
glPopMatrix();/*humanoide completo*/
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);
}
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 't':
torsorot = (torsorot + 5)%360;
glutPostRedisplay();
break;
case 'j':
brazderrot = brazderrot + 1;
angbrazder = 0;
angcododer = angcododer-5;
if(brazderrot==3){
brazderrot = 0;
}
case 'k':
codderrot = codderrot + 1;
angcododer = 0;
angbrazder = angbrazder-5;
if(codderrot==3){
codderrot = 0;
}
case 'd':
angbrazder = (angbrazder + 5)%180;
glutPostRedisplay();
break;
case 's':
angcododer = (angcododer + 5)%180;
glutPostRedisplay();
break;
case 27:
break;
}
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (80, 200);
glutCreateWindow ('Humanoide jerárquico');
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}


2.- Cree de manera jerárquica un brazo robot de dos eslabones, construida a partir de un cubo deformado por escalamiento, función brazorobot() en objetos.h

#include
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 cuadrado()
{
glBegin(GL_LINE_STRIP);
glVertex3f(-1.5,1.5,-1.5);
glVertex3f(-1.5,-1.5,-1.5);
glVertex3f(1.5,-1.5,-1.5);
glVertex3f(1.5,1.5,-1.5);
glVertex3f(-1.5,1.5,-1.5);
glEnd();
}
void cubo()
{
cuadrado();
glPushMatrix();
glTranslatef(0.0f, 0.0f, 0.0f);
cuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(-90, 0.0f, 0.0f, 1.0f);
cuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(90, 0.0f, 0.0f, 1.0f);
cuadrado();
glPopMatrix();
}
void hombro()
{
glPushMatrix();
glScalef(1.5f, 1.5f, 0.5f);
cubo();
glPopMatrix();
}
void brazo()
{
glPushMatrix();
glRotatef(10, 0.0f, 0.0f, 1.0f);
glTranslatef(6.0f, -0.5f, 0.0f);
glScalef(3.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
}
void brazo_robot()
{
hombro();
brazo();
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(3,1,3);
glLoadIdentity();
glRotatef(0, 0.0f, 0.0f, 1.0f);
brazo_robot();
glFlush();
}
void init()
{
glClearColor(-6,0,1,-2);
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(500, 100);
glutInitWindowSize(400, 400);
glutCreateWindow("Brazo Robot");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}



3.- Agregue dos eslabones más al brazo robot a manera de una tenaza y cree la función brazo robot con tenaza() en objetos.h.

#include
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 cuadrado()
{
glBegin(GL_LINE_STRIP);
glVertex3f(-0.9,0.9,-0.9);
glVertex3f(-0.9,-0.9,-0.9);
glVertex3f(0.9,-0.9,-0.9);
glVertex3f(0.9,0.9,-0.9);
glVertex3f(-0.9,0.9,-0.9);
glEnd();
}
void cubo()
{
cuadrado();
glPushMatrix();
cuadrado();
glPopMatrix();
glPushMatrix();
cuadrado();
glPopMatrix();
glPushMatrix();
cuadrado();
glPopMatrix();
}
void hombro()
{
glPushMatrix();
glScalef(2.0f, 2.0f, 1.0f);
cubo();
glPopMatrix();
}
void brazo()
{
glPushMatrix();
glTranslatef(4.5f, 0.0f, 0.0f);
glScalef(4.0f, 1.0f, 1.0f);
cubo();
glPopMatrix();
}
void dedos()
{
glPushMatrix();
glTranslatef(9.0f, 0.25f, 0.0f);
glScalef(1.0f, 0.25f, 1.0f);
cubo();
glTranslatef(0.0f, -2.0f, 0.0f);
cubo();
glPopMatrix();
}
void brazo_robot_tenaza()
{
hombro();
brazo();
dedos();
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1,0,0);
glLoadIdentity();
brazo_robot_tenaza();
glFlush();
}
void init()
{
glClearColor(-10,2,-10,0);
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(500, 100);
glutInitWindowSize(300, 200);
glutCreateWindow("Brazo con un par de tenazas");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}