freeglut et openGL - Création de sphère

Version imprimable

Bonjour à tous,

Je souhaite créer une sphère à l'aide d'openGL et freeglut.. cependant je ne parviens qu'à obtenir un cercle.
La lib m'est encore assez obscure alors ne soyez pas étonnez si vous trouvez des abérations dans le code x)
(Par contre les souligner en expliquant pourquoi serait bienvenu ^^ )

Bref, le code tronqué (tout n'est pas inclus) - mais il contient la création de la fenêtre ainsi que ses fonctions de rafraichissement.. donc tout ce qu'il faut je suppose :P

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#define FREEGLUT_STATIC
#include <GL/freeglut.h>
#include <list>
#include <cstdlib>
#include "Coordinate.hh"
 
static void resize(int width, int height)
{
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity() ;
  glOrtho(0.0f, (GLfloat) width, 0.0f, 
          (GLfloat) height, -1.0f, 1.0f); 
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity() ;
  glViewport(0, 0, width, height);
}
 
 
static void display(void)
{
  glutMainLoopEvent();
 
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glColor3d(1,0,0);
  for (std::list<Coordinate *>::iterator it = Positions.begin(); it != Positions.end(); ++it)
    {
// Coordinate est une classe contenant deux floats 
//(x et y, accessibles publiquement, et deux trois bricoles).
      glColor3f(0.60f,0.80f,0.90f);
      glPushMatrix();
      glTranslatef((**it).x, (**it).y, -20.0f);                                                   
      glRotatef(100.0, 10.0, 0, 0);                                                             
      glutSolidSphere(30, 18 , 36);
      glPopMatrix();
    }
  glutSwapBuffers();
}
 
void init_window(const unsigned int &size_x, const unsigned int &size_y)
{
  int init_glut = 0;
 
  glutInit(&init_glut, NULL);
  glutInitWindowSize(size_x, size_y);
  glutInitWindowPosition(10,10);
  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
  glutCreateWindow("sphere");
 
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(0.0f, (GLfloat) size_x, 0.0f,
          (GLfloat) size_y, -1.0f, 1.0f);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
 
  glutReshapeFunc(resize);
  glutDisplayFunc(display);
  glutKeyboardFunc(key);
  glutSpecialFunc(SpecialKeys);
  glutIdleFunc(idle);
}

Exemple de résultat:

http://imageup.fr/uploads/1331323440.png

Si quelqu'un pouvait m'éclairer.
Merci d'avance :)

10/03/2012, 11h02
LittleWhite

Bonjour,

Je vous conseillerai d'utiliser une std::list < Coordinate > à la place de votre std::list < Coordinate * >.
(Les pointeurs c'est moche).
Ce qui permettrai de simplifier cette ligne qui est effrayante :

Code:

glTranslatef((**it).x, (**it).y, -20.0f);

Qui d'ailleurs, pouvait être écrite :

Code:

glTranslatef((*it)->x, (*it)->y, -20.0f);

Sinon, vous faites un glColor3d puis dans la boucle, un glColor3f ... j'imagine que nous pouvons supprimé le premier.
Je ne comprends pas pourquoi vous faites une rotation d'une sphère :aie:

Et je ne vois pas pourquoi vous avez ce rendu ...
10/03/2012, 12h26
LittleWhite

J'ai testé le programme.
Votre problème est lié à la profondeur. Si vous faites :

Code:

glTranslatef((*it)->x, (*it)->y -30.0f);

Vous allez voir la sphère :)

Je conseille d'utiliser un système de caméra ... ou dit autrement, d'utiliser un matrice de vue pour votre scène. (gluLookAt() pour faire simple, mais cela est déprécié)
10/03/2012, 14h59
EvilSakray

Bonjour,

Merci de votre réponse :)

En ce qui concerne la liste de Coordinate *, j'en prend note, merci du conseil.

Pour le glColor3d puis le glColor3f, c'est ... en effet totallement stupide :mrgreen:
Alors pour la rotation.. heu *se cache*

Plus sérieusement, cela provient de test que j'avis fait avec d'autres objets auparavant et j'ai oublié de le retirer :oops:

Quand au problème principal,
En effet la modification de la profondeur semble régler le problème, une très petite sphère bleue se formant.

Cependant j'avoue ne pas être sûr de comprendre le résultat moi même.

Pourquoi la profondeur influe telle le rendu de cette facon ?
10/03/2012, 15h04
LittleWhite

Alors, c'est "simple".

Disons que la caméra (ou point de vue de l'utilisateur) se trouve en Z = 0.
Vous placez votre sphère en Z = -20 (20 unité devant l'utilisateur). Celle ci a un radius de 30. Donc le sommet de la sphère sera en 10 (derrière l'utilisateur). Du coup, elle est découpée.

Le fait que l'on ne voit pas la partie interne du la sphère est du à une technique d'optimisation appelée "backface culling" qui permet de ne pas calculer les faces cachées (normalement, nous ne sommes pas dans la sphère donc nous n'affichons pas son intérieur)

C'est encore assez flou, mais je commence a y voir plus clair. :P

J'ai tenté de placer une caméra à l'aide de glFrustum et mis une profondeur positive.. qui me semble plus sencée (a tord ?)

Dans tous les cas j'ai pu obtenir une "sphère", un cercle remplis tout du moins, mais en gérant l'éclairage l'effet de 3D peut être obtenu je pense.

Cependant.. j'ai souhaité déplacer cette sphère sur mon écran.. et le résultat
fut assez désastreux:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 // Fonction d'init identique. static void resize(int width, int height) { glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); glLoadIdentity() ; glFrustum(-1, 1, -1, 1, 1, 100); // Ajout de Frustum pour placer une caméra. glOrtho(0.0f, (GLfloat) width, 0.0f, (GLfloat) height, -1.0f, 1.0f); glMatrixMode(GL_MODELVIEW); glLoadIdentity() ; } static void display(void) { // Pour tester (Fenetre en 800x600 = coordonnées du centre de celle-ci) static unsigned int test_x = 400; static unsigned int test_y = 300; glutMainLoopEvent(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glColor3d(1,0,0); glPushMatrix(); glTranslatef(test_x, test_y, 20.0f); glutSolidSphere(50, 18 , 36); glPopMatrix(); glutSwapBuffers(); // Déplacement avec un usleep pour temporiser un peu. test_x += 20; test_y += 10; usleep(50000); }
J'ai obtenu, sans le déplacement:

http://imageup.fr/uploads/1331389767.png

Mais avec, rapidement quelque chose de ce genre:

http://imageup.fr/uploads/1331389795.png

Je ne doute pas que cela vient justement de glFrustum, mais de la à comprendre ce qu'il se passe vraiment :s

12/03/2012, 15h20
pyros

Salut,

Le problème viens peut être de glFrustum() et glOrtho().
glFrustum permet de définir une projection perspective. glOrtho une projection orthogonale.
Là, tu cumule les 2. Ce qui doit donner une matrice de projection assez tordue (j'ai la flème de faire les calculs pour voir ce que ça donne :P). N'utilise que glOrtho(), ou alors gluPerspective (je trouve ses paramètres plus simple et plus expressif que glFrustum) si tu souhaite de la perspective.

Si tu ne souhaite pas utiliser le préhistorique gluPerspective, tu peux toujours te servir de la la doc pour créer une matrice correspondante et l'envoyer avec un glLoadMatrix.