Discussion :

[EvilSakray]

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

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
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:



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

[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 :

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

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

Qui d'ailleurs, pouvait être écrite :

Code :

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

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

Et je ne vois pas pourquoi vous avez ce rendu ...

[LittleWhite]

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

Code :

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

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é)

[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
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

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 ?

[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)

[EvilSakray]

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

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 :

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
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:



Mais avec, rapidement quelque chose de ce genre:



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

[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 ). 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.