Discussion :

[jomeo]

Je dois appliquer tout bêtement une texture sur une surface carrée. J'ai récupérée des sources qui me montrent comment faire. Je programme en java avec JOGL.

Cependant, sans comprendre pourquoi, pour que l'image s'affiche à l'endroit sur mon ordinateur, je dois changer les coordonnées des glTexCoords, comme si je n'avais pas les mêmes axes que tout le monde.

Voici le code que je croyais bon :

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
gl.glPushMatrix();
gl.glEnable(gl.GL_TEXTURE_2D);
gl.glBindTexture(gl.GL_TEXTURE_2D, texturePlateau);
 
gl.glBegin(gl.GL_QUADS);
 
gl.glTexCoord2f(0.0f, 0.0f);
gl.glVertex3f(0.0f, 0.0f, 0.1f);
 
gl.glTexCoord2f(1.0f, 0.0f);
gl.glVertex3f(1.0f, 0.0f, 0.1f);
 
gl.glTexCoord2f(1.0f, 1.0f);
gl.glVertex3f(1.0f, 1.0f, 0.3f);
 
gl.glTexCoord2f(0.0f, 1.0f);
gl.glVertex3f(0.0f, 1.0f, 0.1f);
 
gl.glEnd();
 
gl.glDisable(gl.GL_TEXTURE_2D);
gl.glPopMatrix();

Si je fais cela, mon image est à l'envers... Voici le code que j'ai du mettre pour avoir un affichage correct :

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
 
        gl.glPushMatrix();
        gl.glEnable(gl.GL_TEXTURE_2D);
        gl.glBindTexture(gl.GL_TEXTURE_2D, texturePlateau);
 
        gl.glBegin(gl.GL_QUADS);
 
        gl.glTexCoord2f(0.0f, 1.0f);
        gl.glVertex3f(0.0f, 0.0f, 0.1f);
 
        gl.glTexCoord2f(1.0f, 1.0f);
        gl.glVertex3f(1.0f, 0.0f, 0.1f);
 
        gl.glTexCoord2f(1.0f, 0.0f);
        gl.glVertex3f(1.0f, 1.0f, 0.3f);
 
        gl.glTexCoord2f(0.0f, 0.0f);
        gl.glVertex3f(0.0f, 1.0f, 0.1f);
 
        gl.glEnd();
 
        gl.glDisable(gl.GL_TEXTURE_2D);
        gl.glPopMatrix();

Il n'y a pas de glRotate avant ce bout de code. Mon image n'est pas enregistrée à l'envers sur le disque dur. Quelqu'un sait-il d'où vient mon problème ?

Merci

[crischprolch]

Je n'ai pas eu le tps de regarder ton code attentivement mais il faut savoir qu'une image a son propre systeme de coordonnées :


0,1________
| |
| |
|_________|
0,0 1,0

[crischprolch]

Je n'ai pas eu le tps de regarder ton code attentivement mais il faut savoir qu'une image a son propre systeme de coordonnées :

0,1 1,1
_________
| |
| |
|_________|
0,0 1,0

Il faut faire attention à cela...

[jomeo]

Ok c'est exactement ce que j'allais demandé. J'ai l'impression que les axes d'images sont tels que l'origine est en haut à gauche et non pas en bas à gauche. Pourtant on m'avait dit l'inverse... Mais enfin bon, au moins j'ai compris désormais.

Merci !

edit :

Ah bah je viens de relire ton message et finalement je n'y comprend plus rien. Où est l'origine pour une texture ? En bas à gauche ou bien en haut à gauche ? Pourquoi mon programme se comporte-t-il comme si elle était en haut à gauche ?
Est-ce que cela vient du chargement de la textures ?

[razmott]

Salut !

J'ai une hypothèse, mais il faut vérifier :
non seulement OpenGL a un système de coordonnées "inversé" pour les textures mais il les charge aussi à l'envers. Je m'explique, le tableau de pixel que tu envoie à glTexImage2D ou glTexSubImage2D décrit les pixels du coin inférieur gauche jusqu'au coin supérieur droit.

Cependant, ce n'est qu'un souvenir, c'est donc à vérifier.

Bon coding !
@+

[jomeo]

Et pendant que j'y suis avec ces histoires de coordonnées, j'ai activé le CullFace pour justement repérer facilement lorsque j'affiche les faces du mauvais sens.

Je me suis rendu compte que j'affichais toutes les faces à l'envers.

Dans quel sens faut-il créer les Vertex ?

Pour qu'une face soit visible en face de la caméra, je dois les mettre dans le sens inverse des aiguilles d'une montre :

Code :

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

1
2
3
4
gl.glVertex3f(0.0f, 0.0f, 0.0f);
gl.glVertex3f(1.0f, 0.0f, 0.0f);
gl.glVertex3f(1.0f, 1.0f, 0.0f);
gl.glVertex3f(0.0f, 1.0f, 0.0f);

Si je fais dans l'autre sens, alors je dois tourner la caméra pour voir la face.

[jomeo]

J'ai changé le FrontFace en le forcant à l'initialisation à la valeur ClockWise ( gl.glFrontFace(gl.GL_CW) ) et désormais mes faces d'affichent bien elles le devraient. Comment se fait-il que CW ne soit pas la valeur par défaut ?!

Par ailleurs, mes experiences me prouvent que dans l'état actuel de mon programme, l'origine d'une texture se trouve en haut à gauche, et non pas en bas à droite comme cela est écrit dans les cours et tutoriaux openGL. Là encore, pourquoi n'ai je pas le paramètrage par défaut ?

Est-ce une particularité de JOGL ? Je vous remercie.

[ShevchenKik]

Comment se fait-il que CW ne soit pas la valeur par défaut ?!

Je pense que ca vient des maths, tout simplement. En Maths le sens "anti-horaire" (aussi appelé sens trigonométrique) est celui privilégié. Je pense que quand OpenGL a été créé il a bien fallu choisir un sens et ils ont pris le plus utilisé en maths, vu qu'OpenGL, c'est des maths

Code :

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

1
2
 
, mes experiences me prouvent que dans l'état actuel de mon programme, l'origine d'une texture se trouve en haut à gauche, et non pas en bas à droite comme cela est écrit dans les cours et tutoriaux openGL

Une texture en OpenGL est paramétrée en (U, V), avec (0,0) = coin INFERIEUR GAUCHE. Je ne sais pas où tu as lû que c'était sensé être en bas à droite mais c'est faux (ou alors j'ai mal compris tes explications

[jomeo]

Merci de tes réponses !

Concernant le sens des vertexs :

Tu dis que le sens des aiguilles d'une montre n'est donc pas la valeur par défaut dans OpenGL ? Mais alors pourquoi dans les cours sur le net les vertexs sont donnés dans le sens des aiguilles d'une montre ? o_O
Par exemple : http://fly.cc.fer.hr/~unreal/theredb...res/fig2-6.gif

Concernant les textures :

Je me suis trompé dans mon précédent post :

En fait on m'a expliqué et j'avais cru comprendre sur les exemples trouvés sur internet que l'origine du repère d'une texture en OpenGL est le coin inférieur droit.

Seulement, mes tests ne fonctionnent que lorsque je considère le coin supérieur gauche comme origine du repère.

On est donc bien d'accord que chez moi c'est pas normal... Ca vient peut-être de la façon dont est chargé la texture ? J'ai utilisé la classe TextureIO de java...

[ShevchenKik]

Salut,

conernant tes exemples, il s'agit d'exemples qui illustrent l'ordre des points des différentes primitives, quand tu fais un glBegin(NOM_DE_TA_PRIMITIVE)

ca t'indique juste dans quel ordre passer les points dans ton programme, ce qui en fait n'est important que pour les _STRIP et les _FAN, puisque pour des GL_TRIANGLES par exemple, tu passes toujours 3 points = 1 triangle, puis les 3 suivants, etc...

maintenant c'est vrai qu'ils auraient pu représenter leurs figures en sens trigo...(mais encore une fois, si tu prends l'exemple du GL_QUAD_STRIP, tu verras que V0, V1, V2 et V3 ne sont ni en sens trigo, ni en sens horaire.... donc l'exemple ne se rapporte pas à ca).

Pour les textures, si ca vient de java je ne peux pas t'aider, je fais tout en c++...

[jomeo]

Merci de ton aide. J'ai réussi à m'en sortir pour l'ordre de passage des Vertex (je ne comprends pas pourquoi le GL_CW n'était pas la valeur par défaut mais bon, c'est pas grave).

Et pour les textures, je viens de trouver dans la doc java une justification que les coordonnées sont bien inversées quand on utilise les classes Textures et TextureIO pour qui les images ont le coin haut gauche comme origine des coordonnées. Il faudrait peut-être que je me trouve un autre moyen de m'y faire, ou bien je m'adapte

Merci de votre aide.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EDIT

Bon je n'avais rien compris en fait. J'ai cru que le sens par défaut dans OpenGL était celui des aiguilles d'une montre, et j'ai trouvé plein de mauvais exemples sur le NET qui affichent des QUADS ainsi par exemple. Seulement, ces faces n'apparaissent pas si on active le FrontCulling (qui masque les faces de derrière).

Après quelques recherches sur la doc officielle d'OpenGL, il s'avère bien que la valeur par défaut a toujours été le sens inverse des aiguilles d'une montre (donc bien comme en mathématique avec le sens trigonométrique).

Ma mésentente venait des exemples faux qu'on trouve sur les tutoriaux les plus répandus sur OpenGL.