Discussion :

[Switi]

Bonjour.

J'ai suivi ce cours : http://raptor.developpez.com/tutorial/opengl/vbo/ sur la partie VBO.

Je dois avouer que pour une première approche à l'OpenGL, ce n'est pas ce qu'il y a de plus simple.

Ici, j'ai un tétris qui fait 11*20. Je voudrais créer un tableau qui définirait la place de chaque cube. Il est fait en SDL est c'est pas très performant (voire carrément nul niveau perfs) alors je me suis mis à l'OpenGL, et on m'a conseillé les Vertex Buffer Objects.

void glGenBuffers(GLsizei nombre, Guint *buffers);
Crée nombre identifiants de buffer et les place dans le bloc mémoire commençant par buffers (élément simple ou tableau)

"nombre" est-il le nombre de formes que l'on veut ? donc 11*20 ?

Ensuite vient cette question : dans le buffer, comment doivent être organisées les données? et qu'est-ce que ça représente ? Quand je vois :

GLfloat CubeArray[48] = {
1.0f, 0.0f, 0.0f, -1.0f, 1.0f, -1.0f,
1.0f, 0.0f, 1.0f, -1.0f, -1.0f, -1.0f,
1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f, -1.0f, -1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f,
1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f,
1.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f
};

ça me fait peur.

Pour l'instant, je pense que si je comprends ça, je comprendrai la suite.

Quelqu'un peut-il venir à mon secours ? Je suis très motivé pour comprendre le fonctionnement de cette machine de guerre, pour une optimisation à mon petit Tetris parfaite.
Merci du secours que vous allez surement m'apporter

[dragonjoker59]

E, fait pour ton tétris, je pense que tu vas avoir des formes découpées en cubes, si je ne me trompe pas.
Donc tu auras 1 primitive (le cube) que tu dessineras à plusieurs (et même beaucoup) d'endroits.
Les VBO te permettent de stocker une géométrie une fois pour pouvoir la dessiner une à plusieurs fois à différents endroits.

Il faut pour cela, à l'initialisation :
- Créer le buffer (glGenBuffers)
- Activer le buffer créé pour le remplir, puis le désactiver (glBindBuffer, glBufferData)

Une fois que le buffer est créé et rempli, dans la boucle de dessin il faut activer le buffer (glBindBuffer) puis pour chaque cube à dessiner :
- placer la matrice de vue où il faut (glMultMatrix)
- dessiner le cube (glDrawElements)

glGenBuffers crée donc des buffers, sans information sur les données qu'il vont recevoir et est utilisée généralement ainsi :

Code :

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

1
2
3
4
5
6
int l_index = GL_INVALID_INDEX;
glGenBuffers( 1, &l_index );
if( l_index != GL_INVALID_INDEX )
{
	// Le buffer est créé et utilisable
}

[LittleWhite]

Bonjour,

Que la SDL soit lente, cela peut venir du SDL_DisplayFormat (il faut convertir les surfaces dans le format de l'écran).

Pour les VBO, le nombre à indiquer dans glGenBuffers() correspond au nombre de buffers que vous voulez avoir. Un buffer est une zone mémoire qui sera partagé entre le CPU et le GPU (ou, du moins, envoyé au GPU).

Dans ce tableau (buffer) :

Code :

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

1
2
3
4
5
6
7
8
9
10
GLfloat CubeArray[48] = {
1.0f, 0.0f, 0.0f, -1.0f, 1.0f, -1.0f,
1.0f, 0.0f, 1.0f, -1.0f, -1.0f, -1.0f,
1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f, -1.0f, -1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f,
1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f,
1.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f
};

Les données de couleur et la position des points sont liés (sont contenus dans le même buffer). C'est un choix
En rouge, ce sont les couleurs de chaque point.
C'est lorsque vous faites les appels à glVertexPointer/glColorPointer que vous indiquez au GPU comment lire et utiliser votre buffer (notamment qu'il doit faire un bon de trois float après chaque segment lu, que le segment contient trois composant et qu'ils doivent être utilisé comme des coulleurs).

Vous avez aussi une petite explication ici : http://tcuvelier.developpez.com/tuto...pengl-4/5-vbo/

[Switi]

Merci à vous deux, je vais faire des tests.

Pour la SDL, c'est SDL_BlitSurface qui prend beaucoup de ressources.
Si je dessine sans sprites, c'est SDL_FillRect, donc pas moyen de vraiment optimiser ça en ayant un max de fps.

Je vous tient au courant.

[imperio]

J'ai lu que désormais il valait mieux utiliser les vertex shaders. Cela doit apporter un gain de performance non négligeable mais je n'ai rien trouve sur le net me permettant de vraiment me pencher dessus car trop obscur de mon point de vue (et mon niveau en développement graphique ne me permet pas d’appréhender ce genre de chose facilement).

[LittleWhite]

Utiliser le vertex shader fera gagner des performances, mais c'est indirect. Je m'explique.

Avant 2002, les cartes graphiques étaient constitués d'un pipeline fixe (le rendu était toujours effectué de la même façon et les triangles toujours affiché de la même façon). Un exemple de la limitation de ce pipeline fixe est la limitation des huit lampes (que l'on peut découvrir assez rapidement lorsque l'on regarde la documentation sur OpenGL 1).
Puis, autour des années 2000, les shaders (le pipeline programmable) sont arrivés. Les shaders permettent de remplacer/programmer le morceau de code qui tourne sur la carte graphique afin de gérer selon sa propre volonté le rendu des triangles. Ce qui a permit l'introduction d'une multitude de nouveaux effets (et d'avoir plus de huit lampes en passant). Cela, c'est à partir d'OpenGL 2 (donc toute carte compatible OpenGL 2 possède un pipeline programmable).

Maintenant, la compatibilité avec les anciens programme n'a pas été perdue (heureusement). Du coup, les programmes utilisant OpenGL 1 devant continuer à fonctionner, pour cela, le pipeline fixe a été ré-implémenté en interne dans la carte graphique sous la forme d'un shader.

Donc, technique, shader ou pas, nous sommes aussi rapide. Par contre, il y a une chose qui diffère et cela se ressentira dans les performances, c'est l'utilisation de l'ancienne API, celle d'OpenGL 1.
En effet, les commandes glBegin()/glEnd() et celles que l'on place entre, datent du début des années 90 et ont été pensé pour les cartes graphiques de l'époque. Le problème, c'est que ce genre de commandes entraînent un échange entre de données entre le CPU et la carte graphique complètement inefficace (notamment car on demande à la carte graphique de dessiner la primitive au glEnd(). Si vous avez des milliers de triangles, cela fait des millieurs de demande de dessin. Il est plus efficace de regrouper les ordres de rendu au maximum (conseil toujours valides avec les fonctions draw*)). Du coup, des techniques tels que les VBO ont été mis en place, permettant entre autre de regrouper toutes les données dans un segment mémoire et surtout de les transférer d'un bloc au GPU et d'en faire le dessin grâce à une sorte de "GO" (les commandes draw*).

Ce tutoriel explique un peu mieux le pipeline et l'historique des cartes graphiques : http://alexandre-laurent.developpez....ge=page_1#L1-A

Pour conclure : il faut mieux utiliser les vertex shader, car l'implémentation du pipeline fixe est obsolète et disparaîtra plus ou moins prochainement. Donc, pour ce préparer et faire des programmes compatibles, oui il faut les utiliser. Pour s’entraîner et s'habituer avec les technologies d'actualité, oui, il faut les utiliser. De là à dire qu'il y a un gain de performances, je ne suis pas sur (sauf lorsque l'on compare un shader qui est conçu/optimisé pour une scène, contre un shader répliquant le pipeline fixe et gérant milles trucs activés ou non, oui, il y aura une différence), mais le plus important, c'est d'éviter les trucs OpenGL 1 du style glBegin()/glEnd().

[imperio]

Malheureusement, la majorité des tutos utilisent glBegin / glEnd. Avec mon niveau, tous ceux qui abordaient les VBO ou les vextex shaders étaient juste trop compliqués à comprendre. Il m'a fallu longtemps avant de finir d'y voir plus clair. Pourquoi n'y a-t-il pas plus d'exemple sur ces méthodes qui pourtant commencent à dater ?