lunes, 7 de octubre de 2013

U3 ACTIVIDAD 3 Glosario

GLOSARIO




Análisis numérico (cálculo numérico)- es la rama de las matemáticas que se encarga de diseñar algoritmos para, a través de números y reglas matemáticas simples, simular procesos matemáticos más complejos aplicados a procesos del mundo real.

CAD-Diseño asistido por computadora, más conocido por sus siglas inglesas CAD (computer-aided design), es el uso de un amplio rango de herramientas computacionales que asisten  ingenierosarquitectos y diseñadores . El CAD es también utilizado en el marco de procesos de administración del ciclo de vida de productos (en inglés product lifecycle management).

Cálculo vectorial  (análisis vectorial)- es un campo de las matemáticas referidas al análisis real multivariable de vectores en 2 o más dimensiones. Es un enfoque de la geometría diferencial como conjunto de fórmulas y técnicas para solucionar problemas muy útiles para la ingeniería y la física.

CAM -Fabricación asistida por computadora (en Hispanoamérica) o fabricación asistida por ordenador (en España), también conocida por las siglas en inglés CAM (computer-aided manufacturing), implica el uso de computadores y tecnología de cómputo para ayudar en la fase directa de manufactura de un producto, es un puente entre el Diseño Asistido por Computadora CAD y el lenguaje de programación de las máquinas herramientas con una intervención mínima del operario.

Estructura de datos- es una forma de organizar un conjunto de datos elementales con el objetivo de facilitar su manipulación. Un dato elemental es la mínima información que se tiene en un sistema. Una estructura de datos define la organización e interrelación de estos y un conjunto de operaciones que se pueden realizar sobre ellos.
Geometría analítica estudia las figuras geométricas mediante técnicas básicas del análisis matemático y del álgebra en un determinado sistema de coordenadas.

Geometría descriptiva es un conjunto de técnicas geométricas que permite representar el espacio tridimensional sobre una superficie bidimensional. Por tanto, mediante «lectura» adecuada posibilita resolver problemas espaciales en dos dimensiones de modo que se garantiza la reversibilidad del proceso.
Método es una subrutina cuyo código es definido en una clase y puede pertenecer tanto a una clase, como es el caso de los métodos de clase o estáticos, como a un objeto, como es el caso de los métodos de instancia.

Método matricial- es un método de cálculo aplicable a estructuras hiperestáticas de barras que se comportan de forma elástica y lineal.
Técnica es un procedimiento o conjunto de reglas, normas o protocolos que tiene como objetivo obtener un resultado determinado, ya sea en el campo de las ciencias, de la tecnología, del arte, del deporte, de la educación o en cualquier otra actividad.
Teoría de conjuntos es una rama de las matemáticas que estudia las propiedades de los conjuntos: colecciones abstractas de objetos, consideradas como objetos en sí mismas. Los conjuntos y sus operaciones más elementales son una herramienta básica en la formulación de cualquier teoría matemática.
Topología es la rama de las matemáticas dedicada al estudio de aquellas propiedades de los cuerpos geométricos que permanecen inalteradas por transformaciones continuas.

U3 ACTIVIDAD 2-vertices de objeto (cpu) y codigo OpenGL aplicacando transformaciones al objeto

CODIGO  openGL(CPU lineas)


#include <GL/glut.h>

GLfloat tx= 1.0f;
GLfloat ty = 1.0f;
GLfloat ax = 0.0f; 
GLfloat ay = 0.0f;
GLfloat escala = 1.0f; 

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

}

void DibujaCPU(void)
{
glColor3f (0.25, 0.25, 0.25);
glBegin(GL_LINE_LOOP);
glVertex3f (0.0, 0.0, 0.0);
glVertex3f (5.0, 0.0, 0.0);
glVertex3f (5.0, 9.0, 0.0);
glVertex3f (0.0, 9.0, 0.0);
glEnd();

glColor3f (0.25, 0.25, 0.25);
glBegin(GL_LINE_LOOP);
glVertex3f (5.0, 0.0, 3.0);
glVertex3f (5.0, 9.0, 3.0);
glVertex3f (0.0, 9.0, 3.0);
glVertex3f (0.0, 0.0, 3.0);
glEnd();

glColor3f (0.25, 0.25, 0.25);
glBegin(GL_LINE_LOOP);
glVertex3f (3.0, 5.0, 0.0);
glVertex3f (4.0, 5.0, 0.0);
glVertex3f (4.0, 6.0, 0.0);
glVertex3f (3.0, 6.0, 0.0);
glEnd();

glColor3f (0.25, 0.25, 0.25);
glBegin(GL_LINE_LOOP);
glVertex3f (1.0, 7.0, 0.0);
glVertex3f (4.0, 7.0, 0.0);
glVertex3f (4.0, 8.0, 0.0);
glVertex3f (1.0, 8.0, 0.0);
glEnd();

glColor3f (0.25, 0.25, 0.25);
glBegin(GL_LINE_LOOP);
glVertex3f (0.0, 9.0, 0.0);
glVertex3f (5.0, 9.0, 0.0);
glVertex3f (5.0, 9.0, 3.0);
glVertex3f (0.0, 9.0, 3.0);
glEnd();

glColor3f (0.25, 0.25, 0.25);
glBegin(GL_LINE_LOOP);
glVertex3f (0.0, 0.0, 0.0);
glVertex3f (5.0, 0.0, 0.0);
glVertex3f (5.0, 0.0, 3.0);
glVertex3f (0.0, 0.0, 3.0);
glEnd();

glColor3f (0.25, 0.25, 0.25);
glBegin(GL_LINE_LOOP);
glVertex3f (0.0, 0.0, 0.0);
glVertex3f (0.0, 9.0, 0.0);
glVertex3f (0.0, 9.0, 3.0);
glVertex3f (0.0, 0.0, 3.0);
glEnd();



}


void display(){

glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(tx,ty,0.0f);
glScalef(escala, escala, escala);
glRotatef(ax, 1.0f, 0.0f, 0.0f);
glRotatef(ay, 0.0f, 1.0f, 0.0f);
DibujaCPU();
glFlush();
glutSwapBuffers();
ax+=0.1f;
ay+=0.1f;
}
void init(){
glClearColor(0,0,0,0);
glEnable(GL_DEPTH_TEST);
}
void idle()
{
display();
}
void Teclado(unsigned char key, int x, int y){ 
switch (key){
case 'a'://presionar tecla a
if( ty<10.0 ){ty = ty + 1.0;}//se mueve  en y positivo(arriba)
if(ty>0.1 && ty<4){escala = ty;}//y aumenta 
break;
case 'b'://presionar tecla b
if( ty>-10.0 ){ty = ty - 1.0;}//se mueve  en y negatibo(abajo)
if(ty>0.1 && ty<4){escala = ty;}//y disminuye 
break;
case 'd'://presionar tecla d 
if( tx<10.0 ){tx = tx + 1.0;}//se mueve  en x positivo(Derecha) 
break;
case 'i'://presionar tecla i
if( tx>-10.0 ){tx = tx - 1.0;}//se mueve en x negativo(Izquierda)
break;

}
switch (key) {
case 27:
exit(0);
break;
}
}
int main(int argc, char **argv) 
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutInitWindowPosition(400,200);
glutInitWindowSize(800,500);
glutCreateWindow("Ruben De La Cruz Venegas");
init();glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutKeyboardFunc(Teclado);
glutMainLoop();
return 0;}




CODIGO  openGL(CPU solido)



#include <GL/glut.h>

GLfloat tx= 1.0f;
GLfloat ty = 1.0f;
GLfloat ax = 0.0f;
GLfloat ay = 0.0f;
GLfloat escala = 1.0f;

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

}

void DibujaCPU(void)
{
glColor3f (0.25, 0.25, 0.25);
glBegin(GL_POLYGON);
glVertex3f (0.0, 0.0, 0.0);
glVertex3f (5.0, 0.0, 0.0);
glVertex3f (5.0, 9.0, 0.0);
glVertex3f (0.0, 9.0, 0.0);
glEnd();

glColor3f (0.25, 0.25, 0.25);
glBegin(GL_POLYGON);
glVertex3f (5.0, 0.0, 3.0);
glVertex3f (5.0, 9.0, 3.0);
glVertex3f (0.0, 9.0, 3.0);
glVertex3f (0.0, 0.0, 3.0);
glEnd();

glColor3f (0.25, 0.25, 0.25);
glBegin(GL_POLYGON);
glVertex3f (3.0, 5.0, 0.0);
glVertex3f (4.0, 5.0, 0.0);
glVertex3f (4.0, 6.0, 0.0);
glVertex3f (3.0, 6.0, 0.0);
glEnd();

glColor3f (0.0, 0.0, 0.0);
glBegin(GL_POLYGON);
glVertex3f (1.0, 7.0, 0.0);
glVertex3f (4.0, 7.0, 0.0);
glVertex3f (4.0, 8.0, 0.0);
glVertex3f (1.0, 8.0, 0.0);
glEnd();

glColor3f (0.25, 0.25, 0.25);
glBegin(GL_POLYGON);
glVertex3f (0.0, 9.0, 0.0);
glVertex3f (5.0, 9.0, 0.0);
glVertex3f (5.0, 9.0, 3.0);
glVertex3f (0.0, 9.0, 3.0);
glEnd();

glColor3f (0.25, 0.25, 0.25);
glBegin(GL_POLYGON);
glVertex3f (0.0, 0.0, 0.0);
glVertex3f (5.0, 0.0, 0.0);
glVertex3f (5.0, 0.0, 3.0);
glVertex3f (0.0, 0.0, 3.0);
glEnd();

glColor3f (0.25, 0.25, 0.25);
glBegin(GL_POLYGON);
glVertex3f (0.0, 0.0, 0.0);
glVertex3f (0.0, 9.0, 0.0);
glVertex3f (0.0, 9.0, 3.0);
glVertex3f (0.0, 0.0, 3.0);
glEnd();



}


void display(){

glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(tx,ty,0.0f);
glScalef(escala, escala, escala);
glRotatef(ax, 1.0f, 0.0f, 0.0f);
glRotatef(ay, 0.0f, 1.0f, 0.0f);
DibujaCPU();
glFlush();
glutSwapBuffers();
ax+=0.1f;
ay+=0.1f;
}
void init(){
glClearColor(0,0,0,0);
glEnable(GL_DEPTH_TEST);
}
void idle()
{
display();
}
void Teclado(unsigned char key, int x, int y){
switch (key){
case 'a'://presionar tecla a
if( ty<10.0 ){ty = ty + 1.0;}//se mueve  en y positivo(arriba)
if(ty>0.1 && ty<4){escala = ty;}//y aumenta
break;
case 'b'://presionar tecla b
if( ty>-10.0 ){ty = ty - 1.0;}//se mueve  en y negatibo(abajo)
if(ty>0.1 && ty<4){escala = ty;}//y disminuye
break;
case 'd'://presionar tecla d
if( tx<10.0 ){tx = tx + 1.0;}//se mueve  en x positivo(Derecha)
break;
case 'i'://presionar tecla i
if( tx>-10.0 ){tx = tx - 1.0;}//se mueve en x negativo(Izquierda)
break;

}
switch (key) {
case 27:
exit(0);
break;
}
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutInitWindowPosition(400,200);
glutInitWindowSize(800,500);
glutCreateWindow("Ruben De La Cruz Venegas");
init();glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutKeyboardFunc(Teclado);
glutMainLoop();
return 0;}





U3 Actividad 1-Modelos Geometricos

MODELOS GEOMÉTRICOS
Los modelos gráficos también se le conocen como modelos geométricos, debido a que las partes componentes de un sistema se representan con entidades geométricas como líneas, polígonos o circunferencias de modo que el término modelo se refiere a una representación geométrica generada por la computadora.
EJEMPLOS
Formas entre los que se puede representar un modelo geométrico:
  • Distribución espacial y forma de los componentes y otros componentes que afectan a la apariencia de los componentes.
  • Conectividad de los componentes.
  • Los valores de datos específicos para la aplicación. 







MODELADO DE SUPERFICIE
Es la estimación de los valores de una superficie en cualquiera de sus puntos, partiendo de un conjunto de datos de muestreo (x, y, z), denominados puntos de control.
Existen dos enfoques para la presentación de la superficie externa del objeto:  
1  El objeto se representa con una lista de facetas, descritas por los lados y las aristas que la delimitan. La lista de caras puede incluir solamente informaciones geométricas propias de cada faceta (tamaño, posición respecto a un origen, etc.), o puede estar estructurada en un conjunto más complejo, donde los nodos de tipo “cara” se ligan a los nodos arista a través de los nodos “lados”. Estas conexiones pueden presentarse en forma de gráficas o de una estructura de árbol.
2  El objeto se representa empleando superficies de “forma libre”, que el usuario manipula interactivamente a través de puntos llamados de “control”. Se utiliza una superficie representada por ecuaciones paramétricas, que efectúa una aproximación de la envoltura exterior del objeto. Estas ecuaciones paramétricas dan como resultado una malla de elementos finitos de forma específica (generalmente cuadrados o triangulares) y utilizan puntos característicos para cambiar la forma final de la superficie. El modelo algebraico describe un sólido a partir de su frontera. (Conjunto de superficies que separa el sólido de la parte del espacio no ocupada por el).
La frontera se puede ver como la piel del sólido. Obviamente cualquier superficie no determina un sólido. Para que un conjunto de superficies describan un sólido deben satisfacer la siguiente propiedad.
Para que el sólido sea representable se suele imponer una condición adicional de suavidad en su frontera, más concretamente se suele exigir que la frontera sea algebraica (o al menos analítica). Esto es, debe ser representable por un polinomio de grado finito. Este modelo nos permite utilizar representaciones de los sólidos basadas el almacenamiento de la frontera, que es una entidad bidimensional.
El modelado con superficies permite al usuario obtener una mayor precisión geométrica y un gran realismo cuando desean obtenerse diseños de productos basados en geometrías complejas. 
EJEMPLO modelacion solidworks




MODELADO DE SÓLIDO
El Modelado Sólido es una rama relativamente reciente del Modelado Geométrico, que hace hincapié en la aplicabilidad general de los modelos, e insiste en crear solamente modelos "completos" de los sólidos, es decir, modelos que son adecuados para responder algorítmicamente (sin la ayuda externa del usuario) a cualquier pregunta geométrica que se formule.
Métodos de representación:
Instanciación de primitivas. El modelo se representa como un conjunto de primitivas que se instancian en el espacio. Para pode realizar cálculos es necesario que las diferentes instancias no se solapen en el espacio. El dominio depende del repertorio de primitivas.
Barrido (sweep). Se puede ver como una generalización de los métodos de desarrollo de superficies a partir de curvas. El elemento a desplazar es ahora una superficie, que describe un volumen al desplazarse a lo largo de una trayectoria o al rotarse.
Descomposición. El sólido se describe en base a una descomposición del espacio en una colección de elementos simples disjuntos, celdas (por ejemplo tetraedros o cubos). La representación de un sólido es el conjunto de celdas que ocupa.
Fronteras. El sólido se representa mediante un conjunto de caras que describen su frontera. La mayor parte de los sistemas utilizan representaciones de fronteras, con caras poligonales.
EJM

viernes, 27 de septiembre de 2013

U2-ACT8-Investigacion y Ejemplos Programas (Rotacion)




Para rotar un objeto sobre uno de los 3 ejes de coordenadas, o sobre cualquier otro vector definido V (x,y,z), OpenGL nos permite utilizar la función:
glRotatef (GLfloat angulo, GLfloat x, GLfloat y, GLfloat z);
El ángulo de rotación es siempre un ángulo en sentido en contra de las agujas del reloj y  medido en grados.  Si por ejemplo quisieramos rotar 45 grados nuestro cubo sobre el eje x el código sería el siguiente:
// Realizamos la rotación
glRotatef(45.0f, 1.0f, 0.0f, 0.0f);
//Pintamos el cubo
glutWireCube(10.0f);

Concepto pila (stack en inglés) es una lista ordenada o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out,último en entrar, primero en salir) que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el área de informática debido a su simplicidad y ordenación implícita de la propia estructura.
Para el manejo de los datos se cuenta con dos operaciones básicas: apilar (push), que coloca un objeto en la pila, y su operación inversa, retirar (o desapilar, pop), que retira el último elemento apilado.
En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objeto apilado (denominado TOS, Top of Stack en inglés). La operación retirarpermite la obtención de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con anterioridad), que pasa a ser el nuevo TOS.
Por analogía con objetos cotidianos, una operación apilar equivaldría a colocar un plato sobre una pila de platos, y una operación retirar a retirarlo.
Las pilas suelen emplearse en los siguientes contextos:
  • Evaluación de expresiones en notación postfija (notación polaca inversa).
  • Reconocedores sintácticos de lenguajes independientes del contexto
  • Implementación de recursividad.

SECUENCIA Y MANEJO DE PILAS EN OPENGL
Cuando se trata de aplicar una sola transformación no hay ningún problema con las funciones anteriormente comentadas, pero en el caso de que queramos realizar varias transformaciones a un objeto tendremos que entender mejor cómo las gestiona y lleva a cabo OpenGL. La idea principal es que OpenGL utiliza una pila (LIFO) para almacenar las transformaciones.
comportamiento diferente pila opengl transformaciones
En la imagen anterior vemos la diferencia entre ejecutar una traslación  primeramente y un escalado en segundo lugar, y ejecutar primero un escalado y luego una traslación:
//primer ejemplo
glScalef( 2.0f, 2.0f, 2.0f);
glTranslatef( 10.0f, 0.0f, 0.0f);
glutWireCube(4.0f);
//segundo ejemplo
glTranslatef( 10.0f, 0.0f, 0.0f);
glScalef( 2.0f, 2.0f, 2.0f);
glutWireCube(4.0f);
En el primer caso, la primera transformación que se ejecuta es la Traslación y posteriormente el Escalado, aunque en el código lo veamos al revés. ¿Cuál es la razón? La razón está en el comportamiento de la pila. Al ejecutar secuencialmente el código la primera transformación es el Escalado,  que es la primera en entrar en la pila, mientras que la Traslación entra después. La traslación está encima del Escalado y por eso se ejecutará antes.
OpenGL tiene una pila para las transformaciones geométricas y de la cámara llamadaGL_MODELVIEW, y otra para las proyecciones denominada GL_PROYECTION. Para indicar sobre qué pila estamos trabajando se utiliza la función glMatrixMode(Nombre_Pila).
Si quisieramos realizar diversas transformes a diferentes objetos la situación se nos complicaría ya que las transformaciones se irían acumulando en la pila. Si se quieren aplicar distintas transformaciones a distintos objetos sería necesario poder modificar el contenido de la pila. OpenGL nos ofrece 3 funciones para manejar las pilas:glLoadIdentity(), glPushMatrix() y glPopMatrix().
matriz push pop translate
La función glLoadIdentity sustituye el contenido de la pila por la matriz de identidad.
La función glPushMatrix() realiza una copia de la matriz superior y la pone encima de la pila, de tal forma que las dos matrices superiores son iguales. De esta forma al llamara a la función glPushMatrix() se duplica la matriz superior y por tanto las siguientes transformaciones que se realizan se aplicarán sólo a la matriz superior de la pila, quedando la anterior con los valores que tenía en el momento de llamar a la función glPushMatrix().
La función glPopMatrix() elimina la matriz superior, quedando en la parte superior de la pila la matriz que estaba en el momento de llamar a la función glPushMatrix().
----------------------------------------------------------------------------------------------------------------------------------

EJEMPLOS (PROGRAMAS)


#include<windows.h>
#include <GL/glut.h>
#include<iostream>
#include <stdlib.h>
 
using namespace std;
 
void handleKeypress(unsigned char key, int x, int y)
{
switch(key)
{
case 27:
exit(0);
}
}
void initRendering()
{
glEnable(GL_DEPTH_TEST);
}
 
void handleResize(int w,int h)
{
glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0,(double)w/(double)h,1.0,200.0);
}
 
float _angle=0.0;
float _cameraangle=30.0;
 
void drawScene()
{
 
 
 
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glRotatef(_cameraangle,0.0f,1.0f,0.0f); //ROTAR OBJETO 30 GRADOS CON RESPECTO A "Y"
glTranslatef(0.0f, 0.0f, -10.0f);
 
glPushMatrix();
glTranslatef(5.0f, -1.0f, 0.0f);
glScalef(2.0f,2.0f,2.0f);
glRotatef(_angle,1.0f,3.0f,2.0f); //ROTACION CONTINUA DE 2 GRADOS
glBegin(GL_QUADS);
 
glVertex3f(-0.7f,0.0f,0.0);
glVertex3f(0.7f,0.0f,0.0);
glVertex3f(0.5f,2.0f,0.0);
glVertex3f(-0.5f,2.0f,0.0);
 
glEnd();
 
glPopMatrix();
glutSwapBuffers();
 
 
}
void update(int value)
{
_angle+=2.0f;
if(_angle>360.f)
{
_angle-=360;
}
glutPostRedisplay();
glutTimerFunc(25,update,0);
}
 
int main(int argc,char**argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowSize(600,600);
 
 
glutCreateWindow("rotate");
initRendering();
 
 
 
glutDisplayFunc(drawScene);
glutKeyboardFunc(handleKeypress);
glutReshapeFunc(handleResize);
 
glutTimerFunc(25,update,0);

glutMainLoop();
 
 
return 0;
}
---------------------------------------------------------------------------------------------------------

Ejemplo 2

#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
 
#include <iostream>
#include <stdlib.h>
using namespace std;
 
static GLfloat spin = 0.0;
static GLfloat speed = 0.0;
static int running = 0;
float lngh ; float width ; float depth ;
int i;
 
void box(float lngh,float width,float depth);
void Fan_Physics();
void Fan_Render(); 
 
void init(void) 
{
   GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
   GLfloat mat_shininess[] = { 50.0 };
   GLfloat light_position[] = { 5.0, 1.0, 5.0, 0.0 };
   GLfloat mat_amb_diff_color_red[]  = {1.0, 0.5, 0.0, 0.5};
   GLfloat mat_amb_diff_color_green[]  = {0.0, 1.0, 0.0, 0.5};
   GLfloat light_diffuse[] = {1.0, 1.0, 1.0, 1.0};
   GLfloat light_ambient[] = {0.15, 0.15, 0.15, 0.15};
   GLfloat light_specular[] = {1.0, 1.0, 1.0, 1.0};
 
 
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel (GL_SMOOTH);
 
   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
   glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
   glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_amb_diff_color_green);
   glLightfv(GL_LIGHT0, GL_POSITION, light_position);
 
   glEnable(GL_LIGHTING);
   glEnable(GL_LIGHT0);
   glEnable(GL_DEPTH_TEST);
 
}
 
void display(void)
{
   //glClear (GL_COLOR_BUFFER_BIT);
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   //glColor3f (1.0, 1.0, 1.0);
   glLoadIdentity ();             /* clear the matrix */
           /* viewing transformation  */
   //gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
   glTranslatef(0.0, 0.0, -4.0); 
   gluLookAt(5,5,5,0,1.5,0,0,1,0);
   //Fan_Physics();
   Fan_Render();
    glutSwapBuffers();
 glutPostRedisplay();
 
}
 
void Fan_Physics(void)
{
 if (running == 1)
   speed = speed + 0.9;
      if (speed > 360.0)
         speed = 360.0;
    if (running == 0)
     speed = speed - 1.8;
    if (speed < 0)
     speed = 0;
   spin = spin + speed/100;
   //glutPostRedisplay(); 
 
}
 
void Fan_Render(void)
{
 glPushMatrix();
     /* Fan*/
 glPushMatrix();
  GLfloat mat_amb_diff_color_red[]  = {1.0, 0.5, 0.0, 0.5};
     GLfloat mat_amb_diff_color_green[]  = {0.0, 1.0, 0.0, 0.5};
 glTranslatef(0.0, 2.0, 0.5);
 glRotatef(spin, 0.0, 0.0, 1.0 );
 for (i = 1; i<=360; i=i+60)
 
 {
  glPushMatrix();
  glRotatef( i, 0.0, 0.0, 1.0 );///ROTACION CON RESPECTO A X
  glTranslatef(1.5, 0.0, 0.0);
  glRotatef( -45, 1.0, 0.0, 0.0 );
  glShadeModel(GL_FLAT);   
        glEnable(GL_DEPTH_TEST);
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);  
     //glMaterialfv_p(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_amb_diff_color);
     glPushMatrix();
  
  glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_amb_diff_color_green);
  box(1.0,0.3,0.01);
  //glEnable(GL_LIGHTING);
  glPopMatrix();
  glPopMatrix();
 
 }
glPopMatrix();
glPopMatrix();
glPopMatrix();
}
 
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);
}
 
void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
      case 27:
         exit(0);
         break;
      case 32:
         if (running == 0)
          {running = 1;glutIdleFunc(Fan_Physics);}
          else {running = 0;glutIdleFunc(Fan_Physics);}
   }
}
 
int main(int argc, char** argv)
{
   glutInit(&amp;argc, argv);
   glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
   glutInitWindowSize (640, 480); 
   glutInitWindowPosition (0, 0);
   glutCreateWindow ("                   press  SpaceBar to toggle fan rotation");
   init ();
   glutDisplayFunc(display); 
   glutReshapeFunc(reshape);
   glutKeyboardFunc(keyboard);
   glutMainLoop();
   return 0;
}
 
void box(float lngh, float width, float depth)
 {
 float a = lngh; float b = width; float c = depth;
 
 
glBegin(GL_QUADS);
 
    /* Top face of box*/
 
    glVertex3f(a, b, -c);    
    glVertex3f(-a, b, -c);   
    glVertex3f(-a, b, c);    
    glVertex3f(a, b, c);     
 
    // Bottom face of box
 
    glVertex3f(a, -b, -c);   
    glVertex3f(-a, -b, -c);  
    glVertex3f(-a, -b, c);   
    glVertex3f( a, -b, c);   
    glColor3f(1.0,0.0,0.0);
    // Front of box
 
    glVertex3f(a, b, c);      
    glVertex3f(-a, b, c);     
    glVertex3f(-a, -b, c);    
    glVertex3f(a, -b, c);     
    glColor3f(1.0,0.0,0.0);
    // Back of box
 
    glVertex3f(a, -b, -c);    
    glVertex3f(-a, -b, -c);   
    glVertex3f(-a, b, -c);    
    glVertex3f(a, b, -c);     
    glColor3f(1.0,0.0,0.0);
    // Left of box
 
    glVertex3f(-a, b, c);     
    glVertex3f(-a, b, -c);    
    glVertex3f(-a, -b, -c);   
    glVertex3f(-a, -b, c);    
    glColor3f(1.0,0.0,0.0);
    // Right of box
 
    glVertex3f(a, b, -c);     
    glVertex3f(a, b, c);      
    glVertex3f(a, -b, c);     
    glColor3f(1.0,0.0,0.0);
    // End drawing the box
    glEnd(); 
    //return TRUE;
 
}
---------------------------------------------------------------------------------

EJEMPLO 3 Muestra cubo girando en origen y una esfera girando en un punto fijo



#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(-3.0f, 0.0f, -5.0f);
    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(-1.0f, 0.0f, -1.0f);
    glRotatef(anguloEsfera, 0.0f, 1.0f, 0.0f);//ROTACION PUNTO FIJO
  glTranslatef(0.0f, 0.0f, 0.0f);
    glColor3f(1.0f, 1.0f, 1.0f);
    glutWireSphere(0.9f, 8, 8);
    glFlush();
    glutSwapBuffers();
    anguloCuboX+=0.1f;
    anguloCuboY+=0.1f;
    anguloEsfera+=0.1f;
}
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;
}