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



martes, 4 de septiembre de 2007

previo 3 (LABORATORIO)

1.- ¿Qué es una composición de transformación?
Una composición de transformación es el conjunto de transformaciones geométricas que se le pueden aplicar a un objeto, estas transformaciones son:
  • escalamiento
  • rotación
  • traslación
2.-¿Afecta el orden en dónde se aplican las transformaciones sobre un vector o conjunto de vectores ¿Por qué?

Sí, el orden en que se aplican las transformaciones pueden afectar el resultado final del objeto. LAs transformaciones de rotación y traslación son als que peuden provocar un cambio en el resultado dependiendo del orden en que se apliquen.

3.-¿Es lo mismo?

glRotatef(30,1,0,0);
glTranslatef(1,1,1);
glScalef(2,2,2);
cubo();

que:
cubo();
glRotatef(30,1,0,0);
glTranslatef(1,1,1);
glScalef(2,2,2);

o que:
glScalef(2,2,2);
glRotatef(30,1,0,0);
cubo();

-La primera y la segunda dan un resultado distinto
-La primera y la tercera dan el mismo resultado.



4.-¿Qué es modelado jerárquico?

En general, los modelos geométricos suelen tener estructura jerárquica, obtenida por descomposición del elemento a modelar en componentes más pequeños. Cuando todos los niveles de la jerarquía contengan el mismo tipo de información hablaremos de modelos jerárquicos homogéneos, por el contrario, cuando cada nivel contenga información de un tipo tendremos un modelo heterogéneo.

Cuando descomponemos el elemento a modelar en partes que contienen información de naturaleza diferente a la del propio elemento, obtenemos un modelo jerárquico heterogéneo. En este tipo de modelos la jerarquía suele tener un nivel de profundidad fijo, almacenando en cada nivel un tipo distinto de información. Por ejemplo, un elemento puede estar representado por un conjunto de líneas, y cada línea estar representada por dos puntos. En este caso, la jerarquía tendrá solo dos niveles. Usualmente podemos ver cada nivel como un tipo de primitivas diferentes, por este motivo algunos autores llaman a estos modelos primitivas relacionadas Este tipo de modelos es útil cuando existe dependencias topológicas entre componentes, lo que suele ocurrir cuando hay conexiones entre componentes

5.- ¿Cómo se modela jerarquicamente el humanoide del reporte de la práctica 2?

6.- Modele jerarquicamente el humanoide del reporte de la práctica 2 y escriba el programa que lo dibuja


//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,0.8,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,-1.2,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,-1.2,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