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 ?