Discussion :

[fransL]

Bonjour à tous,

Je suis actuellement en train d'essayer de réaliser un programme permettant d'afficher le profil d'une surface en 3D. C'est-à-dire qu'à l'aide d'un outil externe balayant une surface suivant un rectangle, je récupère la profondeur (ou l'altitude) de milliers de points (tout en sauvegardant leur position). Chaque point aura donc des coordonnées et une valeur.

Au final, et à l'aide d'OpenGL, je dois afficher ce rectangle pour pouvoir observer les dénivelés, etc. Voici une image illustrant plus ou moins le résultat à obtenir : image. Il s'agit en fait d'une sorte de graphique.

Ma question porte sur la manière la plus performante d'afficher tous ces points (dont le nombre peut monter jusqu'à plusieurs millions). Car j'ai beau réfléchir et chercher un peu partout, je n'ai pas encore trouver la solution idéale à mes yeux.

Pour être vraiment précis, comment créer des VBOs (ou autres) à partir d'une telle matrice de points de manière à être le plus performant possible ? Je suis à la recherche d'idées principalement car je n'ai aucune expérience dans le domaine de la 3D.

À noter que j'utilise la version 2.0 d'OpenGL à travers la bibliothèque OpenTK (oui c'est du C# et, non, je n'ai pas le choix du langage :/).

Merci d'avance pour vos propositions éclairées ;o).

[pyros]

Salut,

Si je comprend bien, tu souhaite afficher une height map ?

Peut être que ceci pourra t'aider:
http://newbiz.developpez.com/tutorie...ngl/heightmap/

Sinon "height map", "height field", "elevation map", "displacement mapping", etc... dans google. Les méthodes sont nombreuse, plus ou moins complexes et plus ou moins efficace.

En général, le plus simple est de dessiner une grille régulière de triangles (triangle strip à l'aide d'un VBO), et de changer la valeur z des vertexs, soit coté CPU (le plus simple), soit coté GPU avec un vertex shader. Cette technique permet d'avoir un bon framerate jusqu'à quelques millions de points. Au delà, il faut commencer à sortir l'artillerie lourde (level of detail, multi-résolution, raycast, ...)

Voila, je t'ai donné quelques mot clef, à toi de te faire une idée

[fransL]

Bonjour,

Tout d'abord merci pour ta réponse.

En général, le plus simple est de dessiner une grille régulière de triangles (triangle strip à l'aide d'un VBO), et de changer la valeur z des vertexs, soit coté CPU (le plus simple), soit coté GPU avec un vertex shader.

Je ne comprends pas bien ce que m'apporterait de modifier la valeur z des vertexs après la création du VBO vu que je connais cette valeur pour chaque point.

Pour l'instant, je crée un VBO pour chaque ligne de ma matrice contenant les coordonnées des sommets (les points) de quadrangles (que je dessine en mode QUADS_STRIP) :

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
33
34
35
36
37
bool eboEmpty = true;
 
for (int i = 0; i < maxX - 1; ++i)
{
    // contient les coordonnées des quadrangles
    // chaque indice = un vbo
    points[i] = new VertexPositionColor[2 * (int)maxY];
 
    for (int j = 0, a = 0; j < maxY - 1; j += 2)
    {
        points[i][a] = new VertexPositionColor(i, j, data.Donnees[i, j] - minZ,
            lut.getColor(data.Donnees[i, j] - minZ, 0, maxZ - minZ));
 
        points[i][a + 1] = new VertexPositionColor(i + 1, j, data.Donnees[i + 1, j] - minZ, 
            lut.getColor(data.Donnees[i + 1, j] - minZ, 0, maxZ - minZ));
 
        points[i][a + 2] = new VertexPositionColor(i, j + 1, data.Donnees[i, j + 1] - minZ, 
            lut.getColor(data.Donnees[i, j + 1] - minZ, 0, maxZ - minZ));
 
        points[i][a + 3] = new VertexPositionColor(i + 1, j + 1, data.Donnees[i + 1, j + 1] - minZ, 
            lut.getColor(data.Donnees[i + 1, j + 1] - minZ, 0, maxZ - minZ));
 
        if (eboEmpty)
        {
            // tableau d'indices
            coordQuad[a] = (short)a;
            coordQuad[a + 1] = (short)(a + 1);
            coordQuad[a + 2] = (short)(a + 2);
            coordQuad[a + 3] = (short)(a + 3);
        }
 
        a += 4;
    }
 
    if (eboEmpty)
        eboEmpty = false;
}

En écrivant ceci, je crois avoir saisi ce que tu disais. L'idée serait donc de créer un seul VBO plat (ne contenant pas la valeur en Z des points) représentant n'importe quelle ligne de la matrice et au moment de construire la scène, j'afficherais ce VBO plusieurs fois en modifiant la valeur en Z des points à chaque fois ? Malheureusement, étant débutant, je ne vois pas trop comment faire (enfin, côté CPU, je vois à peu près mais je ne me suis pas encore attardé sur l'utilisation de shaders). D'ailleurs, l'utilisation du mode triangle_strip serait-il plus réellement plus avantageux ?

Je me demandais également comment déterminer si un point est réellement dessiné ou non ? C'est-à-dire s'il se trouve dans la scène ou en dehors ?

Merci d'avance pour vos éclaircissements (et merci pour ceux déjà donnés). Je vais me plonger sur les shaders en attendant.

[pyros]

Salut,

En fait, je voulais dire que si ta height-map est statique (qu'elle ne change pas 50 fois par secondes), tu peux créer ton VBO en prenant comme valeur Z directement la valeur de ta map. Pas besoin de passer par des shaders.

Au final, tu cré un seul VBO contenant une grille régulière sur le plan XY avec des triangles strip, comme ceci:

Et en z, tu prend la valeur de ta height-map.

Dsl de ne pas détailler plus, je n'ai pas trop le temps en ce moment