Discussion :

[aimad41]

Bonjour,

Je suis sur la créa d'un globe webgl en utilisant Three.js, je rencontre des difficultés pour creer les pays sous forme de Mesh, j'ai du oublier un détail qui fera certainement la différence, j'arrive à créer un simple globe avec une texture maintenant j'aimerai créer des pays pour intéragir...

Voici un morceau de code (le principal), pour le moment niveau rendu, j'ai des points de couleurs hazardeux qui apparaissent sur ma sphére..

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
,
  latLongToVector3:function(lat,lon,r,h){
    var phi = (lat)*Math.PI/180;
    var theta = (lon-180)*Math.PI/180;
    var x = -(r+h) * Math.cos(phi) * Math.cos(theta);
    var y = (r+h) * Math.sin(phi);
    var z = (r+h) * Math.cos(phi) * Math.sin(theta);   
    return new THREE.Vector3(x,y,z);
  },
  clearScene: function(){
   for(i=0;i<this.group-1;i++)
     this.renderer.deallocateObject(this.group[i]);
  },
  addBoundaries: function(){
    this.landsGeometries = [];
    webgl.prototype.countriesGeo.forEach(function(c){
      var geometry = new THREE.Geometry();
      geometry.name = c.name;
      c.borders.forEach(function(c){
        c.forEach(function(c){
         geometry.vertices.push(self.latLongToVector3(c.lat, c.lng, 600, 2));
       });
      geometry.faces.push(new THREE.Face3(0, 1, 2));
      geometry.mergeVertices();
      geometry.computeBoundingSphere();
      self.landsGeometries.push(geometry);
      self.scene.add(new THREE.Mesh(geometry));
      })
    });
 
  },
  testGlobe: function(){
    var geometry = new THREE.SphereGeometry(600,32,32);
    var material = new THREE.MeshPhongMaterial({
                    wireframe:true,color:0xffffff});
    this.globe = new THREE.Mesh(geometry,material);
 
    this.scene.add(this.globe);
    this.addLights();
  },
  addEarth: function(){
    this.addBoundaries();
    this.scene.add(this.group);
    this.render(function(m,o){
       var timer = Date.now() * 0.0001;
       o.light.position = o.camera.position;
       m.rotation.y += (o.tRotation - m.rotation.y)* 0.05;
       //o.clouds.rotation.z+=0.00015;
      },self.globe);
  }

Un exemple de l'array Countries:

Code :

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

{code:"LU", name:"Luxembourg", borders:[[[6.04305983,50.12805176],[6.24272013,49.90224075],[6.18628979,49.46382904],[5.89773989,49.44268036],[5.67404985,49.52947998],[5.78239012,50.09032822],[6.04305983,50.12805176],[6.04305983,50.12805176]]]}

j'ai pas eu le temps de me familiariser avec l'API native.

Coté traitement: Recup positions latitude, longtitude, conversion vers un vecteur 3 dimensions, injection du vecteur dans la geometry du pays concerné, création de Mesh avec la geometry correspondante .

[c.aug]

Le point dur dans ton programme c'est trianguler un polygone concave. Ca n'est pas une opération simple... c'est pas sûr que ta lib le fasse facilement et sans accrocs. Faudrait regarder quel algorithme Three.js utilise pour ça.

[LittleWhite]

Bonjour,

Pourquoi vouloir faire les pays sous forme de mesh ? Une texture, un bump mapping ou un displacement mapping ne suffit t-il pas ?
Si c'est pour une histoire de clic, si vous vous débrouillez à transformer le point cliquer en point sur la sphère, vous avez réussi et vous n'aurez toujours pas besoin de mesh.

[p3ga5e]

Salut aimad41 !

Avant de comprendre la 3D il te faut comprendre comment fonctionne le processus de rastérisation d’une carte graphique par un pipeline programmable (vertex et pixel shader).

Rien ne t’impose de travailler à partir de coordonnées 3D cartésiennes orthogonales tu peux utiliser directement tes coordonnées sphériques (latitude et longitude) avec ta carte graphique en utilisant un vertex shader dédié.

J’avais réalisé un POC permettant la rastérisation de carte marine vectoriel avec WebGL ici, la prise en charge du zoom dans mon vertex shader est bogué.
Le voici quand même :

Code GLSL :

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
#define RADIUS 111319.49079327357264771338267056
#define PI 3.1415926535897932384626433832795
#define RAD2DEG 57.295779513082320876798154814105
attribute vec2 Vertex;
uniform float MetersPerPixel;
uniform vec2 Center;
uniform vec2 OffCenter;
uniform vec2 HalfScreenSize;
 
void main(void) 
{
	vec2 ps = vec2((Center.x - Vertex.x) * cos(Center.y/RAD2DEG + PI) * RADIUS / MetersPerPixel,
				   (Vertex.y - Center.y)* RADIUS / MetersPerPixel);
	gl_Position.x = (ps.x + OffCenter.x)/ HalfScreenSize.x;
	gl_Position.y = (ps.y + OffCenter.y)/ HalfScreenSize.y;
	gl_Position.z = 0.0;
	gl_Position.w = 1.0; 
}

La définition géométrique de mes polygones sont les suivantes tous d’abord un énorme Vertex buffer regroupant tous mes sommets (coordonnées lat et long). Et ensuite une collection polygones comme ceci :

Code JSON :

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
[ {
		Polygons : [
			{
				Stroke : [190, 191, 192, 193, 194, 195, 196, 197],
				Fill : [190, 197, 196, 196, 195, 194, 193, 192, 191, 191, 190, 196, 196, 194, 193, 193, 191, 196]
			}
		]
	},
	{	
		Polygons : [
			{
				Stroke : [198, 199, 200, 201],
				Fill : [198, 201, 200, 200, 199, 198]
			}
		]
	},
	...
]

Mes polygones contiennent 2 Index Buffer :

• Stroke : contenant les indices de mes sommets et définissant le contour de mon polygone
• Fill : contenant la séquence d’indices de mon polygone triangulé.

Le tous rendu comme ceci :

Code JavaScript :

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
var poly = Polygons[i];
if(poly.Fill)
{
	if(!poly.FillBuffer)
	{
		poly.FillBuffer = gl.createBuffer();
		gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, poly.FillBuffer);
		gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(poly.Fill), gl.STATIC_DRAW);  
	}
	else
		gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, poly.FillBuffer);
 
	gl.drawElements(gl.TRIANGLES, poly.Fill.length, gl.UNSIGNED_SHORT, 0); 
}
 
if(poly.Stroke)
{
	if(!poly.StrokeBuffer)
	{
		poly.StrokeBuffer = gl.createBuffer();
		gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, poly.StrokeBuffer);
		gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(poly.Stroke), gl.STATIC_DRAW);  
	}
	else
		gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, poly.StrokeBuffer);
 
	gl.drawElements(gl.LINE_LOOP, poly.Stroke.length, gl.UNSIGNED_SHORT, 0); 
}

Je n’ai pas trouvé de moyen de trianguler dans le pipeline de rendu avec WebGL, si une solution existe je suis preneur. J’ai donc triangulé mes polygones en utilisant un outil en C# :

Code C# :

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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
public static class Triangulate
{
	static public List<uint> ProcessIndex(List<Vector> contour)
	{
		int n = contour.Count;
		if (n < 3)
			throw new Exception("[Triangulate::ProcessIndex] ERROR - vertex count <3 !");
		else if (n == 3) 
			return new List<uint>(new uint[] { 0, 1, 2});
 
		int[] V = new int[n];
 
		/* we want a counter-clockwise polygon in V */
 
		if (0.0 < Area(contour))
			for (int v = 0; v < n; v++) V[v] = v;
		else
			for (int v = 0; v < n; v++) V[v] = (n - 1) - v;
 
		int nv = n;
 
		/*  remove nv-2 Vertices, creating 1 triangle every time */
		int count = 2 * nv;   /* error detection */
		List<uint> result = new List<uint>(count);
		for (int m = 0, v = nv - 1; nv > 2; )
		{
			/* if we loop, it is probably a non-simple polygon */
			if (0 >= (count--))
			{
				throw new Exception("[Triangulate::ProcessIndex] ERROR - probable bad polygon!");
 
			}
 
			/* three consecutive vertices in current polygon, <u,v,w> */
			int u = v; if (nv <= u) u = 0;     /* previous */
			v = u + 1; if (nv <= v) v = 0;     /* new v    */
			int w = v + 1; if (nv <= w) w = 0;     /* next     */
 
			if (Snip(contour, u, v, w, nv, V))
			{
				int a, b, c, s, t;
 
				/* true names of the vertices */
				a = V[u]; b = V[v]; c = V[w];
 
				/* output Triangle */
				result.Add((uint)a);
				result.Add((uint)b);
				result.Add((uint)c);
 
				m++;
 
				/* remove v from remaining polygon */
				for (s = v, t = v + 1; t < nv; s++, t++) V[s] = V[t]; nv--;
 
				/* resest error detection counter */
				count = 2 * nv;
			}
		}
		return result;
 
	}
 
	// compute area of a contour/polygon
	static double Area(List<Vector> contour)
	{
		int n = contour.Count;
 
		double A = 0.0f;
 
		for (int p = n - 1, q = 0; q < n; p = q++)
		{
			A += contour[p].x * contour[q].y - contour[q].x * contour[p].y;
		}
		return A * 0.5f;
	}
 
	/*
	 InsideTriangle decides if a point P is Inside of the triangle
	 defined by A, B, C.
	 */
	static bool InsideTriangle( double Ax, double Ay,
								double Bx, double By,
								double Cx, double Cy,
								double Px, double Py)
 
	{
		double ax, ay, bx, by, cx, cy, apx, apy, bpx, bpy, cpx, cpy;
		double cCROSSap, bCROSScp, aCROSSbp;
 
		ax = Cx - Bx;  ay = Cy - By;
		bx = Ax - Cx;  by = Ay - Cy;
		cx = Bx - Ax;  cy = By - Ay;
		apx= Px - Ax;  apy= Py - Ay;
		bpx= Px - Bx;  bpy= Py - By;
		cpx= Px - Cx;  cpy= Py - Cy;
 
		aCROSSbp = ax*bpy - ay*bpx;
		cCROSSap = cx*apy - cy*apx;
		bCROSScp = bx*cpy - by*cpx;
 
		return ((aCROSSbp >= 0.0f) && (bCROSScp >= 0.0f) && (cCROSSap >= 0.0f));
	}
 
	static bool Snip(List<Vector> contour,int u,int v,int w,int n,int[] V)
	{
		int p;
		double Ax, Ay, Bx, By, Cx, Cy, Px, Py;
 
		Ax = contour[V[u]].x;
		Ay = contour[V[u]].y;
 
		Bx = contour[V[v]].x;
		By = contour[V[v]].y;
 
		Cx = contour[V[w]].x;
		Cy = contour[V[w]].y;
 
		if (Constants.Epsilon > (((Bx - Ax) * (Cy - Ay)) - ((By - Ay) * (Cx - Ax)))) return false;
 
		for (p = 0; p < n; p++)
		{
			if ((p == u) || (p == v) || (p == w)) continue;
			Px = contour[V[p]].x;
			Py = contour[V[p]].y;
			if (InsideTriangle(Ax, Ay, Bx, By, Cx, Cy, Px, Py)) return false;
		}
 
		return true;
	}
 
}

[aimad41]

Je vais arrêter de poster sur Stackoverflow, vous êtes bien plus réactif ici

Un plaisir de vous lire Messieurs !

Alors pour vous répondre, je me forme encore aujourd'hui au techniques de rendu et process GPU, rasterization ect... je veux tout comprendre donc c'est un peu long

Une mesh pour pouvoir bosser avec plus tard, pouvoir manipuler mon object ect... incluant forcement un clic sur un pays et changement de couleur au clic ect....

Je vais me rapprocher de la dernière réponse, qui m'as l'air vraiment intéressante, je peaufine ça quand je rentre du boulot

Merci pour l'intérêt porté aux problèmes !

@LittleWhite Ta réponse est intéressante, question perf coté fonctionnel pas sûre, mais je vais réfléchir à cette idée, ce qui m'importe c'est vraiment d'avoir un rendu avec le plus de détails possible niveau territoire (frontières, au survol highlight le pays ect..)

@p3ga5e Génial ! Vraiment top ! Je check ça ce soir, jte donne mes retours assez fast, mais je vais prendre le temps de bien comprendre les vertex shaders et fragment shader ! Super le rendu en tout cas !

[LittleWhite]

Le niveau de détails dépendra de la texture ou de l’application des textures
Pour le moment, je ne vois pas pourquoi faire des mesh et si jamais vous maintenanez cette idée, quelle sera la taille mémoire des mesh de tous les pays à une certaine échelle ?

[aimad41]

Le niveau de détails dépendra de la texture ou de l’application des textures
Pour le moment, je ne vois pas pourquoi faire des mesh et si jamais vous maintenanez cette idée, quelle sera la taille mémoire des mesh de tous les pays à une certaine échelle ?

Certes, mais comment faire pour voir les différentes frontières ? Comment faire pour changer la couleur d'un pays au survol en passant par les textures ? sans coordonnées ? Tu dois avoir une vision plus globale que moi si tu peux développer ce serait top .

1) Bump mapping ok pour le relief !
2) Textures déjà appliqué de 8k fonction zoom limité toutefois, je vais rajouter du bruit sur la texture plus tard mais frontiéres inexistantes, pas top.

[LittleWhite]

Alors, oui, on peut faire plusieurs choses, mais je vais ne parler que d'une solution (car je ne suis pas encore certains pour les autres).

Déjà, il faut utiliser plusieurs textures :

• la texture graphique pour les couleurs de la planètes
• la normal map pour le bump mapping
• une texture des frontières
• une texture des pays (chaque pays à une couleur unique associée)

Les deux premières, je suis certains que vous avez déjà compris.
La troisième permet un overlay sur votre planète pour faire un rendu prononcé des frontières (elle n'est pas obligatoire).
La quatrième permet de détecter sur quel pays nous nous trouvons. En fait, selon la couleur du pixel sur lequel le curseur se trouve, nous pourrons déterminer le pays ciblé.
Pour que cela fonctionne, on peut imaginer faire un FBO, dans lequel le rendu de la planète est effectué, mais uniquement avec cette texture et donc, uniquement pour faire les tests. Cette passe n'est jamais affiché à l'écran.
La seconde passe, permet d'afficher réellement la planète comme vous le faites actuellement.

Finalement, pour le zoom, je propose de mettre un algorithme intélligent (il doit y avoir des ressources sur internet pour cela, sinon : Google Scholar). Le truc, c'est que plus vous zoomer et plus vous chargez une texture différente mais plus précise. Vous aurez donc des textures avec plusieurs niveaux de détails que vous allez alterner sur la planète.

J'espère que cela est un peu plus clair, peut-être que je suis un peu rapide

[aimad41]

Sur le principe j'ai compris, aprés pour appliquer un long périple m'attend

Je vais essayer de compiler tout ça, je reviens vers vous ce week end probablement, merci encore vraiment !

[p3ga5e]

Pourquoi tout le monde sur ce forum préfèrent se compliquer la vie à utiliser des ressources et model de données de type raster ? L’accélération matérielle des cartes graphique ne se limite pas au blitting et blending d’images raster, leur fonctionnement inclut une phase de traitements géométriques programmables par les vertex shaders qui travaillent sur des données vectorielles en entrées et non de type raster.

Tu es programmeur graphiste et tu n’utilises pas le vertex shader ! Non mais allo quoi !

aimad41 , tu disposes d’une définition de tes frontières pays en vectoriel ! Et c’est une bonne chose ! Tu peux, d’un point de vue métier, calculer l’intersection d’une intrusion, chose plus difficile à partir d’une donnée raster… de plus les données vectoriel sont moins coûteuse en espace mémoire sur la RAM et la VRAM

Les techniques décrite par LittleWhite ne sont pas mauvaises, je conteste uniquement l’utilisation d’un texture pour les frontières pays . La rastérisation de données vectoriel se doit d’etre effectué par les cartes graphique, c’est même leurs jobs … ceux pourquoi elles ont été conçues !

[c.aug]

Trianguler une carte c'est une opération qui pompe un max de calculs, tu ne peux pas le faire décemment au runtime.

Il faut le précalculer, et il y'a des logiciels 3d qui font ça très bien.

[aimad41]

J'ai compris le principe de triangulation ainsi que le clockwise, puisque mon jeu de donnée n'est pas ordonnée de base, j'ai egalement essayer de trianguler des polygones avec les données openstreetmap mais sans succés three.js atteint clairement ces limites, du coup je me rapproche de plus en plus au natif, aussi si vous avez quelconque ressource, extrait de code, data ordonnée et triangulé (je rêve un peu), des tutoriels je suis preneur.

Merci à vous encore !

[p3ga5e]

mon jeu de donnée n'est pas ordonnée de base

Pour définir un polygone, une collection de sommets n’est pas suffisant, un ordre est obligatoirement nécessaire pour définir l’adjacence des sommets et des arêtes.

j'ai également essayer de trianguler des polygones avec les données openstreetmap mais sans succés

As-tu testé la class C# que j’ai posté plus haut ?

du coup je me rapproche de plus en plus au natif

Qu’entends-tu par natif ?

si vous avez quelconque ressource, extrait de code, data ordonnée et triangulé (je rêve un peu), des tutoriels je suis preneur.

Pour les ressources on travaille beaucoup avec le SDK OGR, tu peux trouver un outils précompilé ogr2ogr qui permet de convertir de nombreux formats de carte vectoriel, bien que non documenter sur cette page , l’outil permet d’exporter en JSON

[aimad41]

Hello there !

Alors j'avance doucement, j'ai déjà su tracer les frontières (LINE, LINE_STRIP ), merci http://www.naturalearthdata.com/down...n-0-countries/ en gros, je plug un fichier shape contenant toutes mes données non ordonnée je présume (j'imagine pouvoir le parser plus tard en python surement).

J'ai bien compris le clockwise oui d'ou ma problématique, si j'ai bien tout compris, je peux trianguler mes polygones avec le fichier shape (TRIANGLE)? J'ai trouvé une source en C (qui ressemble beaucoup à ton code source, je tourne sur du linux et mono pas installé) du coup je vais me lancer ce soir, l'avantage de mon fichier et que je n'ai pas de trou sur mes lignes (holes).

Si tu peux me confirmer

Après ça je serais capable de construire mes mesh avec mes 256 polygones ? j'ai peur que ça explose niveau perf, puis enfin pouvoir remplir ces fameux polygones avec une couleur au survol souris?

J'ai abandonné le fait de mettre une texture frontière ect... c'est pas vraiment ce qui m’intéresse ici finalement..

ps:natif => sans Three js mais globalement je peux continuer à m'en servir, la couche native reste aisément accessible

[p3ga5e]

Si tu effectues la transformation de coordonnées sphériques en coordonnées cartésiennes sur le vertex shader, alors tu n’auras pas a t’inquiter des perfs.

Par contre, Si tu rends tes frontières avec une primitive LINE, tu ne dois pas trianguler, c’est pourquoi dans mon exemple que j’ai posté plus haut j’utilise 2 IndexBuffer par polygone, l’un pour dessiner le contour avec la primitive LINE_LOOP et l’autre, qui la séquence trianguler, pour mon polygone avec TRANGLE.

[aimad41]

J'ai mis en suspend mes polygones, je me suis concentré sur les perfs sur le draw de mes lines (Line_STRIP), mon soucis c'est que je dessine chaque frontiére de mes pays par itération ce qui implique une création de buffer pour chaque pays * 3 (color,index,vertexdata) j'arrive à environ 650 buffers pour un traçage de frontiére pas top , du coup je me suis interrogé ! ça m'arrive oui

J'ai donc choisit de fuisionner toutes mes lignes sur un type geometrique, mais ça part dans tout les sens , l'afrique rejoins le japon par exemple, j'ai donc analysé comment fonctionne le draw des primitives LINE, et j'ai essayé de faire une boucle sur sur GL_LINE par morceau donc:

indices de mon array : 0,1 1,2 2,3 3,4 (je repére l'indice pair dans le second ect...) mais non toujours pas...

J'aimerai savoir s'il existe une methode permettant de fusionner plusieurs boucles de lines dans un buffer ? Coté perf +600% mémoire, un calcul index au runtime pas gourmand, clairement pas photo, ce doit être forcement possible ?

Une sorte d'insertion de vertex null pour dire au GPU attention autre boucle, ce vertex tu l'ignores ? une sorte de chunk data

[aimad41]

Ok, alors après plusieurs recherches, j'ai donc évolué vers une direction moins gourmande :

- Draw all primitive LINE by a single call (évitant ainsi de devoir faire 256 call pour des polylines)
- Draw all primitive TRIANGLE by a single call with indexed elements, generate by the triangulation process(même principe)

Pour cela, 2 possibilités, soit en utlisant un gros VAO indexé, soit en utilisant la fonction primitive restart (pointeur restart index)

Ma question est la suivante, est'il possible d'utiliser tel technique en Webgl (pour le single VAO indexed ok, mais la primitive restart ?)

[p3ga5e]

Les VAO ne sont pas disponible en WebGL, de plus cette technique ne réduit pas le nombre de buffer.

J'ai mis en suspend mes polygones, je me suis concentré sur les perfs sur le draw de mes lines (Line_STRIP), mon soucis c'est que je dessine chaque frontiére de mes pays par itération ce qui implique une création de buffer pour chaque pays * 3 (color,index,vertexdata) j'arrive à environ 650 buffers pour un traçage de frontiére pas top , du coup je me suis interrogé ! ça m'arrive oui

Pourquoi 3 buffers par pays ? Tous d’abord la couleur, si cette couleur est invariant sur le traçage d’une frontières alors pas besoin d’un buffer dédié (car une seul valeur) cela doit être déclaré par un simple uniform dans tes shaders.

Ensuite, si tu choisi d’utiliser un vertex buffer par pays et que tu l’ordonne correctement, alors pour tracer le contour du polygone avec la primitive LINE_LOOP ou LINE_STRIP, tu n’es pas obliger d’utiliser un buffer d’indices, en utilisant la fonction drawArrays a la place drawElements.

Comme les pays ont des sommets et segments en commun, l’autre choix et d’utiliser un et un seul buffer pour tous les sommets et d’utiliser un buffer d’indices par pays. Je ne sais pas si cette solution est plus optimisée que la soluce : vertex buffer par pays, mais elle consomme moins en VRAM (en nombre de buffer et en taille).

Pour moi le volume de 650 buffers alloués en VRAM ne me choque pas. As-tu peur d’etre limite en VRAM ?

[aimad41]

Hello,

Merci pour ta réponse, alors oui en effet je préfère de loin la 2 éme solution pour la simple raison que j'ai besoin de le faire tourner sur du laptop genre netbook avec un chipset d’après guerre et une mémoire partagé, j'essaie de trouver quelques tricks pour diminuer la consommation mémoire, je vais étudier donc cela..

[aimad41]

Bonjour !

Voilà les news, j'ai réussis après acharnement à comprendre les différents stades de transformation (primitive assembly et rasterization) mais surtout process de tesselation incluant triangulation delaunay

Merci à vous pour les idées changées, j'ai beaucoup appris ici..




Pour ceux que ça intéressent il me reste des choses à faire encore:

- Merging des # mesh pour ne faire qu'un seul appel drawElements
- Artifacts résolution (z-fighting je présume?)
- Récupérer la position de la souris au clic et transformer ce point avec notre echelle (lat, lon clic)
- Generer un bruit (Bruit de perlin?) pour les textures (terrain)