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 ?