Discussion :

[qnop]

Bonjour à vous tous.

Je vous explique mon problème. Je possède une scène contenant 2833 polygones triangulaire.
J'utilise assimp pour récupérer les données, données que je récupère sous forme de VBO indicé, des IBO donc.
Je précise que cette scène n'utilise que un seul VBO et un seul IBO.
Je l'affiche à l'écran en tant que 1920 * 1080 (full HD donc), et je trouve ça bizarre que mon programme descend jusque 350 FPS. J'ai quand même un ordi assez récent... et moins de 3000 triangles ne devraient pas être la mort...

Je voulais savoir si auriez une solution pour pallier à ce problème? Ou est ce normal justement.
Je ne gère pas de lumière au moment du rendu, seulement, lorsque j'ajoute des lumières cela descend très vite les FPS.
Est ce que le deffered Shading est bien plus rapide pour les lumières?
Est il accessible en OpenGL 2.1?

Quels seraient vos conseil afin d'augmenté les performances de mon "moteur".
Je tiens à préciser que ce qui est glfrontSurface(gl_CW) et glcullface(gl_back) déforme mon rendu.

Merci de vos conseils .

[dragonjoker59]

mon programme descend jusque 350 FPS

Quelle est la base de ta comparaison pour dire que ça "descend" ?.

Ensuite pour ton problème de lumières, combien de sources gères-tu et comment t'y prends-tu ?

Le deferred lighting est disponible à partir du moment où tu peux faire du multi render target (je crois que 4 render targets est un minimum). Il faut donc, pour que ce soit efficace, que tu aies accès aux FBO et la possibilité d'avoir au moins 4 sorties possibles pour ton fragment shader.

Enfin, que veux tu dire par :

glfrontSurface(gl_CW) et glcullface(gl_back) déforme mon rendu

?

[qnop]

Pour les 350 FPS, c'est juste la résolution qui ralentit je pense, en mettant du 800/600 je monte a 2 000 ^^.

Pour les lumières, j'utilise le premier tutoriel de ce site : les lumières par vertex.

Pour le deffered Shading je pense que c'est bon du coup, OpenGL 2.1 a accès aux FBO ^^.

Pour accélerer le rendu, j'ai vu qu'il fallait appliqué ce code source :
glEnable(GL_CULL_FACE);
glFrontFace(GL_CW);
glCullFace(GL_BACK);

Or, quand j'utilise ce "morceau de code", mon rendu est mal affiché, genre il manque des parties, ou elles ne sont pas à leur places...
Ce code permet d'activé le culling à ce que j'ai compris ^^.

Merci .

[dragonjoker59]

Il est en effet conseillé d'activer le culling, au moins pour les mesh opaques.

Si tu utilises ASSIMP pour récupérer les faces triangulaires, elles sont normalement ordonnées en sens inverse des aiguilles d'une montre.

il faut donc utiliser glFrontFace(GL_CCW);.

[qnop]

Bonjour, désolé de la réponse tardive...

J'ai fait quelques petits tests avec et sans culling.
Avantages du culling, je gagne environ 100 FPS en full HD je passe de 420 a 520 FPS avec une scène contenant le décor + une voiture, une grosse araignée et Faerie.md2 (sans animation).
Donc je remarque qu'avec le culling, en utilisant le CCW, je n'ai pas de défaut d'affichage, ou du moins pas encore remarqué .
Néanmoins, lorsque j'utilise un fichier ("non texturé"), les couleurs venant du mtl, je remarque un mauvais affichage de ces dîtes couleurs. (Genre du noir à l'endroit qu'il ne devrait pas être et d'autre dans le même genre .
Mais globalement j'en suis content.

Sinon, j'ai effectué quelques petites améliorations que l'on m'avait conseillé il y a fort longtemps (ayant repris la programmation il y a peu justement) :
http://www.developpez.net/forums/d12...-que-glvertex/

Je cite ce que DonQuiche m'avait conseillé

* La façon dont tes données sont représentées en mémoire : des tableaux interlacés (interleaved arrays - avec des strides multiples de 4 octets) donnent en principe de meilleures performances (meilleure localité spatiale), sauf si tes données sont constamment modifiées et qu'il faut sans cesse réinterlacer ou remettre à jour plus que nécessaire.
* Utiliser des indices quand cela se justifie (i.e. si économie notable de mémoire et de bande passante).
* Minimiser les changements d'états (rendre en une fois tous les objets qui doivent être rendus de la même façon - mêmes shaders, etc). Essentiel.
* Minimiser les allers-retours mémoire (render targets, mise à jour des données géométriques ou de textures, etc).
* Minimiser le jeu de données (taille des textures, des géométries, des buffers, etc)
* Garder des shaders simples et efficaces.
* Comprendre où se situent les goulots d'étranglement dans ton appli (cpu/gpu, texture interpolation, vertex shaders et traitements géométriques, fragments shaders, rasterization, etc) pour agir sur eux et pas au pif.

Donc en 1).
Etant donné que pour plus tard, je risquais d'avoir besoin d'optimiser le chargement de mes mesh, j'ai pu en profité de cette "refonte" pour y insérer ces fameux intervealed array (mes objets étant fixe et insérer de type GL_STATIC_DRAW dans le VBO). Ce qui fait que mes coordonnées de texture, normales, et position sont codé dans un vec4. La "dernière coordonnée" est de 1.0 pour la position : vec4(x, y, z, 1.0) et de 0.0 pour les normales et des coordonnées de textures : vec4(x, y, z 0.0).

En 2). J'utilise les indices, en théorie, Assimp permet d'y optimisé grâce au ai_JoinIdenticalVertice (activé dans aiProcessPreset_TargetRealtime_Fast normalement).

Pour le dernier point, je n'ai pas le niveau pour la plupart, donc je n'y touche pas pour le moment.

Pour les derniers points, voilà comment j'opère mon rendu et mon chargement.

Je récupère tout les vertices et indices dans deux buffer, un VBO, et un IBO (pour les indices, j'y rajoute un offset car lorsqu'il y a plusieurs Meshs, l'indice 0 du deuxième mesh n'est pas le premier vertices, mais par exemple le deux centièmes ^^)

Pour l'affichage, j'envoie mes pointeurs une seule fois. Puis après, pour chaque mesh, j'envoie un uniform et je change de texture si besoin et j'apelle glDrawElements à chaque tour de boucle (je fais donc autant de glDrawElements que j'ai de mesh, faudra que je trouve le moyen de faire autrement). Le fait de n'utilisé qu'un VBO / IBO permet entre autre de réduire le nombre de bind nécessaire. Mon shader est "appelé avec glUseProgram" qu'une fois par, non pas un seul modèle, mais pour l'affichage de tous les modèles : 1 fois par affichage donc.

Voilà, est il possible d'accélérer encore plus mon rendu? Avez vous une idée pour les défauts du culling avec des objets "Coloré"?

Merci

[dragonjoker59]

Pour le problème que tu rencontres avec le culling, ça ne vient certainement pas du culling, mais plutôt du mesh.
J'ai déjà rencontré ce genre de soucis quand les normales étaient inversées ou nulles pour certaines faces (généralement après export des normales avec blender)