previo 6

1. Escribir el código que escripa en la pantalla de glut mi nombre y mi número de cuenta

#include "GL/glut.h"
#include "string.h"
char etiqueta[80];

void Escribe (char *cadena)
{
unsigned int Nletras;
for (Nletras=0; Nletras glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_10, cadena[Nletras]);
}
void texto(void)
{
char *nombre="Eduardo Ademir Hernández García";
char *númeroCuenta="301594679";
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode( GL_MODELVIEW_MATRIX );
glLoadIdentity();
glColor3f(1.0, 1.0, 1.0);
sprintf(etiqueta,"%s", nombre);
glRasterPos2f(95, 20);
texto(etiqueta);
sprintf(etiqueta,"%s", númeroCuenta);
glRasterPos2f(100, 35);
texto(etiqueta);
glFlush();
}
void reshape(int w, int h)
{
if (!h)
return;
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, w, 0, h);
glScalef(1, -1, 1);
glTranslatef(0, -h, 0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(300,320);
glutInitWindowPosition(0, 0);
glutCreateWindow("Cadenas Dibujadas");
glutDisplayFunc(texto);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

PRACTICA 4

Este es el código que dibuja a los 3 humanoides y al cubo con la esfera arriba y los brazos saliendo de ella.

#include
#include "cubo0.h"
#include "triangulo.h"

void mano (void)
{
glPushMatrix();
glScalef(1.2,1,1);
cubo();
glPopMatrix();
}

void brazo(void)
{
glPushMatrix();
glScalef(1,0.3,0.6);
cubo();
/*glPushMatrix();
glTranslatef(1.1,0,0);
mano();
glPopMatrix();*/
glPopMatrix();
}
void pierna(void)
{
glPushMatrix();
glScalef(0.5,3,1.1);
cubo();
glPopMatrix();
}

void brazoRobot(void)
{
//brazo
glPushMatrix();
glRotatef(30,0.0,0.0,1.0);
glTranslatef(0.0,1.5,0.0);
glPushMatrix();
glScalef(0.5,3.0,0.5);
cubo();
glPopMatrix();
//antebrazo

glTranslatef(0.0,1.5,0.0);
glRotatef(-30,0.0,0.0,1.0);
glTranslatef(0.0,1.0,0.0);
glPushMatrix();
glScalef(0.5,2.0,0.5);
cubo();
glPopMatrix();

//dedos
//dedo1
glPushMatrix();
glTranslatef(0.0,0.5,0.0);
glRotatef(10,0.0,0.0,1.0);
glTranslatef(-0.125,1.0,0.0);
glPushMatrix();
glScalef(0.25,1.0,0.5);
cubo();
glPopMatrix();
glPopMatrix();
//dedo2
glPushMatrix();
glTranslatef(0.0,0.5,0.0);
glRotatef(-10,0.0,0.0,1.0);
glTranslatef(0.125,1.0,0.0);
glPushMatrix();
glScalef(0.25,1.0,0.5);
cubo();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glFlush();
}

void monito (void)
{
glPushMatrix();
glTranslatef(0,1,0);
glScalef(1.2,1.5,1);
cubo(); //PECHO
glPushMatrix();
glTranslatef(0,0.75,0);
glScalef(0.75,0.6,0.8);
cubo(); //CABEZA
glPopMatrix();
glPushMatrix();
glTranslatef(1,0.15,0);
glRotatef(-20,0,0,1);
brazo(); //BRAZO DERECHO
glPopMatrix();
glPushMatrix();
glTranslatef(-1,0.15,0);
glRotatef(200,0,0,1);
brazo(); //BRAZO IZQUIERDO
glPopMatrix();
glPushMatrix();
glTranslatef(0,-0.75,0);
glScalef(0.8,0.5,0.8);
cubo(); //CINTURA
glPushMatrix();
glTranslatef(-0.35,-2,0);
pierna(); //PIERNA
glPushMatrix();
glTranslatef(-0.25,-1.75,0);
glScalef(1,0.5,1);
cubo();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glTranslatef(0.35,-2,0);
pierna();
glPushMatrix();
glTranslatef(0.25,-1.75,0);
glScalef(1,0.5,1);
cubo();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();

}

void escena (void)
{
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glClearDepth(1.0);
glClearColor(1.0,1.0,1.0,0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(50.0,1.0,1.0,100.0);

glMatrixMode(GL_MODELVIEW);

glPushMatrix();
glTranslatef(0,0,-7);
monito();
glPopMatrix();
glPushMatrix();
glTranslatef(7,-1.7,7);
glRotatef(-120,0,1,0);
glScalef(2,0.5,1);
monito();
glPopMatrix();
glPushMatrix();
glTranslatef(-7,1.7,7);
glRotatef(120,0,1,0);
glScalef(0.5,1.5,1);
monito();
glPopMatrix();
glPushMatrix();
glTranslatef(0,-3.3,0);
glScalef(3,3,3);
triangulo();
glPopMatrix();
glPushMatrix();
glTranslatef(0,0,0);
glScalef(1.5,5.5,1.5);
cubo();
glPushMatrix();
glTranslatef(0,1.3,0);
glColor3d(0.8,0.3,0.7);
glutWireSphere(0.8,30,30);
glPushMatrix();
glTranslatef(-0.8,0,0);
glScalef(1,0.1,1);
brazoRobot();
glPopMatrix();
glPushMatrix();
glTranslatef(0,0,0.8);
glRotatef(90,0,1,0);
glScalef(1,0.1,1);
brazoRobot();
glPopMatrix();
glPushMatrix();
glTranslatef(0,0,-0.8);
glRotatef(-90,0,1,0);
glScalef(1,0.1,1);
brazoRobot();
glPopMatrix();
glPushMatrix();
glTranslatef(0.8,0,0);
glRotatef(180,0,1,0);
glScalef(1,0.1,1);
brazoRobot();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glRotatef(45,1,1,1);
glFlush();
}

int main(int argc,char *argv)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA| GLUT_DEPTH );
glutInitWindowPosition(0,0);
glutInitWindowSize(600,600);
glutCreateWindow("Practica 4");
gluLookAt(0.0, 5.0, 25.0,0.0, 0.0, 0.0,0.0, 1.0, 0.0);
//Vista desde el punto 0,0,0. Con el 3er parámetro se acerca o se aleja la cámara
glutDisplayFunc(escena);
glutMainLoop();
return 0;
}


2. Para qué sirve tener una escena construida jerárquicamente?

Sirve para poder tener el control sobre el objeto o la escena que se crea, ya que de esta manera el movimiento o traslado de los objetos sucede de forma "natural", es decir, que por ejemplo si se desea mover algo que esta conectado o ligado a otra cosa, este objeto se mueva también. Esto lo vimos con el modelado del humanoide. Para que el humanoide pueda mover el pie por ejemplo es necesario mover la pierna o si se desea mover la cabeza se tenga que mover forzosamente la cabeza.

tarea 5

TAREA PROXIMAMENTE ..........

PREVIO 5

#include
#include
#include

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

void mouse(int button, int state, int x, int y)
{
if (state == GLUT_DOWN)
{
if ((glutGetWindow() == ventana1) && button == GLUT_LEFT_BUTTON)
{
xzoom = 255 - x;
yzoom = y - 255;
printf("%d, %d \n",x, y);
glutInitWindowSize (500, 500);
glutInitWindowPosition (700, 50);
ventana2 = glutCreateWindow ("Coordenadas especificas");
glutDisplayFunc(display_coordenadas);
glutReshapeFunc(reshape_coordenadas);
glutSetWindow(ventana2);
glutIdleFunc(NULL);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
}
else if ((glutGetWindow() == ventana2) && (button == GLUT_RIGHT_BUTTON)){
glutIdleFunc(NULL);
glutDestroyWindow(ventana2);
}
}
if (state == GLUT_UP)
{
if ((glutGetWindow() == ventana1) && button == GLUT_RIGHT_BUTTON)
{
printf("%d, %d \n",x, y);
glutInitWindowSize (800, 800);
glutInitWindowPosition (450, 0);
ventana3 = glutCreateWindow ("vENTANA3");
glutReshapeFunc(reshape_fractal);
glutSetWindow(ventana3);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
}
else if ((glutGetWindow() == ventana3) && (button == GLUT_RIGHT_BUTTON)){
glutIdleFunc(NULL);
glutDestroyWindow(ventana3);
//glutSetWindow(win1);
}
}
}

int main(int argc, char** argv)
{
//codigo para la primer ventana que despliega el fractal
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (700, 700);
glutInitWindowPosition (25, 50);
ventana1=glutCreateWindow ("Fractal Triangulo de Sierpenski Gasket");
glutSetWindow(ventana1);
init ();
glutDisplayFunc(mouse);
glutReshapeFunc(reshape_mouse);
glutIdleFunc(NULL);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMainLoop();
return 0;
}

TAREA 4: "PUERCO ARAÑA"

Este es el código para hacer el puerco araña

#include

GLUquadricObj * qobj;

void colaDePuerco (void)
{
glPushMatrix();
glTranslatef(0, 0,0); // cilindro al punto de origen (0,0,0)
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_LINE);
gluCylinder(qobj, 0.8, 0.8, 1.5, 50,10);
glPopMatrix();
}

void cabezaDePuerco (void)
{
glPushMatrix();
glTranslatef(0,0,0);
glutWireSphere(3,10,10);
glPopMatrix();
}

void ojosDePuerco (void)
{
glPushMatrix();
glTranslatef(0, 0,0); // cilindro al punto de origen (0,0,0)
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_LINE);
gluCylinder(qobj, 0.8, 0.8, 0.5, 100,5);
glPopMatrix();
}

void trompaDePuerco (void)
{
glPushMatrix();
glTranslatef(0, 0,0); // cilindro al punto de origen (0,0,0)
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_LINE);
gluCylinder(qobj, 0.5, 0.5, 1, 8,6);
glPopMatrix();
}

void orejaDePuerco (void)
{
glPushMatrix();
glTranslatef(0,0,0);
glRotatef(-90,1,0,0);
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_LINE);
gluCylinder(qobj, 1, 0, 1.3, 5,5);
glPopMatrix();
}

void patapuerco (void)
{
glPushMatrix();
glTranslatef(0, 0,0); // cylinder at (0,0,1)
glRotatef(90,1,0,0);
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_LINE);
gluCylinder(qobj, 1, 1, 1.5, 10,8);
glPopMatrix();
}

void Puerco (void)
{
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glClearDepth(1.0);
glClearColor(1.0,1.0,1.0,0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(50.0,1.0,1.0,100.0);

glMatrixMode(GL_MODELVIEW);

//gluCylinder(qobj, baseRad, topRad, height, nSlices, nStacks); Dibuja el cilindro
/*glPushMatrix();
glTranslated(0, 0,0); // cylinder at (0,0,1)
glRotatef(90,1,0,0);
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_LINE);
glColor3d(0.1,0.3,0.7);
gluCylinder(qobj, 0.3, 1.3, 5.4, 10,8);
glPopMatrix();*/

glPushMatrix();
glColor3d(0.1,0.3,0.7);
glTranslatef(0,0,0);
glRotatef(90,0,1,0);
glutWireSphere(4,8,8);

glPushMatrix();
glTranslatef(-2.5,-2,2);
patapuerco();
glPopMatrix();

glPushMatrix();
glTranslatef(-2.5,-2,-2);
patapuerco();
glPopMatrix();

glPushMatrix();
glTranslatef(2.5,-2,2);
patapuerco();
glPopMatrix();

glPushMatrix();
glTranslatef(2.5,-2,-2);
patapuerco();
glPopMatrix();

glPushMatrix();
glTranslatef(0,1,4);
cabezaDePuerco();

glPushMatrix();
glTranslatef(-1.4,2,0.5);
orejaDePuerco();
glPopMatrix();

glPushMatrix();
glTranslatef(1.4,2,0.5);
orejaDePuerco();
glPopMatrix();

glPushMatrix();
glTranslatef(0,0,2.8);
trompaDePuerco();
glPopMatrix();

glPushMatrix();
glTranslatef(1.2,1.2,1.9);
ojosDePuerco();
glPopMatrix();

glPushMatrix();
glTranslatef(-1.2,1.2,1.9);
ojosDePuerco();
glPopMatrix();
glPopMatrix();

glPushMatrix();
glTranslatef(0,0,-5.5);
colaDePuerco();
glPopMatrix();

glPopMatrix();

glRotatef(45,1,1,1);
glFlush();
}

int main(int argc,char *argv)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA| GLUT_DEPTH );
glutInitWindowPosition(0,0);
glutInitWindowSize(600,600);
glutCreateWindow("Puerco Araña");
gluLookAt(0.0, 5.0, 20.0,0.0, 0.0, 0.0,0.0, 1.0, 0.0);
//Vista desde el punto 0,0,0. Con el 3er parámetro se acerca o se aleja la cámara
glutDisplayFunc(Puerco);
glutMainLoop();
return 0;
}

Practica 3

Hacer el código que dibuje la mano de un robot jerárquicamente.

#include

#include

void init(void)

{

glClearColor (0.0, 0.0, 0.0, 0.0);

glShadeModel (GL_FLAT);

}

void cuborelleno(void)

{

glBegin(GL_QUADS);

glVertex3f(0.5,0.5,0.5);//v1

glVertex3f(-0.5,0.5,0.5);//v2

glVertex3f(-0.5,-0.5,0.5);//v3

glVertex3f(0.5,-0.5,0.5);//v4

glEnd();

glBegin(GL_QUADS);

glVertex3f(-0.5,0.5,-0.5);//v5

glVertex3f( 0.5,0.5,-0.5);//v6

glVertex3f(0.5,-0.5,-0.5);//v7

glVertex3f(-0.5,-0.5,-0.5);//v8

glEnd();

glBegin(GL_QUADS);

glVertex3f(-0.5,0.5,0.5);//v2

glVertex3f(-0.5,0.5,-0.5);//v5

glVertex3f(-0.5,-0.5,-0.5);//v8

glVertex3f(-0.5,-0.5,0.5);//v3

glEnd();

glBegin(GL_QUADS);

glVertex3f(0.5,0.5,0.5);//v1

glVertex3f(0.5,-0.5,0.5);//v4

glVertex3f( 0.5,-0.5,-0.5);//v7

glVertex3f(0.5,0.5,-0.5);//v6

glEnd();

glBegin(GL_QUADS);

glVertex3f(-0.5,0.5,-0.5);//v5

glVertex3f(-0.5,0.5,0.5);//v2

glVertex3f(0.5,0.5,0.5);//v1

glVertex3f( 0.5,0.5,-0.5);//v6

glEnd();

glBegin(GL_QUADS);

glVertex3f(0.5,-0.5,-0.5);//v7

glVertex3f(-0.5,-0.5,-0.5);//v8

glVertex3f(-0.5,-0.5,0.5);//v3

glVertex3f(0.5,-0.5,0.5);//v4

glEnd();

}

void cubohueco(void)

{

glBegin(GL_LINE_LOOP);

glVertex3f(0.5,0.5,0.5);//v1

glVertex3f(-0.5,0.5,0.5);//v2

glVertex3f(-0.5,-0.5,0.5);//v3

glVertex3f(0.5,-0.5,0.5);//v4

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3f(-0.5,0.5,-0.5);//v5

glVertex3f( 0.5,0.5,-0.5);//v6

glVertex3f(0.5,-0.5,-0.5);//v7

glVertex3f(-0.5,-0.5,-0.5);//v8

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3f(-0.5,0.5,0.5);//v2

glVertex3f(-0.5,0.5,-0.5);//v5

glVertex3f(-0.5,-0.5,-0.5);//v8

glVertex3f(-0.5,-0.5,0.5);//v3

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3f(0.5,0.5,0.5);//v1

glVertex3f(0.5,-0.5,0.5);//v4

glVertex3f( 0.5,-0.5,-0.5);//v7

glVertex3f(0.5,0.5,-0.5);//v6

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3f(-0.5,0.5,-0.5);//v5

glVertex3f(-0.5,0.5,0.5);//v2

glVertex3f(0.5,0.5,0.5);//v1

glVertex3f( 0.5,0.5,-0.5);//v6

glEnd();

glBegin(GL_LINE_LOOP);

glVertex3f(0.5,-0.5,-0.5);//v7

glVertex3f(-0.5,-0.5,-0.5);//v8

glVertex3f(-0.5,-0.5,0.5);//v3

glVertex3f(0.5,-0.5,0.5);//v4

glEnd();

}

/*Variables globales utilizadas para los movimientos de las falanges de los dedos y dos variables auxiliares para dar un efecto adecuado a la animación.*/

static int munecax = 0;

static int munecay = 0;

static int munecaz = 0;

static int pulgfalmay = 0;

static int pulgfalmedx = 0;

static int pulgfalmedy = 0;

static int pulgfalmen = 0;

static int menfalmay = 0;

static int anufalmay = 0;

static int medfalmay = 0;

static int indfalmay = 0;

static int x = 0;

static int y = 0;

void pulgar (){ /* Función que despliega el pulgar. */

glPushMatrix();

/*Falange mayor*/

glTranslatef(-0.14,-0.6,-0.02);

glTranslatef(0.0,0.4,0.0);

glRotatef((GLfloat)pulgfalmay,-1.0,0.0,0.0);

glPushMatrix();

glTranslatef(0.0,-0.47,0.02);

glScalef(0.25,0.35,0.25);

cubohueco();

glPopMatrix();

/*Falange media*/

glTranslatef(0.0,-0.57,-0.385);

glTranslatef(-0.12,0.1,0.37);

glRotatef((GLfloat)pulgfalmedx,-1.0,0.0,0.0);

glRotatef((GLfloat)pulgfalmedy,0.0,0.0,1.0);

glPushMatrix();

glTranslatef(0.12,-0.3,0.03);

glScalef(0.25,0.25,0.25);

cubohueco();

glPopMatrix();

/*Falange menor*/

glTranslatef(0.12,-0.5,-0.17);

glTranslatef(0.38,0.15,0.25);

glRotatef((GLfloat)pulgfalmen,-1.0,0.0,0.0);

glPushMatrix();

glTranslatef(-0.38,-0.14,-0.05);

glScalef(0.25,-0.12,0.25);

cubohueco();

glPopMatrix();

glPopMatrix(); /*Dedo pulgar completo*/

}

void palma (float x, float y, float z, float ang, float ang2){ /*Función que despliega la palma.*/

glTranslatef(x,y,z);

glTranslatef(-0.25,0.0,0.0);

glRotatef(180,1.0,0.0,0.0);

glRotatef(180,0.0,1.0,0.0);

glRotatef((GLfloat)munecax,1.0,0.0,0.0);

glRotatef((GLfloat)munecay,0.0,1.0,0.0);

glRotatef((GLfloat)munecaz,0.0,0.0,1.0);

glRotatef(ang,0.0,1.0,0.0);

glRotatef(ang2,0.0,0.0,-1.0);

glPushMatrix();

glTranslatef(0.25,0.0,0.0);

glScalef (1.0,1.0,0.5);

cubohueco();

glPopMatrix(); /*Palma completa*/

}

void dedos (){ /*Función que despliega los dedos índice, medio, anular y meñique.*/

glPushMatrix();

/*Meñique, falange mayor*/

glTranslatef(0.95,0.38,0.0);

glTranslatef(-0.5,0.0,0.0);

glRotatef((GLfloat)menfalmay,0.0,-1.0,0.0);

glPushMatrix();

glTranslatef(0.5,0.0,0.0);

glScalef(0.4,0.25,0.4);

cubohueco();

glPopMatrix();

/*Meñique, falange media*/

glTranslatef(0.9,0.0,0.0);

glTranslatef(-0.4,0.0,-0.04);

glRotatef((GLfloat)menfalmay,0.0,-1.0,0.0);

glPushMatrix();

glTranslatef(0.4,0.0,0.04);

glScalef(0.4,0.25,0.4);

cubohueco();

glPopMatrix();

/*Meñique, falange menor*/

glTranslatef(1.15,0.005,0.04);

glTranslatef(-0.7,0.0,0.02);

glRotatef((GLfloat)menfalmay,0.0,-1.0,0.0);

glPushMatrix();

glTranslatef(0.3,0.0,-0.02);

glScalef(0.3,0.25,0.4);

cubohueco();

glPopMatrix();

glPopMatrix();/*Meñique completo*/

glPushMatrix();

/*Anular, falange mayor*/

glTranslatef(0.95,0.13,0.0);

glTranslatef(-0.5,0.0,0.0);

glRotatef((GLfloat)anufalmay,0.0,-1.0,0.0);

glPushMatrix();

glTranslatef(0.5,0.0,0.0);

glScalef(0.4,0.25,0.4);

cubohueco();

glPopMatrix();

/*Anular, falange media*/

glTranslatef(0.88,0.0,0.0);

glTranslatef(-0.4,0.0,-0.04);

glRotatef((GLfloat)anufalmay,0.0,-1.0,0.0);

glPushMatrix();

glTranslatef(0.5,0.0,0.04);

glScalef(0.55,0.25,0.4);

cubohueco();

glPopMatrix();

/*Anular, falange menor*/

glTranslatef(1.32,0.005,0.04);

glTranslatef(-0.7,0.0,0.02);

glRotatef((GLfloat)anufalmay,0.0,-1.0,0.0);

glPushMatrix();

glTranslatef(0.3,0.0,-0.02);

glScalef(0.3,0.25,0.4);

cubohueco();

glPopMatrix();

glPopMatrix(); /*Anular completo*/

glPushMatrix();

/*Medio, falange mayor*/

glTranslatef(0.95,-0.12,0.0);

glTranslatef(-0.5,0.0,0.0);

glRotatef((GLfloat)medfalmay,0.0,-1.0,0.0);

glPushMatrix();

glTranslatef(0.5,0.0,0.0);

glScalef(0.4,0.25,0.4);

cubohueco();

glPopMatrix();

/*Medio, falange media*/

glTranslatef(0.88,0.0,0.0);

glTranslatef(-0.4,0.0,-0.04);

glRotatef((GLfloat)medfalmay,0.0,-1.0,0.0);

glPushMatrix();

glTranslatef(0.545,0.0,0.04);

glScalef(0.63,0.25,0.4);

cubohueco();

glPopMatrix();

/*Medio, falange menor*/

glTranslatef(1.4,0.005,0.04);

glTranslatef(-0.7,0.0,0.02);

glRotatef((GLfloat)medfalmay,0.0,-1.0,0.0);

glPushMatrix();

glTranslatef(0.3,0.0,-0.02);

glScalef(0.3,0.25,0.4);

cubohueco();

glPopMatrix();

glPopMatrix(); /*Medio completo*/

glPushMatrix();

/*Índice, falange mayor*/

glTranslatef(0.95,-0.37,0.0);

glTranslatef(-0.5,0.0,0.0);

glRotatef((GLfloat)indfalmay,0.0,-1.0,0.0);

glPushMatrix();

glTranslatef(0.5,0.0,0.0);

glScalef(0.4,0.25,0.4);

cubohueco();

glPopMatrix();

/*Índice, falange media*/

glTranslatef(0.81,0.0,0.0);

glTranslatef(-0.4,0.0,-0.04);

glRotatef((GLfloat)indfalmay,0.0,-1.0,0.0);

glPushMatrix();

glTranslatef(0.545,0.0,0.04);

glScalef(0.5,0.25,0.4);

cubohueco();

glPopMatrix();

/*Índice, falange menor*/

glTranslatef(1.35,0.005,0.04);

glTranslatef(-0.7,0.0,0.02);

glRotatef((GLfloat)indfalmay,0.0,-1.0,0.0);

glPushMatrix();

glTranslatef(0.3,0.0,-0.02);

glScalef(0.3,0.25,0.4);

cubohueco();

glPopMatrix();

glPopMatrix(); /*Índice completo*/

}

void display()

{

glClear (GL_COLOR_BUFFER_BIT);

glColor3f (1.0, 1.0, 1.0);

glLoadIdentity (); /* clear the matrix */

gluLookAt (0.0, 1.5, 3.5, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0);

glPushMatrix();

glScalef(-0.5,0.5,0.5);

/*Palma*/

palma(1.5,1.5,0.0,90.0,90.0);

/*Pulgar*/

pulgar();

/*Dedos (índice, medio, anular, meñique)*/

dedos();

glPopMatrix();/*Mano completa*/

glPushMatrix();

glScalef(0.5,0.5,0.5);

/*Palma*/

palma(1.5,1.5,0.0,90.0,90.0);

/*Pulgar*/

pulgar();

/*Dedos (índice, medio, anular, meñique)*/

dedos();

glPopMatrix();

glFlush ();

}

void idle() /*Función para animar las manos.*/

{

for(x = 0; x <>

{

}

if (y <>

{

pulgfalmay = pulgfalmay + 5;

pulgfalmedx = pulgfalmedx + 5;

pulgfalmen = pulgfalmen + 5;

menfalmay = menfalmay + 5;

anufalmay = anufalmay + 5;

medfalmay = medfalmay + 5;

indfalmay = indfalmay + 5;

y = y + 5;

}

else if (y <>

{

pulgfalmay = pulgfalmay - 5;

pulgfalmedx = pulgfalmedx - 5;

pulgfalmen = pulgfalmen - 5;

menfalmay = menfalmay - 5;

anufalmay = anufalmay - 5;

medfalmay = medfalmay - 5;

indfalmay = indfalmay - 5;

y = y +5;

}

if (y == 180)

{

y = 0;

}

display();

}

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 'p':

pulgfalmay = (pulgfalmay+5)%90;

pulgfalmedx = (pulgfalmedx+5)%90;

pulgfalmen = (pulgfalmen+5)%90;

glutPostRedisplay();

break;

case 'a':

pulgfalmay = (pulgfalmay+5)%90;

glutPostRedisplay();

break;

case 'h':

menfalmay = (menfalmay+5)%90;

glutPostRedisplay();

break;

case 'j':

anufalmay = (anufalmay+5)%90;

glutPostRedisplay();

break;

case 'k':

medfalmay = (medfalmay+5)%90;

glutPostRedisplay();

break;

case 'l':

indfalmay = (indfalmay+5)%90;

glutPostRedisplay();

break;

case 'x':

munecax = (munecax+5)%360;

glutPostRedisplay();

break;

case 'y':

munecay = (munecay+5)%360;

glutPostRedisplay();

break;

case 'z':

munecaz = (munecaz+5)%360;

glutPostRedisplay();

break;

case 'v':

pulgfalmedy = (pulgfalmedy+5)%90;

glutPostRedisplay();

break;

case 'c':

pulgfalmedx = (pulgfalmedx+5)%90;

glutPostRedisplay();

break;

case 'b':

pulgfalmen = (pulgfalmen+5)%90;

glutPostRedisplay();

break;

case 27:

exit(0);

break;

}

}

int main(int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

glutInitWindowSize (800, 800);

glutInitWindowPosition (100, 100);

glutCreateWindow (argv[0]);

init ();

glutIdleFunc(idle);

glutDisplayFunc(display);

glutReshapeFunc(reshape);

glutKeyboardFunc(keyboard);

glutMainLoop();

return 0;

}

Previo Práctica 4

1. ¿Qué es una escena?

Es el lugar donde interactúan 2 o más objetos ya sea que esten relacionados entre sí o no. Esta escena es un espacio donde se juntan varios objetos creados anteriormente para recrear o crear un entorno.

2. ¿Cómo podemos definir una escena jerárquicamente?

Consiste en ordenar objetos geométricos complejos a partir de un objeto raiz. Teniendo diferentes ramificaciones de este objeto raíz que derivan en los demás objetos. Esto se usa para poder organizar mejor una escena ya que haciendo dependencias entre ellos podemos construir de objetos sencillos una escena compleja.

3. Describa el funcionamiento y parámetros de la función:

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

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

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

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. ¿Qué es un double buffer (búfer doble)? ¿Para qué sive? ¿Cómo se declara con GLUT?

El doble buffering es una técnica muy simple, que dibuja la escena en un buffer fuera de la pantalla, mientras que la imágen de la pantalla no se toca para nada. Una vez que la imágen se ha dibujado en el buffer de fondo, se intercambia por el de la pantalla, de manera que eliminamos el parpadeo. El siguiente frame lo dibujaremos en lo que antes era el buffer de pantalla (ahora oculto), y luego se cambiará, y así sucesivamente.

Activar el doble buffering es algo muy sencillo. Hemos de indicar a GLUT que vamos a utilizar doble buffering al crear la pantalla con GLUT_DOUBLE, en lugar de GLUT_SINGLE:

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);

5. ¿Qué es un function callback (llamada a función) pista: sirve para manejo de eventos.

Cuando GLUT detecta un evento, manda llamar a una función, conocida como callback. Esta función tiene un conjunto de parámetros conocidos que describirán el evento. De esta manera se detectan eventos producidos por el usuario o por el sistema de ventanas.

TAREA 3: "MODELADO JERÁRQUICO DE UNA HORMIGA"

1. Modelar jerárquicamente la hormiga

En principio para empezar a modelar jerárquicamente algún objeto lo primero es descomponer hasta la unidad más simple a este objeto e irlo armando poco a poco. En este caso, la unidad más simple de la hormiga es el cubo y con este vamos a ir trabajando la figura. Para empezar se debe definir una rama o una sección del objeto que sea la principal y que de ahí se deriven todas las demás. Para seleccionar corrctamente esta rama se divide a la hormiga. La forma en la que yo la dividí fue la siguiente:

• Cabeza
• Pecho
• Base
• Torzo
• Patas

Hay que aclarar que las patas se dividen también en 3 secciones. Para este ejercicio tomé como la rama principal el pecho ya que viendo el dibujo hecho por el profesor me parece que es la manera más fácil de hacerlo ya que de ahí se derivan directamente las patas, cabeza y torzo, la base se puede tomar como un derivación del torzo. A mi parecer dibujarlo con esta jerarquía es la manera más fácil de dibujar a la figura completa dándole libertad para el movimiento posterior que se le pueda dar.

2. Construir el árbol del modelo

3. Escribir pseudocódigo

void hormiga ()
{
push();
....
push();
Rotacion(); //Estos 3 renglones
Traslacion(); //son opcionales
Escalamiento(); //
pecho();
pop();
....
pop();
}

void pecho();
{
push();
traslacion();
escala();
cubo();
push();
traslacion();
torzo();
pop();
push();
traslacion();
cabeza();
pop();
push();
traslacion();
patas();
pop();
pop();
}

void patas()
{
push
push();
rotacion();
escalamiento();
trozo1();
pop();
push();
rotacion();
escalamiento();
trozo2();
pop();
push();
rotacion();
escalamiento();
trozo3();
pop();
pop();
}

void torzo()
{
push();
escalamiento();
cubo();
push();
traslacion();
base();
pop();
pop();
}

void cabeza ()
{
push();
escalamiento();
cubo();
pop();
}

void base()
{
push();
escalamiento();
cubo();
pop();
}

Práctica 2

1.Definir el uso, argumentos y declaración de las siguientes funciones:

a) void glutSolidCube(GLdouble size)
Renderiza un cubo sólido.El cubo se centra en el origen de las coordenadas de modelato con lados cuya longitud la determina size.

b) void glutSolidSphere(GLdouble base, GLdouble height,GLint slices, GLint stacks);
Los parámetros son:
*base:define el radio de la base del cono.
*height:para establecer la altura del cono.
*slices:define el número de subdivisiones alrededor del eje Z.
*stacks: establece el número de subdivisiones a lo largo del eje z.

Descripción: renderiza un cono sólido orientado a lo largo del ejeZ. La base del cono se pone en Z=0, y la punta superior en Z=height. El cono se subdivide alrededor del eje Z en slices, y a lo largo del mismo eje en stacks.

c) void glutSolidCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);
Sus parámetros son:
*base: para el radio de la base del cono.
*height: define la altura del cono.
*slices:define el número de subdivisiones alrededor del eje Z.
*stacks: establece el número de subdivisiones a lo largo del eje z.

Descripción:
Renderiza un cono sólido orientado a lo largo del eje Z. La base del cono se pone en Z =0, y la parte superior en Z=height. El cono se e subdivide alrededor del eje Z en slices, y a lo largo del mismo eje en stacks.

d)void glutSolidTorus(GLdouble innerRadius, GLdouble outerRadiusGLint nsides, GLint rings);
Parámetros:
*innerRadius: radio interno del toro.
*outerRadius: radio externo del toro.
*nsides: número de lados para cada sección radial.
*rigs: número de divisiones radiales para el toro.

Descripción: renderiza un toro sólido ( en forma de donda) centrada en el
de las coordenadas de modelado cuyo eje se alinea con el eje Z.

El código siguiente dibuja las cuatro figuras en el mismo programa pero se ven planas.

#include

float aspect = 1.0f;
/*La función dibujaObjetos es para dibujar el
torus,el cilindro, la esfera y el cubo en la misma ventana.*/
void dibujaObjetos(void) {
//Limpiamos el buffer que es en donde dibujaremos:
glClear(GL_COLOR_BUFFER_BIT);
//Para trabajar con el modelador.
glMatrixMode(GL_MODELVIEW);
//Para las transformaciones utilizaremos la matriz identidad:
glLoadIdentity();
/*Utilizo sólo transformaciones para ubicar las figuras en diferentes sitios
de la pantalla: */
glTranslatef(0.5,.5,0);
glColor3f(1,0,0);
glutSolidCube(.5);
/*La siguiente transformación se hará con respecto al origen,debo utilizar
la matriz identidad: */
glLoadIdentity();
glTranslatef(-0.5,0.5,0);
glColor3f(1,1,0);
glutSolidCone(.4,.7,100,2);
glLoadIdentity();
glTranslatef(0.5,-0.5,0);
glColor3f(0,1,0);
glutSolidSphere(.4,100,4);
glLoadIdentity();
glColor3f(0,0,1);
glTranslatef(-0.5,-0.5,0);
glutSolidTorus(.1,.3,100,20);
/*Hacemos que todos los comandos que estén en espera de ogl se ejecuten:*/
glFlush();
//Para volcar un frame de un buffer a otro:
glutSwapBuffers();
}
//Función para redimensionar la ventana;
void onSize(int sx, int sy) {
//Para definir el puerto de vista:
glViewport(0, 0, sx, sy);
aspect = (float) sx / (float) sy;
}

void main(void) {
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(500, 300);
glutInitWindowPosition(100, 100);
glutCreateWindow("Objetos definidos");
glutDisplayFunc(dibujaObjetos);
//Callback para cuando la ventana se redimensiona:
glutReshapeFunc(onSize);
glutMainLoop();
}

#include

#include

#include

#include

void Cabeza()

{

glfloat vertices[]{ {0.5,0.5,0.5},

{-0.5,0.5,0.5},

{-0.5,0.5,0.5},

{0.5,-0.5,0.5},

{0.5,-0.5,-0.5},

{-0.5,-0.5,0.5},

{-0.5,0.5,0.5},

{0.5,0.5,-0.5}};

glBegin(GL,Quads);

glVertex3fu(vertices[0]);

glVertex3fu(vertices[1]);

glVertex3fu(vertices[2]);

glVertex3fu(vertices[3]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[8]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[2]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[3]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[3]);

glVertex3fu(vertices[4]);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[8]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[1]);

glVertex3fu(vertices[8]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[2]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[3]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[4]);

glEnd(); //Para unir los vertices

}

void Cuerpo()//Para trazar el cuerpo "tronco"

{

glfloat vertices[]{ {1.0,-0.5,0.5},

{-1.0,-0.5.0.5},

{-1.0,-3.0,0.5},

{1.0,-3.0,0.5},

{1.0,-3.0,-0.5},

{-1.0,-3.0,-0.5},

{-1.0,0.5,-0.5},

{1.0,0.5,-0.5}};

glBegin(GL,Quads);

glVertex3fu(vertices[0]);

glVertex3fu(vertices[1]);

glVertex3fu(vertices[2]);

glVertex3fu(vertices[3]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[8]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[2]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[3]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[3]);

glVertex3fu(vertices[4]);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[8]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[1]);

glVertex3fu(vertices[8]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[2]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[3]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[4]);

glEnd(); //Para unir los vertices

}

void BrazoDer()//Para trazar el brazo derecho

{

glfloat vertices[]{ {1.0,-0.5,0.5},

{1.5,-0.5,0.5},

{1.5,-1.5,0.5},

{1.0,-1.5,0.5},

{1.0,-1.5,-0.5},

{1.5,-1.5,-0.5},

{1.5,-0.5,-0.5},

{1.0,-0.5,-0.5}};

glBegin(GL,Quads);

glVertex3fu(vertices[0]);

glVertex3fu(vertices[1]);

glVertex3fu(vertices[2]);

glVertex3fu(vertices[3]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[8]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[2]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[3]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[3]);

glVertex3fu(vertices[4]);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[8]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[1]);

glVertex3fu(vertices[8]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[2]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[3]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[4]);

glEnd(); //Para unir los vertices

}

void BrazoIzq()//Para trazar el brazo izquierdo

{

glfloat vertices[]{ {-1.0,-0.5,0.5},

{-1.5,-0.5,0.5},

{-1.5,-1.5,0.5},

{-1.0,-1.5,0.5},

{-1.0,-1.5,-0.5},

{-1.5,-1.5,-0.5},

{-1.5,-0.5,-0.5},

{-1.0,-0.5,-0.5}};

glBegin(GL,Quads);

glVertex3fu(vertices[0]);

glVertex3fu(vertices[1]);

glVertex3fu(vertices[2]);

glVertex3fu(vertices[3]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[8]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[2]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[3]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[3]);

glVertex3fu(vertices[4]);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[8]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[1]);

glVertex3fu(vertices[8]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[2]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[3]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[4]);

glEnd(); //Para unir los vertices

}

void PiernaDer()//Para trazar la pierna derecha

{

glfloat vertices[]{ {0.5,-3.0,0.5},

{1.0,-3.0,0.5},

{1.0,-4.0,0.5},

{0.5,-4.0,0.5},

{0.5,-4.0,-0.5},

{1.0,-4.0,-0.5},

{1.0,-3.0,-0.5},

{0.5,-3.0,-0.5}};

glBegin(GL,Quads);

glVertex3fu(vertices[0]);

glVertex3fu(vertices[1]);

glVertex3fu(vertices[2]);

glVertex3fu(vertices[3]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[8]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[2]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[3]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[3]);

glVertex3fu(vertices[4]);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[8]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[1]);

glVertex3fu(vertices[8]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[2]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[3]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[4]);

glEnd(); //Para unir los vertices

}

void PiernaIzq()//Para trazar la pierna izquierda

{

glfloat vertices[]{ {-0.5,-3.0,0.5},

{-1.0,-3.0,0.5},

{-1.0,-4.0,0.5},

{-0.5,-4.0,0.5},

{-0.5,-4.0,-0.5},

{-1.0,-4.0,-0.5},

{-1.0,-3.0,-0.5},

{-0.5,-3.0,-0.5}};

glBegin(GL,Quads);

glVertex3fu(vertices[0]);

glVertex3fu(vertices[1]);

glVertex3fu(vertices[2]);

glVertex3fu(vertices[3]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[8]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[2]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[3]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[3]);

glVertex3fu(vertices[4]);

glVertex3fu(vertices[5]);

glVertex3fu(vertices[8]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[1]);

glVertex3fu(vertices[8]);

glVertex3fu(vertices[7]);

glVertex3fu(vertices[2]);

glEnd(); //Para unir los vertices

glBegin(GL,Quads);

glVertex3fu(vertices[3]);

glVertex3fu(vertices[6]);

glVertex3fu(vertices[5]);
glVertex3fu(vertices[4]);
glEnd(); //Para unir los vertices
}

main()
{
Cabeza();
Cuerpo();
BrazoDer();
BrazoIzq();
PiernaDer();
Pierna Izq();
}

Previo práctica 3

Investigar el uso, parámetros y variables de los comandos OpenGL

Podemos dibujar puntos, líneas y polígonos. Para definir un punto en el espacio 3D, usaremos la función:
glVertex3f(x, y, z). Estos puntos se unen formando estructuras, como líneas y polígonos. La siguiente tabla muestra alguna de las opciones que tenemos:

Modo Descripción

GL_POINTS Puntos individuales aislados
GL_LINES Cada par de puntos corresponde a una recta
GL_LINE_STRIP Segmentos de recta conectados
GL_LINE_LOOP Segmentos de recta conectados y cerrados
GL_TRIANGLES Cada tres puntos un triángulo
GL_QUADS Cada cuatro puntos un cuadrado
GL_POLYGON Un polígono

glBegin(): Se va a empezar una secuencia de lo que haya en el argumento, p. ej. glBegin(GL_TRIANGLES) Se empieza una secuencia de triángulos.

glEnd(): para terminar el ciclo que definimos

void glBegin(GLenum mode);

Marca el inicio de una lista de vértices que describen una primitiva geométrica. El tipo de primitiva está indicado por modo, el cual puede tener uno de los siguientes valores.

Valores Significado

GL_POINTS Puntos individuales

GL_LINES Par de vértices interpretados como líneas de segmentos individuales

GL_POLYGON Límite de un polígono simple convexo

GL_TRIANGLES Trios de vértices interpretados como triángulos

GL_QUADS Cuádruples de vértices interpretados como polígonos de cuatro lados

GL_LINE_STRIP Series de líneas de segmentos conectados

GL_LINE_LOOP Igual que el anterior, pero con un segmento añadido entre el primer y el último vértice

GL_TRIANGLE_STRIP Enlazar tiras de triángulos

GL_TRIANGLE_FAN Enlazar abanicos de triángulos

GL_QUAD_STRIP Enlazar tiras de cuadriláteros

void glEnd(void);

Marca el final de una lista de vértices.

void glClear(Glbitfdield mask)
Limpia los buffers especificados asignándoles los valores actuales. El argumento mask puede tener los siguientes valores:

Buffer Nombre
Buffer de color GL_COLOR_BUFFER_BIT
Buffer de fondo GL_DEPTH_BUFFER_BIT
Buffer de acumulación GL_ACCUM_BUFFER_BIT
Buffer de patrón GL_STENCIL_BUFFER_BIT

void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
Establece el color actual que va a aparecer en el fondo de la ventana en modo RGBA. Los valores red, green, blue y alpha están restringidos entre los
valores [0,1]. El valor por defecto es (0,0,0,0) negro.

void glPushMatrix() y glPopMatrix()

Dado que las operaciones sobre las matrices son acumulativas, es necesario tener una manera de recuperar el estado anterior de la matriz.
OpenGL dispone de una pila para cada matriz; para la matriz ModelView el tamaño de esta pila es de al menos 32 matrices, mientras que para la matriz Projection es de al menos 2.
La función glPushMatrix nos permite guardar la matriz actual en la pila, mientras que la función glPopMatrix coge la matriz que se encuentre en el top de la pila y la asigna a la matriz actual.
La función glPushMatrix () realiza una copia de la matriz superior y la pone encima de la pila, de tal forma que las dos matrices superiores son iguales.
La función glPopMatrix () elimina la matriz superior, quedando en la parte superior de la pila la matriz que estaba en el momento de llamar a la función glPushMatrix ().

TAREA 2

Espacio Vectorial

Es el objeto básico de estudio en la rama de la matemática llamada álgebra lineal. Las operaciones que podemos realizar entre ellos son: la suma de vectores y la multiplicación por un escalar,el producto punto, el producto vectorial y el triple producto escalar con algunas restricciones naturales como el cierre de estas operaciones, la asociatividad de estas y la combinación de estas operaciones, siguiendo, llegamos a la descripción de una estructura matemática llamada espacio vectorial.

Campo Vectorial

En matemática un campo vectorial es una construcción del cálculo vectorial que asocia un vector a cada punto en el espacio euclídeo. Los campos vectoriales se utilizan a menudo en la física para, por ejemplo, modelar la velocidad y la dirección de un líquido móvil a través del espacio, o la intensidad y la dirección de una cierta fuerza, tal como la fuerza electromagnética o la gravitatoria, pues cambian punto a punto.

Anillo

Es una estructura algebraica formada por un conjunto y dos operaciones que están relacionadas entre sí mediante la propiedad distributiva, de manera que generalizan la noción de número, especialmente en el sentido de su "operabilidad".m

Previo práctica 2

1. Investigar el uso, parámetros y variantes de las siguientes funciones:

a) glVertex()

Esta función se usa para especificar un punto de dibujo en una paleta 3d ó 2d, en pocas palabras, se puede decir que representa el vértice de cualquier línea, punto o de una figura como lo son los polígonos. Es ta función puede tomar de 2 a 4 parámetros (siempre numéricos) según lo que se desee ya que estos parámetros representan coordenadas en un plano. Se puede utilizar para dibujos en 2d y en 3d y se le pueden dar valores enteros, flotantes, shorts y dobles, además de tener la opción de darle parámetros como arreglos. Las derivaciones de esta función y la forma en la que se invocan son las siguientes:

void glVertex2d( GLdouble x, GLdouble y )
void glVertex2f( GLfloat x, GLfloat y )
void glVertex2i( GLint x, GLint y )
void glVertex2s( GLshort x, GLshort y )
void glVertex3d( GLdouble x, GLdouble y, GLdouble z )
void glVertex3f( GLfloat x, GLfloat y, GLfloat z )
void glVertex3i( GLint x, GLint y, GLint z )
void glVertex3s( GLshort x, GLshort y, GLshort z )
void glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
void glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
void glVertex4i( GLint x, GLint y, GLint z, GLint w )
void glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w )

***Para mandar arreglos se hace las funciones son:

void glVertex2dv(const GLdouble *v);
void glVertex2fv(const GLfloat *v);
void glVertex2iv(const GLint *v);
void glVertex2sv(const GLshort *v);
void glVertex3dv(const GLdouble *v);
void glVertex3fv(const GLfloat *v);
void glVertex3iv(const GLint *v);
void glVertex3sv(const GLshort *v);
void glVertex4dv(const GLdouble *v);
void glVertex4fv(const GLfloat *v);
void glVertex4iv(const GLint *v);
void glVertex4sv(const GLshort *v);


b) glBegin

Esta función sirve para delimitar los vértices de un primitivo o de un grupo de primitivos parecidos.Esta función acepta un argumento simple que especifica en cuál de las 10 formas los vértices son interpretados (puntos, líneas, triángulos, cuadrados, polígonos). El argumento mandado a esta función representa el número total de vértices especificados y siendo este número un entero pudiendo empezando desde uno. La forma en que se invoca a la función es la siguiente:

void glBegin(GLenum mode);

Las variables simbólicas que se pueden mandar (GLenum mode) son:

GL_POINTS: Trata a cada vértice como un punto.
GL_LINES: Cada par de vértices en un segmento de línea independiente.
GL_LINE_STRIP: Dibuja un grupo de segmentos de línea conectados, desde el primer vértice hasta el último.
GL_LINE_LOOP:Dibuja un grupo de segmentos de línea conectados, desde el primer vértice hasta el último y luego regresa al primero.
GL_TRIANGLES:Trata a cada tripleta de vértices como un triángulo independiente.
GL_TRIANGLE_STRIP: Dibuja un grupo de triángulos conectados. Un triángulo es definido para cada vértice presentado después de los primeros dos vértices.
GL_TRIANGLE_FAN:Dibuja un grupo de triángulos conectados pero ahora estos triángulos tienen un vértice central en común.
GL_QUADS:Trata a cada grupo de 4 vértices como un cuadrilatero independiente.
GL_QUADS_STRIP:Dibuja un grupo de cuadrilateros conectados. Un cuadrilatero es definido para cada par de vértices presentados después del primer par.
GL_POLYGON:Dibuja un polígono convexo. Los vértices 1 a n definen al polígono.

c) glEnd()

Esta función no requiere parámetros ya que sólo indica que ahí se acaban las sentencias para definir glBegin(). Esta función es necesaria al escribir glBegin() ya que marca el fin de esta función.

d) glPushMatrix()

Si hay una pila de matrices, esta función hace una copia de la matriz superior y la pone encima de la pila, haciendola que las dos primeras matrices sean iguales. La forma en la que se declara la función es:

void glPushMatrix();

Existe una pila de matrices para cada modo de matriz. En el modo GL_MODELVIEW la profundidad de la pila es de al menos 32 y en los modos GL_PROJECTION y GL_TEXTURE la profundidad es de al menos 2.

e) glPopMatrix();

Con esta función se elimina en una pila la matriz superior, quedando así en la primera posición de la pila la matriz que era la primera antes de usar la función glPushMatrix(). La función se declara de la siguiente forma:

void glPopMatrix();

f) glTranslate();

Esta es una instrucción que sirve para trasladar nuestro sistema de coordenadas (los ejes) desde el punto de origen hasta el punto de las coordenadas especificadas mediante los parámetros (x,y,z). Estos parámetros pueden ser de tipo doble o flotante y se declara de la siguiente manera:

void glTranslated (GLdouble x, GLdoubley, GLdoublez);
void glTranslatef (GLfloat x, GLfloat y, GLfloat z);

g) glRotate();

Como su nombre lo dice, esta función sirve para poder rotar en grados un vector (x,y,z). Esta función toma los parámetros primero del ángulo en grados y después los parámetros x,y,z que representan al vector respecto al cual se dara la rotación. El ángulo se toma en sentido contrario a las manecillas del reloj y su declaración es la siguiente:

void glRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
void glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloatz);

h) glScale();

Esta función produce un escalamiento general a lo largo de los ejes x, y, z. Esta función requiere de 3 parámetros que indican el factor de escala deseado para cada uno de los ejes. Estos parámetros pueden ser de tipo doble o flotantes y su declaración es la siguiente:

void glScaled (GLdouble x, GLdouble y, GLdouble z);
void glScalef (GLfloat x, GLfloat y, GLfloat z);

i) glClear();

Se usa para limpiarr el contenido del buffer. Sus parámetros son banderas que indican qué buffer se va a limpiar. Al aplicar la función regresa al buffer los valores por defecto. La declaración de esta función es la siguiente:

void glClear (GLbitfield mask);

con los siguientes parámetros

GL_COLOR_BUFFER_BIT (Buffer de color RGBA)
GL_DEPTH BUFFER_BIT (Buffer de profundidad)
GL_STENCER_BUFFER_BIT (Buffer de esténcil)
GL_ACCUM_BUFFER_BIT (Buffer acumulado)

j) glClearColor();

Esta función especifica los valores de rojo, verde, azul y alpha usados por la función glClear() para limpiar los buffer de color, es decir, limpia la pantalla con el color especificado. El rango de valores que se pueden especificar es de [0,1] y su valor por defecto es (0,0,0,0). La forma en la que se invoca es la siguiente:

void glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);

2. Hacer el código para un Tetraedro

#include

void HaceTetra() {

glClear(GL_COLOR_BUFFER_BIT);

glBegin(GL_TRIANGLE_STRIP);

glColor3f(1, 0, 0);
glVertex3f(0, 2, 0);
glVertex3f(-1, 0, 1);
glVertex3f(1, 0, 1);
glColor3f(0, 1, 0);
glVertex3f(0, 0, -1.4);
glVertex3f(0, 2, 0);
glVertex3f(-1, 0, 1);

glEnd();
glFlush();
}

void SetPantalla() {

glClearColor(1, 1, 1, 1.0);
glColor3f(0.0, 0.0, 0.0);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-2, 2, -2, 2, 1, 50);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0, 0, -3);
glRotatef(50, 1, 0, 0);
glRotatef(45, 0, 1, 0);
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(80, 80);
glutInitWindowSize(400, 300);
glutCreateWindow("Tetra");
glutDisplayFunc(HaceTetra);
SetPantalla();
glutMainLoop();
}

3.Hacer un archivo de cabecera y llamarlo Objetos.h y ahí poner el código que dibuja un tetraedro.

Objetos.h

void HaceTetra() {

glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_TRIANGLE_STRIP);

glColor3f(1, 0, 0);
glVertex3f(0, 2, 0);
glVertex3f(-1, 0, 1);
glVertex3f(1, 0, 1);
glColor3f(0, 1, 0);
glVertex3f(0, 0, -1.4);
glVertex3f(0, 2, 0);
glVertex3f(-1, 0, 1);

glEnd();
glFlush();
}

4. En ese mismo archivo de cabecera hacer una función que dibuje un prisma triangular

objetos.h

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

void drawTetraedro()
{
glClear(GL_COLOR_BUFFER_BIT);
glLoadIdentity();
glBegin(GL_TRIANGLE_STRIP);
glColor3f(.6,.7,0);
glVertex3f(1,0,0);glVertex3f(0,1,0);glVertex3f(0,0,1);
glColor3f(1,1,0);
glVertex3f(-.5,-.5,.5);glVertex3f(0,1,0);glVertex3f(0,0,1);
glColor3f(.6,.7,.4);
glVertex3f(-.5,-.5,.5);glVertex3f(1,0,0);glVertex3f(0,0,1);
glEnd();
glFlush();

}

void prismaTriangular()
{
glClear(GL_COLOR_BUFFER_BIT);
glLoadIdentity();
glBegin(GL_QUADS);
glColor3f(1,0,0);
glVertex3f(-0.5,0.5,-0.5);
glVertex3f(-0.5,-0.5,0.5);
glColor3f(1,.75,.75);
glVertex3f(0.5,-0.5,0.5);
glColor3d(1,.2,.2);
glVertex3f(0.5,0.5,-0.5);

glEnd();

glBegin(GL_TRIANGLE_STRIP);
glColor3f(.85,0,0);
glVertex3f(0,.72,0);
glColor3f(1,0,0);
glVertex3f(.5,.5,-.5);
glColor3f(1,.75,.75);
glVertex3f(-.5,.5,-.5);
glEnd();
glFlush();

}

void init()
{
glClearColor(0,0,0,0);
}

#include
#include "objetos.h"

int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("Prisma de base triangular");
init();
glutDisplayFunc(prismaTriangular);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}