Discussion :

[KevinduC]

Bonsoir, je suis (Encore) sur un projet OpenGL et le but est d'avoir le rendu le plus réaliste possible. Pour commencer j'ai un sol constitué d'un maillage dont la topographie est défini au moyen d'une heightmap générée par un algorithme de Perlin Noise. Une autre texture (Que j'ai baptisée "floormap") générée de la même manière permet de définir le type de sol, sa texture en fait. Il y a en fait plusieurs textures envoyées au fragment shader et stockées dans un tableau et l'index de la texture à afficher est calculé au moyen de la floormap. Les textures sont quant à elles récupérées sur ce site. Voici mes codes :

Le chargement :

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
decor.sol.vbo.nbVertices=decor.sol.vbo.coordVertices.size()/3;
 
glGenVertexArrays(1,&decor.sol.vbo.VAO);
glGenBuffers(1,&decor.sol.vbo.bufferVRAM);
 
glBindVertexArray(decor.sol.vbo.VAO);
glBindBuffer(GL_ARRAY_BUFFER,decor.sol.vbo.bufferVRAM);
 
glBufferData(GL_ARRAY_BUFFER,decor.sol.vbo.nbVertices*3*sizeof(float)+decor.sol.vbo.nbVertices*2*sizeof(float)+decor.sol.vbo.nbVertices*3*sizeof(float),NULL,GL_STREAM_DRAW);
 
glBufferSubData(GL_ARRAY_BUFFER,0,decor.sol.vbo.nbVertices*3*sizeof(float),&decor.sol.vbo.coordVertices[0]);
glBufferSubData(GL_ARRAY_BUFFER,decor.sol.vbo.nbVertices*3*sizeof(float),decor.sol.vbo.nbVertices*2*sizeof(float),&decor.sol.vbo.coordTex[0]);
glBufferSubData(GL_ARRAY_BUFFER,decor.sol.vbo.nbVertices*3*sizeof(float)+decor.sol.vbo.nbVertices*2*sizeof(float),decor.sol.vbo.nbVertices*3*sizeof(float),&decor.sol.vbo.normales[0]);
 
glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,3*sizeof(float),(void*)0);
glEnableVertexAttribArray(0);
 
glVertexAttribPointer(1,2,GL_FLOAT,GL_FALSE,2*sizeof(float),(void*)(decor.sol.vbo.coordVertices.size()*sizeof(float)));
glEnableVertexAttribArray(1);
 
glVertexAttribPointer(2,3,GL_FLOAT,GL_FALSE,3*sizeof(float),(void*)(decor.sol.vbo.coordVertices.size()*sizeof(float)+decor.sol.vbo.coordTex.size()*sizeof(float)));
glEnableVertexAttribArray(2);
 
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER,0);

Le rendu :

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
glUniform1i(glGetUniformLocation(shaderSol,"nbTex"),decor.sol.textures.size());
 
int compteurTex=0;
while(1)
{
	glActiveTexture(GL_TEXTURE0+compteurTex);
	glBindTexture(GL_TEXTURE_2D,decor.sol.textures[compteurTex]);
 
	ostringstream os;
 
	os << compteurTex;
 
	string nomShader="textures["+os.str()+"]";
 
	glUniform1i(glGetUniformLocation(shaderSol,nomShader.c_str()),compteurTex);
 
	compteurTex++;
	if(compteurTex==decor.sol.textures.size())
		break;
}
 
glActiveTexture(GL_TEXTURE0+compteurTex);
glBindTexture(GL_TEXTURE_2D,decor.floormap);
glUniform1i(glGetUniformLocation(shaderSol,"floormap"),compteurTex);
 
glUniform1i(glGetUniformLocation(shaderSol,"sol"),true);
 
glUniform1f(glGetUniformLocation(shaderSol,"typeSol"),decor.sol.typeSol);
glUniform1f(glGetUniformLocation(shaderSol,"tailleMap"),decor.sol.taille);
glUniform1f(glGetUniformLocation(shaderSol,"rapportTex"),RAPPORT_TEX);
 
glBindVertexArray(decor.sol.vbo.VAO);
 
glDrawArrays(GL_TRIANGLES,0,decor.sol.vbo.nbVertices);
 
glBindVertexArray(0);
 
glActiveTexture(GL_TEXTURE0);

Le fragment shader :

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
#version 330 core
 
uniform float tailleMap;
uniform float rapportTex;
uniform int nbTex;
 
uniform sampler2D floormap;
uniform sampler2D textures[30];
 
in vec2 coordTexFrag;
in vec4 couleurFrag;
 
out vec4 FragColor;
 
void main(void)
{
	vec2 coordTex2=coordTexFrag/rapportTex;
	int numTex=int((texture(floormap,coordTex2.xy).x)*(nbTex+1));
 
	FragColor=texture(textures[numTex],coordTexFrag.xy)*couleurFrag;
}

Seulement voilà, je trouve pas le résultat très jojo :




J'aimerais quelque chose un minimum réaliste, comme lorsque je vois des images de jeux comme GTA V (Enfin pas à un tel niveau tout de même ...), parce que là ça ressemble pas à grand-chose je trouve. Vous me conseilleriez quoi pour cela ?

[dragonjoker59]

Bonjour !

Tout d'abord, commence par utiliser le mipmapping, pour que le rendu de tes textures ne soit pas aussi moche au loin.

Ensuite, il te faut une "bande de transition" entre tes différents types de sols.

[KevinduC]

Salut, merci pour le conseil !

[LittleWhite]

Bonjour,

Pour les zones de transition, je pensais à utiliser du multitexture et faire de la fusion dans le pixelshader. Globalement, la couleur du sol va dépendre d'une "matérial map", qui sera plus ou moins équivalente à la heightmap, mais qui déterminera la texture à utiliser : par exemple, vert pour l'herbe, blanc pour la neige, bleu pour l'eau. A certains endroits de la carte, le bleu ne sera pas bleu parfait (genre, pas 0, 0, 255), mais mélangé au vert. Alors vous saurez qu'il faut faire une fusion et vous atténuerai l'importance de la texture d'eau, et augmenterai l'importance de la texture d'herbe. Par exemple color_tex_water * 0.2 + color_tex_grass * 0.8.
Après, inspirez vous des tutoriels, ressources YouTube et pas uniquement pour OpenGL. Il y a plein de solution (et je n'ai pas proposé la meilleure).

Sinon, l'autre truc qui me gêne, c'est qu'il n'y a pas de bump mapping (ou technique plus avancé, displacement mapping, je crois, mais c'est encore plus dur à mettre en place). On voit que la texture est plane et je ne le supporte plus depuis quelques temps

[KevinduC]

Salut LittleWhite, merci pour les conseils, j'utilise déjà du multitexturing pour afficher les différentes textures selon la "floormap", pour les transitions je pense avoir une idée : Je calcule l'index (Qui est un entier) de la texture à afficher mais je pense que je pourrais calculer un flottant qui va me permettre d'afficher plus ou moins telle ou telle texture (Ex : 1.5 pour afficher 50% de la texture 1 et 50% de la texture 2).
Le bump mapping : Très interessant apparemment pour donner du relief, je vais me pencher là-dessus, merci !

[KevinduC]

Re, merci pour vos conseils, c'est bien mieux en combinant mipmapping, transitions et bumpmapping :



Je me permets au passage de poser une question à propos des reflets au passage : D'après mes recherches il faut utiliser une cubemap représentant l'environnement et donc faire 6 rendus au moyen de FBO (Un sur chaque face du cube) en un frame, ça ne risque pas de faire grandement chuter les performances ?

[LittleWhite]

Nice !
Si, ajouter des passes de rendu, cela diminue les performances, mais d'un autre côté, les cartes graphiques sont optimisés pour pusher du pixel à la pelle. Donc, il est possible que vous ne le sentiez même pas.
Après, vous pouvez optimiser de plein de façons (bienvenue dans le monde de la 3D temps réel et de la triche), notamment en générant cette cubemap une fois pour toute (si votre scène est statique), ou même, une image sur six , ou même en petite résolution (peut être que cela impactera trop le rendu) et ainsi de suite

[KevinduC]

Merci pour l'info ! Mais cette cubemap doit être générée à partir de quel point de vue ? Le centre de la map ? Parce que si mettons il y a une colline devant l'arrière-plan et que celle-ci apparaît dans la cubemap alors on verra cette colline partout dans les reflets, même dans une étendue d'eau située derrière la colline. Je me demande bien comment ont fait les développeurs de GTA V.
Après j'ai (Encore) une question, à propos du frustum culling cette fois : Comment peut-on savoir si tel objet est dans le champ de vision de la caméra ? Il faut tester la position de chaque objet ? Et s'il y en a des milliers ? Si on utilise une instanciation de plusieurs dizaines de milliers d'objets ? Ça va à l'inverse faire chuter les performances.

[Kannagi]

Non , c'est très facile , il faut juste refaire la transformation de perspective coté CPU et on a au final nos coordonnées 2D à l'écran
Bien sur il faut pas le faire sur chaque vertex (sinon ça perdrait son intérêt) , chaque model 3D à une box de son volume pour éviter le nombre de test , si cette box est complètement hors de l'écran , alors on n'affiche pas ce model.

[KevinduC]

Merci c'est très clair ! Juste un point : Dans ce cas il faut faire un appel à glDrawArrays() pour chaque objet ? Parce que je fais toujours en sorte d'avoir le moins d'appels possibles à cette fonction. Et dans le cas de l'instanciation, si j'ai une forêt par exemple, il faut faire le test sur chaque arbre ?

[Kannagi]

Oui , mais bon il serait plus intéressant de le faire sur un groupe d'arbre.

[KevinduC]

Et s'il faut cacher tel groupe d'arbre, comment faire étant donné qu'il s'agit d'une instanciation ? Car dans ce cas j'ai un seul appel à glDrawArraysInstanced(), ou alors il faut appeler glDrawArrays() en boucle et faire le test à chaque fois mais je doute que ce soit très optimisé

[Kannagi]

Tu ne fais pas de glDrawArraysInstanced() ou glDrawArrays() tout simplement , je vois pas ce qui te pose soucis là , tu aura forcément pas mal de draw call sur un jeu (facile 1000 ) , donc oui tu pourra réduire ces draw call avec le frustrum

Tu parle beaucoup de performance, tu les mesures au moins les performances de ton rendu ?
Je m'étais amusé a faire un banchmark sur ma machine (vielle de 10 ans donc avec un CPU/GPU bas de gamme ), bon avec 700 draw call par frame et 60 millions de polygone/seconde avec OpenGL 1 , normalement tu as de la marge

[KevinduC]

Mais pour tester si chaque objet est dans le champ de vision de la caméra je dois faire une boucle, et s'il y a beaucoup d'objets alors ma boucle sera longue et risque de faire chuter les performances alors le frustum perd tout son intérêt dans ce cas. Oui je mesure les performances en chronométrant la durée d'une boucle avec SDL et je calcule ainsi le FPS que j'affiche dans la barre de titres. Par exemple je suis à environ 1000 FPS dans mon projet actuel si je ne dessine que le sol, mais lorsque je mets des touffes d'herbe par instanciation alors ça peut chuter à 250 FPS.

[Kannagi]

Ah tu parle du test du frustum culling !
Bah long , disons que ma PS2 pouvais faire 50 000 test de frustrum par frame ,donc sauf si tu as un CPU plus vieux de 20 ans ,oui ça peut poser soucis
Donc faut vraiment avoir plus de 100000 test de frustum pour que ça pose un soucis (et encore ) :p

Et puis sérieusement , n’espère pas faire un jeu "next gen" avec de l'OpenGL 3

[KevinduC]

Ok, non mon PC est récent et supporte d'ailleurs GTA V. Dans le cas de l'instanciation j'utilise un tableau dans mon VBO pour la position de chaque instance et c'est sur ce dernier qu'il faudrait vérifier si l'objet est ou non dans le champ de la caméra, ce qui reviendrait à écrire dans la mémoire vidéo à chaque frame donc faire des échanges de données entre CPU et carte graphique, si je fais ça le VBO perd son intérêt.

[dragonjoker59]

Le frustum culling se fait sur le CPU, et quoi que tu puisses en penser, c'est rapide (un test de frustum VS AABB est simple et rapide).
Du coup, oui, il va y avoir une écriture sur ton buffer d'instances (qui devrait juste contenir la matrice de transformation de chaque instance), mais c'est un moindre mal.

Par contre, tu ne sembles pas te rendre compte de la complexité de l'objectif que tu t'es fixé (rendu similaire à GTA 5)
Voilà le découpage d'une frame de rendu sur ce jeu : http://www.adriancourreges.com/blog/...raphics-study/

Et voilà a minima ce qu'il te faudra maitriser pour faire ça en OpenGL : https://fr.slideshare.net/CassEverit...river-overhead

Bon amusement

[KevinduC]

D'accord merci pour l'info ! Non je ne cherche pas à faire l'équivalent de GTA V, c'est juste une comparaison