Sistema Solar realizado en OpenGl que muestra el render de 3 esferas ubicadas en el espacio en reprecentacion al sistema solar (Sol, Tierra y la luna).

En este ejemplo se utiliza la librería GLUT como extensión de OpenGl y es un código sencillo con fines didácticos, en lo que se utiliza las funciones básicas de (render imediato) OpenGl para generación de cuerpos en 3D y la ubicación de los mismo en el espacio.

Podemos observar el trabajo en las matrices  y la pila de matrices para ir cuidando las posiciones relativas de trabajo utiles para ubicar las figuras en el espacio.

Tambien en el ejemplo manejamos los eventos del teclado que permiten realizar los movimientos basicos del sistema, como son la rotacion y traslacion del planeta, que representan los dias y los años, y la traslacion de la luna alrededor del planeta, representando las horas.

 1 //gcc SolarSystem.c -lGL -lGLU -lglut
 2 #include <GL/gl.h>
 3 #include <GL/glu.h>
 4 #include <GL/glut.h>
 5 
 6 static int year = 0, day = 0, moon=0;
 7 //Variables de Control
 8 
 9 void init(void){
10     glClearColor (0.0, 0.0, 0.0, 0.0);
11     glShadeModel (GL_FLAT);
12 }
13 
14 void display(void){
15     glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
16     glDepthFunc(GL_LEQUAL);
17     glEnable(GL_DEPTH_TEST);
18     glClearDepth(1.0);
19     glColor3f (1.0, 0.0, 0.0);
20     glPushMatrix();
21         glutWireSphere(0.7, 20, 16);
22         /* Dibuja el Sol */
23         glRotatef (15, 0.0, 0.0, 1.0);    //angulo constante de inclinacion en z
24         glRotatef ((GLfloat) year, 0.0, 1.0, 0.0);    //angulo segun el año
25         glTranslatef (3.0, 0.0, 0.0);    //Distancia entre el sol y le planeta
26         glPushMatrix();
27             glRotatef ((GLfloat) day, 0.0, 1.0, 0.0);    //angulo del planeta Dia
28             glColor3f (0.0, 0.0, 1.0);
29             glutWireSphere(0.3, 10, 8);                //planeta
30         glPopMatrix();
31         /* Dibuja un planeta */
32         glRotatef (-25, 0.0, 0.0, 1.0);                //Angulo constante de la luna
33         glRotatef ((GLfloat) moon, 0.0, 1.0, 0.0);    //Angulo de la luna segun la hora
34         glTranslatef (0.5, 0.0, 0.0);                //Distancia planeta luna
35         glColor3f (0.7, 0.7, 0.7);
36         glutWireSphere(0.07, 10, 8);                //luna
37         /* draw smaller planet */
38     glPopMatrix();
39     glutSwapBuffers();
40 }
41 
42 void reshape (int w, int h)
43 {
44     glViewport (0, 0, (GLsizei) w, (GLsizei) h);
45     glMatrixMode (GL_PROJECTION);
46     glLoadIdentity ();
47     gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 20.0);
48     glMatrixMode(GL_MODELVIEW);
49     glLoadIdentity();
50     gluLookAt (0.0, 1.0, 6.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
51 }
52 
53 void keyboard (unsigned char key, int x, int y)
54 {
55     switch (key) {
56         case 'd':
57             day = (day + 10) % 360;
58             glutPostRedisplay();
59             break;
60         case 'D':
61             day = (day - 10) % 360;
62             glutPostRedisplay();
63             break;
64         case 'y':
65             year = (year + 5) % 360;
66             glutPostRedisplay();
67             break;
68         case 'Y':
69             year = (year - 5) % 360;
70             glutPostRedisplay();
71             break;
72         case 'm':
73             moon = (moon + 10) % 360;
74             glutPostRedisplay();
75             break;
76         case 'M':
77             moon = (moon - 10) % 360;
78             glutPostRedisplay();
79             break;
80         default:
81             break;
82     }
83 }
84 
85 int main(int argc, char** argv)
86 {
87     glutInit(&argc, argv);
88     glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
89     glutInitWindowSize (500, 500);
90     glutInitWindowPosition (100, 100);
91     glutCreateWindow (argv[0]);
92     init ();
93     glutDisplayFunc(display);
94     glutReshapeFunc(reshape);
95     glutKeyboardFunc(keyboard);
96     glutMainLoop();
97     return 0;
98 }

Ejemplo de programa en OpenGl de brazo robotico.

 

En este ejemplo se muestra el codigo basico, que realize en mi aprendizage basico de openlgl con intenciones didacticas, sobre el render de imagenes (modo inmediato) y la posiscion y visualizacion de la camara, ademas de trasformaciones basicas en las matrices y control de eventos del teclado.

Muestra un pequeño brazo robotico de 3 grados de libertad controlado por 3 letras, invirtiendo su giro segun sea minuscula o mayuscula.
Contiene una esfera roja en cada union de las articualciones con la intencion de ayudar a nuestra vision a dar la profundidas de las figuras tridimencionales geometricas utilizadas.

Para su compilacion en Linux se utiliza el siguiente comando:
gcc robotArm.c -lGL -lGLU -lglut

File:robotArm.c 

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

static int shoulder = 0, elbow = 0, base=0;
//angulos de las uniones (grados de libertad)

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

void display(void)
{
    //rutina de render
    glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glDepthFunc(GL_LEQUAL);
    glEnable(GL_DEPTH_TEST);
    glClearDepth(1.0);            //Funciones para profundidad
   
    glColor3f (1.0, 0.0, 0.0);    //Color Rojo
    glutSolidSphere(0.5, 10, 8);//Esfera de la base
    glPushMatrix();
        glRotatef ((GLfloat) base, 0.0, 1.0, 0.0);        //Gira la base en Y
        glRotatef ((GLfloat) shoulder, 0.0, 0.0, 1.0);    //Gira el hombro en Z
        glPushMatrix();                //Guadra el estado de la matriz anterior
            glTranslatef (1.5, 0.0, 0.0);    //Traslada la primer parte en X
            glScalef (3.0, 1.0, 1.0);        //Escala el cubo a un rectangulo
            glColor3f (1.0, 1.0, 1.0);        //Color Blanco
            glutWireCube (1.0);                //Cubo de 1 unidad de lado
        glPopMatrix();                //Bota la matriz recuperando la posicion anterior
        glTranslatef (3, 0.0, 0.0);    //Mueve el punto central al final de la primer pieza
        glColor3f (1.0, 0.0, 0.0);    //Color rojo para la esfera
        glutSolidSphere(0.5, 10, 8);//Esfera de radio 0.5
        glRotatef ((GLfloat) elbow, 0.0, 0.0, 1.0);    //Angulo de la siguiente union
        glPushMatrix();                //Guadra el estado de la matriz anterior
            glTranslatef (1.5, 0.0, 0.0);    //Ajusta la pieza al inicio de la union
            glScalef (3.0, 1.0, 1.0);        //Escala la matriz
            glColor3f (1.0, 1.0, 1.0);        //Color Blanco
            glutWireCube (1.0);                //Cubo
        glPopMatrix();                //Bota la matriz recuperando la posicion anterior
        glTranslatef (3, 0.0, 0.0);    //Traslada el centro al final del brazo
        glColor3f (1.0, 0.0, 0.0);    //color Rojo
        glutSolidSphere(0.5, 10, 8);//Ultima esfera
    glPopMatrix(); //vuelve a la matriz original (identidad)
    glutSwapBuffers(); //Intercambia los buffers
}

void reshape (int w, int h) //Funcion que adecua el render a la ventana
{
    glViewport (0, 0, (GLsizei) w, (GLsizei) h);
    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();
    gluPerspective(65.0, (GLfloat) w/(GLfloat) h, 1.0, 20.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt (0.0, 7.0, 12.0, 0.0, 3.0, 0.0, 0.0, 1.0, 0.0);
    //posicion de la camara,    A donde apunta, vector superior
}

void keyboard (unsigned char key, int x, int y) //Control del teclado
{
    switch (key) {
        case 's':
            shoulder = (shoulder + 5) % 360;
            glutPostRedisplay();
            break;
        case 'S':
            shoulder = (shoulder - 5) % 360;
            glutPostRedisplay();
            break;
        case 'e':
            elbow = (elbow + 5) % 360;
            glutPostRedisplay();
            break;
        case 'E':
            elbow = (elbow - 5) % 360;
            glutPostRedisplay();
            break;
        case 'b':
            base = (base + 5) % 360;
            glutPostRedisplay(); 
            break;
        case 'B':
            base = (base - 5) % 360;
            glutPostRedisplay();
            break;
        default:
            break;
    }
}

int main(int argc, char** argv) //Funcion principal
{
    glutInit(&argc, argv);
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize (500, 500);
    glutInitWindowPosition (100, 100);
    glutCreateWindow (argv[0]);
    init ();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutKeyboardFunc(keyboard);
    glutMainLoop();
    return 0;
}

Hola, despues de mucho tiempo de ausencia xP, publico esta entrada, para dejar el material en el que estado trabajando.

Por el momento, en este mes, eh vuelto a revivir mi amor a ubuntu xP, (10.04) y puesto en marcha para desarrollar con todo, (y algunos juegos xP).

Ademas de revisar contenido de desarrollo en 3D con openGl, siguiente un libro que denominan, el libro rojo.

http://glprogramming.com/red/

Es un material interezante y bien redactado, obviamente en ingles, pero superando esa barrera de lenguaje es muy practico.

En la proxima entrada publicare lo aprendido y los ejemplos que pude concretar con exito.

Ademas del unicio de un modelo de brazo robotico con sus ecuaciones de posicion y las inversas (angulo) xP...

Por el momento es todo, y como es mi primer entrada del año, pues feliz 2012.