Discussion :

[florentbuisson]

Bonjour à tous !

Alors, j'ai fait un moteur de rendu en OpenGL es que j'ai peaufiné avec une application iOS. J'aimerai pour qu'on puisse bosser dessus depuis n'importe quelle plateforme, faire une appli Qt qui appelle exactement le même moteur de rendu.

J'avais commencé sous Qt4.8.2 dans un QGLWidget avec QGLFunctions, mais maintenant j'ai tout porté en 5.0.0 avec juste une QWindow et le nouveau QOpenGLFunctions.

Tout fonctionne presque mais j'ai encore des problèmes avec les shaders. Pour que ceux ci compilent sans erreur j'ai dû ajouter un ifdef qui précise «version 120». Donc ça compile, ça tourne presque bien mais mes sprites ne s'affichent pas à la bonne taille. Le problèmes vient je pense , de la version de glsl qui est donc 1.20 et qui ne semble pas prendre en compte des attributs comme gl_PointSize. Je sais que la version glsl de es2 dérive de la 1.20 mais je ne sais pas en quoi elles diffèrent.

Quelqu'un sait comment configurer Qt pour fonctionner exactement comme OpenGL ES 2 sur tablette, y compris GLSL ?

Pour info mon code demande à l'application Qt de lui renvoyer l'id du Shader Program compilé comme ça :

Code :

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

1
2
3
4
5
6
7
8
9
  QOpenGLShaderProgram program;
  program.addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShaderSource);
  program.addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShaderSource);
  if (!program.link())
    QString error = program.log();
  if (!program.bind())
    QString error = program.log();
 
  return program.programId();

Mes codes de shader, qui fonctionnent pour les Qt et iOS à l'exception de la taille des sprites prêt (enfin c'est tellement petit que je ne sais pas si ce sont les bonnes textures aussi ):

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
const GLchar vShaderStr[] =
#ifdef  __BUILD_DESKTOP__
"#version 120\n" // necessary for Qt to compile shaders
#endif //__BUILD_DESKTOP__
"attribute lowp vec4 Position;\n"
"attribute mediump vec2 TextureCoord;\n"
"attribute lowp float Weight;\n"
"uniform mat4 MVP;\n"
"varying mediump vec2 TextureCoordOut;\n"
"void main(void)\n"
"{\n"
"  gl_Position = MVP * Position;\n"
"  TextureCoordOut = TextureCoord;\n"
"  gl_PointSize = Weight;\n"
"}\n";
 
const GLchar fShaderStr[] =
#ifdef  __BUILD_DESKTOP__
"#version 120\n" // necessary for Qt to compile shaders
#endif //__BUILD_DESKTOP__
"varying mediump vec2 TextureCoordOut;\n"
"uniform sampler2D Sampler;\n"
"uniform bool IsSprite;\n"
"uniform lowp vec3 TextureColor;\n"
"uniform lowp float Opacity;\n"
"void main(void)\n"
"{\n"
"   lowp vec4 textureColorResult;\n"
"   textureColorResult = texture2D(Sampler,  IsSprite ? gl_PointCoord : TextureCoordOut);\n"
"   gl_FragColor = IsSprite ? vec4(mix(textureColorResult.rgb,TextureColor, 1.0),\n"
"                    textureColorResult.a * Opacity) : textureColorResult;\n"
"}\n";

Pour info j'avais déjà posé la question sur SO et le forum de qt.

Mais pas de réponses... et j'espère trouver ici une expertise glsl que je n'ai pas du tout. Si vous avez des idées d'où chercher sur le net la solution, je prends aussi volontiers mais pour l'instant malgré que le support d'es2 soit la grosse pub de Qt je ne trouve pas trop d'infos.

Si vous voulez des tutos sur quelque chose qui s'approche de ce que j'ai fait, n'hésitez pas non plus à demander

[LittleWhite]

Bonjour,

J'ai un peu de mal à comprendre une chose, c'est que lorsque vous parlez de ES2 c'est OpenGL ES 2 (qui est une variante d'OpenGL pour les plateformes embarqués). Oui Qt améliore le support vers multiple version d'OpenGL.
(Note, OpenGL ES 2 et proche de OpenGL 3).

D'après la documentation : http://qt.developpez.com/doc/5.0-sna...shaderprogram/ rien n'indique qu'il faille spécifié la version. Toutefois, dans une implémentation d'OpenGL 3, le langage de shader est passé à la nouvelle numérotation. Le second changement, c'est que les mots clés varying et attribute ont été supprimé (faisant que le shader devient incompatible). C'est la raison pour laquelle je pense que vous devez spécifier la version du shader.

Finalement, dans une application professionnelle, on écrira une version des shaders pour la plateforme mobile et une version pour la plateforme de bureau. En effet, vous allez surement vouloir implémenter des calculs lourds qui ne pourront pas être porté sur le mobile (que ce soit au niveau des performances ou des capacités).

Pour votre autre problème, je ne suis pas complètement sur que ce soit de la faute du shader (du moins, pas directement).

[florentbuisson]

Bonjour et merci de votre réponse !

J'ai un peu de mal à comprendre une chose, c'est que lorsque vous parlez de ES2 c'est OpenGL ES 2 (qui est une variante d'OpenGL pour les plateformes embarqués). Oui Qt améliore le support vers multiple version d'OpenGL.
(Note, OpenGL ES 2 et proche de OpenGL 3).

Oui je parle bien d'OpenGL ES2. Il me semble que justement, dans qt5.0.0, le nombre de versions d'opengl supportées est grandement réduit par rapport aux précédentes au profit d'opengl es 2 , qui correspond davantage aux besoin de qt d'être multi plateformes.

Je n'ai lu nulle part qu'il comptaient passer à opengl es 3.
Pour référence : http://www.developpez.net/forums/d12...ngl-supportee/

Finalement, dans une application professionnelle, on écrira une version des shaders pour la plateforme mobile et une version pour la plateforme de bureau. En effet, vous allez surement vouloir implémenter des calculs lourds qui ne pourront pas être porté sur le mobile (que ce soit au niveau des performances ou des capacités).

C'est dans l'optique d'être également multiplateformes que l'on essaie de mettre en commun le code de rendu, qui est pour nos applications à la portée du mobile.

[LittleWhite]

Oui je parle bien d'OpenGL ES2. Il me semble que justement, dans qt5.0.0, le nombre de versions d'opengl supportées est grandement réduit par rapport aux précédentes au profit d'opengl es 2 , qui correspond davantage aux besoin de qt d'être multi plateformes.

Toutes les versions sont supportés, il suffit de définir le contexte adéquat et si la carte le supporte, le contexte avec la version demandée sera chargée.

Simplement, les fonctions avancées (extensions) ne seront disponibles que pour certaines versions de OpenGL et ne seront pas englober dans Qt. Mais au final, cela importe peu.
D'un point de vue personnel, pour un moteur multi-plateforme j'éviterai de trop me lier à Qt, mais c'est un choix personnel .

Je n'ai lu nulle part qu'il comptaient passer à opengl es 3.
Pour référence : http://www.developpez.net/forums/d12...ngl-supportee/

La formation qu'ils ont fait durant les Qt Dev Days était OpenGL 3. Ils essayaient clairement de nous faire passer sur les shaders et autre petites particularités (pour la bonne cause). Le code de la formation est disponible ici : http://qt.developpez.com/evenement/2.../dd-opengl.zip

C'est dans l'optique d'être également multiplateformes que l'on essaie de mettre en commun le code de rendu, qui est pour nos applications à la portée du mobile.

Cela a une limite. Souvent, du moins dans les moteurs haut niveau que je connais, l'idée est de faire une partie full capacité pour les PCs de bureau (donc blur/FBO à gogo, Direct X 11/ OpenGL 4, instantiation, geometry shader, tesselation) pour en mettre plein la vue et d'enlever, disons la moitié pour les versions mobiles (sinon ils grilleraient). La MSDN de DirectX 10 le conseille aussi, un shader pour les différents profiles/niveau de compatibilité.
Sinon, si cela n'est pas fait et que l'on se limite à OpenGL ES 2, alors la version PC pourra sembler pauvre, graphiquement.

Et puis, une fois les particularités techniques encapsulé dans le moteur (couche native) bah y a plus à s'en soucier et cela reste multi-plateforme. Mais bon, c'est aussi un choix.

Pour faire du compatible, il faut passer par http://qt-project.org/doc/qt-5.0/qtg...functions.html ainsi que les objets encapsulés pas Qt (FBO, Buffer et Shader). Pour le code du shader en lui même, faire du shader strict OpenGL ES 2 résoudra le problème. D'ailleurs en Qt 4.8 c'est ce que j'ai fait sans faire de code spécifique à la machine et qui tourne sur le N9 et le PC.

[florentbuisson]

D'un point de vue personnel, pour un moteur multi-plateforme j'éviterai de trop me lier à Qt, mais c'est un choix personnel .

Et tu as bien raison . En l'occurrence Qt sert simplement à faire une fenêtre de visualisation d'une vue opengl es2 sur les trois plateformes desktop utilisées pour le dev (linux, macosx, windows). Et des applis android et ios donnent similairement un exemple d'utilisation de la vue en question.

Merci pour le code de la formation !

Cela a une limite. Souvent, du moins dans les moteurs haut niveau que je connais, l'idée est de faire une partie full capacité pour les PCs de bureau (donc blur/FBO à gogo, Direct X 11/ OpenGL 4, instantiation, geometry shader, tesselation) pour en mettre plein la vue et d'enlever, disons la moitié pour les versions mobiles (sinon ils grilleraient). La MSDN de DirectX 10 le conseille aussi, un shader pour les différents profiles/niveau de compatibilité.
Sinon, si cela n'est pas fait et que l'on se limite à OpenGL ES 2, alors la version PC pourra sembler pauvre, graphiquement.

C'est certain que sans davantage de précisions ça peut sembler étrange.
L'application que l'on en fait est principalement à destination des appareils mobiles: c'est le rendu visuel d'encre électronique capturée. Le code étant pour un rendu 2D ce qui tourne iOS/android suffit bien pour desktop. Et on a une contrainte supplémentaire qui est que l'utilisateur peut vouloir des rendu identiques dans tous les cas, si il recharge son document sur un autre appareil.

Pour faire du compatible, il faut passer par http://qt-project.org/doc/qt-5.0/qtg...functions.html ainsi que les objets encapsulés pas Qt (FBO, Buffer et Shader). Pour le code du shader en lui même, faire du shader strict OpenGL ES 2 résoudra le problème. D'ailleurs en Qt 4.8 c'est ce que j'ai fait sans faire de code spécifique à la machine et qui tourne sur le N9 et le PC.

C'est bien ce que je fais, à part que je ne suis pas certain de faire du es2 strict dans mes shaders. Ma seule certitude est que le moteur de rendu fait ce que je veux sur iOS (pour android, je ne vais pas tarder à savoir). Il faudrait que je poste des screenshots pour que tu aies une idée du souci (gl_PointSize qui ne semble pas influencer la taille des sprites).

[LittleWhite]

Si c'est du OpenGL ES 2 strict, alors un #version 120 dans le shader devrait suffire à mettre toutes les plateformes d'accord (et cela pour toutes les plateformes, pas seulement pour le PC).
Si le PC coince toujours, alors, il faut lui dire de prendre OpenGL en version 2.1, je pense (par le contexte). Peut être une version 3.0 passerai, c'est à essayer.

[florentbuisson]

Finalement résolu !

J'ai gardé le #version 120 et j'ai trouvé ce qu'il manquait pour que ça fonctionne comme sur iOS:

Code :

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

1
2
glEnable(GL_POINT_SPRITE);
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);

Ces fonctionnalités semblent être activées par défaut sur iOS, donc je n'avait pas eu besoin de m'en soucier et je n'en soupçonnait pas l'existence.