Discussion :

[Kimy_Ire]

Bonjour,

ma question va peut-être parraître très bête. Je suis actuellement en train de créer un système solaire sous opengl. Je ne suis pas expert en la matière... comme vous allez pouvoir le constater...

J'ai créé des planètes, réussi à bouger ma caméra dans cet univers (pour le moment fixe) et j'aimerai donc que mes planètes tounent autour du soleil. Mais je ne sais pas comment faire pour qu'elles tournent à un rythme différent...

J'imagine qu'il faut que j'update ma scène tous les (mettons) 0.1 sec.

Ici je fais tourner mon univers... mais entier (planètes + soleil au même rythme) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int drawGLScene(float theta)	// Draw the scene; 
{                                       
// theta is amount to rotate -> général (pour toutes mes planètes)
    glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear Screen 
 
    //ma camera
    camera->look();
 
    //la rotation
    glRotatef (theta, 0.0f, 1.0f, 0.0f);
 
    glColor3f(0.0f, 1.0f, 0.0f); 
    sg->renderScene(0.0f);
 
    GetFramesPerSecond();
	return TRUE; 
}

J'update mon theta dans une boucle infini dans une autre partie de mon programme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
        else
        {
            drawGLScene(theta);
            SwapBuffers(hDC);
            theta -= 1.0f;
            Sleep (10);
        }

Mais si je comprends bien, "glRotatef (theta, 0.0f, 1.0f, 0.0f);" déplace tout mon univers et pas seulement une planete. Comment puis-je faire un "scope" sur mes planètes ?

Je ne sais pas si j'ai été très clair... J'espère que vous pourrez m'aidez... Je reste à votre disposition pour toute questions !

Merci d'avance en m'excusant de vous dérangez.

Kimy

[Kimy_Ire]

Je devrais peut-être ajouter que la création de mes planètes se fait de la manière suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void createPlanete(string source, float size, float position, DummyObject *root)
{
     float scale = 0.001;
     float UA = 149.598;
 
     matrix m;
     m.makeTranslate(position*UA, 0.0f, 0.0f);
     Transform *t = new Transform(m);
     root->addChild(t);
     Primitive *p = new Primitive(SPHERE, size*scale, 50.0f);
     p->getMaterial()->setDiffuse(Vec4(0.9f, 0.9f, 0.9f, 1.0f));
     p->getMaterial()->setEmission(Vec4(1.0f, 1.0f, 1.0f, 1.0f));
     Texture *tex = new Texture(source);
     p->setTexture(tex);
     t->addChild(p);
}

avec:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
    createPlanete("sun.bmp", 69600.0f, 0.0f, root);
    createPlanete("mercury.bmp", 4878.0f, 0.387f, root);
    createPlanete("venus.bmp", 12104.0f, 0.7233f, root);
    createPlanete("earth.bmp", 12756.0f, 1.0f, root);
    createPlanete("mars.bmp", 6794.0f, 1.5337f, root);
    createPlanete("jupiter.bmp", 142796.0f, 5.2026f, root);
    createPlanete("saturn.bmp", 120000.0f, 9.5547f, root);
    createPlanete("uranus.bmp", 51200.0f, 19.218f, root);
    createPlanete("neptun.bmp", 48600.0f, 30.1096f, root);
    createPlanete("pluto.bmp", 2200.0f, 139.4387f, root);

Je peux, bien entendu, faire en sorte que mon programme me retourne quelque chose. J'ajoute en effet mes planètes directement au root... mais je peux retourner la transform de mes planètes si nécessaire.

[MaximeL]

OpenGL fonctionne avec des matrices pour positionner tes objets. Lorsque du fait un glRotate, tu modifie la matrice courante et ainsi, tous les objets définis après seront placés en fonction de cette matrice.

Ainsi, il faut déjà initialiser tes matrice à chaque frame via glLoadIdentity() (sinon, le placement de tes objets dépendra de la frame précédente).

Ensuite, pour tes objets proprement dit, il faut faire une rotation pour chacuns de tes objets (à priori, ça se passe dans sg->renderScene(0.0f) ). Une façon simple étant de "sauvegarder" la valeur de la matrice courante avec glPushMatrix(), de faire une rotation propre à la planette, placer ton objet, puis de restaurer la matrice à sa valeur de départ avec glPopMatrix(). Tu peut ensuite passer à la planette suivante, et etc, ... .

Pour glPush et glPop, c'est une bonne façon d'isoler les modifications sur les matrices pour qu'elle n'impactent pas le reste du code. Je crois que c'est déprécié dans les version 3 et 4, mais ne connait pas comment ils font maintenant.

[Bousk]

Bonjour,

effectivement en GL 1 & 2 il te faudra push puis pop une matrice pour chaque planète.
J'ajouterai qu'évidemment il te faut un theta différent pour chaque planète..

[LittleWhite]

Je suis totalement en accord avec les réponses ci dessus
Habituellement, dans ce genre de TP / programmes d'entrainement, on utilise des glPushMatrix() / glPopMatrix().

Pour glPush et glPop, c'est une bonne façon d'isoler les modifications sur les matrices pour qu'elle n'impactent pas le reste du code. Je crois que c'est déprécié dans les version 3 et 4, mais ne connait pas comment ils font maintenant.

Chaque planète aura sa propre matrice (par exemple, gérée avec GLM). Du coup, comme on fera les transformations sur chaque matrice indépendamment, il n'y aura pas besoin de push / pop.

[LastSpear]

Pour un peut plus de réalisme, il faudrait prendre en note que les planètes décrives pas des cercles mais des ellipses. Donc faire varier la distance soleil-planette.

De plus, si je ne me trompe pas, le soleil n'est autre que l'un des deux foyers des trajectoires elliptiques. Donc il faudrait un translation permanente de celles ci dans le plans écliptique.