Esfera con piso

#include <GL/glut.h>
GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;
GLint ancho=400;
GLint alto=400;
int hazPerspectiva = 0;
int moverY = 0;

void reshape(int width, int height)
{
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
  
    if(hazPerspectiva)
     gluPerspective(60.0f, (GLfloat)width/(GLfloat)height, 1.0f, 20.0f);
    else
      glOrtho(-4,4, -4, 4, 1, 10);
    glMatrixMode(GL_MODELVIEW);
    ancho = width;
    alto = height;
 if(moverY)
    gluPerspective(100.0f, (GLfloat)width/(GLfloat)height, 100.0f, 100.0f);
 else
      glOrtho(-4,4, -4, 4, 1, 10);
    glMatrixMode(GL_MODELVIEW);
    ancho = width;
    alto = height;
}
void drawCube(void)
{

    glColor3f(1.0f, 0.0f, 1.0f);
    glBegin(GL_QUADS);      
    glVertex3f( 2.0f,-2.0f, -1.0f);
    glVertex3f( 3.0f,-5.0f, 2.0f);
    glVertex3f(-4.0f,-4.0f,  2.0f);
   glVertex3f(-3.0f,-2.0f, -2.0f);
    glEnd();
}
void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
    glTranslatef(3.0f, 0.0f, -5.0f);
    glTranslatef(-3,0,0);
  
    glScalef(1.0f, 1.0f, 1.0f);
    drawCube();
    glLoadIdentity();
    glTranslatef(0.0f, 0.0f, -5.0f);
  glRotatef(anguloEsfera, 1.0f, 0.0f, 0.0f);
    glTranslatef(0.0f, 0.0f, 0.0f);
    glColor3f(1.0f, 1.0f, 1.0f);
    glutWireSphere(0.5f, 8, 8);
    glFlush();
    glutSwapBuffers();
    anguloCuboX+=0.1f;
    anguloCuboY+=1.1f;
    anguloEsfera+=0.2f;
}
void init()
{
    glClearColor(0,0,0,0);
    glEnable(GL_DEPTH_TEST);
    ancho = 400;
    alto = 400;
}

void idle()
{
    display();
}

void keyboard(unsigned char key, int x, int y )
{
    switch(key)
    {
    case 'p':
    case 'P':
      hazPerspectiva=1;
      reshape(ancho,alto);
      break;
    case 'o':
    case 'O':
      hazPerspectiva=0;
      reshape(ancho,alto);
      break;
   
 case 'w':
  case 'W':
  moverY=1.0;
   reshape(ancho,alto);
   break;
    case 27:
      break;
 }
}
int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(ancho, alto);
    glutCreateWindow("Cubo 1");
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutIdleFunc(idle);
    glutKeyboardFunc(keyboard);
    glutMainLoop();
    return 0;
}

Carro 2D

#include <GL/glut.h>
float posicion;
int grados;
void reshape(int width, int height){
  glViewport(0, 0, width, height);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  //gluPerspective(60.0f,1.0f, 0.01f, 100.0f);
    glOrtho(-10, 10, -10, 10, 0.1f, 20);
  glTranslatef(-3.0f, 0.0f, -15.0f);
  //glRotatef(40, 1.0f, 1.0f, 0.0f);
  glMatrixMode(GL_MODELVIEW);
}
void dibujar_tornillos(){
  glPushMatrix();
   glColor3f(0.0f,0.0f,0.0f); 
   glTranslatef(0.0f,0.0f, 1.0f);
   glPushMatrix();
    glTranslatef(-0.5f,-0.1f, 0.0f);
    glutSolidSphere(0.1f,20,20);
   glPopMatrix();
   glPushMatrix();
    glTranslatef(0.5f,-0.1f, 0.0f);
    glutSolidSphere(0.1f,20,20);
   glPopMatrix();
   glPushMatrix();
    glTranslatef(0.0f,0.5f, 0.0f);
    glutSolidSphere(0.1f,20,20);
   glPopMatrix();
   glPushMatrix();
    glTranslatef(-0.2f,-0.5f, 0.0f);
    glutSolidSphere(0.1f,20,20);
   glPopMatrix();
   glPushMatrix();
    glTranslatef(0.2f,-0.5f, 0.0f);
    glutSolidSphere(0.1f,20,20);
   glPopMatrix();
  glPopMatrix();
}
void dibujar_rueda_y_tornillos_delante(){
  glPushMatrix();
  glColor3f(0.5f,0.5f,0.5f); 
  glTranslatef(1.5f,0.0f, 0.0f);
  glRotatef(grados, 0.0f, 0.0f, 1.0f);
  glutSolidSphere(1.0f,20,20);
  dibujar_tornillos();
  glPopMatrix();
}
void dibujar_rueda_y_tornillos_detras(){
  glPushMatrix();
  glColor3f(0.5f,0.5f,0.5f); 
  glTranslatef(5.5f,0.0f, 3.0f);
  glRotatef(grados, 0.0f, 0.0f, 1.0f);
  glutSolidSphere(1.0f,20,20);
  dibujar_tornillos();
  glPopMatrix();
}

void dibujar_ventanas(){
  glPushMatrix();
  glColor3f(0.0f,1.0f,1.0f); 
  glTranslatef(1.2f,2.0f, 0.01f);
  glBegin(GL_TRIANGLES);
      glVertex3f(0.0f, 0.0f, 0.0f);
      glVertex3f(0.8f, 0.0f, 0.0f);
      glVertex3f(0.8f, 0.8f, 0.0f);
  glEnd();
  glBegin(GL_QUADS);
      glVertex3f(0.8f, 0.0f, 0.0f);
      glVertex3f(1.7f, 0.0f, 0.0f);
      glVertex3f(1.7f, 0.8f, 0.0f);
      glVertex3f(0.8f, 0.8f, 0.0f);
  glEnd();
  glTranslatef(1.9f,0.0f, 0.0f);
  glBegin(GL_QUADS);
      glVertex3f(0.0f, 0.0f, 0.0f);
      glVertex3f(0.9f, 0.0f, 0.0f);
      glVertex3f(0.9f, 0.8f, 0.0f);
      glVertex3f(0.0f, 0.8f, 0.0f);
  glEnd();
  glBegin(GL_TRIANGLES);
      glVertex3f(0.9f, 0.0f, 0.0f);
      glVertex3f(1.7f, 0.0f, 0.0f);
      glVertex3f(0.9f, 0.8f, 0.0f);
  glEnd();
  glPopMatrix();
}
void techo(){
  glPushMatrix();
  glTranslatef(1.0f,2.0f, 0.0f);
  glBegin(GL_TRIANGLES);
      glVertex3f(0.0f, 0.0f, 1.0f);
      glVertex3f(1.0f, 0.0f, 0.0f);
      glVertex3f(1.0f, 1.0f, 0.0f);
  glEnd();
  glBegin(GL_QUADS);
      glVertex3f(1.0f, 0.0f, 0.0f);
      glVertex3f(3.0f, 0.0f, 0.0f);
      glVertex3f(3.0f, 1.0f, 0.0f);
      glVertex3f(1.0f, 1.0f, 0.0f);
  glEnd();
  glBegin(GL_TRIANGLES);
      glVertex3f(3.0f, 0.0f, 0.0f);
      glVertex3f(4.0f, 0.0f, 0.0f);
      glVertex3f(3.0f, 1.0f, 0.0f);
  glEnd();
  glPopMatrix();
}
dibujar_cuerpo_coche(){
  glColor3f(1,1,0); 
  glTranslatef(posicion,0.0f, 0.0f);
  glBegin(GL_QUADS);
      glVertex3f(0.0f, 0.0f, 0.0f);
      glVertex3f(7.0f, 0.0f, 0.1f);
      glVertex3f(7.0f, 2.0f, 0.0f);
      glVertex3f    (1.0f, 2.0f, 1.0f);
  glEnd();   
}
void display(){
  GLfloat angulo;
  int i;
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glLoadIdentity();
  dibujar_cuerpo_coche();
 
  techo();
  dibujar_ventanas();
  dibujar_rueda_y_tornillos_delante();
  dibujar_rueda_y_tornillos_detras();

  glutSwapBuffers();
}
void init(){
  glClearColor(0,0,0,0);
  posicion=0;
  grados=0;
  glEnable(GL_DEPTH_TEST);
}

void keyboard(unsigned char key, int x, int y){
  switch(key)
    {
    case 'p':
    case 'P':
      posicion+=0.1f;
      grados-=180/3.14;
      display();
      break;
  
    case 'o':
    case 'O':
      posicion-=0.1f;
      grados+=180/3.14;
      display();
      break;
    case 27:   // escape
//      exit(0);
      break;
    }
}
int main(int argc, char **argv){
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
  glutInitWindowPosition(50, 50);
  glutInitWindowSize(500, 500);
  glutCreateWindow("Practica Final");
  init();
  glutDisplayFunc(display);
  glutReshapeFunc(reshape);
  glutKeyboardFunc(keyboard);
  glutMainLoop();
  return 0;
}

Resumen Unidad 3

Transformaciones en OpenGL
En algunos tutoriales anteriores de OpenGL se han mencionado de manera fragmentaria los conceptos de transformaciones:

• En “Primeros Pasos en OpenGL” se mencionaba de manera general algunos conceptos relacionados con las transformaciones en OpenGL, específicamente la proyección. Es recomendable revisar y entender “Primeros Pasos en OpenGL” antes de aventurarse a leer el presente tutorial.
• En los “Hola Mundo 3d en OpenGL” y “Hola Complicado Mundo OpenGL-win32” se utilizaron algunas transformaciones de proyección y viewport para ajustar la inicialización de la ventana, pero sin entrar mucho en detalle acerca de su funcionamiento.

Este tutorial explora los diferentes tipos de transformaciones en OpenGL, a saber:

• Proyección: Trasforman una escena 3d “abstracta”, en una imagen plana que puede ser visualizada en una pantalla.
• Viewport: Ajustan el producto de la proyección a las dimensiones de un rectángulo contenedor (ventana).
• De vista: Que definen y afectan la posición desde la cual se visualizan las escenas tridimensionales.
• Modelado: Sirven para manipular los objetos en la escena, permitiendo trasladarlos, rotarlos y deformarlos (escalarlos).
• Modelo-Vista: Son la combinación de las dos transformaciones anteriores, que desde un punto de vista práctico son semejantes.

Antes de empezar a detallar cada tipo de transformación es bueno tener una idea de las funciones que permiten acceder directamente a las matrices que representan los estados de las transformaciones:

• void glMatrixMode( enum mode ); Permite seleccionar la matriz sobre la cual se realizaran las operaciones, los posibles valores de mode son TEXTURE, MODELVIEW, COLOR o PROJECTION .
• Void glLoadMatrix{fd} (T m[16]); Recibe una matriz de 4×4 que reemplaza la actual seleccionada. El arreglo es ordenado en forma de una matriz que tiene orden Y, a diferencia de las matrices convencionales que tienen orden X, lo que quiere decir que tiene la forma: m = [a1 ,a2 ,a3 ,a4 ,a5 ,a6 ,a7 ,a8 ,a9 ,a10, a11, a12, a13, a14, a15, a16]
  es interpretada internamente por OpenGL como:
  
• void glMultMatrix{fd}( T m[16] ); Multiplica la matriz actual por la matriz m[16] y reemplaza la matriz actual con el resultado de la operación.
• void glLoadTransposeMatrix{fd}( T m[16] ); Realiza una función similar a LoadMatrix(), con la diferencia que trabaja sobre una matriz en orden X así:
  
  que es evidentemente la transpuesta de la m que recibe LoadMatrix.
• void glMultTransposeMatrix{fd}( T m[16] ); Misma funcionalidad que MultMatrix() , solo que actúa en base al la matriz en orden X, o sea la transpuesta.
• void glLoadIdentity( void ); Remplaza la matriz actual por la matriz identidad de tamaño 4×4.

Estas operaciones afectan directamente las matrices mencionadas anteriormente, debido a que las operaciones de “alto nivel” (trasladar, rotar, escalar) que existen mas adelante se concatenan, es decir su efecto se acumula sobre matriz actual, existen dos operaciones que permiten guardar la matriz actual en una pila y restaurarla cuando sea necesario, estas son:

• void glPushMatrix( void ); Coloca una copia de la matriz actual en la parte superior de la pila correspondiente.
• void glPopMatrix( void ); Saca el elemento superior de la pila, que pasa a reemplazar a la matriz actual.

Estas dos operaciones son muy utilizadas, debido a que permiten realizar transformaciones sobre objetos diferentes, manteniendo algunas de las anteriores sin modificar.
Hay una última función que es útil en la manipulación de matrices y otros aspectos de OpenGL:

• void glGetFloatv(enum value, float *data); Permite obtener una copia de aquello que se indica en value. Por ejemplo si se pasan como parámetros MODELVIEW_MATRIX y un apuntador a un arreglo de flotantes tamaño 16 se obtiene una copia de dicha matriz a través del arreglo.

Proyección
Como ya se ha visto en tutoriales anteriores, OpenGL maneja 2 tipos de proyección, en perspectiva y ortográfica, donde la primera corresponde a la visión “realista” de la escena, mientras que la segunda es una “plana” que no deforma las dimensiones de los objetos dependiendo de su distancia a la cámara.
Ortográfica: Para ajustar la proyección ortográfica se utiliza el siguiente grupo de funciones:
glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far); gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top);
Esta función es simplemente una forma de la anterior, en donde se ha despreciado el valor de Z asignando los valores near = -1 y far = 1, generalmente se utiliza para escenas planas, en las que los objetos carecen de profundidad.
Perspectiva: Existen dos manera de manejar la proyección en perspectiva, a través de de una función gl o mediante la librería glu (una tercera puede ser realizar los cálculos de la matriz “manualmente”. En el primer caso:
glFrustrum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)

Transformaciones ModelView
Una tarea muy común en la creación de gráficos 2d, 3d y videojuegos es la de mover objetos par crear cierta animación.

void glRotate[fd](GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
Realiza una rotación del espacio coordenado por una medida de (angle) tomados en grados a lo largo del vector determinado por (x,y,z). Es recomendable que (x,y,z) representen un vector normalizado (o sea magnitud(x,y,z) = 1), debido a que si no es así OpenGL intentará normalizarlo. La rotación se lleva siguiendo la regla de la mano derecha, teniendo en cuenta que el vector (x,y,z) apunta con el “pulgar” hacia adentro (hacia uno).
void glTranslate[fd](GLfloat x, GLfloat y, GLfloat z);
Esta función traslada el espacio coordenado en x, y, z unidades sobre sus respectivos ejes coordenados X, Y, Z.
void glScalef(GLfloat x, GLfloat y, GLfloat z);
Cambia la proporción de los objetos respecto a los ejes coordenados, lo que es equivalente a decir que los estira o encoge una cantidad determinada por los parámetros de la función x,y,z.

 Transformaciones en OpenGL
En el primero se ilustra el uso de la translación y de glPushMatrix() y glPopMatrix(), utilizando las teclas ‘w’,'a’,'s’,'d’ se pueden mover el triángulo seleccionado y con ‘e’ se cambia de triangulo a mover. En el segundo se utiliza ‘w’,'a’,'s’,'d’ para girar el un cubo alrededor de los ejes X y Y transformado, mostrando al mismo tiempo las coordenadas de objeto y de ojo.

Fundamento Matemático.

EL ESPACIO EUCLÍDEO

La geometría euclídea se desarrolla en los siglos XIX y XX, tras la aparición del concepto de espacio vectorial. Recibe su nombre en honor a Euclides, matemático griego (~300 a.C.) quien estudió los conceptos básicos de la Geometría plana, aunque por supuesto no en un contexto vectorial.

Para generalizar esos conceptos geométricos, observamos el comportamiento de los vectores del plano. En

2 tenemos definido el producto escalar usual ℜ

(a

1,a2) · (b1,b2) = a1 b1 + a2 b2

Es una operación entre dos vectores, cuyo resultado es un escalar (de ahí el nombre "producto escalar").

Definición: Producto escalar en cualquier espacio. Espacio euclídeo.

Cualquier operación en un espacio vectorial que cumpla las anteriores propiedades, diremos que es un producto escalar (aunque no se trate del producto escalar usual).

Llamaremos espacio euclídeo a un espacio vectorial dotado de un producto escalar.

Jerarquia de objetos en OpenGL

Una vez conocida la estructura y comandos básicos de OpenGl y Glut, es hora de adentrarnos más y aplicar algunas nuevas ideas. Intentaremos crear un modelo que simule el movimiento de piernas de una persona andando.
Previamente necesitamos haber aprendido como se realizan las transformaciones de modelado y la proyección que serán usadas en la creación de este modelo. Si aun no has leído estos temas te recomendamos lo hagas antes de empezar.

Para explicar la construcción del citado modelo con movimiento de una manera sencilla, en lugar de crearlo completamente, vamos a construir solo una parte que corresponde a la parte baja del tronco (que llamaremos base), las piernas y los pies. Luego animaremos este modelo incompleto. Crearemos con este propósito una función 'caminar'. Cuando este ejemplo este terminado, comprendido y suficientemente trabajado podríamos seguir desarrollando el modelo y hasta hacer un cuerpo completo.
Comenzaremos esta sección describiendo la estructura y los conceptos para crear modelos "jerárquicos".


Conceptos basicos de jerarquía

Imaginemos que queremos construir un coche para realizar una cierta simulación. El coche estará compuesto por el cuerpo, cuatro ruedas con sus respectivos 5 tornillos, y seis ventanas (ventana delantera, ventana trasera y dos ventanas más a cada lado del coche que serán simétricas (ver figura 1). Para este ejemplo, utilizaremos solo el lado derecho del coche (visible en la figura). Por lo tanto usaremos el cuerpo, dos ruedas con sus diez tornillos y dos ventanas laterales. Para no tener que repetir código sería deseable construir el coche de una forma "jerárquica", significa esto que cuando los cinco tornillos estén correctamente colocados en la rueda, estos deberían moverse en concordancia con la misma sin ningún tipo de ayuda exterior. También seria deseable que cuando el cuerpo del coche se mueva, el resto de las partes sigan este movimiento y no permanezcan estáticas. Para realizar esta construcción "jerárquica" comenzaremos por poner el cuerpo de nuestro coche como el elemento principal y a partir de él colocaremos las ventanas y las ruedas con los tornillos enlazados a ellas. Con esta parte jerárquica lo que conseguimos es que cuando el cuerpo del coche se está moviendo, las ventanas y las ruedas se mueven con él de forma coordinada. Y además cuando las ruedas giran los tornillos lo hagan con ella. OpenGl nos permite realizar la construcción "jerárquica" de modelos con las funciones glPushMatrix y glPopMatrix. Si asumimos que con estas funciones podemos crear las partes separadas del coche (tornillos, ruedas, ventanas y cuerpo) entonces la figura 2 nos demuestra la necesidad de la "jerarquía" y el ejemplo 1 el pseudo-código para la realización del mismo.

Ejemplo 1. Pseudo-código que demuestra la "jerarquía" del coche

functión dibujar_coche{ glPushMatrix dibujar_cuerpo_coche glPushMatrix ir_posición_ventana_delantera dibujar_ventana_delantera ir_posición_ventana_trasera invertir_ejes dibujar_ventana_trasera invertir_ejes ir_posición_rueda_delantera dibujar_rueda_y_tornillos ir_posición_rueda_trasera dibujar_rueda_y_tornillos glPopMatrix glPopMatrix } functión dibujar_rueda_y_tornillos{ glPushMatrix dibuja_rueda glPushMatrix for counter = 1 up to 5 do { ir_posición_tornillo dibujar_tornillo } glPopMatrix glPopMatrix }

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

Cubo y pelota en rotacion

#include <GL/glut.h>

GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;

GLint ancho=400;

GLint alto=400;

int hazPerspectiva = 0;

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

      glOrtho(-4,4, -4, 4, 1, 10);

    glMatrixMode(GL_MODELVIEW);

    ancho = width;
    alto = height;
}

void drawCube(void)
{
    glColor3f(1.0f, 0.0f, 0.0f);
    glBegin(GL_QUADS);       //cara frontal
    glVertex3f(-1.0f, -1.0f,  1.0f);
    glVertex3f( 1.0f, -1.0f,  1.0f);
    glVertex3f( 1.0f,  1.0f,  1.0f);
    glVertex3f(-1.0f,  1.0f,  1.0f);

    glEnd();

    glColor3f(0.0f, 1.0f, 0.0f);

    glBegin(GL_QUADS);       //cara trasera
    glVertex3f( 1.0f, -1.0f, -1.0f);
    glVertex3f(-1.0f, -1.0f, -1.0f);
    glVertex3f(-1.0f,  1.0f, -1.0f);
    glVertex3f( 1.0f,  1.0f, -1.0f);

    glEnd();

    glColor3f(0.0f, 0.0f, 1.0f);
    glBegin(GL_QUADS);       //cara lateral izq
    glVertex3f(-1.0f,-1.0f, -1.0f);
    glVertex3f(-1.0f,-1.0f,  1.0f);
    glVertex3f(-1.0f, 1.0f,  1.0f);
    glVertex3f(-1.0f, 1.0f, -1.0f);
    glEnd();

    glColor3f(1.0f, 1.0f, 0.0f);
    glBegin(GL_QUADS);       //cara lateral dcha
    glVertex3f(1.0f, -1.0f,  1.0f);
    glVertex3f(1.0f, -1.0f, -1.0f);
    glVertex3f(1.0f,  1.0f, -1.0f);
    glVertex3f(1.0f,  1.0f,  1.0f);
    glEnd(); 

    glColor3f(0.0f,      1.0f, 1.0f);
    glBegin(GL_QUADS);       //cara arriba
    glVertex3f(-1.0f, 1.0f,  1.0f);
    glVertex3f( 1.0f, 1.0f,  1.0f);
    glVertex3f( 1.0f, 1.0f, -1.0f);
    glVertex3f(-1.0f, 1.0f, -1.0f);
    glEnd();

    glColor3f(1.0f, 0.0f, 1.0f);
    glBegin(GL_QUADS);       //cara abajo
    glVertex3f( 1.0f,-1.0f, -1.0f);
    glVertex3f( 1.0f,-1.0f,  1.0f);
    glVertex3f(-1.0f,-1.0f,  1.0f);
    glVertex3f(-1.0f,-1.0f, -1.0f);
    glEnd();
}

void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glLoadIdentity();

    glTranslatef(0.0f, 0.0f, -5.0f);
    glTranslatef(-3,0,0);

    glRotatef(anguloCuboX, 1.0f, 0.0f, 0.0f);
    glRotatef(anguloCuboY, 0.0f, 1.0f, 0.0f);
    glScalef(0.5f, 0.5f, 0.5f);
    drawCube();

    glLoadIdentity();

    glTranslatef(0.0f, 0.0f, -5.0f);
  glRotatef(anguloEsfera, 1.0f, 0.0f, 0.0f);
    glTranslatef(3.0f, 0.0f, 0.0f);

    glColor3f(1.0f, 1.0f, 1.0f);
    glutWireSphere(0.5f, 8, 8);

    glFlush();
    glutSwapBuffers();

    anguloCuboX+=0.1f;
    anguloCuboY+=0.1f;
    anguloEsfera+=0.2f;
}

void init()
{
    glClearColor(0,0,0,0);
    glEnable(GL_DEPTH_TEST);
    ancho = 400;
    alto = 400;
}


void idle()
{
    display();
}


void keyboard(unsigned char key, int x, int y)
{
    switch(key)
    {
    case 'p':
    case 'P':
      hazPerspectiva=1;
      reshape(ancho,alto);
      break;

    case 'o':
    case 'O':
      hazPerspectiva=0;
      reshape(ancho,alto);
      break;

    case 27:   // escape
     // exit(0);
      break;
    }
}

int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(ancho, alto);
    glutCreateWindow("Cubo 1");
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutIdleFunc(idle);
    glutKeyboardFunc(keyboard);
    glutMainLoop();
    return 0;
}

Rebote de Pelota

#include <GL/glut.h>
    #include <GL/gl.h>
    #include <GL/glu.h>
    #include <math.h>
    #include <stdio.h>
    #include <string.h>
  
    #define WIDTH 640
    #define HEIGHT 480

  
    void reshape(int width, int height){
    glViewport(0,0,width,height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-WIDTH/2,WIDTH/2-1,-HEIGHT/2,HEIGHT/2-1,-1,1);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
     glColor3f(0.0,0.0,1.0);
        glBegin (GL_LINES);

    }
  

    void init(void){
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glPointSize(0.0);
 
 
    }
  
    void Timer(int ex)
    {
  
  
    glutPostRedisplay();
    glutTimerFunc(30,Timer,0);
    }
  
    int k=20;
    void circle(int p,int m)
    {
    int x=0,y,d,r;
    r=m;
    y=r;
    d=3-2*r;
    while(x<=y)
    {
    glVertex2i(-x,y+p);
     glVertex2i(x,y+p);
    glVertex2i(y,x+p);
    glVertex2i(-x,y+p);
    glVertex2i(-y,x+p);
    glVertex2i(-x,-y+p);
    glVertex2i(-y,-x+p);
    glVertex2i(y,-x+p);
   glVertex2i(x,-y+p);
    if(d<0)
    d=d+4*x+6;
    else
    {
    d=d+4*(x-y)+10;
    y--;
    }
    x++;
    }
    }
  

int r=50,flag=0;
  
    void display(void)
    {
  
           typedef GLfloat point2[2];
  point2 vertice[6] = {
  {-100.0,-100.0},
  {-500.0,-100.0},
  {-50.0,50.0},
  {-50.0,50.0},
  {100.0,50.0},
  {100.0,50.0}
 };
  glColor3f(1.1,0.0,1.0);
  {
   glClear(GL_COLOR_BUFFER_BIT);
  glBegin(GL_QUADS);
          glVertex2f (-500.0, -240.0);
          glVertex2f (500.0, -240.0);
          glVertex2f (100.0, -100.0);
          glVertex2f (-500.0, -200.0);
           glVertex2f (100.0, -300.0);
          glVertex2f (100.0, -200.0);
           glVertex2f (100.0, -300.0);
          glVertex2f (100.0, -200.0);
    }

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(1.0,0.5,0.0);
    glBegin(GL_POINTS);

    circle(k,r);
  
  
    if(flag==0)
    {
    if((k+r)<=240)
    {
    k=k+10;
  
    }
  
    if((k+r)>=240){
    flag=1;
  
    }
    }
  
    if(flag==1)
    {
    k=k-10;
  
  
    if((k-r)<=-210)
    {
flag=0;
}
    }
  
    glEnd();
    glutSwapBuffers();
    }
  
void idle(void){
 
}
  
    int main(int argc, char **argv){
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowPosition(0,0);
    glutInitWindowSize(WIDTH,HEIGHT);
glutCreateWindow(argv[0]);
init();
glutIdleFunc(idle);
    glutReshapeFunc(reshape);
    glutDisplayFunc(display);
    glutTimerFunc(0,Timer,0);
    glutMainLoop();
    return(1);
    }

CODIGO CUBO 3D

 // cubolulu.cpp : Defines the entry point for the console application.
//

#include <GL/glut.h>
GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;
GLfloat x,y,z, ang, paso, dtx, dtz,pasoc,pasoa;
GLfloat pasob=-0.5;
GLint ancho=400;
GLint alto=400;
GLfloat trasy=0.0;
GLfloat a,b,c=2;

int hazPerspectiva = 0;
void reshape(int width, int height)
{
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
  glOrtho(-4,4, -4, 4, 1, 10);
  glMatrixMode(GL_MODELVIEW);
  ancho = width;
  alto = height;
}
void dibujarContorno()
{
    glColor3f(0.0f, 0.0f, 0.0f);
    glBegin(GL_LINE_STRIP);  //cara frontal
    glVertex3f(a-1.0f, b-1.0f,  c+1.0f);
    glVertex3f(a+ 1.0f,b-1.0f, c+1.0f);
    glVertex3f( a+1.0f, b+1.0f,  c+1.0f);
    glVertex3f(a-1.0f,  b+1.0f,  c+1.0f);
 glEnd();
    glColor3f(0.0f, 0.0f, 0.0f);
    glBegin(GL_LINE_STRIP);       //cara trasera
    glVertex3f( a+1.0f, b-1.0f, c-1.0f);
    glVertex3f(a-1.0f, b-1.0f, c-1.0f);
    glVertex3f(a-1.0f,  b+1.0f, c-1.0f);
    glVertex3f( a+1.0f,  b+1.0f, c-1.0f);
    glEnd();
    glColor3f(0.0f, 0.0f, 0.0f);
    glBegin(GL_LINE_STRIP);      //cara lateral izq
    glVertex3f(a-1.0f,b-1.0f, c-1.0f);
    glVertex3f(a-1.0f,b-1.0f,  c+1.0f);
    glVertex3f(a-1.0f, b+1.0f,  c+1.0f);
    glVertex3f(a-1.0f, b+1.0f, c-1.0f);
    glEnd();
    glColor3f(0.0f, 0.0f, 0.0f);
    glBegin(GL_LINE_STRIP);       //cara lateral dcha
    glVertex3f(a+1.0f, b-1.0f,  c+1.0f);
    glVertex3f(a+1.0f, b-1.0f, c-1.0f);
    glVertex3f(a+1.0f,  b+1.0f, c-1.0f);
    glVertex3f(a+1.0f,  b+1.0f,  c+1.0f);
    glEnd();
      glColor3f(0.0f, 0.0f, 0.0f);
    glBegin(GL_LINE_STRIP);       //cara arriba
    glVertex3f(a-1.0f, b+1.0f,  c+1.0f);
    glVertex3f( a+1.0f, b+1.0f,  c+1.0f);
    glVertex3f( a+1.0f, b+1.0f, c-1.0f);
    glVertex3f(a-1.0f, b+1.0f, c-1.0f);
    glEnd();
    glColor3f(0.0f, 0.0f, 0.0f);
    glBegin(GL_LINE_STRIP);       //cara abajo
    glVertex3f( a+1.0f,b-1.0f, c-1.0f);
    glVertex3f( a+1.0f,b-1.0f,  c+1.0f);
    glVertex3f(a-1.0f,b-1.0f,  c+1.0f);
    glVertex3f(a-1.0f,b-1.0f, c-1.0f);
    glEnd();
}
void dibujarCube()
{
    glColor3f(0.0f, 1.0f, 0.0f);
    glBegin(GL_POLYGON);  //cara frontal
    glVertex3f(a-1.0f, b-1.0f,  c+1.0f);
    glVertex3f(a+ 1.0f,b-1.0f, c+1.0f);
    glVertex3f( a+1.0f, b+1.0f,  c+1.0f);
    glVertex3f(a-1.0f,  b+1.0f,  c+1.0f);
 glEnd();
    glColor3f(1.0f, 0.0f, 0.0f);
    glBegin(GL_POLYGON);       //cara trasera
    glVertex3f( a+1.0f, b-1.0f, c-1.0f);
    glVertex3f(a-1.0f, b-1.0f, c-1.0f);
    glVertex3f(a-1.0f,  b+1.0f, c-1.0f);
    glVertex3f( a+1.0f,  b+1.0f, c-1.0f);
    glEnd();
    glColor3f(1.0f, 0.0f, 1.0f);
 glBegin(GL_POLYGON);       //cara lateral izq
    glVertex3f(a-1.0f,b-1.0f, c-1.0f);
    glVertex3f(a-1.0f,b-1.0f,  c+1.0f);
    glVertex3f(a-1.0f, b+1.0f,  c+1.0f);
    glVertex3f(a-1.0f, b+1.0f, c-1.0f);
    glEnd();
    glColor3f(1.0f, 0.0f, 1.0f);
 glBegin(GL_POLYGON);       //cara lateral dcha
    glVertex3f(a+1.0f, b-1.0f,  c+1.0f);
    glVertex3f(a+1.0f, b-1.0f, c-1.0f);
    glVertex3f(a+1.0f,  b+1.0f, c-1.0f);
    glVertex3f(a+1.0f,  b+1.0f,  c+1.0f);
    glEnd();
    glColor3f(1.0f,0.6f, 1.0f);
 glBegin(GL_POLYGON);       //cara arriba
    glVertex3f(a-1.0f, b+1.0f,  c+1.0f);
    glVertex3f( a+1.0f, b+1.0f,  c+1.0f);
    glVertex3f( a+1.0f, b+1.0f, c-1.0f);
    glVertex3f(a-1.0f, b+1.0f, c-1.0f);
    glEnd();
 glColor3f(1.0f, 1.0f, 0.0f);
    glBegin(GL_POLYGON);       //cara abajo
    glVertex3f( a+1.0f,b-1.0f, c-1.0f);
    glVertex3f( a+1.0f,b-1.0f,  c+1.0f);
    glVertex3f(a-1.0f,b-1.0f,  c+1.0f);
    glVertex3f(a-1.0f,b-1.0f, c-1.0f);
    glEnd();
}
void gldrawCube()
{
    float xMark = -1.0f;
    float yMark = -1.0f;
    float zMark = 1.0f;
    for (int i = 0; i < 2; i++)
    //moves back one unit on z-axis
    {
        for (int j = 0; j < 2; j++)
        //moves up one unit on y-axis
        {
            for (int k = 0; k < 2; k++)
            //builds 3 cubes along x-axis
            {
                dibujarCube();
    dibujarContorno();
    a=xMark;
    b=yMark;
    c=zMark;
                xMark++;
            }
            xMark = -1.0f;
            yMark++;
        }
        yMark = -1.0f;
        zMark--;
    }
}

void display()
{  
 glShadeModel(GL_SMOOTH);
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 glLoadIdentity();
 glTranslatef(0.0f, 0.0f, -5.0f);
 glRotatef(anguloCuboX, 1.0f, 0.0f, 0.0f);
    glRotatef(anguloCuboY, 0.0f, 1.0f, 0.0f);
 //glScalef(2.0f,2.0f,2.0f);
 gldrawCube();
 glLoadIdentity();
 glTranslatef(0.0f, 0.0f, -5.0f);
   // glRotatef(anguloEsfera, 1.0f, 0.0f, 0.0f);
 glColor3f(1.0f, 1.0f, 1.0f);   
 glFlush();
    glutSwapBuffers();
 anguloCuboX+=0.1f;
    anguloCuboY+=0.1f;
  //  anguloEsfera+=0.2f;
}
void init()
{
    glClearColor(0,0,0,0);
    glEnable(GL_DEPTH_TEST);
    ancho = 400;
    alto = 400;
}
void idle()
{
    display();
}
 void specialkeyevent( int key,  int Xx, int Yy )
{
 //float angrad;
  switch ( key )
  {
  case GLUT_KEY_UP:
   if(pasoa<.55)
    pasoa=pasoa+0.5;
    break;
   case GLUT_KEY_DOWN:
    if(pasoa>=-0.4)
    pasoa=pasoa-0.5;
   break;
  case GLUT_KEY_LEFT:
   if(pasoc>-.55)
    pasoc=pasoc-.5;
   break;
  case GLUT_KEY_RIGHT:
   if(pasoc<0.5)
    pasoc=pasoc+.5;
   break;
  }
   glutPostRedisplay();
}
void keyboard(unsigned char key, int x, int y)
{ 
 switch(key)  
 {
  case 'z':
   if(pasob<.1)
    pasob+=0.5;
   break;
  case 'Z':
   if(pasob>-.1)
    pasob-=0.5;
   break;
 }
 glutPostRedisplay();
}

 int main(int argc, char **argv)
 {
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
  glutInitWindowPosition(100, 100);
  glutInitWindowSize(ancho, alto);
  glutCreateWindow("Cubo Rubik");
  init();
  glutDisplayFunc(display);
  glutReshapeFunc(reshape);
  glutIdleFunc(idle);
  glutKeyboardFunc(keyboard);
  glutSpecialFunc( specialkeyevent );
  glutMainLoop();
  return 0;
 }