Open GL - Sistema Solar

Hola, estoy haciendo un sistema solar con los planetas Sol, Tierra y Luna, en los que el sol es estatico y la Tierra tiene los movimientos de rotacion y traslacion sobre el Sol y la Luna sobre la Tierra. El programa cuando pulsar T rota y traslada la Tierra y la Luna y cuando pulsar R la Tierra solo rota y la Luna rota y se traslada sobre la tierra. Mi problema es que cuando pulso T y se traslada la tierra y luego pulso R no se como hacer para que la Tierra rote en el punto en que se me quedo despues de pulsar T. Si quito glTranslatef(traslacionTierra,0.0,0.0); se me va al origen y si lo pongo me hace lo mismo que al pulsar T. Gracias por la ayuda de antemano. El codigo que he escrito es el siguiente:

#include <glgl.h>
#include <glglu.h>
#include <glglut.h>

GLfloat anguloTierra=0.0;
GLfloat anguloLuna=0.0;
GLfloat traslacionTierra=1.5;
GLfloat traslacionLuna=0.5;
GLfloat r=0.0;

void funcionDePintado (void)
{
//color de fondo
glEnable(GL_DEPTH_TEST);//habilitamos test de profundidad
glClearColor(0.0, 0.0, 0.0, 0.0);//cargamos color para pantalla
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);//limpiamos la pantalla
glLoadIdentity();//cargamos la matriz identidad
glTranslatef(0.0, 0.0, -5.0);//alejamos la camara
glRotatef(90,1.0,0.0,0.0);
//si hacemos traslacion de tierra y luna
if(r==2)
{
glPushMatrix();//colocamos la matriz de transformación en la cima de la pila
//color de dibujo

glColor3f (1.0, 1.0, 0.0);
glutWireSphere(0.8,20,20);//sol
glRotatef(anguloTierra,0.0,0.0,1.0);
glTranslatef(traslacionTierra,0.0,0.0);
glColor3f(0.0,0.0,1.0);
glutWireSphere(0.3,10,10);//tierra
glRotatef(anguloLuna,0.0,0.0,1.0);
glTranslatef(traslacionLuna,0.0,0.0);
glColor3f(0.5,0.5,0.5);
glutWireSphere(0.1,10,10);//luna
// glFlush();
glPopMatrix();
glutSwapBuffers();//intercambiamos los buffers
}
else
{
glPushMatrix();
glColor3f (1.0, 1.0, 0.0);
glutWireSphere(0.8,20,20);//sol
glRotatef(anguloTierra,0.0,0.0,1.0);
//glTranslatef(traslacionTierra,0.0,0.0);
glColor3f(0.0,0.0,1.0);
glutWireSphere(0.3,10,10);//tierra
glRotatef(anguloLuna,0.0,0.0,1.0);
glTranslatef(traslacionLuna,0.0,0.0);
glColor3f(0.5,0.5,0.5);
glutWireSphere(0.1,10,10);//luna
glutSwapBuffers();//intercambiamos los buffers
glPopMatrix();
}
}

void funcionDeReescalado(GLsizei w, GLsizei h)
{
glMatrixMode (GL_PROJECTION); //activar la matriz de proyeccion
glLoadIdentity ();
//glFrustum(-1.5, 1.5, -1.5, 1.5, 2.0, 10.0);//establecemos el frustrum de visualizado (izq,der,abaj,arrib,cerca,lejos)
gluPerspective(60.0, (float)w/(float)h, 2.0, 7.0);
glViewport (0, 0, w, h);
glMatrixMode (GL_MODELVIEW); //activar la matriz de modelo-vista
}

void funcionRotarTrasladar(unsigned char key, int x, int y)
{
if((key=='r')||(key=='R'))
{
anguloTierra+=5.0;
anguloLuna+=5.0;

if(anguloTierra>=360)
{
anguloTierra=0.0;
}
if(anguloLuna>=360)
{
anguloLuna=0.0;
}
funcionDePintado();
r=1;
}
if((key=='t')||(key=='T'))
{
anguloTierra+=5.0;
anguloLuna+=5.0;
if(anguloTierra>=360)
{
anguloTierra=0.0;
}
if(anguloLuna>=360)
{
anguloLuna=0.0;
}
funcionDePintado();
r=2;
}

}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(800,600);
glutInitWindowPosition(100,100);
glutCreateWindow("Practica 2 - Javier Alcon Palazon");
glutReshapeFunc(funcionDeReescalado);
glutKeyboardFunc (funcionRotarTrasladar);
glutDisplayFunc(funcionDePintado);
glutMainLoop();
return 0;
}

Hola Javier

He mirado el codigo por encima, y... si tienes que hacer el //glTranslatef(traslacionTierra,0.0,0.0); Lo que no comprendo es que la variable translacionTierra. Yo lo haria asi (para la tierra).

1. Roto la tierra (rotacion propia)
glrotatef (rotacionTierra, 0, 1, 0);
2. Translado la tierra
glTranslatef (radio*cos(translacionTierra), 0, radio*sen(translacionTierra))
3. Dibujo la tierra
DibujarTierra()

Date cuenta que tanto para la opcion R como T, dibujo igual. La diferencia la pondria al leer los eventos

void funcionTeclado (.....)

si tecla=T entonces
transladando = true
rotando = false
sino si tecla=R entonces
transladando=false
rotando = true
sino si tecla = P entonces
transladando = false
rotando = false
sino si tecla = "Escape" entonces
Salir!!!
fin si

Ahora, en la funcion timer, en funcion de la bandera activa, actualizo los valores de las variables rotacionTierra y traslacionTierra.

void FuncionReloj

si transladando = true entonces
rotacionTierra += 1
translacionTierra+=1
fin si

si rotando = true entonces
rotacionTierra += 1
fin si

Y listo. Lo he dejado un poco en pseudolenguaje. Si lo deseas, dilo aqui en el foro y te coloco un ejemplo C++ usando GLUT completo. Saludos!!

Hola Angel,

Muchas gracias por la ayuda. Si puedes mandarme o postear el ejemplito te lo agradeceria mucho. Cuando dices "la funcion timer" ¿que te refieres a la funcion glutTimer() o a una que me cree yo como tu has puesto "funcionReloj"? es que nunca la he usado (como te habras dado cuenta estoy empezando en este mundillo).

Un saludo!

Hola que tal? Bueno, he recibido el enunciado, por ello, gracias. Lo que voy a hacer es solucionar el ejercicito y publicarlo en el foro, de modo que le sea util a la gente del foro. Un sistema solar es a OpenGL lo que "Hola Mundo" a cualquier lenguaje de programación, asi que es muy habitual esta duda.

Solo una pregunta, ¿las esferas son de color plano? me explico, si no usas sombras, no usas texturas.... ¿como ver la rotacion de la esfera? Quiza la dibujais con alambres o algo, supongo.

Bueno, voy a hacerlo y lo mando, saludos.

Hola Angel, bueno en esta practica son como bien dices estructuras de alambre. Luego en la siguiente tengo que hacer lo siguiente sobre el sistema solar con estructura de alambre:

- Incorporar una fuente de luz situada en el sol

- Modificar el tipo de material de cada planeta, para observar el efecto
diferente de la luz sobre cada uno de ellos.

Seguro que a muchos lectores del foro que esten iniciandose en este mundillo como yo les vendra como anillo al dedo ambas practicas.

Gracias por todo, un saludo.

Hola a todos, voy a presentar la solucion.

Te muestro el programa, yo entendi el problema de T y R asi, pero puedes modificarlo si no te cuadra, pero sera facil, veras. Añado un modo N (pulsando tecla n) que hace el movimiento normal rotacion y traslacion. El programa actualiza en el timer los valores de angulos... Es fundamental hacer los programas asi, en modo time based, ya que, de lo contrario, en unos PC's irá más lento que en otros.

Te muestro la solucion.

---------------------------------------------------------------------------------------
Codigo: Sistema solar PLANO
Lenguaje: C/C++ con DevCpp (en mi caso) usando GLUT
---------------------------------------------------------------------------------------

#include <GL/glut.h>
#include <stdlib.h>
#include <iostream>
#include <math.h>

float traslacion_tierra = 0.0;
float rotacion_tierra = 0.0;
float traslacion_luna = 0.0;
float rotacion_luna = 0.0;

bool modo_rotacion = true; // Por defecto
bool modo_traslacion = false;

static void resize(int width, int height)
{
const float ar = (float) width / (float) height;

glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho (-6.4,6.4,-4.8,4.8, 1.0, -1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity() ;
}

static void display(void)
{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3d(1,0,0);

const float dist_tierra_sol = 4.0;
const float dist_tierra_luna = 1.5;

// SOL
glColor3f (1.0, 1.0, 0.0);
glutWireSphere(1.0,20,20);

// TIERRA
glPushMatrix();
glTranslatef (dist_tierra_sol*cos(traslacion_tierra),dist_tierra_sol*sin(traslacion_tierra),0);
glRotatef(rotacion_tierra,0,0,1.0);
glColor3f(0.0,0.0,1.0);
glutWireSphere(0.8,10,10);
glPopMatrix();
// LUNA
glPushMatrix();
glTranslatef (dist_tierra_sol*cos(traslacion_tierra),dist_tierra_sol*sin(traslacion_tierra),0);
glTranslatef (dist_tierra_luna*cos(traslacion_luna),dist_tierra_luna*sin(traslacion_luna),0);
glRotatef(rotacion_luna,0,0,1.0);
glColor3f(0.5,0.5,0.5);
glutWireSphere(0.4,10,10);
glPopMatrix();

glutSwapBuffers();
}

static void key(unsigned char key, int x, int y)
{
switch (key)
{
case 27 :
case 'q':
exit(0);
break;
case 'r':
modo_rotacion=true;
modo_traslacion=false;
break;
case 't':
modo_rotacion = false;
modo_traslacion=true;
break;
case 'n':
modo_rotacion = true;
modo_traslacion=true;
break;
}

glutPostRedisplay();
}

static void idle(void)
{
glutPostRedisplay();
}

static void timer(int x)
{
if (modo_traslacion) traslacion_tierra += 0.02;
if (traslacion_tierra>360.0) traslacion_tierra = traslacion_tierra - 360.0;
if (modo_rotacion) rotacion_tierra += 10.0;
if (rotacion_tierra>360.0) rotacion_tierra = rotacion_tierra - 360.0;
if (modo_rotacion) traslacion_luna += 0.05;
if (traslacion_luna>360.0) traslacion_luna = traslacion_luna - 360.0;
if (modo_rotacion) rotacion_luna += 5.0;
if (rotacion_luna>360.0) rotacion_luna = rotacion_luna - 360.0;

glutTimerFunc(25, timer,0);
}

/* Program entry point */

int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitWindowSize(640,480);
glutInitWindowPosition(10,10);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

glutCreateWindow("Sistema Solar");

glutReshapeFunc(resize);
glutDisplayFunc(display);
glutKeyboardFunc(key);
glutIdleFunc(idle);
glutTimerFunc(25, timer,0);

glClearColor(0,0,0,1);

glEnable(GL_DEPTH_TEST);

glutMainLoop();

return
EXIT_SUCCESS;
}

---------------------------------------------------------------------------------------
Saludos

Necesito que alguie me mande el codigo del sistema solar en Open GL

hola:
he estado viendo lo que subieron y la verdad es que se me hace muy interesante, solo que la verdad voy comenzando en esto de la programación en OpenGL e intento compilar el programa y me marca errores, me podrian ayudar mandandome el proyecto para que yo pueda ver como es que corre?, porque me interesa ver como es que logran verse la rotación y la traslación de los planetas.

muchas gracias y espero que me puedan ayudar

Hola Paola, si quieres puedo ayudarte a corregir los errores que te da. ¿Tienes las dll de opengl y demás?

oye brother, por casualidad quisiera saber si a un tienes el codigo del sistema solar con el efecto de iluminosidad, ya q apenas voy empesando en esto de la programacion en opengl y no le entiendo muy bien y este mismo codigo me lo dejaron de proyecto, te agredeceria mucho si me lo pudieras pasar....

Saludos.

Para más información recomiendo la página http://rominacgd.es.tl
SALUDOS!!!!!

que programa usan para compilarlo?