Discussion :

[baton]

Bonjour,

Je suis actuellement entrain de codé pour le fun un Minecraft like. (Du moin uniquement la gestion de la map et des blocks.)
Je me suis lancé dans ce périple car je comprenais pas pourquoi Minecraft avais une limite de hauteur dans la map.
(Je débute en opengl)

J'utilise le C++ avec SFML et OpenGL ainsi que GLUT

Bref, je viens vers vous car je cherche maintenant a optimisé au maximum l'affichage de cette map pour pouvoir voir le paysage le plus vaste possible, sans descendre en dessous des 40/50 fps.

Pour ceux qui ne connaissent pas MineCraft la map est constitué uniquement de cube.

Voici les optimisations que j'ai faite :

- Un tri des bloc de la map en deux catégories. Ceux visible en surface (la croute de la map) et tous les autres.
Cela me permet d'afficher beaucoup moins de blocks.

- Utilisation des DrawList pour l'affichage d'un cube.

- La map (qui n'a pas de limite en x y et z) s'affiche autour du point de vu du personnage (a une certaine distance).


Cependant cela ne suffi pas du tout. Les perfs sont ridicule dés que je veux afficher une grande distance de clipping.


J'ai donc cherché sur le net un moyen pour mieux sélectionné les bloc a afficher. Sans y parvenir...

Je me suis donc mis dans la tête de faire un affichage comme suit :
Il me permettrais de diminué considérablement (enfin je pense) le nombre de cube a afficher (tout les cube caché derrière d'autre ne serai pas affiché)

- On affiche les blocs les plus proche du perso en premier.
- Dans un autre affichage avec un fond noir ces blocks s'affichent en blanc.
- A l'affichage de chaque blocks je regarde si il change quelque chose dans le second affichage en noire et blanc. Si c'est le cas alors je le dessine.
- La mise a jour de ce second affichage ne se fait pas a chaque frame mais toute les 2secondes.

Qu'en pensez vous sur le principe?
Vous, expert openGl vous auriez fait quoi?


Merci d'avance pour vos contributions.

[screetch]

les draw list sont vieilles et "deprecated". pour les performances on utilise maintenant les vertex buffer.
En gros tu aurais un vertex buffer pour chaque type de cube, et ils seraient tous dessinés en une passe.

[baton]

Merci pour ta réponse screetch.

Il me semble (pas du tout sur) qu'il n'y a pas de différence entre les DrawList et les VBO si on n'a pas a modifier l'objet. (Ce qui est mon cas, tous les cubes sont les même (a des places différentes) )

Je vais testé avec les VBO ne sait jamais

Dans le doute voici comment j'utilise les callList

J'affiche mes cubes comme ça :

Code :

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

1
2
3
glTranslated(this->getX(),this->getY(),this->getZ());
glCallList(drawListCube);
glTranslated(-this->getX(),-this->getY(),-this->getZ());

La liste contient :

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
glBindTexture(GL_TEXTURE_2D, this->textures[0].at(0));
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2d(0,0);glVertex3f(-0.5f, -0.5f, -0.5f);
glTexCoord2d(1,0);glVertex3f(0.5f, -0.5f, -0.5f);
glTexCoord2d(0,0.5);glVertex3f(-0.5f, 0.5f, -0.5f);
glTexCoord2d(1,0.5);glVertex3f(0.5f, 0.5f, -0.5f);
glTexCoord2d(0,1);glVertex3f(-0.5f, 0.5f, 0.5f);
glTexCoord2d(1,1);glVertex3f(0.5f, 0.5f, 0.5f);
glEnd();
 
glBindTexture(GL_TEXTURE_2D, this->textures[0].at(1));
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2d(0,0);glVertex3f(0.5f, 0.5f, -0.5f);
glTexCoord2d(0,1);glVertex3f(0.5f, -0.5f, -0.5f);
glTexCoord2d(0.5,0);glVertex3f(0.5f, 0.5f, 0.5f);
glTexCoord2d(0.5,1);glVertex3f(0.5f, -0.5f, 0.5f);	
glTexCoord2d(1,0);glVertex3f(-0.5f, 0.5f, 0.5f);
glTexCoord2d(1,1);glVertex3f(-0.5f, -0.5f, 0.5f);
glEnd();
 
glBindTexture(GL_TEXTURE_2D, this->textures[0].at(2));
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2d(0,0);glVertex3f(0.5f, -0.5f, -0.5f);
glTexCoord2d(0,1);glVertex3f(0.5f, -0.5f, 0.5f);
glTexCoord2d(0.5,0);glVertex3f(-0.5f, -0.5f, -0.5f);
glTexCoord2d(0.5,1);glVertex3f(-0.5f, -0.5f, 0.5f);
glTexCoord2d(1,0);glVertex3f(-0.5f, 0.5f, -0.5f);
glTexCoord2d(1,1);glVertex3f(-0.5f, 0.5f, 0.5f);
glEnd();

[Nyarlathotep]

En général, on obtient peu de gains de performances en passant des display lists aux VBOs, sauf si les drivers de la carte vidéo sont mauvais. Il faut essayer de dessiner le moins de cubes possible.

Une idée toute bête (si tu n'y as pas déjà pensé), est de ne pas afficher les cubes qui ne sont pas dans le view frustum (la pyramide de vision) - et ainsi supprimer presque la moitié des cubes à dessiner. Je n'ai jamais joué à Minecraft, donc je ne sais pas à quoi ressemble ta carte, mais si il n'y a que des cubes, alors une structure de données comme un octree ou arbre AABB est parfaitement adaptée pour éliminer ces cubes du rendu de manière très rapide.

Si cette méthode t’intéresse, tape dans google "frustum culling", ou encore "octree", tu devrais tomber sur des articles sur le sujet.

[screetch]

je parle de mettre tous les cubes dans un seul VBO pour tous les rendre en un seul appel de fonction
la tu colles 3 appels de fonction par cube, c'est a peine une optimisation, et c'est toujours en complexité proportionnelle au nombre de cubes.
et donc je parle pas d'un VBO par cube, qi changerait pas des masses.

[Nyarlathotep]

je parle de mettre tous les cubes dans un seul VBO pour tous les rendre en un seul appel de fonction
la tu colles 3 appels de fonction par cube, c'est a peine une optimisation, et c'est toujours en complexité proportionnelle au nombre de cubes.

Tout à fait d'accord. Mais de toute façon la complexité pour dessiner n cubes est toujours en O(n) - même avec un VBO, parce qu'il faut remplir le VBO en question avec les 6 * n faces (au plus). C'est juste que le fait d'envoyer tous ces cubes à la carte vidéo en une fois est comme tu le dis beaucoup plus rapide que de les envoyer en plusieurs fois.

Pour garder la compatibilité avec les vieilles cartes qui ne supportent pas les VBOs il y a toujours les vertex arrays (dans OpenGL 1.1). Sur ma carte vidéo, utiliser des vertex arrays pour des données dynamiques est aussi rapide que d'utiliser des VBOs en mode dynamique (GL_DYNAMIC_DRAW, pour être exact).

Une autre optimisation pour diminuer le nombre de faces à dessiner est de supprimer les faces partagées des cubes (s'il y en a). Par exemple, deux cubes accolés peuvent être dessinés avec 10 faces au lieu de 12.