Compilation d'un projet avec des fonctions OpenGL

Bonjour !

Je viens vers vous parce que j'ai de grosses difficultés de compilation pour un projet en C++ qui utilise Qt5 et OpenGL. Je compile et exécute sous Windows, grâce au logiciel QtCreator et à CMake.

Le problème est que pour certaines fonctions, la compilation me renvoie le message d'erreur suivant :

Code:

---

1 2 3 4 5

Undefined reference to `_imp__glMatrixMode@4` Camera.cpp Undefined reference to `_imp__glLoadIdentity@0` Camera.cpp Undefined reference to `_imp__glFrustum@48` Camera.cpp CMakeFiles\Project3Donut.dir/objects.a(Camera.cpp.obj):bad reloc address 0x53 in section `.text $_ZmiRK9QVector4DS1_[__ZmiRK9QVector4DS1_]` Error: ld returned 1 exit status collect2.exe

---

De ce que j'en comprends, il n'arrive pas à trouver la définition des fonctions MatrixMode, LoadIdentity et Frustum qui ont été appelées de la façon suivante :

Code:

---

1 2 3

glMatrixMode(GL_PROJECTION); glLoadIdentity(); glFrustum(_xmin, _xmax, _ymin, _ymax, _zNear, _zFar);

---

J'ai également une erreur d'une même type lorsque j'essaye d'utiliser des fonctions de la bibliothèque QtXmlPatterns.

Pour OpenGL, les fichiers devraient être trouvés grâce au CMake :

Code:

---

1 2 3 4 5 6

FIND_PACKAGE( Qt5OpenGL REQUIRED ) IF( Qt5OpenGL_FOUND ) MESSAGE( STATUS "Qt5 OpenGL module FOUND!" ) ELSE() MESSAGE( WARNING "Qt5 OpenGL module NOT FOUND!" ) ENDIF()

---

Qui ne génère aucune erreur... Si ce n'est plus tard les "undefined reference".
A savoir que ce projet compile chez un de mes camarades qui travaille en ligne de commande (et inclut OpenGL32 dans sa compilation avec CMake de ce que j'ai compris, je ne sais pas si ça peut jouer...), mais que chez un autre camarade qui utilise également QtCreator sous Windows on retrouve la même erreur...

Pensez vous qu'il faille préciser clairement que l'on veut utiliser la bibliothèque OpenGL32 pour que ça fonctionne aussi ? Et si oui, à quel moment ?

Merci d'avance à ceux qui pourront m'aider !

Rapidement (pour les details, cf le tuto "Utiliser OpenGL avec Qt 5.4" en ligne). Qt5 utilise OpenGL ES 2 en interne, avec une redirection vers DirectX9 sous Windows (projet ANGLE). Donc par defaut, seules les fonctions ES 2 sont dispo dans Qt 5 (et donc pas les fonctions d'OpenGL 1 que tu utilises - qui est vieux de plus de 15 ans). Deux solutions : linker manuellement les drivers OpenGL 1 (c'est ce que font tes camarades en incluant opengl32.dll), soit utiliser du code OpenGL a jour.

Je te conseille bien sur de choisir la seconde solution, il est finallement assez idiot de continuer a travailler avec GL 1. Il existe pas mal de tutos sur l'utilisation d'OpenGL > 2, il y a une serie d'articles recents traduit par la rubrique Jeux par exemple.

Merci beaucoup pour ta réponse. En effet un de ma camarade a regardé et c'est bien des fonctions trop anciennes...

Pour ce qui est de QtXmlPatterns par contre je ne pense pas que ça soit le même problème si ? J'avais essayé de l'inclure dans le CMake, mais ça ne changeait pas le problème...

Tu as quels messages de CMake ? Peut etre une dependance de QXmlPaterns ? (je n'utilises pas trop ce module) Essaies peut etre avec Dependencies Walker pour trouver les dependances

Désolée du temps de réponse, pour l'instant je n'ai pas retouché à QXmlPatterns mais c'était des undefined reference comme pour l'autre.

Pour OpenGL, j'ai réussi à trouver l'équivalent à certaines fonctions en OpenGL 2, mais pour d'autres (comme par exemple glNormal3f ou glColor3f) je ne trouve pas d'équivalent...

C'est normal, il n'y a pas d'equivalent. Si ces fonctions ont ete retirees, ce n'est pas pour rien. Lis un cours OpenGL recent

J'ai déjà passé des heures sur Google à chercher ces fonctions sans trouver clairement ces fonctions, donc en effet l'information que ces fonctions n'existent plus aident dans les recherches...
Sans lire un tuto, je viens de tomber sur cette ligne dans un cours OpenGL : 2.0, (09/04): Introduction du langage GLSL pour la programmation de "shaders"
-> implantation et exécution de programmes "utilisateurs" sur la carte graphique
Est-ce que cela signifie que ces fonctions ont disparu pour favoriser l'utilisation de shaders ? Parce qu'un petit détail que j'ai oublié de préciser est que justement on ne doit pas utiliser de shaders dans notre projet pour une question de portabilité. Et dans ce cas, seule l'utilisation de OpenGL 1 peut permettre la réalisation du logiciel.


Petite question subsidiaire pour le coup : comment est-il possible d'inclure OpenGL 1 à l'aide de CMake ? Avec un find_package ?

C'est amusant de dire que OpenGL1 est plus portable alors que tu as justement un problème de portabilité. C'est pas très convainquant.

Effectivement, un code OpenGL 1 pourra fonctionner sur les processeurs graphiques qui supportent GL1 et pas GL 2... mais trouve moi un seul processeur graphique comme ça de nos jours, et je fais vos devoirs pendant toutes l'année !
En fait, c'est même l'inverse, un code écrit avec OpenGL 1 sera moins portable, il ne sera pas compatible avec les processeurs graphiques qui n'acceptent que GL 2 minimum. Comme pas exemple les mobile. Donc pas d'Andoid ou de iOS.

Petit rappel d'histoire. Avec OpenGL 1, le rendu 3D est réalisé en utilisant des fonctions 3D qui sont implémentées directement dans le processeur, en dur (le pipeline statique). Comme cela n'était pas performant, OpenGL 2 est sorti il y a plus de 10 ans, permettant d'utiliser un pipeline dynamique (les fameux shaders). Dans ce cas, les fonctions 3D sont codées dans un shader et peuvent être changées dans un programme.
Il est cependant possible d'utiliser OpenGL 1 sur un processeur qui a un pipeline dynamique, parce que les drivers des processeurs graphiques peuvent simuler par logiciel le pipeline graphique (moyennant une perte de performances). Pour des raisons de légèreté des drivers, ces fonctions de compatibilité ne sont pas forcement disponible sur mobile. Donc pas de GL 1 dessus.
Pour le cas particulier de Qt 5, c'est encore pire : Qt 5 est basé sur OpenGL ES 2. Donc il n'est pas possible de faire tourner ton code sur un système qui ne supporte que GL 1.

Donc ajouter du code OpenGL 1 réduit la portabilité de ton programme Qt 5.

Donc, la bonne méthode pour écrire du code portable avec Qt 5, c'est d'utiliser un objet QOpenGLFunctions (que l'on peut récupérer du contexte courant) qui fournit les fonctions OpenGL ES 2 et d'écrire son code avec des shaders. L'argument de GL 1 pour la portabilité ne tient pas la route. (Je ne sais pas d'où tu sors cet argument, j'espère que ce n'est pas de ton prof...)

Si tu veux quand même utiliser GL 1, tu peux importer manuellement OpenGL et gérer les problèmes de portabilité (et d'incompatibilité) toi même. Avec cmake :

Code:

---

1 2 3 4

find_package(OpenGL) include_directories( ${OPENGL_INCLUDE_DIRS}) target_link_libraries(ton_application ${OPENGL_LIBRARIES})

---

Pour poser un peu mieux le contexte (ce qui semble nécessaire ici), nous avons à réaliser un projet en C++ qui sera un logiciel de visualisation d'une scène 3D créée à partir de fichiers OBJ ou PLY (comme Meshlab et Blender), et à partir de cette scène nous devons pouvoir générer des images comme des anaglyphes ou des autostéréogrammes. Cette application n'aura donc pas à fonctionner sur mobile, mais devra être portable pour pouvoir générer un rendu aussi bien sous Windows que sous Linux.

Pour ce qui est de la portabilité, c'est bien un prof (qui est chercheur dans l'imagerie numérique si je ne me trompe pas, et qui est notre "client" pour ce projet) qui nous a dit de ne pas utiliser les shaders pour permettre la portabilité. En effet, il nous a expliqué que sous Linux, certains drivers de carte graphique n'existaient pas, et que donc notre logiciel ne pourrait pas être aussi portable que nous le souhaitons. Cela s'est révélé vrai sur les PC (portables) de certains de mes camarades qui ne pouvaient pas ouvrir le logiciel à cause des shaders. Et donc le prof nous a dit de ne surtout pas les utiliser, de rester à un rendu basique en OpenGL (et c'est pour ça que depuis la semaine dernière je cherche un moyen de créer un visuel avec des fonctions obsolètes).

Après je sais que ce choix va engendrer de grosses pertes de fluidité (ce qui est dommage sur un logiciel de scène 3D mais bon la portabilité passe avant). J'ai entièrement confiance dans les connaissances de mon prof malgré ce que tu me dis sur la portabilité d'OpenGL1, après je ne sais pas si utiliser des shaders moins récents pourrait tout aussi bien régler le problème (on utilisait des shaders 3.x de 2012 de ce que j'ai compris, peut-être que des shaders plus vieux serait compatibles avec plus de machines). Il y a probablement plusieurs solutions qui ont chacune leurs conséquences, et je cherche à trouver la meilleure d'entre elle pour satisfaire le client au maximum...

Merci en tout cas pour tes réponses, je ne comprends pas vraiment pourquoi il y a un écart entre ce que tu me dis et ce que me dit le prof mais je pourrais toujours en parler avec lui.

Imprime mon message et présente le à ton prof pour avoir son avis. Ou propose lui de venir sur cette discussion.
Prend la référence de la carte graphique de ton ami qui n'a pas réussit à faire tourner le programme et vérifie la version d'OpenGL qu'il peut supporter : c'est quasi sur qu'il acceptera au moins du GL 2 (à moins d'avoir un ordinateur qui date de plus de 10 ans... mais dans ce cas, il ne fera pas beaucoup d'imagerie numérique).
Qt 5 est basé sur OpenGL ES 2, donc n'importe quel système qui supporte une application Qt 5 supporte également les shaders. Sinon l'application ne pourrait pas tourner du tout.

Donc si vous ne voulez pas du tout utiliser les shaders, vous ne pouvez pas utiliser Qt 5.

Après, en termes d'apprentissage, je trouve cela idiot de vouloir apprendre l'imagerie numérique avec des techniques et matériels datant de plus de 10 ans. Cela servira à quoi d'avoir ces connaissances ?
Il est possible que les drivers ne soit pas à jour sur un ordinateur. Mais dans ce cas, est-ce que cela à un intérêt de vouloir faire de l'imagerie dessus ? (et de toute façon, cela ne change pas le problème de Qt 5)

Ton prof est probablement hyper compétent dans son domaine de recherche. Mais ça serait pas le premier prof qui donne des cours qui ne sont pas à jour. On le voit régulièrement en C++ et en OpenGL. Les profs ne mettent pas forcement leur connaissances à jour sur leur domaine d'enseignement (qui n'est pas forcement leur domaine de recherche, d'où ce décalage).

Tout ce que je dis est facilement vérifiable.
Je suppose que si tu es à l'université, c'est que tu n'as plus 10 ans. Ne soit donc plus naive et ne crois pas ton prof sur parole (ni moi d'ailleurs). Fais des recherches, trouves des sources pertinentes (documentation de Qt 5, documentation d'OpenGL), vérifies les choses par toi même.