Interpolation d'altitude sur un heightmap

**LapinGarou** · 08/08/2006, 19h10

Bonjour à tous !

Je code actuellement un moteur 3d en OpenGL qui affiche un heightmap (ou heightfield ?!).
Tout marche comme il faut, sauf que j'ai un souci pour le déplacement de la caméra : comment lui donner la valeur adéquate pour ne pas passer au travers du sol ?
Pour le moment j'ai réussi à récupérer une altitude à partir du vertex le plus proche je suppose en faisant une fonction qui donne ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
m_Position.y = (GLfloat)((map->GetVertex(m_Position.x/map->m_ScaleValue,
-m_Position.z/map->m_ScaleValue)/map->GetDiviseur())*map->m_ScaleValue * (map->GetHeightScale()))+5*map->m_ScaleValue;

où :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
GLfloat diviseur; //paramètre qui permet de diviser les hauteurs (0-255) pour aplanir les "angles"
GLfloat ScaleValue;//facteur d'agrandissement
le +5*map->m_ScaleValue; à la fin est une valeur perso qui me permet de maintenir la caméra au dessus de la map, sinon avec le backface culling on ne voir rien.

Donc, c'est là que vient la question : comment savoir à quelle altitude dois-je placer la camera pour qu'elle se déplace sur le triangle et non pas d'altitude de vertex en altitude de vertex... pour avoir un déplacement "fluide".
J'ai une piste : calculer la normale du plan, mais déjà pour commencer... comment savoir au dessus de quel triangle se trouve la camera ?

Merci à ceux qui pourront m'aiguiller...

ps : pour afficher mes triangles... version courte :

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
glBegin(GL_TRIANGLES);
for (int x=0; x<height-precision; x+=precision) 
{
	for (int z=0; z<width-precision; z+=precision) 
	{               
		//======Points du triangle
		Point3D normale;
		//-- Premier point (X+1, Z)
		Point3D triangle1( (x+precision)*size_scale,				  				(GLfloat)GetVertex(x+precision, z)/diviseur,
			z*size_scale);
		//-- Deuxième point (X, Z)
		Point3D triangle2( x*size_scale,
			  (GLfloat)GetVertex(x, z)/diviseur,
			  z*size_scale);
		//-- Troisième point (X+1, Z+1)
		Point3D triangle3( (x+precision)*size_scale,
			  (GLfloat)GetVertex(x+precision, z+precision)/diviseur,
			  (z+precision)*size_scale);
		//-- Quatrième point (X, Z+1)
		Point3D triangle4( x*size_scale,
			  (GLfloat)GetVertex(x, z+precision)/diviseur,
			  (z+precision)*size_scale);
		//========== Selection
		//== Premier triangle
		//-- Normale
		// on calcule la normale du triangle (optionnel)
		normale = (triangle1-triangle2)*(triangle2-triangle3);
		glNormal3f(normale.x, normale.y, normale.z);
 
		glVertex3f(triangle3.x, triangle3.y, triangle3.z);
		glVertex3f(triangle1.x, triangle1.y, triangle1.z);
		glVertex3f(triangle2.x, triangle2.y, triangle2.z);
		...etc pour les autres triangle...

**bafman** · 09/08/2006, 08h41

je ne suis pas un specialiste en affichage de terrain mais a vu de nez je dirais :
calculer la normale de chaque triangle et stocker pour chaque triangle l'equation de son plan (sous la forme normale + d de l'equation ax+by+cz+d = 0), ensuite il ne te reste plus qu'a calculer la hauteur en fonction de cette equation et de la position (2D) du point à tester...

enfin je dis ca, c'est de la grosse theorie et je ne sais meme pas si c'est facilement réalisable en pratique

**LapinGarou** · 09/08/2006, 09h12

Ok, pour l'équation de plan je me doutais de la piste à suivre puisque si vous regardez mon code, il y a déjà un calcul de la normale intégré.
Mais en fait, je commence à manquer de recul je pense sur mon programme, je n'arrive pas à trouver l'astuce pour savoir au dessus de quel triangle ma camera FPS se trouve, le maillage donnant ceci : (image piquée sur le premier site trouvé sur Google)

Je pense qu'en prenant cam.x%map_largeur et -cam.z%map_largeur (map carrée), je trouve le vertex le plus proche de ma camera, mais ensuite ? pour le carré coin superieur 2.2 par exemple ? comment savoir lequel des 2 triangles ?

Faut il que je crée une structure perso pour ma map ? genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
struct triangle
{
point3d x,y,z;
point3D normale;
GLfloat d;
maclassetexture *textureprincipale;
...etc
}

?

**Sixissor** · 09/08/2006, 11h18

Salut

Te prends surtout pas la tête à compliquer les choses... NORMALEMENT y'a toujours moyen de faire simple...

Le principe: cette fois tu n'update plus la coord Y de ta caméra en fonction de la hauteur du terrain en les coordonnées de la caméra MAIS en fonction des points de la map les plus proches vis-à-vis de la caméra en faisant une interpolation linéaire.
Pour ça il nous faut 2 coordonnées en X et 2 en Z, puis le pas, c'et à dire la distance entre 2 coords de même axe (en gros ça dépend comment t'as subdiviser ta map). Ici on prendra pas = 1 pour des raisons de simplicité de calcul.
Pour le reste c'est ici-bas

(codé avec les pieds mais bon... c'est compréhensible c'est le + important

)

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
 
reel coordX_1, coordX_2
reel coordZ_1, coordZ_2
reel inter_cam1, inter_cam2
 
coordX_1 = coord caméra en X arrondi à l'entier inférieur (car pas = 1)
coordX_2 = coord caméra en X arrondi à l'entier supérieur (car pas = 1)
 
coordZ_1 = coord caméra en Z arrondi à l'entier inférieur (car pas = 1)
coordZ_2 = coord caméra en Z arrondi à l'entier supérieur (car pas = 1)
 
inter_cam1 = hauteur terrain en (coordX_1 , coordZ_1 )
inter_cam2 = hauteur terrain en (coordX_2 , coordZ_2 )
 
nouvelles coord caméra en Y = ( inter_cam1 + inter_cam2 ) / 2 + marge
 
Updater la caméra

Avec tout ça j'espère que t'arriveras à résoudre ton problème

Remarque: c'est la première fois que je fais ça et j'y ai réfléchit que 5 minutes donc me crie pas dessus si ça bug

lol

++

**Ti-R** · 09/08/2006, 12h09

D'un côté les coordonnées de la cam x,y,z

De l'autre la map.

Il faut trouver sur quel triangle la camera se trouve.
Si on a les coordonnées des 3 sommets du triangle, c'est quasi fini, enfin pas tout à fait.

Tu calculs la distance entre ta caméra et chaque sommets.
Avec les 3 distances obtenus (d1,d2,d3), (qui nous permet la majoration de la coordonnée z en chaque sommet pour définir la coordonnée z de la caméra au final), tu calculs l'altitude local à ajouter à ta caméra.

z_camera = z_altitude_camera + (d1/(d1 + d2 + d3))*z_sommet1 + (d2/(d1 + d2 + d3))*z_sommet2 + (d3/(d1 + d2 + d3))*z_sommet3;

Bon si je ne me suis pas trompé, cela devrait fonctionner

**LapinGarou** · 09/08/2006, 16h01

Sixissor> j'ai un doute là : si je doit seulement prendre les 2 points les plus proches de la camera, c'est comme si mon perso se déplaçait sur la droite de ces deux points du coup, ça ne tient plus compte de l'altitude du 3eme point: du coup on se retrouve soit au dessus soit au dessous du sol. Je vais tester pour voir mais ça m'a l'air pas très glop

(surtout que je prévoie du multijoueurs)

Ti-R> Voilà ! tu as mis le doigt sur mon problème : Comment trouver le triangle ? si on est sur le supérieur, ou l'inférieur... il faudrait 4 test pour le savoir non ?

**Sixissor** · 09/08/2006, 17h06

Envoyé par LapinGarou

Sixissor> j'ai un doute là : si je doit seulement prendre les 2 points les plus proches de la camera, c'est comme si mon perso se déplaçait sur la droite de ces deux points du coup, ça ne tient plus compte de l'altitude du 3eme point: du coup on se retrouve soit au dessus soit au dessous du sol. Je vais tester pour voir mais ça m'a l'air pas très glop

(surtout que je prévoie du multijoueurs)

C'est vrai... J'étais pas réveillé on va dire

Mea Culpa.
Pratiquement hors-sujet...

Pour la caméra qui passe à travers le sol:
T'as une autre méthode, mais d'un horizon différent, et fonctionne très bien pour les pentes (je pense que c'était ton but non ? Vu que le reste n'est pas si compliqué...)
Modifier le plan de clipping, et le rapprocher au max de soi, tout en faisant gaffe qu'il soit différent de 0 (pour éviter les divisions par zéro).
S'il est de 0.1 par exemple, il faut une pente de 90% pour voir à travers (et encore). S'il est de 0.01, il faut une pente de 99% pour voir à travers...

Vérifie alors tes coordonnées de clipping

Normalement cette méthode marche très bien et finit les prises de tête

En ce qui concerne les déplacements fluides, au lieu d'ajouter le PAS d'un coup, essaie de lisser les mouvements. Va peut-être voir du côté de la fonctions carré ou des fonctions trigos...

++

**Ti-R** · 09/08/2006, 17h16

Dépend comment tu affiches ta "heightmap".
Si elle n’est pas déformée, (si tu considères un pas régulier en x et y pour séparer les vertex.)

X_hm et Y_hm représente les coordonnées les plus petites de ton "heightmap" en X et Y

X1 = ((X_cam-X_hm)/W_hm)*nb_pixel_x
Y1 = ((Y_cam-Y_hm)/H_hm) *nb_pixel_y

X1=20.64
Y1=12.89
Ensuite tu test si les coordonnées se trouve dans un des 2 triangles (0.64 et 0.89)
Si ce n’est pas le premier, c’est forcément le second et vice-versa.

J’ai trouvé ce code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
bool estDansTriangle(Point const & p, Triangle const & t)
{
    int const fAB = (p.y-t.sommets[0].y)*(t.sommets[1].x-t.sommets[0].x) - (p.x-t.sommets[0].x)*(t.sommets[1].y-t.sommets[0].y);
    int const fCA = (p.y-t.sommets[2].y)*(t.sommets[0].x-t.sommets[2].x) - (p.x-t.sommets[2].x)*(t.sommets[0].y-t.sommets[2].y);
    int const fBC = (p.y-t.sommets[1].y)*(t.sommets[2].x-t.sommets[1].x) - (p.x-t.sommets[1].x)*(t.sommets[2].y-t.sommets[1].y);
 
    return ( (fAB*fBC)>0 && (fBC*fCA)>0 );
}

https://dpt-info.u-strasbg.fr/~lamy/.../ihm/tp12.html

Donc tu auras tous les sommets de ton triangle.

**LapinGarou** · 16/08/2006, 18h56

Bon, je crois que j'ai trouvé comment faire... mais le fait de tester à chaque mouvement sur quel triangle on se trouve ne va t'il pas ramer si j'utilise l'algorithme ROAM qui utilise la tessellation et donc le nombre de triangles ?

**Ti-R** · 16/08/2006, 19h02

J'ai peut être mal compris... tu subdivises encore derrière ?
Sinon il n'y a que 2 triangles à tester. En fait 1 seul car, s’il n’est pas dans le premier, forcément, il est dans le second.

**LapinGarou** · 16/08/2006, 19h35

Non, pour l'instant je ne subdivise pas, pas de tessellation, mais la question est : comme avec ROAM, on a un facteur de subdivision, mon algo ne va pas un peu ramer à calculer à chaque fois l'equation du plan pour chaque boucle du programme? ou utiliser un espèce de callback, qui ne recalcule l'equation du plan que si on change de triangle.. (facile à dire, mais apres...

)

**Ti-R** · 16/08/2006, 19h48

La méthode expliquée ci-dessus est assez légère, tu peux reproduire le calcul pour chaque frame.

C'est de l'ordre de 20 multiplications en tout. Ou alors j'ai vraiment du mal ce soir...

Interpolation d'altitude sur un heightmap

Moteurs 3D

Discussions similaires

Partager

Partager