[JOGL] Problème de visualisation d'une scène simple

Version imprimable

Bonjour à tous sur ces forums de developpez.net. :)

(je suis tout nouveau ici ou presque car j'ai déjà lu pas mal d'articles du site et des posts mais je n'ai pas été inscrit jusque là...)

Bon, j'ai un problème avec jogl et la visualisation d'une (très) simple scène plus que basique. Il s'agit simplement d'un tile que j'applique en tant que texture sur le sol sur une pseudo-case.

L'application de base crée une JFrame, y ajoute un GLCanvas ainsi qu'un écouteur à ce dernier.
L'écouteur GLEventListener est une classe nommée ViewLoop.
De plus, j'ai une classe utilitaire nommée Tools qui contient des fonctions utiles dans mon cas pour les textures et autres traitements de la vue.

Soit déjà l'utilitaire Tools.java :

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
public class Tools {
 
    /**
     * Modèle de couleur avec transparence pour opengl
     */
    public static final ColorModel glAlphaColorModel =
            new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB),
            new int[]{8, 8, 8, 8}, true, false, ComponentColorModel.TRANSLUCENT, DataBuffer.TYPE_BYTE);
    /**
     * Modèle de couleur sans transparence pour opengl
     */
    public static final ColorModel glColorModel =
            new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB),
            new int[]{8, 8, 8, 0}, false, false, ComponentColorModel.OPAQUE, DataBuffer.TYPE_BYTE);
 
    /**
     * Charge une texture
     * 
     * @param src la source
     * @return la texture
     */
    public static Texture load(String src){
        try{
            BufferedImage img = ImageIO.read(new File(src));
            return TextureIO.newTexture(resize(img), true);
        }catch(Exception e){
            e.printStackTrace();
            return null;
        }
    }
 
    /**
     * Renvoie la puissance de 2 la plus proche,
     * égale ou supérieure à un nombre.
     * 
     * @param num le nombre
     * @return la puissance de 2
     */
    public static int asPower2(int num) {
        int b = 2;
        while (b < num) {
            b *= 2;
        }
        return b;
    }
 
    /**
     * Lie un identifiant à une image
     * transformée en texture.
     * 
     * @param id l'identifiant
     * @param img l'image
     * @return la texture créée
     */
    public static BufferedImage resize(BufferedImage img) {
        // image pour opengl
        BufferedImage glTex = null;
 
        // taille de l'image gl
        int width = asPower2(img.getWidth());
        int height = asPower2(img.getHeight());
 
        // création de l'image de bonne taille
        WritableRaster raster;
        boolean alpha = img.getColorModel().hasAlpha();
        // 4 ou 3 ? le nombre de composantes (rgba ou rgb)
        if (alpha) {
            raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, width, height, 4, null);
            glTex = new BufferedImage(glAlphaColorModel, raster, false, new Hashtable());
        } else {
            raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, width, height, 3, null);
            glTex = new BufferedImage(glColorModel, raster, false, new Hashtable());
        }
 
        // dessin de l'image
        Graphics g = glTex.getGraphics();
        g.setColor(new Color(0f, 0f, 0f, 0f));
        g.fillRect(0, 0, width, height);
        g.drawImage(img, 0, 0, null);
        g.dispose();
 
        GraphicsConfiguration configuration = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
        BufferedImage glTexAlpha = configuration.createCompatibleImage(glTex.getWidth(),
                glTex.getHeight(),
                BufferedImage.TRANSLUCENT);
        Graphics g2 = glTexAlpha.getGraphics();
        g2.drawImage(glTex, 0, 0, null);
        g2.dispose();
 
        return glTexAlpha;
    }
 
    /**
     * Génère un nombre entier borné
     * 
     * @param width la valeur maximale exclue
     * @return un nombre aléatoire
     */
    public static int generate(int width) {
        return (int) Math.round(Math.random() * width);
    }
 
    /**
     * Initialise la vue utilisée pour afficher 
     * les composants à l'écran.
     * 
     * @param gl la ressource opengl
     * @see <a href="http://www.cokeandcode.com/node/315">http://www.cokeandcode.com/node/315</a>
     */
    public static void initView(GL gl) {
        // enregistrement de l'état actuel
        gl.glPushAttrib(GL.GL_DEPTH_BUFFER_BIT | GL.GL_ENABLE_BIT);
        gl.glPushMatrix();
        gl.glLoadIdentity();
        gl.glMatrixMode(GL.GL_PROJECTION);
        gl.glPushMatrix();
 
        // nouvel état de projection
        gl.glLoadIdentity();
        gl.glOrtho(0, 600, 400, 0, -1, 1);
        gl.glDisable(GL.GL_DEPTH_TEST);
        gl.glDisable(GL.GL_LIGHTING);
    }
 
    /**
     * Replace la vue par défaut.
     * 
     * @param gl la ressource opengl
     * @see <a href="http://www.cokeandcode.com/node/315">http://www.cokeandcode.com/node/315</a>
     */
    public static void disposeView(GL gl) {
        // remet en place la transformation par défaut
        gl.glPopMatrix();
        gl.glMatrixMode(GL.GL_MODELVIEW);
        gl.glPopMatrix();
        gl.glPopAttrib();
    }
}

Bon, en fait je l'ai posté pour la partie de modification de la vue. J'ai réutilisé le code de cokeandcode (le jeu asteroid) principalement, mais je n'arrive pas réussi à faire ce que je veux... et c'est presque pire car les choses qui fonctionnent normalement (en simple 2d avec jogl) ne fonctionnent plus.

Le problème vient, à mon avis, des méthodes d'initialisation de la vue opengl qui se trouve dans ViewLoop.java :

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
public class ViewLoop implements GLEventListener {
 
    /**
     * Animateur
     */
    private Animator animator;
 
    /**
     * Initialise la vue
     * 
     * @param drawable le composant opengl
     */
    public void init(GLAutoDrawable drawable) {
        GL gl = drawable.getGL();
        gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        gl.glViewport(0, 0, 600, 400);
 
        animator = new Animator(drawable);
        animator.start();
 
        init(gl);
    }
 
    /**
     * Initialise l'application
     * 
     * @param gl le contexte opengl
     */
    public void init(GL gl) {
 
        gl.glEnable(GL.GL_TEXTURE_2D);
        gl.glEnable(GL.GL_CULL_FACE);
        gl.glEnable(GL.GL_LIGHTING);
        gl.glEnable(GL.GL_DEPTH_TEST);
        gl.glDepthFunc(GL.GL_LEQUAL);
        gl.glEnable(GL.GL_LIGHTING);
 
        // define the properties for the perspective of the scene
        gl.glMatrixMode(GL.GL_PROJECTION);
        gl.glLoadIdentity();
        new GLU().gluPerspective(45.0f, ((float) 600) / ((float) 400), 0.1f, 100.0f);
        gl.glMatrixMode(GL.GL_MODELVIEW);
 
        // chargement de la texture
        tex = Tools.load("tex.png");
    }
    /**
     * Texture
     */
    private Texture tex;
    /**
     * Système de rendu du texte
     */
    private TextRenderer tr = new TextRenderer(new Font("Arial", 10, Font.PLAIN));
    /**
     * Nombre de frames exécutées
     */
    int fps = 0;
    /**
     * Fps à afficher
     */
    float fpsText = 0f;
    /**
     * Dernière date
     */
    long last = System.currentTimeMillis();
 
    /**
     * Met à jour le rendu
     * 
     * @param drawable le composant opengl
     */
    public void display(GLAutoDrawable drawable) {
        GL gl = drawable.getGL();
 
        // affichage d'une case texturée
        // tex.bind();
        gl.glBegin(GL.GL_QUADS);
        quad:
        {
            gl.glNormal3i(0, 0, 1);
            gl.glTexCoord2i(0, 0); // gl.glTexCoord2f(0f, 0.5f);
            gl.glVertex3f(-1f, -1f, 0f);
 
            gl.glNormal3i(0, 0, 1);
            gl.glTexCoord2i(0, 1); // gl.glTexCoord2f(0.5f, 1f);
            gl.glVertex3f(1f, -1f, 0f);
 
            gl.glNormal3i(0, 0, 1);
            gl.glTexCoord2i(1, 1); // gl.glTexCoord2f(1f, 0.5f);
            gl.glVertex3f(1f, 1f, 0f);
 
            gl.glNormal3i(0, 0, 1);
            gl.glTexCoord2i(1, 0); // gl.glTexCoord2f(0.5f, 0f);
            gl.glVertex3f(-1f, 1f, 0f);
        }
        gl.glEnd();
 
        // fps
        fps:
        {
 
            long time = System.currentTimeMillis();
            long diff = time - last;
            if (diff >= 1000) {
                fpsText = fps;
                last = time;
                fps = 0;
            } else {
                fps++;
            }
 
            // affichage
            Tools.initView(gl);
            tr.beginRendering(600, 400);
            tr.draw(String.format("%5.2f fps", fpsText), 20, 20);
            tr.endRendering();
            Tools.disposeView(gl);
        }
    }
...

Il y a deux gros problèmes :
1. Je ne vois absolument rien à l'écran... c'est tout noir... donc la texture 2D n'a pas été plaquée sur la case. Où alors je suis mal positionné ?

2. Le rendu du texte est totalement détruit - c'est la partie qui marche bien normalement... : je ne vois qu'un morceau de pixel blanc à l'écran qui correspondrait au texte - ce dernier a donc subit des dégats involontaires. :oops:

Alors voici mes quelques questions :
- à propos de la partie d'initialisation (glEnable & co), qu'est-ce qui est utile, qu'est-ce qui est inutile, qu'est-ce qui est faux ou mal placé ?
- je n'ai pas compris les états des matrices, PROJECTION ou MODEL_VIEW... ok, mais pourquoi avoir à définir un état et le remplacer directement par la suite, il ne sera jamais utilisé, non ?
- pourquoi faut-il empiler les deux matrices dans les fonctions utilitaires pour passer en mode ortho ?
- pourquoi le texte ne s'affiche-t-il pas normalement ?
- que faire pour que je puisse enfin voir ma texture appliquée sur une case au sol ?
- comment me positionner correctement avec la caméra ?
- comment fonctionne le système de perspective de GLU ?
- ai-je besoin de rappeller glNormal3x à chaque point vu que c'est toujours la même normale (0,0,1) ?

Ca fait beaucoup de questions et je dois avoir fait plusieurs idioties en reprenant le code de CokeAndCode, mais j'espère que ça ira malgré tout. ;)

Bonnes vacances en passant malgré qu'il fasse si chaud - heureux les nuages et autres orages !

Bon, j'ai un peu avancé. :)
J'ai repris le tutorial de Nehe sur le texturing en 3d d'une simple caisse.

J'utilise alors une display list pour la box et ça fonctionne très bien.
Là où j'ai un problème, c'est que je n'ai pas tout compris... :roll:

D'abord, j'ai créé une seconde box que j'ai translaté un peu et je me suis éloigné un peu plus pour voir les deux box tourner... résultat, ça fonctionne, mais ce n'est pas du tout ce à quoi je m'attendais.

Lorsqu'on utilise les transformations géométriques, on déplace quoi ? le repère de la caméra ou celui du traitement des objets ?
Il semblerait que ça soit le repère de traitement des objets (bien plus logique), mais alors c'est normal que pour m'éloigner il faille utiliser une valeur z négative ?

En fait, j'ai essayé d'y voir plus claire en tentant de créer un repère avec de simples lignes pour essayer de me représenter l'espace de visionnement.
Mais le repère ne s'affiche pas du tout.

Voici le code complet qui peut intéresser et pose problème :
# 1 : l'affichage

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
public class Lesson06
{
  static Animator animator = null;
 
  static class Renderer
    implements GLEventListener,
               KeyListener
  {
    private float	xrot;				// X Rotation ( NEW )
    private float	yrot;				// Y Rotation ( NEW )
    private float	zrot;				// Z Rotation ( NEW )
    private Texture texture;
    private int displayList;
    private int repere;
 
    /** Called by the drawable to initiate OpenGL rendering by the client.
     * After all GLEventListeners have been notified of a display event, the
     * drawable will swap its buffers if necessary.
     * @param gLDrawable The GLDrawable object.
     */
    public void display(GLAutoDrawable gLDrawable)
    {
      final GL gl = gLDrawable.getGL();
      gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
      gl.glLoadIdentity();									// Reset The View
      gl.glTranslatef(0.0f,0.0f,-10.0f);
 
      gl.glRotatef(xrot,1.0f,0.0f,0.0f);
      gl.glRotatef(yrot,0.0f,1.0f,0.0f);
      gl.glRotatef(zrot,0.0f,0.0f,1.0f);
 
      texture.enable();
      texture.bind();
 
      gl.glCallList(displayList);
 
      gl.glTranslatef(6, 0, 2f);
 
      gl.glCallList(displayList);
 
      xrot+=0.3f;
      yrot+=0.2f;
      zrot+=0.4f;
 
      texture.disable();
 
      gl.glLoadIdentity();
 
      // gl.glColor3i(0, 255, 255);
      gl.glCallList(repere);
    }

# 2 : l'initialisation et la création des listes

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
public void init(GLAutoDrawable gLDrawable)
    {
      final GL gl = gLDrawable.getGL();
      gl.glShadeModel(GL.GL_SMOOTH);              // Enable Smooth Shading
      gl.glClearColor(0.0f, 0.0f, 0.0f, 1f);    // Black Background
      gl.glClearDepth(1.0f);                      // Depth Buffer Setup
      gl.glEnable(GL.GL_DEPTH_TEST);							// Enables Depth Testing
      gl.glDepthFunc(GL.GL_LEQUAL);								// The Type Of Depth Testing To Do
      /*
      gl.glEnable(GL.GL_LIGHT0);								// Quick And Dirty Lighting (Assumes Light0 Is Set Up)
      gl.glEnable(GL.GL_LIGHTING);								// Enable Lighting
      gl.glEnable(GL.GL_COLOR_MATERIAL);							// Enable Material Coloring
      */
      gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);	// Really Nice Perspective Calculations
      gl.glEnable(GL.GL_TEXTURE_2D);
      gLDrawable.addKeyListener(this);
 
      texture = TextureIO.newTexture(readPNGImage("data/NeHe.png"), true);
 
      // génération d'une liste d'affichage pour le cube
      displayList = gl.glGenLists(1);
      gl.glNewList(displayList, GL.GL_COMPILE);
      box:{
          gl.glBegin(GL.GL_QUADS);
            // Front Face
            gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f,  1.0f);
            gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f( 1.0f, -1.0f,  1.0f);
            gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f( 1.0f,  1.0f,  1.0f);
            gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(-1.0f,  1.0f,  1.0f);
            // Back Face
            gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f, -1.0f);
            gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(-1.0f,  1.0f, -1.0f);
            gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f( 1.0f,  1.0f, -1.0f);
            gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f( 1.0f, -1.0f, -1.0f);
            // Top Face
            gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(-1.0f,  1.0f, -1.0f);
            gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(-1.0f,  1.0f,  1.0f);
            gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f( 1.0f,  1.0f,  1.0f);
            gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f( 1.0f,  1.0f, -1.0f);
            // Bottom Face
            gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(-1.0f, -1.0f, -1.0f);
            gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f( 1.0f, -1.0f, -1.0f);
            gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f( 1.0f, -1.0f,  1.0f);
            gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f,  1.0f);
            // Right face
            gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f( 1.0f, -1.0f, -1.0f);
            gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f( 1.0f,  1.0f, -1.0f);
            gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f( 1.0f,  1.0f,  1.0f);
            gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f( 1.0f, -1.0f,  1.0f);
            // Left Face
            gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f, -1.0f);
            gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f,  1.0f);
            gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(-1.0f,  1.0f,  1.0f);
            gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(-1.0f,  1.0f, -1.0f);
          gl.glEnd();
      }
      gl.glEndList();
 
      repere = gl.glGenLists(1);
      gl.glDisable(GL.GL_TEXTURE_2D);
      gl.glNewList(repere, GL.GL_COMPILE);
 
      repere:{
          gl.glBegin(GL.GL_LINES);
            // x
            gl.glVertex3f(-5f, 0f,  0f);
            gl.glVertex3f(5f, 0f,  0f);
 
            // y
            gl.glVertex3f(0f, -5f,  0f);
            gl.glVertex3f(0f, 5f,  0f);
 
            // z
            gl.glVertex3f(0f, 0f,  -5f);
            gl.glVertex3f(0f, 0f,  5f);
 
          gl.glEnd();
      }
      gl.glEndList();
    }

Pour ce qui est de la lumière, j'ai tenté de faire :

Code:

1
2
3
gl.glEnable(GL.GL_LIGHT0);								// Quick And Dirty Lighting (Assumes Light0 Is Set Up)
      gl.glEnable(GL.GL_LIGHTING);								// Enable Lighting
      gl.glEnable(GL.GL_COLOR_MATERIAL);							// Enable Material Coloring

(l'idée était aussi de colorier différemment la texture du second bloc)

Mais malheureusement, y a un problème visible avec la couleur de manière générale. Si je décommente ces lignes, le cube passe du sombre au lumineux puis revient au sombre et continue indéfiniment... donc l'origine de la lumière doit avoir un sens particulier. (Comment gérer la lumière ?)

Ensuite, la colorisation des cubes ne marche pas.

Et la colorisation pose plus que problème vue que je n'arrive pas non plus à afficher mon repère.

Code:

1
2
3
4
     gl.glLoadIdentity();
      // gl.glColor3i(0, 255, 255);
      gl.glCallList(repere);
    }

Pour mon repère, je me replace à l'origine absolue, puis je le dessine (j'ai préalablement enlever le mode GL_TEXTURES_2D grâce à texture.disable()).

J'a commenté la ligne de couleur parce qu'elle détruit tout. Sans définition de couleur, ça devrait être blanc, non ?
Bas y a rien...
Et avec définition de la couleur (mélange vert bleu), bas y a plus rien du tout qui s'affiche, les cubes disparaissent...

Que se passe-t-il donc ?

Edit :

J'ai continué ma lecture des tutoriaux de Nehe et j'ai plus ou moins compris le problème de la disposition spacial (en fait c'était logique si l'on prend une représentation habituelle d'un axe en 3D).

Il reste donc le problème du passage du texturing à la couleur qui semble ne pas fonctionner correctement.

01/07/2008, 01h51
xion.luhnis
Bon, je continue mon avancement.
J'ai compris les problèmes liés au repère, j'ai compris les problèmes liés aux types de matrices et pourquoi le système de passage de la perspective à la projection 2d ortho est si rempli.

J'ai corrigé mon premier programme et ai réussi à faire le rendu de ma texture de case sur le sol. Il y avait plusieurs erreurs au départ :
1. le positionnement était tout sauf bon (bien que ce n'est pas une erreur suffisante)

2. les paramètres suivants :
Code:

1 2 gl.glEnable(GL.GL_CULL_FACE); gl.glEnable(GL.GL_LIGHTING);
Le problème est que j'ai l'impression de dessiner les quads dans le mauvais sens de rotation et les faces sont donc orientées vers le bas.
Si j'utilise le face culling, bas on ne voit pas la case vu qu'elle est sensée être au-dessus pour qu'on puisse voir le dessous (le dessus n'étant pas affiché).
Ensuite, bas la gestion de la lumière agit comme le face culling et les faces indirectes ne sont pas affichées ... ou alors il faut définir des normales qui soient correctes.

Mais là, je n'en sais trop rien :
- peut-on gérer la lumière pour qu'elle illumine correctement les deux faces d'un quad ?
- faut-il pour cela créer deux quads formant chacun une face et ayant chacun leur propre vecteur normal, les deux étant opposés ?

3. je ne nettoyais pas les attributs de couleur et de profondeur... ce qui fait qu'on ne sait plus où on en est dès qu'on a fait 50'000 itérations involontaires... :mrgreen: et sans revenir à l'origine...

---

Reste maintenant deux problèmes à régler :
1. pourquoi l'affichage du texte ne se fait-il pas ? il doit y avoir un problème d'attributs car le texte s'affiche correctement si je ne passe pas en MODELVIEW du tout (bien que j'affiche le texte en mode PROJECTION, ça ne fonctionne pas) ...
2. pourquoi l'affichage des lignes du repère dans mon deuxième exemple de scène simple ne se fait-il pas correctement non plus ?
01/07/2008, 02h00
xion.luhnis

Quand les fautes sont bêtes... bien qu'elles ne le soient jamais.

Arghkkkkk.... :oops:

Bon sang, la honte que j'ai. :oops:

Le texte n'a aucun problème, c'est juste que j'ai inversé les deux paramètres à la création de la police d'écriture, il vaut mieux écrire :

Code:

new Font("Arial", Font.PLAIN, 10)

Font.PLAIN vaut 0, donc si j'inverse, la taille est de zéro pixel... voilà donc le problème !
En plus, le type de valeur 10 ne semble pas exister... à moins que ça gère sur les bits, auquel cas ça aurait voulu dire tous les types sauf PLAIN.

Bon, bas il ne reste plus qu'à régler le problèmes des lignes du repère. :)

Solution

Finalement, j'ai réussi à résoudre mon problème. :D

Ma fonction d'affichage ressemble désormais à :
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 gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT); gl.glLoadIdentity(); new GLU().gluLookAt(3d, 3d, 7d, 0d, 0d, 0d, 0d, 0d, 1d); gl.glTranslatef(0f, 0f, -3f); gl.glRotatef(xrot,1.0f,0.0f,0.0f); gl.glRotatef(yrot,0.0f,1.0f,0.0f); gl.glRotatef(zrot,0.0f,0.0f,1.0f); texture.enable(); texture.bind(); gl.glCallList(displayList); gl.glTranslatef(6, 0, 2f); gl.glCallList(displayList); xrot+=0.3f; yrot+=0.2f; zrot+=0.4f; texture.disable(); gl.glLoadIdentity(); new GLU().gluLookAt(3d, 3d, 7d, 0d, 0d, 0d, 0d, 0d, 1d); gl.glColor3f(1f, 1f, 1f); gl.glLineWidth(2); gl.glPointSize(5); gl.glCallList(repere);
A noter que j'ai rajouté des points aux extrémités de mon repère et je l'ai corrigé pour que je puisse distinguer les valeurs positives.

En fait, je ne comprends pas pourquoi ça a marché ou plutôt pourquoi avant ça ne marchait pas vu que je n'ai pas modifié des choses relatives au problème... :roll:

Ah et pour la caméra et le gluLookAt (très pratique), j'imagine bien que le dernier vecteur vertical a un sens pour déterminer la rotation de la caméra... mais est-ce que ça change de l'avoir perpendiculaire au vecteur de vue (de la position à l'endroit regardé) ou est-ce que c'est seulement le vecteur résultant du produit vectoriel des deux qui a de l'importance dans sa direction ?

01/07/2008, 03h12
xion.luhnis

Solution et explication complémentaire

Finalement (de nouveau), j'ai trouvé sur internet le problème réel lié à la couleur :

http://www.gamedev.net/community/for...opic_id=389313

En fait, je me suis rendu compte qu'il n'y avait aucun problème si j'utilisais glColor3f à la place de glColor3i.

D'après la réponse au post sur gamedev, glColor3i utilise des valeurs de 0 à la valeur maximale d'un entier.

C'est juste d'après la documentation opengl : http://www.opengl.org/sdk/docs/man/xhtml/glColor.xml

Citation:

Current color values are stored in floating-point format, with unspecified mantissa and exponent sizes. Unsigned integer color components, when specified, are linearly mapped to floating-point values such that the largest representable value maps to 1.0 (full intensity), and 0 maps to 0.0 (zero intensity).
Signed integer color components, when specified, are linearly mapped to floating-point values such that the most positive representable value maps to 1.0, and the most negative representable value maps to -1.0.
(Note that this mapping does not convert 0 precisely to 0.0.) Floating-point values are mapped directly.

Bizarre comme choix à la conception... :roll:

Mais bon, quand ça marche, on ne se plaint pas... ;)

Post résolu.

Edit / Ajout : c'est pas actuellement très important, mais est-ce normal que la définition de la couleur influe sur l'affichage des textures ? je n'ai pas défini l'utilisation de matériaux et ça influe quand même... et il n'y a pas de lumière spécifique non plus... :roll: