Codigos Unidad 3

Cubo

#include <GL/glut.h>

GLfloat angr, delta;
GLfloat z;


void idleevent()
{
 // cambia el angulo de rotación constantemente (animación)
 angr += delta;
 // redibuja la escena
 glutPostRedisplay();
}

void displayevent(void)
{
 // limpia la escena (ventana)
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

 // verfica superficies visibles
 glEnable( GL_DEPTH_TEST );

 // inicializa la Matriz de transformación de coordenadas (Matriz del Modelo)
 glLoadIdentity();

 // traslada la escena al centro del espacio (Hortiz y Vert: 0,0)
 glTranslatef( -0.5, -0.5, z );
 // rota la escena
 glRotatef( angr, 1,1,-1 );

 // construcción de la escena
 // dibuja un cubo en la coord 0,0,0 con dimensiones 1 x 1 x -1

 glColor3f(0,0,1);
 glBegin( GL_QUADS ); // frontal
  glVertex3f( 0, 0,  0 );
  glVertex3f( 1, 0,  0 );
  glVertex3f( 1, 1,  0 );
  glVertex3f( 0, 1,  0 );
 glEnd();

 glColor3f(0,1,0);
 glBegin( GL_LINE_LOOP ); // lateral derecha
  glVertex3f( 1, 0,  0 );
  glVertex3f( 1, 0, -1 );
  glVertex3f( 1, 1, -1 );
  glVertex3f( 1, 1,  0 );
 glEnd();

 glColor3f(1,0,0);
 glBegin( GL_LINE_LOOP ); // superior
  glVertex3f( 0, 1,  0 );
  glVertex3f( 1, 1,  0 );
  glVertex3f( 1, 1, -1 );
  glVertex3f( 0, 1, -1 );
 glEnd();

 // muestra la escena
 glutSwapBuffers();
}

void specialkeyevent( int key, int Xx, int Yy )
{
 // manejo de teclas especiales
 
 switch ( key ) {
 // cambia la z para la traslación del cubo
 case GLUT_KEY_UP:    z += 0.1; break;
 case GLUT_KEY_DOWN:  z -= 0.1; break;

 // cambia el delta del angulo de rotación
  case GLUT_KEY_F1:    delta += 0.1; break;
 case GLUT_KEY_F2:    delta -= 0.1; break;
 }
 // redibuja la escena
 glutPostRedisplay();
}

void reshapeevent(GLsizei width, GLsizei height)
{
 // establecer el área de visualizacion en la ventana
 glViewport(0,0,width,height);

 // seleccionar la matriz de Proyección
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();

 // Vista en Perspectiva
 gluPerspective(45,(GLfloat)width/(GLfloat)height,  0.01, 20);

 // Restaurar a la matriz del Modelo (escena)
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();

} // reshape


int main(int argc, char** argv)
{
 // inicialización del GLUT
 glutInit( &argc, argv );

 // inicialiación de la ventana
 glutInitWindowSize( 300, 300 );
 glutInitWindowPosition( 100, 100 );
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA);
    glutCreateWindow( "" );

 glutSetWindowTitle( "Cubo" );

 // inicialización de los datos del programa
 delta  = 0;
 angr  = 0;
 z = -5;

 // registro de los eventos
    glutReshapeFunc (reshapeevent);
 glutDisplayFunc( displayevent );
 glutSpecialFunc( specialkeyevent );
 glutIdleFunc( idleevent );
 
 // lazo de eventos
 glutMainLoop();

 return 0;
} // main

Curvas

#include <GL/glut.h>

typedef GLfloat TVertice[3];

TVertice ctrlpoints[4] = {
 { -4, 0, 0 },
 { 2, -0.5, 0 },
 { 1, -3, 0 },
 { 4, 4, 0 }
};

GLfloat *P1, *P2, *P3, *P4, * movpoint;
int  movidx;
int curva; // 0: hermite, 1: bezier

GLfloat delta;
GLfloat z;


void dibujaHermite()
{
 GLfloat c1, c2, c3, c4, t;
 TVertice P;
 int i;

 glBegin( GL_LINE_STRIP );
 for ( i = 0; i <= 30; i++ )
 {
  t = i/30.0;

  c1 = 2*t*t*t - 3*t*t + 1;
  c2 = -2*t*t*t + 3*t*t;
  c3 = t*t*t - 2*t*t + t;
  c4 = t*t*t - t*t;
  P[0] = c1*P1[0] + c2*P2[0] + c3 * P3[0] + c4* P4[0];
  P[1] = c1*P1[1] + c2*P2[1] + c3 * P3[1] + c4* P4[1];
  P[2] = c1*P1[2] + c2*P2[2] + c3 * P3[2] + c4* P4[2];
  glVertex3fv(P);
 }
 glEnd();
}

// coeficientes
// c1 = (1-t)^3
// c2 = t^3
// c3 = 3*t*(1-t)^2
// c4 = 3*t^2 * (1-t)

void dibujaBezier()
{
}

void displayevent(void)
{
 int i;
 // limpia la escena (ventana)
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

 // verfica superficies visibles
 glEnable( GL_DEPTH_TEST );

 glLoadIdentity();

 glTranslatef( 0, 0, z );

 // construcción de la escena

 // dibuja la curva
 glColor3f(0,0,1);

 if ( curva == 0 )
 {
  glutSetWindowTitle( "Hermite" );
  dibujaHermite();
 }
 else
 {
  glutSetWindowTitle( "Bezier" );
  dibujaBezier();
 }


 // dibuja las lineas de los ptos de control
 glColor3f(1,1,1);

 glBegin( GL_LINES );
  glVertex3fv(P1);
  glVertex3fv(P3);
  glVertex3fv(P2);
  glVertex3fv(P4);
    glEnd();

 // dibuja los puntos de control

 glPointSize(5);
 glBegin( GL_POINTS );
 for ( i = 0; i < 4; i++ )
 {
   if ( i != movidx )
      glColor3f(1,1,0);
   else
      glColor3f(1,0,0);
      glVertex3fv( ctrlpoints[i] );
 }
 glEnd();

 glPointSize(1);


 // muestra la escena
 glutSwapBuffers();
}

void specialkeyevent( int key, int Xx, int Yy )
{
 
 switch ( key ) {
 case GLUT_KEY_UP:    movpoint[1] += delta; break;
 case GLUT_KEY_DOWN:  movpoint[1] -= delta; break;
 case GLUT_KEY_LEFT:  movpoint[0] -= delta; break;
 case GLUT_KEY_RIGHT: movpoint[0] += delta; break;

  case GLUT_KEY_F1:    movidx = (movidx+1)%4; 
       movpoint = ctrlpoints[movidx];
       break;
 case GLUT_KEY_F2:    curva = !curva; break;
 }
 glutPostRedisplay();
}

void reshapeevent(GLsizei width, GLsizei height)
{
 // establecer el área de visualizacion en la ventana
 glViewport(0,0,width,height);

 // seleccionar la matriz de Proyección
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();

 // Vista en Perspectiva
 gluPerspective(45,(GLfloat)width/(GLfloat)height,  0.5, 100);

 // Restaurar a la matriz del Modelo (escena)
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();

} // reshape


int main(int argc, char** argv)
{
 // inicialización del GLUT
 glutInit( &argc, argv );

 // inicialiación de la ventana
 glutInitWindowSize( 300, 300 );
 glutInitWindowPosition( 100, 100 );
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA);
    glutCreateWindow( "" );

 glutSetWindowTitle( "Curvas" );

 // inicialización de los datos del programa
 delta  = 0.1;
 movpoint = 0;
 z = -20;

 P1 = ctrlpoints[0];
 P2 = ctrlpoints[1];
 P3 = ctrlpoints[2];
 P4 = ctrlpoints[3];
 movpoint = P1;
 movidx = 0;
 curva = 0;

 // registro de los eventos
    glutReshapeFunc (reshapeevent);
 glutDisplayFunc( displayevent );
 glutSpecialFunc( specialkeyevent );
 
 // lazo de eventos
 glutMainLoop();

 return 0;
} // main

Laberinto

#include <GL/glut.h>
#include <stdio.h>
#include <math.h>
GLfloat x,y,z, ang, paso, dtx, dtz;
GLfloat angcuad;

#define ANCHOL 6
#define LARGOL 4

int PH[LARGOL+1][ANCHOL] = {
 { 1,1,0,0,1,1 },
 { 0,0,1,1,0,0 },
 { 0,0,0,0,0,1 },
 { 0,1,1,0,1,0 },
 { 1,1,1,1,1,1 },
};


int PV[LARGOL][ANCHOL+1] = {
 { 1,0,0,0,0,1,1 },
 { 1,1,0,1,0,0,1 },
 { 1,0,1,0,1,0,1 },
 { 1,0,0,0,1,0,1 },
};


void idleevent()
{
 angcuad += 1;
 glutPostRedisplay();
}

void displayevent(void)
{
 // limpia la escena (ventana)
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

 // inicializa la Matriz de transformación de coordenadas (Matriz del Modelo)
 glLoadIdentity();

 // traslada la escena al centro del espacio (Hortiz)
 glRotatef( ang, 0,1,0 );
 glTranslatef( -ANCHOL/2.0+x, y, z );

 // construcción de la escena
 // dibuja un cubo en la coord 0,0,0 con dimensiones 1 x 1 x -1

 int i, j;

 glColor3f(0,0,1);
 for (i = 0; i < LARGOL+1; i++ )
  for (j = 0; j < ANCHOL; j++ )
   if ( PH[i][j] != 0 ) {
    glBegin( GL_LINE_LOOP );
      glVertex3f( j, 0, -i );
      glVertex3f( j+1, 0, -i );
      glVertex3f( j+1, 1, -i );
      glVertex3f( j, 1, -i );
    glEnd();
   }

 glColor3f(1,0,0);
 for (i = 0; i < LARGOL; i++ )
  for (j = 0; j < ANCHOL+1; j++ )
   if ( PV[i][j] != 0 ) {
    glBegin( GL_LINE_LOOP );
      glVertex3f( j, 0, -i );
      glVertex3f( j, 0, -i-1 );
      glVertex3f( j, 1, -i-1 );
      glVertex3f( j, 1, -i );
    glEnd();
   }

 // Piso
 glColor3f(0.3,0.3,0.3 );
 for (i = 0; i < LARGOL; i++ )
  for (j = 0; j < ANCHOL; j++ ) {
    glBegin( GL_LINE_LOOP );
      glVertex3f( j, 0, -i );
      glVertex3f( j+1, 0, -i );
      glVertex3f( j+1, 0, -i-1 );
      glVertex3f( j, 0, -i-1 );
    glEnd();
  }


 glPushMatrix();
 // al centro de la cuadrícula (4,2) del laberinto
 glTranslatef( 4+0.5, 0.5, -2-0.5);
 glRotatef( angcuad, 1,1,1 );
 glColor3f(1,1,1);
 glBegin( GL_LINE_LOOP );
  glVertex3f( 0,0,0 );
  glVertex3f( 0.2,0,0 );
  glVertex3f( 0.2 ,0.2, 0 );
  glVertex3f( 0,0.2 ,0 );
 glEnd();
 glPopMatrix();


 glPushMatrix();
 // al centro de la cuadrícula (1,-3) del laberinto
 glTranslatef( 1+0.5, 0.5, -3-0.5);
 glRotatef( -angcuad, 1,1,1 );
 glColor3f(0,1,1);
 glBegin( GL_LINE_LOOP );
  glVertex3f( 0,0,0 );
  glVertex3f( 0.2,0,0 );
  glVertex3f( 0.2 ,0.2, 0 );
  glVertex3f( 0,0.2 ,0 );
 glEnd();
 glPopMatrix();

 // muestra la escena
 glutSwapBuffers();
}

float dtr( float d )
{
 return d*3.141592/180;
}

void specialkeyevent( int key, int Xx, int Yy )
{
 float angrad;

 switch ( key ) {
 case GLUT_KEY_UP:    x-=dtx; z+=dtz; break;
 case GLUT_KEY_DOWN:  x+=dtx; z-=dtz; break;

 case GLUT_KEY_LEFT:
  ang -= 2; 
  angrad = dtr(ang);
  dtx = paso * sin(angrad);
  dtz = paso * cos(angrad);
  break;
 case GLUT_KEY_RIGHT: 
  ang += 2; 
  angrad = dtr(ang);
  dtx = paso * sin(angrad);
  dtz = paso * cos(angrad);
  break;
 case GLUT_KEY_HOME:
  y += 0.1;
  break;
 case GLUT_KEY_END:
  y -= 0.1;
  break;
 }
  glutPostRedisplay();
}


void reshapeevent(GLsizei width, GLsizei height)
{
 // establecer el área de visualizacion en la ventana

 glViewport(0,0,width,height);

 // seleccionar la matriz de Proyección
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();

 // Vista en Perspectiva
 gluPerspective(45,(GLfloat)width/(GLfloat)height,  0.01, 100);

 // Restaurar a la matriz del Modelo (escena)
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();

} // reshape


int main(int argc, char** argv)
{
 // inicialización del GLUT
 glutInit( &argc, argv );

 // inicialiación de la ventana
 glutInitWindowSize( 500, 400 );
 glutInitWindowPosition( 100, 100 );
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA);
    glutCreateWindow( "" );

 glutSetWindowTitle( "Laberinto" );

 // inicialización de los datos del programa
 ang = 0;
 angcuad = 0;
    x = 0;
    y = -0.7;
 z = -5;
 paso = 0.1;
 dtx = 0;
 dtz = paso;
 
 printf("UP/DOWN     : Avanza/Retrocede\n");
 printf("LEFT/RIGHT  : Rota en el lugar\n");
 printf("HOME/END    : Sube/Baja el laberinto\n");

 // verfica superficies visibles
 glEnable( GL_DEPTH_TEST );

 // registro de los eventos
    glutReshapeFunc (reshapeevent);
 glutDisplayFunc( displayevent );
 glutSpecialFunc( specialkeyevent );
 glutIdleFunc( idleevent );
 
 // lazo de eventos
 glutMainLoop();

 return 0;
} // main