Discussion :

[KevinduC]

il faut utiliser la macro GLEW_STATIC.

Cest-à-dire ? Je ne trouve pas cette macro. En parlant de macro justement, je me suis aperçu qu'il existait une macro du nom de "glGenBuffers", bref ça n'a pas de sens, je ne comprends plus rien ...

[LittleWhite]

Voici la documentation.
La phrase :

On Windows, you also need to define the GLEW_STATIC preprocessor token when building a static library or executable

Il faut soit, faire un #define GLEW_STATIC dans le main (mais je ne suis pas sûr que cela suffise), soit ajouter le GLEW_STATIC dans les options du préprocesseur, dans les options du projet.

[KevinduC]

Il me dit "cannot find -lGLEW_STATIC"

[LittleWhite]

Je n'ai pas dit de le donner en option de l'éditeur de liens (linker), mais en option du préprocesseur.
Si on prend cette fenêtre :
Il faut mettre GLEW_STATIC dans "Compiler Settings", si je ne dis pas de bêtises.

[KevinduC]

Oui ça fonctionne enfin, merci beaucoup !

[dragonjoker59]

Le principe de ce define est de dire à glew qu'on en utilise la version bibliothèque statique.
Il suffit de le mettre avant chaque include à glew.h, ou comme te l'a indiqué LittleWhite en option de préprocesseur au niveau du projet.

[KevinduC]

D'accord, merci pour le tuyau.
Dès que j'en aurai le temps je me lancerai dans les VBO. En attendant bon réveillon !

[KevinduC]

Bonsoir à tous et bonne année !
Comme prévu, je me suis un peu consacré aux VBO, je suis finalement parvenu à afficher la map mais le résultat est vraiment décevant : C'est de l'image par image, ça marchait bien mieux avec les Vertex Array ! Voici mon code :

La fonction chargeTerrain() :

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
void chargeTerrain(Terrain *Map)
{
    int positionDsFichier,tailleFichier;
    int compteurVertices=0,compteurCoordTex=0;
 
    Vertex *liste_vertices=(Vertex*)malloc(MAX_TOTAL_VERTICES*sizeof(Vertex));
    coordTex *coord_textures=(coordTex*)malloc(MAX_TOTAL_VERTICES*sizeof(coordTex));
 
    FILE *fichierObj=NULL;
    FILE *fichierMtl=NULL;
 
    const int taille_max_ligne=3000;
    char ligneLue[taille_max_ligne];
    char *retour_fgets;
    int tailleTotale;
 
    ...//Ouverture fichiers
 
	if(fichierObj!=NULL && fichierMtl!=NULL)
    {
        fseek(fichierObj,0,SEEK_END);
        tailleFichier=ftell(fichierObj);
        rewind(fichierObj);
 
		while(1)                //Stockage de tous les vertices dans un tableau provisoire
        {
            retour_fgets=fgets(ligneLue,taille_max_ligne,fichierObj);
            if(retour_fgets==NULL)
                break;
 
            if(ligneLue[0]=='v'&&ligneLue[1]==' ')
            {
                sscanf(ligneLue,"v %f %f %f\n",
                       &liste_vertices[compteurVertices].x,
                       &liste_vertices[compteurVertices].y,
                       &liste_vertices[compteurVertices].z);
 
                compteurVertices++;
            }
 
            if(ligneLue[0]=='v'&&ligneLue[1]=='t')
            {
                sscanf(ligneLue,"vt %f %f\n",
                       &coord_textures[compteurCoordTex].x,
                       &coord_textures[compteurCoordTex].y);
 
                compteurCoordTex++;
            }
        }
 
        rewind(fichierObj);
 
        Map->vertices=(float*)malloc(MAX_TOTAL_VERTICES*3*sizeof(float));
        Map->coord_tex=(float*)malloc(MAX_TOTAL_VERTICES*2*sizeof(float));
        Map->couleurs=(float*)malloc(MAX_TOTAL_VERTICES*3*sizeof(float));
        Map->textures=(GLint*)malloc(MAX_TOTAL_FACES*sizeof(GLint));
        Map->nbVerticesParFace=(int*)malloc(MAX_TOTAL_FACES*sizeof(int));
 
        Map->taille_liste_vertices=MAX_TOTAL_VERTICES*3*sizeof(float);
        Map->taille_liste_coordTex=MAX_TOTAL_VERTICES*2*sizeof(float);
        Map->taille_liste_couleurs=MAX_TOTAL_VERTICES*3*sizeof(float);
 
        tailleTotale=Map->taille_liste_vertices+Map->taille_liste_coordTex+Map->taille_liste_couleurs;
 
        chargeVA(fichierObj,fichierMtl,Map,liste_vertices,coord_textures);		//Lecture des faces dans le fichier .obj et chargement des matériaux
 
        glewInit();
 
        glGenBuffers(ID_BUFFER,&Map->Buffer);       //Initialisation identifiant buffer VBO
 
        glBindBuffer(GL_ARRAY_BUFFER,Map->Buffer);
 
        glBufferData(GL_ARRAY_BUFFER,tailleTotale,NULL,GL_STREAM_DRAW);     //Allocation mémoire CG
 
        glBufferSubData(GL_ARRAY_BUFFER,0,Map->taille_liste_vertices,Map->vertices);     //Allocation des tableaux
        glBufferSubData(GL_ARRAY_BUFFER,Map->taille_liste_vertices,Map->taille_liste_coordTex,Map->coord_tex);
        glBufferSubData(GL_ARRAY_BUFFER,Map->taille_liste_vertices+Map->taille_liste_coordTex,Map->taille_liste_couleurs,Map->couleurs);
 
        glBindBuffer(GL_ARRAY_BUFFER,0);
    }
 
    fclose(fichierObj);
    fclose(fichierMtl);
 
    free(liste_vertices);
    free(coord_textures);
}

Fonction dessinTerrain() :

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
#define BUFFER_OFFSET(a) ((char*)NULL + (a))
 
void dessinTerrain(Terrain *Map)
{
    int compteurFaces=0,nbVertices,nouvNbVertices,first=0;
    GLint texPrecedente=-2,texture;
 
    glBindBuffer(GL_ARRAY_BUFFER,Map->Buffer);
 
    glVertexPointer(3,GL_FLOAT,0,BUFFER_OFFSET(0));
    glTexCoordPointer(2,GL_FLOAT,0,BUFFER_OFFSET(Map->taille_liste_vertices));
    glColorPointer(3,GL_FLOAT,0,BUFFER_OFFSET(Map->taille_liste_vertices+Map->taille_liste_coordTex));
 
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);
 
    while(1)
    {
        nbVertices=Map->nbVerticesParFace[compteurFaces];
 
        texture=Map->textures[compteurFaces];
        if(compteurFaces>=1)
            texPrecedente=Map->textures[compteurFaces-1];
 
        if(texture!=texPrecedente)
            glBindTexture(GL_TEXTURE_2D,(GLuint)texture);
 
        if(nbVertices==3)
        {
            glDrawArrays(GL_TRIANGLES,first,3);
            first+=3;
        }
 
        if(nbVertices==4)
        {
            glDrawArrays(GL_QUADS,first,4);
            first+=4;
        }
 
        if(nbVertices>=5)
        {
            glDrawArrays(GL_POLYGON,first,nbVertices);
            first+=nbVertices;
        }
 
        compteurFaces++;
 
        if(first>=Map->nbTotalVertices)
            break;
    }
 
    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    glDisableClientState(GL_COLOR_ARRAY);
}

Je ne m'attendais pas à un résultat si décevant alors que d'après ce que j'ai lu, les VBO permettent un bien meilleur rendu qu'avec les VA, ici c'est l'inverse !

Merci par avance pour votre aide

[KevinduC]

Bon et bien je n'arrive malheureusement à rien, c'est à croire que finalement on obtient un bien meilleur résultat avec les Vertex Array que les Vertex Buffer Objects, dommage ...

[LittleWhite]

Si je comprends bien votre code, vous faites un glDrawArrays par polygones ? (triangle, carré, truc à 5 côté) ? Si c'est ça, il faut savoir que vous devriez diminuer votre nombre de draw call (soit, d'appels à glDrawArrays), car, c'est la bonne pratique de limiter son nombre d'appel. D'ailleurs, en réalité, vous devriez avoir un seul appel à glDrawArrays pour tout votre terrain (en théorie).

[KevinduC]

Oui c'est ça, car je dois contrôler sa texture pour chaque polygone. Sinon comment appliquer mes textures ?

[LittleWhite]

Chaque polygone pourrait avoir des coordonnées de texture différente (et normalement, ne nécessité qu'un seul draw call). Après, si vous ne pouvez pas regrouper tous les détails du terrain en une texture géante que l'on applique comme on pose une nappe sur la table, vous pouvez tenter le multi texturing (plusieurs textures que l'on peut mélanger à volonté et comme vous semble) pour mêler l'herbe, le sable, la neige, tout ça), Et si vraiment cela ne suffit pas, car vous voulez appliquer des textures extrêmement différente et varier par "case" ou "morceau" de terrain, vous pouvez utiliser une méga texture (une texture qui embarque plusieurs textures, comme on peut le voir ici) dont vous contrôlez ce qui va apparaître grâce ... aux coordonnées de texture (comme toujours ).

Dans tous les cas, il faut trouver une méthode pour faire chuter le nombre de draw call, sachant qu'un jeu triple A, c'est 100 draw call en moyenne (et puis de toute façon, c'est une hérésie de dessiner que 3/4/5 sommets par draw call).

[KevinduC]

Je ne peux pas utiliser de texture géante car il y a des détails dans la map comme des panneaux ou des bâtiments, ni de méga texture car certaines textures sont dupliquées et d'autres pas. J'imagine qu'il ne me reste que la solution du multi texturing.

[LittleWhite]

Euh ... ...
Bah il va falloir (au moins trouver une solution).
On peut voir une capture d'écran de votre terrain, afin de mieux comprendre les contraintes (et ainsi donner des solutions).

Aussi, juste par curiosité, pouvez-vous ajouter un compteur de draw calls et nous donner le nombre d'appels par image, s'il vous plait.

[KevinduC]

La map représente divers massifs comme la Ste-Victoire ou la Ste-Baume avec une voie ferrée que je suis entrain de modéliser, ainsi que des gares ferroviaires, tunnels et viaducs :




Comme vous pouvez le voir, il y a des textures pour panneaux, murs, ballast ...

Sous Blender, ça ressemble à ça :



Etant donné qu'il y a 116 737 faces dans la map, je fais 116 737 appels à glDrawArrays() par frame. S'il y a moyen de ne faire qu'un appel par frame alors je suis preneur.

[LittleWhite]

Évidemment qu'il y a des méthodes. Déjà, le terrain ne devrait être composé que ... du terrain (relief). Cela veut dire que vous ne devez pas y intégrer, ni les batiments, ni le chemin de fer (pour ce dernier j'hésite, mais je pense que l'on devrait éviter de l'intégrer).
Pour les bâtiments, il faut en faire des modèles 3D à part (chaque bâtiment, un modèle 3D). Pour le chemin de fer, un modèle 3D (mais juste une section), que vous réutiliserez autant de fois que nécessaire pour faire le chemin.

Ainsi, pour le terrain (relief) vous pourrez utiliser toutes les techniques sus mentionnées.

Ensuite, vous pourrez améliorer l'affichage des modèles, en ne les affichant que s'ils sont dans le champ de vision de la caméra (frustrum culling). Ainsi, un truc à 3 km, vous ne le verrez pas et vous ne perdrez pas de temps à l'afficher.

Aidez-vous des ressources de ce genre :

• http://newbiz.developpez.com/tutorie...ngl/heightmap/
• http://fearyourself.developpez.com/t...TexTerrainGen/

(Hors partie génération qui ne vous intéressent pas.)

[KevinduC]

Corrigez-moi si je me trompe mais on ne peut faire qu'un seul appel à gl*Pointer(), sous peine d'écraser des données. De ce fait, je suis obligé de regrouper tous les vertices dans un seul array, c'est pour ça que je combine le terrain avec les bâtiments et le reste.

[Kannagi]

Etant donné qu'il y a 116 737 faces dans la map, je fais 116 737 appels à glDrawArrays() par frame. S'il y a moyen de ne faire qu'un appel par frame alors je suis preneur.

Violent
Euh ouais encore heureux que tu ne peux faire qu'un appel , c'est quoi qui te pose souci ?
Tu organise tes triangle par texture et donc tu réduit par 7 DrawCall si tu as 7 texture différentes.

[KevinduC]

Tu organise tes triangle par texture et donc tu réduit par 7 DrawCall si tu as 7 texture différentes.

Je crois que c'est effectivement la solution, merci bien !

[KevinduC]

J'ai mis en pratique cette solution : glDrawArrays() est appelée uniquement lorsqu'il faut appliquer une nouvelle texture, et ça fonctionne très bien, le rendu est bien plus fluide, merci beaucoup pour ces conseils !