Discussion :

[KevinduC]

Bonsoir, je suis entrain de coder un petit simulateur, j'utilise les Vertex Array pour le rendu, j'ai créé une structure "Map" qui contient :

- Un tableau de float pour les vertices (De la forme [X1, Y1, Z1, X2, Y2, Z2, ...])
- Un tableau de float pour les coordonnées de texture (De la forme [U1, V1, U2, V2, ...])
- Un tableau de float pour les couleurs (De la forme [R1, V1, B1, R2, V2, B2, ...])
- Un tableau d'entiers pour la liste des faces pour lesquelles il y a changement de texture
- Un tableau d'entiers pour la liste des faces pour lesquelles il y a changement de mesh
- Un tableau de GLint pour les textures
- Des entiers pour le nombre de vertices, de faces ...

Le rendu se fait ensuite en dessinant les vertices de toutes les faces (Qui sont en fait des triangles) avec glDrawArrays() jusqu'au prochain changement de texture, et ainsi de suite jusqu'à la derniers face.
Les donneurs sont stockées dans des fichiers
obj et .mtl exportés sous Blender. Les noms des objets sont également chargés et si l'un d'entre eux commence par "#", alors c'est un objet à animer comme un fluide.

Voici le code de la fonction dessinDecor() :

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
void dessinDecor(Principale *ptr)
{
    int compteurFaces=0,compteurFacesChangeTex=0,compteurTex=0,compteurFacesChangeObj=0,compteurNomsObj=0;
    int compteurVerticesFlux;
    int numFaceChangeTex1,numFaceChangeTex2,numFaceChangeObj1,numFaceChangeObj2,numFaceEnCours;
    int first=0;
    GLint texture;
    const int nbFaces=ptr->Souv.scene.decor.Map.nbTotalFaces;
 
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);
 
    glVertexPointer(3,GL_FLOAT,3*sizeof(float),ptr->Souv.scene.decor.Map.vertices);
    glTexCoordPointer(2,GL_FLOAT,2*sizeof(float),ptr->Souv.scene.decor.Map.coord_tex);
    glColorPointer(3,GL_FLOAT,3*sizeof(float),ptr->Souv.scene.decor.Map.couleurs);
 
    while(1)
    {
        numFaceEnCours=compteurFaces;
 
        numFaceChangeTex1=ptr->Souv.scene.decor.Map.listeFacesChangeTex[compteurFacesChangeTex];
        numFaceChangeTex2=ptr->Souv.scene.decor.Map.listeFacesChangeTex[compteurFacesChangeTex+1];
        if(numFaceChangeTex2==-1)
            numFaceChangeTex2=nbFaces;      //Calcul du nombre de faces jusqu'au prochain changement de texture
 
        if(numFaceEnCours==numFaceChangeTex1)
        {
            texture=ptr->Souv.scene.decor.Map.textures[compteurTex];
            if(texture==-1)
                glDisable(GL_TEXTURE_2D);
            if(texture!=-1)
            {
                glEnable(GL_TEXTURE_2D);
                glBindTexture(GL_TEXTURE_2D,(GLuint)texture);
            }       //Texturing
 
            glDrawArrays(GL_TRIANGLES,first,3*(numFaceChangeTex2-numFaceChangeTex1));
            //Dessin de tous les vertices jusqu'au prochain changement de texture
 
            first+=3*(numFaceChangeTex2-numFaceChangeTex1);
 
            compteurTex++;
            compteurFacesChangeTex++;
 
            compteurFaces+=(numFaceChangeTex2-numFaceChangeTex1)-1;
        }
 
        compteurFaces++;
        if(compteurFaces==nbFaces)
            break;
    }
 
    glEnable(GL_TEXTURE_2D);
 
    compteurFaces=0;
    while(1)
    {
        numFaceEnCours=compteurFaces;
 
        numFaceChangeObj1=ptr->Souv.scene.decor.Map.listeFacesChangeObj[compteurFacesChangeObj];
        numFaceChangeObj2=ptr->Souv.scene.decor.Map.listeFacesChangeObj[compteurFacesChangeObj+1];
        if(numFaceChangeObj2==-1)
            numFaceChangeObj2=nbFaces;
 
        if(numFaceEnCours==numFaceChangeObj1)
        {
            //Si le nom de l'objet commence par "#" => Animation fluide
            if(ptr->Souv.scene.decor.Map.listeNomsObj[compteurNomsObj][0]=='#')
            {
                compteurVerticesFlux=9*numFaceChangeObj1+2;
                while(1)
                {
                    ptr->Souv.scene.decor.Map.vertices[compteurVerticesFlux]=rand()%2-1;
                    //Variation pseudo-aléatoire de la hauteur des vertices
 
                    compteurVerticesFlux+=3;
                    if(compteurVerticesFlux==9*numFaceChangeObj2+2)
                        break;
                }       //Listing de tous les vertices de l'objet
            }
 
            compteurFacesChangeObj++;
            compteurNomsObj++;
        }
 
        compteurFaces++;
        if(compteurFaces==nbFaces)
            break;
    }
}

Mais le résultat n'est pas vraiment celui espéré :



Pour le moment, je cherche simplement à créer des creux et des bosses, mais je constate que les polygones se "décollent" au lieu de rester soudés.

Auriez-vous des idées pour simuler un fluide avec OpenGL ?

[Bousk]

Salut,

pour le décollage de tes triangles, peut-être devrais-tu changer le type de triangles que tu dessines : GL_TRIANGLE est le plus simple, mais d'autres options permettraient de les assembler entre eux à moindre prise de tête, mais il va surement falloir modifier leur représentation en mémoire.


Tu devrais sinon pouvoir utiliser le geometry shader pour la déformation. Voire une combinaison des 2 : changer le type de triangles et ajouter un geometry shader.

Edit: je viens de voir que tu es en GL1.x : seul la première option sera possible.
Ou bien il est temps de passer à un eversion supérieure

[KevinduC]

Bonjour, merci pour ta réponse. La solution du type de triangles semble intéressante, à tester (Je ne pourrai pas avant ce soir). Mais je me pose la question de savoir s'il n'y a pas de meilleure solution pour représenter un fluide. La méthode que j'emploie serait idéale pour représenter la mer (Avec une fonction sinusoïdale pour les vagues), mais une rivière là je sèche ...

[Kannagi]

Je dirai pour ma part qu'il faudrait modifier que l'axe des Y (si Y est bien la hauteur).

[dragonjoker59]

Pour simuler un fluide, on peut passer par un geometry shader.
Tu peux voir le travail d'Eric Bruneton à ce sujet : http://www-evasion.imag.fr/people/Eric.Bruneton/ (section Ocean, tu peux télécharger le source)

[KevinduC]

Bon la solution du GL_TRIANGLE_STRIP n'a rien donné, ça n'a fait que déformer la map.
dragonjoker59, peux-tu m'expliquer brièvement ce qu'est un Geometry Shader. D'après Bousk, ça n'est pas compatible avec la version 1 d'OpenGL.