Practica 4

/** mano_reflejo.c
Este programa despliega una mano formado unicamente por cubos de diferetes tamaños, todos creados a apartir
de un cubo base y aplicando transformadas de traslacion, escalamiento y rotacion, para rotar las manos apretar q,w y e*/
#include <>
#include <>
static int posicionx = 0;
static int posiciony = 0;
static int posicionz = 0;
/*falanges dedo chiquito*/
static int chiquito1 = 0;
static int chiquito2 = 0;
static int chiquito3 = 0;
/*falanges dedo anular*/
static int anular1 = 0;
static int anular2 = 0;
static int anular3 = 0;
/*falanges dedo medio*/
static int medio1 = 0;
static int medio2 = 0;
static int medio3 = 0;
/*falanges dedo indice*/
static int indice1 = 0;
static int indice2 = 0;
static int indice3 = 0;
/*falanges dedo gordo*/
static int gordo1a = 0;
static int gordo1b = 0;
static int gordo2 = 0;
static int gordo3 = 0;
GLUquadricObj *sphereObj;
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}
void actualizaArticulaciones(void)
{
int i,j;
if(chiquito1 <= 90)
{
for (i=0;i<15000000;i++)
{
}
chiquito1 = (chiquito1 +5);
chiquito2 = (chiquito2 + 5);
chiquito3 = (chiquito3 + 5);
/*falanges dedo anular*/
anular1 = (anular1 + 5);
anular2 = (anular2 + 5);
anular3 = (anular3 + 5);
/*falanges dedo medio*/
medio1 = (medio1 + 5);
medio2 = (medio2 + 5);
medio3 = (medio3 + 5);
/*falanges dedo indice*/
indice1 = (indice1 + 5);
indice2 = (indice2 + 5);
indice3 = (indice3 + 5);
/*falanges dedo gordo*/
gordo1a = -45;
gordo1b = (gordo1b + 5);
gordo2 = (gordo2 + 5);
gordo3 = (gordo3 + 5);
}
else
{
for (j = 0; j<18; j++)
{
for (i=0;i<15000000;i++)
{
}
chiquito1 = (chiquito1 -5);
chiquito2 = (chiquito2 - 5);
chiquito3 = (chiquito3 - 5);
/*falanges dedo anular*/
anular1 = (anular1 - 5);
anular2 = (anular2 - 5);
anular3 = (anular3 - 5);
/*falanges dedo medio*/
medio1 = (medio1 - 5);
medio2 = (medio2 - 5);
medio3 = (medio3 - 5);
/*falanges dedo indice*/
indice1 = (indice1 - 5);
indice2 = (indice2 - 5);
indice3 = (indice3 - 5);
/*falanges dedo gordo*/
gordo1a = -45;
gordo1b = (gordo1b - 5);
gordo2 = (gordo2 - 5);
gordo3 = (gordo3 - 5);
}
}
}

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();
}
void muneca (int px, int py, int pz)
{
/*muñeca y palma*/
glTranslatef(0.0,0.0,0.0);
glRotatef(px,1.0,0.0,0.0);
glRotatef(py,0.0,1.0,0.0);
glRotatef(pz,0.0,0.0,1.0);
glTranslatef(0.0,0.5,0.0);
glPushMatrix();
glScalef(1.0,1.0,0.33333);
cubohueco();
glPopMatrix();
}
void dedos(int ch1,int ch2,int ch3,int a1,int a2,int a3,int m1,int m2,int m3,
int i1,int i2,int i3,int g1a,int g1b, int g2, int g3)
{
/*dedo chito*/
glScalef(1.0,1.0,1.0);
glPushMatrix();
/*primera falange*/
glScalef(0.25,0.25,0.25);
glTranslatef(-1.5,2.2,0.0);
glRotatef(ch1,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.0,0.0);
glPushMatrix();
glScalef(1.0,1.5,1.0);
cubohueco();
glPopMatrix();
/*segunda falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(ch2,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,0.85,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
/*tercera falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(ch3,1.0,0.0,0.0);
gluSphere(sphereObj, 0.60, 12, 5);
glTranslatef(0.0,0.75,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*fin dedo chiquito*/
/*dedo anular*/
glPushMatrix();
/*primera falange*/
glScalef(0.25,0.25,0.25);
glTranslatef(-0.5,2.2,0.0);
glRotatef(a1,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.0,0.0);
glPushMatrix();
glScalef(1.0,1.5,1.0);
cubohueco();
glPopMatrix();
/*segunda falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(a2,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.25,0.0);
glPushMatrix();
glScalef(1.0,1.75,1.0);
cubohueco();
glPopMatrix();
/*tercera falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(a3,1.0,0.0,0.0);
gluSphere(sphereObj, 0.60, 12, 5);
glTranslatef(0.0,0.75,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*fin dedo anular*/
/*dedo medio*/
glPushMatrix();
/*primera falange*/
glScalef(0.25,0.25,0.25);
glTranslatef(0.5,2.2,0.0);
glRotatef(m1,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.0,0.0);
glPushMatrix();
glScalef(1.0,1.5,1.0);
cubohueco();
glPopMatrix();
/*segunda falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(m2,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.5,0.0);
glPushMatrix();
glScalef(1.0,2.25,1.0);
cubohueco();
glPopMatrix();
/*tercera falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(m3,1.0,0.0,0.0);
gluSphere(sphereObj, 0.60, 12, 5);
glTranslatef(0.0,0.75,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*fin dedo medio*/
/*dedo indice*/
glPushMatrix();
/*primera falange*/
glScalef(0.25,0.25,0.25);
glTranslatef(1.5,2.2,0.0);
glRotatef(i1,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.0,0.0);
glPushMatrix();
glScalef(1.0,1.5,1.0);
cubohueco();
glPopMatrix();
/*segunda falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(i2,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.25,0.0);
glPushMatrix();
glScalef(1.0,1.75,1.0);
cubohueco();
glPopMatrix();
/*tercera falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(i3,1.0,0.0,0.0);
gluSphere(sphereObj, 0.60, 12, 5);
glTranslatef(0.0,0.75,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*fin dedo indice*/
/*dedo gordo*/
glPushMatrix();
/*primera falange*/
glScalef(0.25,0.25,0.25);
glTranslatef(2.0,-1.25,0.0);
glRotatef(g1a,0.0,-1.0,0.0);
glRotatef(g1b,0.0,0.0,1.0);
glScalef(1.3,1.3,1.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.75,0.0,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
/*segunda falange*/
glTranslatef(0.9,0.0,0.0);
glRotatef(g2,0.0,0.0,1.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.6,0.0,0.0);
glPushMatrix();
glScalef(0.75,1.0,1.0);
cubohueco();
glPopMatrix();
/*tercera falange*/
glTranslatef(0.75,0.0,0.0);
glRotatef(g3,0.0,0.0,1.0);
gluSphere(sphereObj, 0.60, 12, 5);
glTranslatef(0.5,0.0,0.0);
glPushMatrix();
glScalef(0.75,1.0,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*fin dedo gordo*/
}
void mano(int posx, int posy, int posz,int chi1, int chi2, int chi3,int an1, int an2, int an3,
int med1, int med2, int med3,int in1, int in2, int in3,int go1a,int go1b,int go2,int go3)
{
//glScalef(1.0,1.0,1.0);
muneca(posx,posy,posz);
dedos(chi1,chi2,chi3,an1,an2,an3,med1,med2,med3,in1,in2,in3,go1a,go1b,go2,go3);
}
void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity ();
gluLookAt (0.0,0.0,6.0,0.0,0.0, 0.0, 0.0, 1.0, 0.0);
sphereObj = gluNewQuadric();
gluQuadricDrawStyle(sphereObj, GLU_LINE);
glPushMatrix();
glTranslatef(2,-1,0);
glRotatef(-90,0.0,1.0,0.0);
mano(posicionx,posiciony,posicionz,chiquito1,chiquito2,chiquito3,anular1,anular2,anular3,
medio1,medio2,medio3,indice1,indice2,indice3,gordo1a,gordo1b,gordo2,gordo3);
glPopMatrix();
glPushMatrix();
glTranslatef(-2,-1,0);
glScalef(-1,1,1);
glRotatef(-90,0.0,1.0,0.0);
mano(posicionx,posiciony,posicionz,chiquito1,chiquito2,chiquito3,anular1,anular2,anular3,
medio1,medio2,medio3,indice1,indice2,indice3,gordo1a,gordo1b,gordo2,gordo3);
glPopMatrix();
glFlush ();
}
void idle(void)
{
actualizaArticulaciones();
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 27:
exit(0);
break;
case 'q':
posicionx = (posicionx+3)%360;
glutPostRedisplay();
break;
case 'w':
posiciony = (posiciony+3)%360;
glutPostRedisplay();
break;
case 'e':
posicionz = (posicionz+3)%360;
glutPostRedisplay();
break;
case 'a':
posicionx = 0;
posiciony = 0;
posicionz = 0;
glutPostRedisplay();
break;
}
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (800, 800);
glutInitWindowPosition (90, 90);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

Tarea 3

Si:

u = x * (w/a)
v = y * (i/h)

La matriz que representa esta transformación es:






glViewport: la función glViewport selecciona la porción de la ventana que se puede dibujar en OpenGL, la forma en la que define es la siguiente:

void glViewport ( GLint x, GLint y, GLsizei width, GLsizei height);

Donde “x” y “y” son los parámetros que especifican la esquina inferior izquierda de la ventana, generalmente estos parámetros ambos cero, el parámetro width y height la dimensión de la ventana en píxeles.

Bibliografía:

Richard S. Wright Jr, Michael Sweer, “OpenGL SuperBible”
Pagina: 55

Practica 3 y Previo 4

Escena de Humanoides

#include <>
#include <>

static int posicionx = 0;
static int posiciony = 0;
static int posicionz = 0;
/*cabeza*/
static int cuelloy = 0;
/*brazo derecho*/
static int hombroderx = 0;
static int hombrodery = 0;
static int hombroderz = 0;
static int cododerz = 0;
/*brazo izquierdo*/
static int hombroizqx = 0;
static int hombroizqy = 0;
static int hombroizqz = 0;
static int codoizqz = 0;
/*pierna derecha*/
static int musloderx = 0;
static int muslodery = 0;
static int musloderz = 0;
static int rodilladerx = 0;
static int piedery = 0;
/*pierna izquierda*/
static int musloizqx = 0;
static int musloizqy = 0;
static int musloizqz = 0;
static int rodillaizqx = 0;
static int pieizqy = 0;

void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}
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();
}
void torso (int posx,int posy,int posz)
{
glTranslatef(0.0,1.5,0.0);
glScalef (0.5, 0.5, 0.5);
glRotatef(posx,1.0,0.0,0.0);
glRotatef(posy,0.0,1.0,0.0);
glRotatef(posz,0.0,0.0,1.0);
glTranslatef(0.0,0.0,0.0);
glPushMatrix();
glScalef (2.0, 3.0, 1.0);
cubohueco();
glPopMatrix();
}
void cara (int cuey)
{
glPushMatrix();
glRotatef(cuey,0.0,1.0,0.0);
glTranslatef(0.0,2.0,0.0);
cubohueco();
glPopMatrix();
}
void brazoderecho (int hombrodx,int hombrody,int hombrodz,int cododz)
{
/*brazo derecho*/
glPushMatrix();
glTranslatef(1.0,1.0,0.0);
glRotatef(hombrodx,1.0,0.0,0.0);
glRotatef(hombrody,0.0,1.0,0.0);
glRotatef(hombrodz,0.0,0.0,1.0);
glTranslatef(1.0,0.25,0.0);
glPushMatrix();
glScalef(2.0,0.5,1.0);
cubohueco();
glPopMatrix();
/*antebrazo derecho*/
glTranslatef(1.0,0.0,0.0);
glRotatef(cododz,0.0,0.0,1.0);
glTranslatef(1.0,0.0,0.0);
glPushMatrix();
glScalef(2.0,1.0,1.0);
cubohueco();
glPopMatrix();
/*mano derecha*/
glTranslatef(1.25,0.0,0.0);
glPushMatrix();
glScalef(0.5,0.5,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*brazo derecho completo*/
}
void brazoizquierdo (int hombroix,int hombroiy,int hombroiz,int codoiz)
{
/*brazo izquierdo*/
glPushMatrix();
glTranslatef(-1.0,1.0,0.0);
glRotatef(hombroix,1.0,0.0,0.0);
glRotatef(hombroiy,0.0,1.0,0.0);
glRotatef(hombroiz,0.0,0.0,1.0);
glTranslatef(-1.0,0.25,0.0);
glPushMatrix();
glScalef(2.0,0.5,1.0);
cubohueco();
glPopMatrix();
/*antebrazo izquierdo*/
glTranslatef(-1.0,0.0,0.0);
glRotatef(codoiz,0.0,0.0,1.0);
glTranslatef(-1.0,0.0,0.0);
glPushMatrix();
glScalef(2.0,1.0,1.0);
cubohueco();
glPopMatrix();
/*mano derecha*/
glTranslatef(-1.25,0.0,0.0);
glPushMatrix();
glScalef(0.5,0.5,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*brazo izquierdo completo*/
}
void piernaderecha(int muslodx,int muslody,int muslodz,int rodilladx,int piedy)
{
/*muslo derecho*/
glPushMatrix();
glTranslatef(0.665,-1.5,0.0);
glRotatef(muslodx,1.0,0.0,0.0);
glRotatef(muslody,0.0,1.0,0.0);
glRotatef(muslodz,0.0,0.0,1.0);
glTranslatef(0.0,-1.2,0.0);
glPushMatrix();
glScalef(0.68,2.4,1.0);
cubohueco();
glPopMatrix();
/*pantorrilla derecha*/
glTranslatef(0.0,-1.2,0.0);
glRotatef(rodilladx,1.0,0.0,0.0);
glTranslatef(0.0,-1.2,0.0);
glPushMatrix();
glScalef(1.0,2.4,1.0);
cubohueco();
glPopMatrix();
/*pie derecho*/
glTranslatef(0.0,0.-1.25,0.0);
glRotatef(piedy,0.0,1.0,0.0);
glTranslatef(0.25,-0.35,0.0);
glPushMatrix();
glScalef(1.5,0.75,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*pie derecho completo*/
}
void piernaizquierda(int musloix,int musloiy,int musloiz,int rodillaix,int pieiy)
{
/*muslo izquierdo*/
glPushMatrix();
glTranslatef(-0.665,-1.5,0.0);
glRotatef(musloix,1.0,0.0,0.0);
glRotatef(musloiy,0.0,1.0,0.0);
glRotatef(musloiz,0.0,0.0,1.0);
glTranslatef(0.0,-1.2,0.0);
glPushMatrix();
glScalef(0.68,2.4,1.0);
cubohueco();
glPopMatrix();
/*pantorrilla izquierda*/
glTranslatef(0.0,-1.2,0.0);
glRotatef(rodillaix,1.0,0.0,0.0);
glTranslatef(0.0,-1.2,0.0);
glPushMatrix();
glScalef(1.0,2.4,1.0);
cubohueco();
glPopMatrix();
/*pie izquierdo*/
glTranslatef(0.0,0.-1.25,0.0);
glRotatef(pieiy,0.0,1.0,0.0);
glTranslatef(-0.25,-0.35,0.0);
glPushMatrix();
glScalef(1.5,0.75,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*pierna izquierda completo*/
}
void humanoide (int px,int py,int pz,int cy,int hdx,int hdy,int hdz,int cdz,int hix,int hiy,int hiz,int ciz,
int mdx,int mdy,int mdz,int rdx,int pdy,int mix,int miy,int miz,int rix,int piy)
{
torso(px,py,pz);
cara(cy);
brazoderecho(hdx,hdy,hdz,cdz);
brazoizquierdo(hix,hiy,hiz,ciz);
piernaderecha(mdx,mdy,mdz,rdx,pdy);
piernaizquierda(mix,miy,miz,rix,piy);
}
void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity ();
gluLookAt (0.0,0.0,10.0,0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
/*humanoide1*/
glPushMatrix();
glScalef(0.5,0.5,0.5);
glRotatef(-45,0.0,1.0,0.0);
glTranslatef(5.0,0.0,2.0);
humanoide(posicionx,posiciony,posicionz,cuelloy,
hombroderx,hombrodery,hombroderz,cododerz,
hombroizqx,hombroizqy,hombroizqz,codoizqz,
musloderx,muslodery,musloderz,rodilladerx,piedery,
musloizqx,musloizqy,musloizqz,rodillaizqx,pieizqy);
glPopMatrix();
/*humanoide2*/
glPushMatrix();
glTranslatef(1.0,1.0,1.0);
glRotatef(15,1.0,0.0,0.0);
glScalef(0.5,-1.5,0.8);
humanoide(posicionx,posiciony,posicionz,cuelloy,
hombroderx,hombrodery,hombroderz,cododerz,
hombroizqx,hombroizqy,hombroizqz,codoizqz,
musloderx,muslodery,musloderz,rodilladerx,piedery,
musloizqx,musloizqy,musloizqz,rodillaizqx,pieizqy);
glPopMatrix();
/*humanoide3*/
glPushMatrix();
glRotatef(20,0.0,1.0,0.0);
glTranslatef(-2.0,-1.0,-3.0);
humanoide(posicionx,posiciony,posicionz,cuelloy,
hombroderx,hombrodery,hombroderz,cododerz,
hombroizqx,hombroizqy,hombroizqz,codoizqz,
musloderx,muslodery,musloderz,rodilladerx,piedery,
musloizqx,musloizqy,musloizqz,rodillaizqx,pieizqy);
glPopMatrix();
/*humanoide4*/
glPushMatrix();
glScalef(2.0,0.5,1.0);
glRotatef(45,0.0,0.0,1.0);
glTranslatef(-3.0,1.0,2.0);
humanoide(posicionx,posiciony,posicionz,cuelloy,
hombroderx,hombrodery,hombroderz,cododerz,
hombroizqx,hombroizqy,hombroizqz,codoizqz,
musloderx,muslodery,musloderz,rodilladerx,piedery,
musloizqx,musloizqy,musloizqz,rodillaizqx,pieizqy);
glPopMatrix();
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_SINGLE GLUT_RGB);
glutInitWindowSize (800, 800);
glutInitWindowPosition (90, 90);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

Programa de una Mano

#include <>
#include <>
static int posicionx = 0;
static int posiciony = 0;
static int posicionz = 0;
static int posicionx1 = 0;
static int posiciony2 = 0;
static int posicionz3 = 0;
GLUquadricObj *sphereObj;
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}

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();
}
void muneca (void)
{
/*muñeca y palma*/
glTranslatef(0.0,0.0,0.0);
glRotatef(posicionx,1.0,0.0,0.0);
glRotatef(posiciony,0.0,1.0,0.0);
glRotatef(posicionz,0.0,0.0,1.0);
glTranslatef(0.0,0.5,0.0);
glPushMatrix();
glScalef(1.0,1.0,0.33333);
cubohueco();
glPopMatrix();
}
void dedos(void)
{
/*dedo chito*/
glScalef(1.0,1.0,1.0);
glPushMatrix();
/*primera falange*/
glScalef(0.25,0.25,0.25);
glTranslatef(-1.5,2.2,0.0);
glRotatef(posicionx1,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.0,0.0);
glPushMatrix();
glScalef(1.0,1.5,1.0);
cubohueco();
glPopMatrix();
/*segunda falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(posiciony2,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,0.85,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
/*tercera falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(posicionz3,1.0,0.0,0.0);
gluSphere(sphereObj, 0.60, 12, 5);
glTranslatef(0.0,0.75,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*fin dedo chiquito*/
/*dedo anular*/
glPushMatrix();
/*primera falange*/
glScalef(0.25,0.25,0.25);
glTranslatef(-0.5,2.2,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.0,0.0);
glPushMatrix();
glScalef(1.0,1.5,1.0);
cubohueco();
glPopMatrix();
/*segunda falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.25,0.0);
glPushMatrix();
glScalef(1.0,1.75,1.0);
cubohueco();
glPopMatrix();
/*tercera falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.60, 12, 5);
glTranslatef(0.0,0.75,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*fin dedo anular*/
/*dedo medio*/
glPushMatrix();
/*primera falange*/
glScalef(0.25,0.25,0.25);
glTranslatef(0.5,2.2,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.0,0.0);
glPushMatrix();
glScalef(1.0,1.5,1.0);
cubohueco();
glPopMatrix();
/*segunda falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.5,0.0);
glPushMatrix();
glScalef(1.0,2.25,1.0);
cubohueco();
glPopMatrix();
/*tercera falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.60, 12, 5);
glTranslatef(0.0,0.75,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*fin dedo medio*/
/*dedo indice*/
glPushMatrix();
/*primera falange*/
glScalef(0.25,0.25,0.25);
glTranslatef(1.5,2.2,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.0,0.0);
glPushMatrix();
glScalef(1.0,1.5,1.0);
cubohueco();
glPopMatrix();
/*segunda falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.25,0.0);
glPushMatrix();
glScalef(1.0,1.75,1.0);
cubohueco();
glPopMatrix();
/*tercera falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.60, 12, 5);
glTranslatef(0.0,0.75,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*fin dedo indice*/
/*dedo gordo*/
glPushMatrix();
/*primera falange*/
glScalef(0.25,0.25,0.25);
glTranslatef(2.0,-1.25,0.0);
glRotatef(posicionx1,0.0,-1.0,0.0);
glRotatef(posicionx1,0.0,0.0,1.0);
glScalef(1.3,1.3,1.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.75,0.0,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
/*segunda falange*/
glTranslatef(0.9,0.0,0.0);
glRotatef(posiciony2,0.0,0.0,1.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.6,0.0,0.0);
glPushMatrix();
glScalef(0.75,1.0,1.0);
cubohueco();
glPopMatrix();
/*tercera falange*/
glTranslatef(0.75,0.0,0.0);
glRotatef(posicionz3,0.0,0.0,1.0);
gluSphere(sphereObj, 0.60, 12, 5);
glTranslatef(0.5,0.0,0.0);
glPushMatrix();
glScalef(0.75,1.0,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*fin dedo gordo*/
}
void mano(void)
{
muneca();
dedos();
}
void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity ();
gluLookAt (0.0,0.0,5.0,0.0,0.0, 0.0, 0.0, 1.0, 0.0);
sphereObj = gluNewQuadric();
gluQuadricDrawStyle(sphereObj, GLU_LINE);
glPushMatrix();
mano();
glPopMatrix();
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;
case 'q':
posicionx = (posicionx+3)%360;
glutPostRedisplay();
break;
case 'w':
posiciony = (posiciony+3)%360;
glutPostRedisplay();
break;
case 'e':
posicionz = (posicionz+3)%360;
glutPostRedisplay();
break;
case 'i':
posicionx1 = (posicionx1+3)%95;
glutPostRedisplay();
break;
case 'o':
posiciony2 = (posiciony2+3)%95;
glutPostRedisplay();
break;
case 'p':
posicionz3 = (posicionz3+3)%95;
glutPostRedisplay();
break;
case 'a':
posicionx = 0;
posiciony = 0;
posicionz = 0;
posicionx1 = 0;
posiciony2 = 0;
posicionz3 = 0;
glutPostRedisplay();
break;
}
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (800, 800);
glutInitWindowPosition (90, 90);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

Tarea 2

Espacio vectorial (o espacio lineal): 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 esto, 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 euclidiano. Los campos vectoriales se utilizan a menudo en la física para, 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. En el tratamiento matemático riguroso, los campos vectoriales se definen en variedades diferenciables como secciones del fibrado tangente de la variedad.

Anillo: En álgebra, un anillo es una estructura algebraica formada por un conjunto y dos operaciones que están relacionadas entre sí mediante las propiedades distributivas, de manera que generalizan las nociones de número, especialmente en el sentido de su "operabilidad".

La rotación en el eje x es:

x ‘ = x
y ’ = y cos(q) – z sen(q)
z ‘ = y sen(q) + z cos(q)

La rotación en el eje y es:

x ‘ = x cos(q) + z sen(q)
y ’ = y
z ‘ = -x sen(q) + z cos(q)

Fuentes:

http://es.wikipedia.org/wiki/Espacio_vectorial
http://es.wikipedia.org/wiki/Anillo_%28matem%C3%A1ticas%29
http://es.wikipedia.org/wiki/Campo_vectorial

Practica 2 y Previo 3

Aqui esta el código del Humanoide parametrizado


/** humanoide.c
Este programa despliega un humanoide formado unicamente por cubos de diferetes tamaños, todos creados a apartir
de un cubo base y aplicando transformadas de traslacion, escalamiento y rotacion*/
#include
#include
static int posicionx = 0;
static int posiciony = 0;
static int posicionz = 0;
/*cabeza*/
static int cuelloy = 0;
/*brazo derecho*/
static int hombroderx = 0;
static int hombrodery = 0;
static int hombroderz = 0;
static int cododerz = 0;
/*brazo izquierdo*/
static int hombroizqx = 0;
static int hombroizqy = 0;
static int hombroizqz = 0;
static int codoizqz = 0;
/*pierna derecha*/
static int musloderx = 0;
static int muslodery = 0;
static int musloderz = 0;
static int rodilladerx = 0;
static int piedery = 0;
/*pierna izquierda*/
static int musloizqx = 0;
static int musloizqy = 0;
static int musloizqz = 0;
static int rodillaizqx = 0;
static int pieizqy = 0;

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();
}
void torso (int posx,int posy,int posz)
{
glTranslatef(0.0,1.5,0.0);
//glScalef (0.5, 0.5, 0.5);
glRotatef(posx,1.0,0.0,0.0);
glRotatef(posy,0.0,1.0,0.0);
glRotatef(posz,0.0,0.0,1.0);
glTranslatef(0.0,0.0,0.0);
glPushMatrix();
glScalef (2.0, 3.0, 1.0);
cubohueco();
glPopMatrix();
}
void cara (int cuey)
{
glPushMatrix();
glRotatef(cuey,0.0,1.0,0.0);
glTranslatef(0.0,2.0,0.0);
cubohueco();
glPopMatrix();
}
void brazoderecho (int hombrodx,int hombrody,int hombrodz,int cododz)
{
/*brazo derecho*/
glPushMatrix();
glTranslatef(1.0,1.0,0.0);
glRotatef(hombrodx,1.0,0.0,0.0);
glRotatef(hombrody,0.0,1.0,0.0);
glRotatef(hombrodz,0.0,0.0,1.0);
glTranslatef(1.0,0.25,0.0);
glPushMatrix();
glScalef(2.0,0.5,1.0);
cubohueco();
glPopMatrix();
/*antebrazo derecho*/
glTranslatef(1.0,0.0,0.0);
glRotatef(cododz,0.0,0.0,1.0);
glTranslatef(1.0,0.0,0.0);
glPushMatrix();
glScalef(2.0,1.0,1.0);
cubohueco();
glPopMatrix();
/*mano derecha*/
glTranslatef(1.25,0.0,0.0);
glPushMatrix();
glScalef(0.5,0.5,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*brazo derecho completo*/
}
void brazoizquierdo (int hombroix,int hombroiy,int hombroiz,int codoiz)
{
/*brazo izquierdo*/
glPushMatrix();
glTranslatef(-1.0,1.0,0.0);
glRotatef(hombroix,1.0,0.0,0.0);
glRotatef(hombroiy,0.0,1.0,0.0);
glRotatef(hombroiz,0.0,0.0,1.0);
glTranslatef(-1.0,0.25,0.0);
glPushMatrix();
glScalef(2.0,0.5,1.0);
cubohueco();
glPopMatrix();
/*antebrazo izquierdo*/
glTranslatef(-1.0,0.0,0.0);
glRotatef(codoiz,0.0,0.0,1.0);
glTranslatef(-1.0,0.0,0.0);
glPushMatrix();
glScalef(2.0,1.0,1.0);
cubohueco();
glPopMatrix();
/*mano derecha*/
glTranslatef(-1.25,0.0,0.0);
glPushMatrix();
glScalef(0.5,0.5,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*brazo izquierdo completo*/
}
void piernaderecha(int muslodx,int muslody,int muslodz,int rodilladx,int piedy)
{
/*muslo derecho*/
glPushMatrix();
glTranslatef(0.665,-1.5,0.0);
glRotatef(muslodx,1.0,0.0,0.0);
glRotatef(muslody,0.0,1.0,0.0);
glRotatef(muslodz,0.0,0.0,1.0);
glTranslatef(0.0,-1.2,0.0);
glPushMatrix();
glScalef(0.68,2.4,1.0);
cubohueco();
glPopMatrix();
/*pantorrilla derecha*/
glTranslatef(0.0,-1.2,0.0);
glRotatef(rodilladx,1.0,0.0,0.0);
glTranslatef(0.0,-1.2,0.0);
glPushMatrix();
glScalef(1.0,2.4,1.0);
cubohueco();
glPopMatrix();
/*pie derecho*/
glTranslatef(0.0,0.-1.25,0.0);
glRotatef(piedy,0.0,1.0,0.0);
glTranslatef(0.25,-0.35,0.0);
glPushMatrix();
glScalef(1.5,0.75,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*pie derecho completo*/
}
void piernaizquierda(int musloix,int musloiy,int musloiz,int rodillaix,int pieiy)
{
/*muslo izquierdo*/
glPushMatrix();
glTranslatef(-0.665,-1.5,0.0);
glRotatef(musloix,1.0,0.0,0.0);
glRotatef(musloiy,0.0,1.0,0.0);
glRotatef(musloiz,0.0,0.0,1.0);
glTranslatef(0.0,-1.2,0.0);
glPushMatrix();
glScalef(0.68,2.4,1.0);
cubohueco();
glPopMatrix();
/*pantorrilla izquierda*/
glTranslatef(0.0,-1.2,0.0);
glRotatef(rodillaix,1.0,0.0,0.0);
glTranslatef(0.0,-1.2,0.0);
glPushMatrix();
glScalef(1.0,2.4,1.0);
cubohueco();
glPopMatrix();
/*pie izquierdo*/
glTranslatef(0.0,0.-1.25,0.0);
glRotatef(pieiy,0.0,1.0,0.0);
glTranslatef(-0.25,-0.35,0.0);
glPushMatrix();
glScalef(1.5,0.75,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*pierna izquierda completo*/
}
void humanoide (int px,int py,int pz,int cy,int hdx,int hdy,int hdz,int cdz,int hix,int hiy,int hiz,int ciz,
int mdx,int mdy,int mdz,int rdx,int pdy,int mix,int miy,int miz,int rix,int piy)
{
torso(px,py,pz);
cara(cy);
brazoderecho(hdx,hdy,hdz,cdz);
brazoizquierdo(hix,hiy,hiz,ciz);
piernaderecha(mdx,mdy,mdz,rdx,pdy);
piernaizquierda(mix,miy,miz,rix,piy);
}
void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity ();
gluLookAt (0.0,0.0,10.0,0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glPushMatrix();
humanoide(posicionx,posiciony,posicionz,cuelloy,
hombroderx,hombrodery,hombroderz,cododerz,
hombroizqx,hombroizqy,hombroizqz,codoizqz,
musloderx,muslodery,musloderz,rodilladerx,piedery,
musloizqx,musloizqy,musloizqz,rodillaizqx,pieizqy);
glPopMatrix();
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_SINGLE GLUT_RGB);
glutInitWindowSize (800, 800);
glutInitWindowPosition (90, 90);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

Previo 1

1. ¿Qué es una transformación geométrica? ¿Cuáles son las transformaciones básicas y sus matrices?

Las transformaciones geométricas es hacer mediante una ecuación o pasos una traslado o correspondencia de cada punto de un plano a otro plano, esto lleva a la deformación o transformación de las figuras dentro del plano. Las transformaciones básicas y sus matrices se encuentran en la siguiente dirección, en las páginas 3,4 y 5:

http://wwwdi.ujaen.es/asignaturas/igaplicada/pdf/tema3.pdf

2. Escriba los comandos que en OpenGL permiten aplicar transformaciones geométricas, las variantes de dichos comandos y describa sus parámetros.

Para la traslación utilizamos el comando void glTranslate(TYPE x, TYPE y, TYPE z), este comando multiplica la matriz actual por una de traslación haciendo que se mueva el objeto, existen las variantes: void glTranslated( GLdouble x, GLdouble y,GLdouble z) void glTranslatef ( GLfloat x, GLfloat y, GLfloat z) Los parámetros x, y, z especifican las coordenadas del vector de traslación

Para la rotación utilizamos void glRotate(TYPE angle, TYPE x, TYPE y, TYPE z), este commando multiplica la matriz actual por una matriz de rotación, logrando así una rotación en el objeto en sentido de las manecillas del reloj. Existen las variantes:
void glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )void glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )

El parámetro angle especifica el ángulo de rotación en grados, mientras que los parámetros x, y, z son las coordenadas del vector

Para lograr el escalado de usa el comando void glScale(TYPE x, TYPE y, TYPE z), este multiplica la matriz actual por una matriz que cambia el tamaño del objeto a lo largo de los ejes, las coordinas del objeto se multiplican por lo parámetros x,y,z. Existen las variantes:
void glScaled( GLdouble x, GLdouble y, GLdouble z )void glScalef( GLfloat x, GLfloat y, GLfloat z) x, y, z, especifican el factor de escala para cada eje de coordenadas.

3. Describa en OpenGL qué son las matrices GL_MODELVIEW y GL_PROJECTION. ¿Para qué sirven? ¿Cómo se puede intercambiar entre una y otra? ¿Cuál es la matriz activa por defecto? ¿Para que sirve el comando glLoadIdentity()?

GL_MODELVIEW es la matriz que contiene las transformaciones originadas por los cambios de modelado y posición de la cámara, mientras que GL_PROJECTION es la matriz con las transformaciones que realizan las proyecciones de 3 a 2 dimensiones. La matriz activa por defecto es la GL_MODELVIEW, para intercambiarse de una a la otra se hace uso del comando glMatrixMode(Glenum mode) que tiene como argumento una de las tres constantes (la tercer constante es la GL_TEXTURE), este comando se comporta como un estado, por tanto, hasta que se especifique un nuevo estado todas las transformaciones se realizan sobre la última matriz especificada. El comando glLoadIdentity() remplaza la matriz actual por una matriz identidad.

4. ¿Para qué son los comandos glPushMatrix() y glPopMatrix()? Describa su uso a través de un ejemplo en código

Existen para cada modo mencionado anteriormente una pila de matrices, para el modo GL_MODELVIEW la pila es de 32 mientras que para GL_PROJECTION y GL_TEXTURE el tamaño es de al menos 2, las funciones glPushMatrix() y glPopMatrix() hacen uso de estas pilas, glPushMatrix() realiza la operación de Push en esa pila de matrices, este duplica la matriz que se encuentra en el tope de la pila, el comando glPopMatrix() hace la operación de pop en la pila reemplazando la matriz actual con la siguiente. Ejemplo:

glPushMatrix();
apply_sphere_transformation();

glPushMatrix();
apply_cube_transformation();
draw_cube();
glPopMatrix()M

draw_sphere();

5. ¿Para qué sirven los comandos glBegin() y glEnd()? Describa su uso, sus parámetros y ejemplifique a través de una pieza de código.

La definición de primitivas inicia siempre con la función glBegin y finaliza con glEnd. Entre estas dos funciones debemos definir los vértices que forman la primitiva.

void glBegin(GLenum primitiva).- Esta función marca el inicio de un conjunto de vértice que definen una o varias primitivas, primitiva puede valer: GL_POINTS (puntos), GL_LINES (líneas), GL_TRIANGLES (triángulos), GL_LINE_LOOP (poli líneas cerradas), GL_TRIANGLE_FAN (triángulos alrededor de un punto), GL_QUADS (cuadriláteros), GL_QUAD_STRIP (cuadriláteros encadenados), GL_POLYGON (polígono convexo con cualquier número de vértices).

void glEnd(void).- Marca el final de la última primitiva que se haya iniciado con glBegin.

Ejemplo:

// dibuja una linea en las coordenadas especificadas en glVertex3f
glBegin(GL_LINES);
glVertex3f(100.0f, 100.0f, 0.0f); // origin of the line
glVertex3f(200.0f, 140.0f, 5.0f); // ending point of the line
glEnd( );

6. ¿Qué es modelado geométrico? Describa los tipos de modelado geométrico que existen.

El modelado geométrico es la construcción o el uso de modelos geométricos, estos describen la forma de un objeto físico o matemático en términos de conceptos geométricos, es usado en graficas por computadoras, diseño asistido por computadoras y manufactura entre otros.

7. Construya código para dibujar un cubo (revisar en la clase de teoría), y a partir de éste modele jerárquicamente el humanoide de la ilustración y escriba el programa que lo dibuja. Las medidas corren por su cuenta.

/** mono.c
Este programa despliega un humanoide formado unicamente por cubos de diferetes tamaños, todos creados a apartir
de un cubo base y aplicando transformadas de traslacion y escalamiento*/
#include
#include
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}
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);
/*torso*/
glPushMatrix();
glScalef (2.0, 3.0, 1.0);
glTranslatef(0.0,0.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*cara*/
glPushMatrix();
glTranslatef(0.0,3.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*brazo derecho*/
glPushMatrix();
glScalef (2.0, 0.5, 1.0);
glTranslatef(1.0,5.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*antebrazo derecho*/
glPushMatrix();
glScalef (2.0, 1.0, 1.0);
glTranslatef(2.0,2.75,0.0);
glutWireCube(1.0);
glPopMatrix();
/*mano derecha*/
glPushMatrix();
glScalef (0.5, 0.5, 1.0);
glTranslatef(10.5,5.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*brazo izquierdo*/
glPushMatrix();
glScalef (2.0, 0.5, 1.0);
glTranslatef(-1.0,5.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*antebrazo izquierdo*/
glPushMatrix();
glScalef (-2.0, 1.0, 1.0);
glTranslatef(2.0,2.75,0.0);
glutWireCube(1.0);
glPopMatrix();
/*mano izquierda*/
glPushMatrix();
glScalef (0.5, 0.5, 1.0);
glTranslatef(-10.5,5.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*muslo derecho*/
glPushMatrix();
glScalef (0.5, 2.5, 1.0);
glTranslatef(1.5,-0.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*pantorrila derecha*/
glPushMatrix();
glScalef (1.0, 2.5, 1.0);
glTranslatef(0.75,-1.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*pie derecho*/
glPushMatrix();
glScalef (1.75, 0.5, 1.0);
glTranslatef(0.635,-10.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*muslo izquierda*/
glPushMatrix();
glScalef (0.5, 2.5, 1.0);
glTranslatef(-1.5,-0.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*pantorrila izquierda*/
glPushMatrix();
glScalef (1.0, 2.5, 1.0);
glTranslatef(-0.75,-1.5,0.0);
glutWireCube(1.0);
glPopMatrix();
/*pie izquierdo*/
glPushMatrix();
glScalef (1.75, 0.5, 1.0);
glTranslatef(-0.635,-10.5,0.0);
glutWireCube(1.0);
glPopMatrix();
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_SINGLE GLUT_RGB);
glutInitWindowSize (700, 700);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

8. ¿Para qué sirven los comandos glClearColor() y glClear()? Descríbalos su funcionamiento, sus parámetros y ejemplifique a través de una pieza de código

glClearColor() especifica los valores rojo, verde y azul utilizados por glClear() para limpiar el búffer de colores. Los valores especificados por glClearColor() se limitan al rango [0, 1].
glClear() fija el área de mapa de bits de la ventana a valores preestablecidos por glClearColor, glClearIndex, glClearDepth, glClearStencil, y glClearAccum. Sus argumentos son:

GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT, GL_STENCIL_BUFFER_BIT

Para el jemplo vea el codigo del humanoide en la pregunta anterior

9. Describa los comandos glutInit(), glutInitDisplayMode (), glutInitWindowSize (), glutInitWindowPosition (), glutCreateWindow (), glutDisplayFunc(), glutReshapeFunc(), glutKeyboardFunc() y glutMainLoop(). Describa su funcionamiento, uso y parámetros.

glutInit() Se utiliza para inicializar la librería de GLUT. Se utiliza de la siguiente manera: void glutInit(int *argcp, char **argv); donde argcp es un apuntador a la variable sin modificar argc desde main. Argv es el valor de la variable sin modificar desde main, esta información será actualizada ya que esta función extrae cualquier opción de comando entendida por la librería de GLUT.

glutInitDisplayMode() Fija el modo de display inicial.Se utiliza de la siguiente manera: void glutInitDisplayMode(unsigned int mode); el valor entero que se utiliza de argumento funciona como un selector de las máscaras del modo de despliegue

glutInitWindowSize(): la ventana creada por glutCreateWindow, al utilizar esta función, le será indicado que sea creada bajo el tamaño inicial de ventana especificado. Los parámetros son: void glutInitWindowSize(int width, int height); es decir, int width – ancho e int height – largo.

glutInitWindowPosition(): la ventana creada por glutCreateWindow, al utilizar esta función, le será indicado que sea creada en la posición especificada. Los parámetros son: void glutInitWindowPosition(int x, int y); es decir, int x – coordenada en x e int y – coordenada en y.

glutCreateWindow(): crea una ventana. Su parámetro es int glutCreateWindow(char *name); donde name es el nombre que se le va a asignar a la ventana con el cual el sistema de ventanas va a reconocerla.

glutDisplayFunc(): obtiene el callback de display para la ventana actual. Cuando GLUT determina que el plano normal para la ventana necesita ser vuelto a ser mostrado, el callback de display para la función es llamado. Antes de ello, la ventana actual cambia su valor a la ventana que necesita ser mostrada de nuevo y la capa en uso cambia al plano normal. No tiene parámetros. Se emplea del modo siguiente:

void glutDisplayFunc(void (*func)(void));

glutReshapeFunc(). Esta función callback especifica cuál función será llamada cada vez que la ventana sea redimensionada o movida, pero también es utilizada para definir inicialmente el área de proyección de la figura en la ventana. Su uso es:

void glutReshapeFunc(void (*func)(int width, int height)); Donde func es la nueva función que será llamada cada vez que la ventana sea redimensionada

glutKeyboardFunc(). Especifica la rutina de servicio a ejecutar cada vez que se pulsa una de las teclas correspondiente a un código ASCII. Su uso es:

void glutKeyboardFunc(void (*function)(unsigned char key, int x, int y));

El argumento función es un puntero a la función que actúa como rutina de
servicio. Esta función espera tres parámetros, el carácter de la tecla pulsada y laposición del ratón sobre la ventana en coordenadas del mundo real glutMainLoop() entra al evento de procesamiento del GLUT en un loop infinito, este comando debe ser utilizado por lo menos una vez cada vez que se quiera utilizar GLUT, una vez llamada nunca se saldrá del proceso, pero llamara todas las rutinas necesarias para el uso de GLUT, se usa de la siguiente manera: void glutMainLoop(void);

10. ¿Qué es un Function Callback en GLUT?

Una Function Callback es una que no se invoca explícitamente por el programador; en vez de ello, la responsabilidad de su invocación se delega a otra función que recibe la dirección del la función Callback.

Fuentes:

http://wwwdi.ujaen.es/asignaturas/igaplicada/pdf/tema3.pdf
http://usuarios.lycos.es/andromeda_studios/paginas/tutoriales/aptutgl01.htm#Modelado
http://www.opengl.org/documentation/specs/man_pages
http://www.tecnun.es/asignaturas/grafcomp/OpenGL/practica/capitulo2.pdf
http://www.tecnun.es/asignaturas/grafcomp/OpenGL/practica/capitulo3.pdf
http://www.cs.buap.mx/~asanchez/Curso_programacion_opengl_2.pdf
http://www.opengl.org/documentation/specs/glut/
http://serdis.dis.ulpgc.es/~atrujill/iga/Intro_GLUT_archivos/frame.htm
https://www.linux-magazine.es/issue/09/Python.pdf

Practica 1

Pasos a seguir para poder configurar el modulo GLUT para poder usarlo en programas de OpenGL en Visual Studio 2005:

1. Primero se descargaron dos paquetes de GLUT los cuales se encontraban en la pagina de OpenGL (http://www.opengl.org/resources/libraries/glut/), uno de estos contenía las librerías, dll’s y archivos de cabecera para poder compilar cosas con GLUT, mientras que el otro contenían más paqueterías y ejemplos.
2. Los paquetes descargados fueron descomprimidos, el paquete que contenía todas los componentes de GLUT, se dividió en tres subcarpetas, la primera con el nombre dll en la cual obviamente van a ir los dll, las segunda con el nombre de lib, en esta estarán las librerías y la tercera carpeta incluye una subcarpeta con nombre GL en esta se pondrá el archivo de cabecera.
3. Después deben cambiar unas variables de entorno. Dentro de propiedades del Sistema en la pestaña de Opciones Avanzadas, en esta se agrega la variable PATH junto con la dirección de los archivos dll, los cuales se encuentran en la carpeta con el nombre dll que antes creamos.
4. Ya en el Visual Studio 2005 se crea un proyecto nuevo C++ en aplicación de consola con proyecto vacío, en este proyecto se pondrán las variables restantes del GLUT.
5. Primero se carga el código de un programa en la carpeta de Source Files. Después, en el proyecto activo, ingresa a las propiedades, y dentro de la opción de C/C++ se agrego la librería faltante de GLUT. Esta dirección es C/C++/General/Additional Include Directories, ahí se pondrá la dirección de la carpeta de include.
6. Además de esto se debe entrar a properties/linker/general/ Additional libreries Directories para agregar las librerías faltantes.
7. Una vez completado todo esto, se podrá compilar el programa y ejecutar.