Génération d'univers, planètes et surfaces

Version imprimable

Voir 40 message(s) de cette discussion en une page

05/07/2011, 09h40
zuulcoder

Génération d'univers, planètes et surfaces

Bonjour,

J'ai développé en Delphi7 un logiciel de génération "d'univers".
J'entends par génération d'univers la création de systèmes stellaires, étoiles, planètes, satellites, etc.
Il y a grosso modo deux parties principales :
1) La création des systèmes stellaires
2) La génération de cartes pour chaque planète tellurique.

Quelques détails....

Galaxie / système stellaire :
- Génération d'une galaxie regroupant 'n' systèmes stellaires
- Chaque système contient un nombre varié d'étoiles, planètes et lunes.
- La génération d'univers est paramétrable. On peut créer un univers réaliste ou alors carrément "exotique".
- Chaque système peut-être visualisé en :
x 2D sur une coupe "transversale".
x 3D via OpenGL et Glut.

Planète :
- Chaque astre possède des caractéristiques qui lui sont propres et sont cohérentes avec l'ensemble des données du système (rayon, période de révolution, rotation, masse, atmosphère, albédo, composés atmosphériques, etc). Soit plus de 30 propriétés pour chaque planète / lune.
- Pour chaque astre (étoiles, planètes et lune) il est possible d'éditer certaines des propriétés physiques de celui-ci.
- J'ai également mis en place un éditeur de terrain pour les planètes telluriques.

Le projet est bouclé à 90% environ.
Je compte releaser le programme ici même quand il sera terminé histoire d'en faire profiter tout le monde.
L'ensemble des modules précités fonctionnent correctement, cependant je bloque sur quelques points bien précis.
J'ai besoin d'aide !

Problème n°1 :
Comment ajouter une atmosphère aux planètes via OpenGL et Glu ?
Toutes les recherches que j'ai faites m'orientent vers l'utilisation d'un "shade" (dégradé) entre la surface de la planète et l'espace. Mais je n'ai pas trouvé de routine en Delphi 7 ni même d'algo permettant de faire cela via OpenGL et Glut.

Problème n°2 :
Comment générer une carte "sphérique" avec l'algo du Diamond Square ?
C'est à dire, une carte où quand on dépasse le bord droit on revient sur le bord gauche avec bien sûr la continuité du relief (c'est là où je bloque).
Il semble que l'algorithme de Perlin puisse gérer ce cas. Je ne suis pas sûr que le Diamond Square permette de faire cela. Dois-je changer d'algo ?

Problème n°3 :
La génération de rivières.
Quel algorithme permet de générer des rivières sur l'ensemble de la carte ?
Le "post" d'anykeyh sur la génération procédurale de planètes (que je n'ai découvert qu'il y a 1 semaine) était un point de départ intéressant, mais les explications trop succinctes concernant la génération de rivières ne m'ont pas permis de mettre en place un algo qui génère des rivières réalistes.

Problème n°4 :
Comment compter le nombre de continents existant ?
Sachant que pour faire la différence entre un continent et une île c'est avant tout une question de taille.
Cela revient à déterminer les zones entourées d'eau dont la surface est supérieure à une valeur X.
Y a-t-il un algorithme pour cela ?

Voili voulou...

Je rajoute quelques screens du programme histoire que vous vous fassiez une idée de l'appli.

Ecran de paramétrage pour la génération d'univers :
http://imageshack.us/photo/my-images...gparamtres.jpg

Vue 2D du système:
http://imageshack.us/photo/my-images/221/vue2deteditionpropritsn.jpg

Vue 3D :
http://imageshack.us/photo/my-images...eanneaux03.jpg

Vue 3D :
http://imageshack.us/photo/my-images...raproche01.jpg

Vue 3D :
http://imageshack.us/photo/my-images...raproche02.jpg

Système solaire :
http://imageshack.us/photo/my-images...tmesolaire.jpg

Ecran de paramétrage pour la génération de map :
http://imageshack.us/photo/my-images/269/map00.jpg

Map :
http://imageshack.us/photo/my-images/219/map01w.jpg

Vue en fausses couleurs :
http://imageshack.us/photo/my-images/684/map04.jpg

Map :
http://imageshack.us/photo/my-images/52/map05l.jpg

Map :
http://imageshack.us/photo/my-images/804/map08.jpg

Relief fractal couplé à une onde sinusoïdale -> Génération d'atols.
http://imageshack.us/photo/my-images/231/map11.jpg
05/07/2011, 13h13
zuulcoder

C'est en utilisant la fonction "Recherche" que je suis tombé sur l'article en question. J'en parle d'ailleurs dans mon post en expliquant que c'est loin d'être clair.

Son post ne parle pas :
- De l'algo de génération d'une atmosphère
- De la méthode de calcul du nombre de continents

Il parle par contre de la continuité de la surface, et nous dit "un simple modulo suffit". Ok, je veux bien mais je trouve ça un peu succinct.
Il aborde également la génération des rivières, mais des "coquilles" se sont glissées dans le texte comme par exemple "nous prenons un point immergé de la carte au hasard". Il s'agit manifestement d'une erreur. Je pense qu'il voulait dire "émergé". Bref, je tentais de relancer la dynamique et de fouiller un peu plus ce sujet qui me passionne, d'où mon post afin de lever le voile sur les problèmes rencontrés.
06/07/2011, 00h24
pseudocode

Citation:

Envoyé par zuulcoder

Il parle par contre de la continuité de la surface, et nous dit "un simple modulo suffit". Ok, je veux bien mais je trouve ça un peu succinct.

Pourtant ca me parait clair.

Prenons un damier de taille W*H. Si on considère une continuité sphérique, la case (W,y) - donc la 1ere case en dehors du damier à droite - est équivalente à la case (0,y). Il s'agit donc bien d'un modulo.

(x , y) -- equivalent à --> (x%W, y%H)

Citation:

Il aborde également la génération des rivières, mais des "coquilles" se sont glissées dans le texte comme par exemple "nous prenons un point immergé de la carte au hasard". Il s'agit manifestement d'une erreur. Je pense qu'il voulait dire "émergé".

Oui, je pense que c'est un point "émergé", suivi d'une descente de gradient.

Citation:

Envoyé par pseudocode

Pourtant ca me parait clair.

Prenons un damier de taille W*H. Si on considère une continuité sphérique, la case (W,y) - donc la 1ere case en dehors du damier à droite - est équivalente à la case (0,y). Il s'agit donc bien d'un modulo.

(x , y) -- equivalent à --> (x%W, y%H)

Oui, je pense que c'est un point "émergé", suivi d'une descente de gradient.

Oui je sais bien ce qu'est un modulo, le soucis n'est pas là ;)
Le problème est : Comment intégrer cette notion de modulo dans l'algo du Diamond Square (si tant est que cela soit faisable) ?

L'algo que j'utilise est le suivant :
Il est linéarisé plutôt que récursif pour éviter d'avoir un stack overfloww sur de trop grosses matrices.

Code:

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
Procedure TMapGenerator.GenerateFractalLandscape;
Begin
  Lissage := fIndiceErraticite;
  unSpacing := fMapWidth - 1;
 
  fMatrixH[0,0]                 := Random(100);
  fMatrixH[0,unSpacing]         := Random(100);
  fMatrixH[unSpacing,0]         := Random(100);
  fMatrixH[unSpacing,unSpacing] := Random(100);
 
  While (unSpacing > 1) do Begin
    unHalfSpacing := unSpacing Div 2;
 
    // Make the Diamond Step...
    unI := unHalfSpacing;
    While unI < fMapWidth do Begin
      unJ := unHalfSpacing;
      While unJ < fMapWidth do Begin
        Hauteur := Round(DiamondStep(unI, unJ, unHalfSpacing) + (RandomizeSpe * unSpacing * Lissage));
        fMatrixH[unI,unJ] := Hauteur;
        unJ := unJ + unSpacing;
      End;
      unI := unI + unSpacing;
    End;
 
    // Make the Square Step...
    unI := 0;
    While unI < fMapWidth do Begin
		  If ((unI Div unHalfSpacing) Mod 2 = 0) Then unJ := unHalfSpacing Else unJ := 0;
      While unJ < fMapWidth do Begin
        Hauteur := Round(SquareStep(unI, unJ, unHalfSpacing ) + (RandomizeSpe * unSpacing * Lissage));
	fMatrixH[unI,unJ] := Hauteur;
        unJ := unJ + unSpacing;
      End;
      unI := unI + unHalfSpacing;
    End;
 
    // Divide the used map by 2...
    unSpacing := unHalfSpacing;
  End;
End;

Code:

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
Function TMapGenerator.DiamondStep(unI,unJ,unHalfSpacing:Integer):Extended;
    Var Sum :Real;
    N   :Integer;
Begin
  Sum := 0;
  N   := 0;
 
  If (unI >= unHalfSpacing) And (unJ >= unHalfSpacing) Then Begin
	  Sum := Sum + fMatrixH[unI - unHalfSpacing, unJ - unHalfSpacing];
	  Inc(N);
	End;
 
  If (unI >= unHalfSpacing) And (unJ + unHalfSpacing < fMapWidth) Then Begin
	  Sum := Sum + fMatrixH[unI - unHalfSpacing, unJ + unHalfSpacing];
	  Inc(N);
	End;
 
  If (unI + unHalfSpacing < fMapWidth) And (unJ >= unHalfSpacing) Then Begin
	  Sum := Sum + fMatrixH[unI + unHalfSpacing, unJ - unHalfSpacing];
	  Inc(N);
	End;
 
  If (unI + unHalfSpacing < fMapWidth) And (unJ + unHalfSpacing < fMapWidth) Then Begin
	  Sum := Sum + fMatrixH[unI + unHalfSpacing, unJ + unHalfSpacing];
	  Inc(N);
	End;
 
  Result := Sum / N;
End;

Code:

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
Function TMapGenerator.SquareStep(unI,unJ,unHalfSpacing:Integer):Extended;
    Var Sum :Real;
    N   :Integer;
Begin
  Sum := 0;
  N   := 0;
 
  If (unI >= unHalfSpacing) Then Begin
	  Sum := Sum + fMatrixH[unI - unHalfSpacing, unJ];
	  Inc(N);
	End;
 
  If (unI + unHalfSpacing < fMapWidth) Then Begin
	  Sum := Sum + fMatrixH[unI + unHalfSpacing, unJ];
	  Inc(N);
	End;
 
  If (unJ >= unHalfSpacing) Then Begin
	  Sum := Sum + fMatrixH[unI, unJ - unHalfSpacing];
	  Inc(N);
	End;
 
  If (unJ + unHalfSpacing < fMapWidth) Then Begin
	  Sum := Sum + fMatrixH[unI, unJ + unHalfSpacing];
	  Inc(N);
	End;
 
  Result := Sum / N;
End;

Actuellement la solution que j'ai tenté de mettre en place en faisant une jointure entre les hauteurs donne des résultats... comment dire... j'ai honte ! C'est nullissime !

http://imageshack.us/photo/my-images...882195095.jpg/

Concernant les rivières j'ai recodé un algo qui reprend la trame de celui proposé par Anykeyh.
Voilà ce que ça donne :

http://imageshack.us/photo/my-images/21/64165397.jpg

06/07/2011, 19h13
pseudocode

Citation:

Envoyé par zuulcoder

Oui je sais bien ce qu'est un modulo, le soucis n'est pas là ;)
Le problème est : Comment intégrer cette notion de modulo dans l'algo du Diamond Square (si tant est que cela soit faisable) ?

Plutot que de faire des tests conditionnels avant ton calcul

Code:

If (x+s < Width) Then Sum := Sum+matrix[x+s,y];

il suffit de faire tout le temps le calcul mais avec des modulos :

Code:

Sum := Sum+matrix[(x+s)%Width,y];

Idem pour les coordonnées en (x-s) sauf qu'il faut faire attention car le modulo informatique peut renvoyer des valeurs négatives, ce qui n'est pas bon pour les indices de tableaux. Comme on va faire un modulo, on peut ajouter une constante (= au modulo) pour éviter les valeurs négatives :

Code:

Sum := Sum+matrix[(x-s+Width)%Width,y];

PS: utilise les balises CODE (bouton #) quand tu postes du code. Ca colore tout seul et c'est plus lisible.

C'est noté pour les balises CODE. Merci du tuyau, c'est en effet beaucoup plus lisible.

J'ai implémenté les modifications dans le code (blocs ci-dessous). J'ai modifié les procédures SquareStep et DiamondStep, mais le résultat me semble étrange.
Il n'y a pas vraiment de continuité dans le terrain, mais plus une sorte de jointure ou de raccord. C'est en tout cas l'impression que cela donne visuellement. Ai-je fait quelque chose de travers ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 Function TMapGenerator.DiamondStep(X,Y,S:Integer):Extended; Var Sum :Real; N:Integer; Begin Sum := 0; Sum := Sum + fMatrixH[(X - S + fMapWidth) Mod fMapWidth, (Y - S + fMapHeight) Mod fMapHeight]; Sum := Sum + fMatrixH[(X - S + fMapWidth) Mod fMapWidth, (Y + S) Mod fMapHeight]; Sum := Sum + fMatrixH[(X + S) Mod fMapWidth, (Y - S + fMapHeight) Mod fMapHeight]; Sum := Sum + fMatrixH[(X + S) Mod fMapWidth, (Y + S) Mod fMapHeight]; Result := Sum / 4; End;
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 Function TMapGenerator.SquareStep(X,Y,S:Integer):Extended; Var Sum :Real; N:Integer; Begin Sum := 0; Sum := Sum + fMatrixH[(X - S + fMapWidth) Mod fMapWidth, Y]; Sum := Sum + fMatrixH[(X + S) Mod fMapWidth, Y]; Sum := Sum + fMatrixH[X, (Y - S + fMapHeight) Mod fMapHeight]; Sum := Sum + fMatrixH[X, (Y + S) Mod fMapHeight]; Result := Sum / 4; End;
Voila deux exemples de ce que cela donne :

http://imageshack.us/photo/my-images/135/4340.jpg/

http://imageshack.us/photo/my-images...617993877.jpg/

Pour l'algo des rivières j'ai un peu amélioré celui de Anykey.
Je stoppe la récursivité (en plus du cas classique d'arrivé à l'océan), quand je rencontre un fleuve déjà tracé. Cela renforce le visuel.

Exemple rivières en rouge et fleuves en bleu :

http://imageshack.us/photo/my-images...tfleuves2.jpg/

08/07/2011, 00h15
pseudocode

Citation:

Envoyé par zuulcoder

Il n'y a pas vraiment de continuité dans le terrain, mais plus une sorte de jointure ou de raccord. C'est en tout cas l'impression que cela donne visuellement. Ai-je fait quelque chose de travers ?

Je ne vois aucune continuité. Il doit effectivement y avoir un problème quelque-part. Peut-être au niveau de bornes de début/fin lors de ton parcours de la map.

Citation:

Envoyé par pseudocode

Je ne vois aucune continuité. Il doit effectivement y avoir un problème quelque-part. Peut-être au niveau de bornes de début/fin lors de ton parcours de la map.

Je parcours la map sur toute sa largeur / longueur (c'est un carré)
Faut t'il parcourir sur plus que la largeur de la carte ?

Code:

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
 
  unSpacing := fMapWidth - 1;
 
  // Tirage initial des hauteurs des 4 points de la carte
  fMatrixH[0,0]                 := Random(100);
  fMatrixH[0,unSpacing]         := Random(100);
  fMatrixH[unSpacing,0]         := Random(100);
  fMatrixH[unSpacing,unSpacing] := Random(100);
 
  While (unSpacing > 1) do Begin
	  unHalfSpacing := unSpacing Div 2;
 
	  // Make the Diamond Step...
    unI := unHalfSpacing;
    While unI < fMapWidth do Begin
      unJ := unHalfSpacing;
      While unJ < fMapWidth do Begin
        Hauteur := Round(DiamondStep(unI, unJ, unHalfSpacing) + (RandomizeSpe * unSpacing * Lissage));
        fMatrixH[unI,unJ] := Hauteur;
        unJ := unJ + unSpacing;
      End;
      unI := unI + unSpacing;
    End;
 
	  // Make the Square Step...
    unI := 0;
    While unI < fMapWidth do Begin
		  If ((unI Div unHalfSpacing) Mod 2 = 0) Then unJ := unHalfSpacing
                                         Else unJ := 0;
      While unJ < fMapWidth do Begin
        Hauteur := Round(SquareStep(unI, unJ, unHalfSpacing ) + (RandomizeSpe * unSpacing * Lissage));
			  fMatrixH[unI,unJ] := Hauteur;
        unJ := unJ + unSpacing;
      End;
      unI := unI + unHalfSpacing;
    End;
 
	  // Divide the used map by 2...
	  unSpacing := unHalfSpacing;
  End;

Citation:

Envoyé par zuulcoder

Je parcours la map sur toute sa largeur / longueur (c'est un carré)
Faut t'il parcourir sur plus que la largeur de la carte ?

Bah heu... Il faut parcourir tous les points qu'on doit calculer à chaque passe (cf ce lien)

http://www.gameprogrammer.com/fractal/dsa.gif
fig. a : carré de départ, les 4 coins sont connus
fig. b : on calcule le centre de chaque carré de taille 4
fig. c : on calcule le centre de chaque diamant de taille 4
(on divise le "pas" par 2, et on recommence)
fig. d : on calcule le centre de chaque carré de taille 2
fig. e : on calcule le centre de chaque diamant de taille 2

Exemple de ce que ca peut donner (j'ai codé vite fait en Java, mais je pense c'est assez proche de ton code)
Code:

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 int N=512; int[][] hmap = new int[N+1][N+1]; // initialize map hmap[0][0]=128; hmap[N][0]=128; hmap[N][N]=128; hmap[0][N]=128; int W=N, H=N; for(int step=N;step>=2;step=step/2) { int halfstep = step/2; // Square step for(int y=0;y<=H;y+=step) { for(int x=0;x<=W;x+=step) { int xm = x+halfstep, ym = y+halfstep; // mid-point of current square if (xm<=N && ym<=N) { int xn = (x+step)%(W); int yn = (y+step)%(H); int mean = (hmap[x][y]+hmap[xn][y]+hmap[xn][yn]+hmap[x][yn]+2)/4; hmap[xm][ym] = mean + random(); } } } // Diamond step for(int y=0;y<=H;y+=step) { for(int x=0;x<=W;x+=step) { int xm = x+halfstep, ym = y+halfstep; // mid-point of top diamond if (xm<=N) { int xn = (x+step)%(W); int mean = ( hmap[x][y] + hmap[xm][(ym-step+H)%H] + hmap[xn][y] + hmap[xm][ym%H] +2)/4; hmap[xm][y] = mean + random(); } // mid-point of left diamond if (ym<=N) { int yn = (y+step)%(H); int mean = ( hmap[x][y] + hmap[(xm-step+W)%W][ym] + hmap[x][yn] + hmap[xm%W][ym] +2)/4; hmap[x][ym] = mean + random(); } } } }

10/07/2011, 09h04
zuulcoder

Ok, je pense que je vais recoder entièrement l'algo en début de semaine.
Ce sera plus simple...

Yesssssss ! :ccool:

Un grand merci pour ton aide. Avec cet algo cela fonctionne.
J'ai par contre du changer les boucles For en boucles While, plus souples à utiliser sous Delphi.

J'ai deux questions par contre :
1) A quoi sert le + 2 qui est ajouté en fin de calcul sur le "Mean" avant de diviser par 4 ?

2) Il semblerait que les bordures de la carte ne soient pas prises en compte dans l'algo. Je m'en suis aperçu en décalant la carte pour centrer les continents. On voit dans ce cas apparaitre des lignes verticales et horizontales qui étaient les bordures droites et basses avant le décalage. Cela ne le faisait pas avec l'ancien algo. Une idée d'où cela peu provenir ?
Code:

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 Step := fMapWidth - 1; N := fMapWidth - 1; fMatrixH[0,0] := 128; fMatrixH[0,Step] := 128; fMatrixH[Step,0] := 128; fMatrixH[Step,Step] := 128; W := Step; H := Step; Step := N; While Step >= 2 do Begin Halfstep := Step Div 2; // Make the Square Step... Y := 0; While Y <= H do Begin X := 0; While X <= W do Begin XM := X + Halfstep; YM := Y + Halfstep; // Mid-point of current square If (XM <= N) And (YM <= N) Then Begin XN := (X + Step) Mod W; YN := (Y + Step) Mod W; Mean := (fMatrixH[X,Y] + fMatrixH[XN,Y] + fMatrixH[XN,YN] + fMatrixH[X,YN] + 2) / 4; fMatrixH[XM,YM] := Round(Mean + (RandomizeSpe * Step * Lissage)); End; X := X + Step; End; Y := Y + Step; End; // Make the Diamond Step... Y := 0; While Y <= H do Begin X := 0; While X <= W do Begin XM := X + HalfStep; YM := Y + HalfStep; // Mid-point of top diamond If (XM <= N) Then Begin XN := (X + Step) Mod W; Mean := (fMatrixH[X,Y] + fMatrixH[XM,(YM - Step + H) Mod H] + fMatrixH[XN,Y] + fMatrixH[XM,YM Mod H] + 2) / 4; fMatrixH[XM,Y] := Round(Mean + (RandomizeSpe * Step * Lissage)); End; // Mid-point of left diamond If (YM <= N) Then Begin YN := (Y + Step) Mod H; Mean := (fMatrixH[X,Y] + fMatrixH[(XM - Step + W) Mod W, YM] + fMatrixH[X,YN] + fMatrixH[XM Mod W,YM] + 2) / 4; fMatrixH[X,YM] := Round(Mean + (RandomizeSpe * Step * Lissage)); End; X := X + Step; End; Y := Y + Step; End; Step := Step Div 2; End;
Image sans décalage :
http://imageshack.us/photo/my-images...nsdcalage.jpg/

Images après un décalage de la matrice. On aperçoit une ligne horizontale et verticale centrées sur la petite ile en bas à droite. Ces deux lignes étaient les bordures de la carte avant le décalage, et les valeurs de hauteurs sont incohérentes sur ces lignes. Elle n'est pas été calculées semble t'il.
http://imageshack.us/photo/my-images/837/dcalage.png/

16/07/2011, 12h26
pseudocode

Citation:

Envoyé par zuulcoder

1) A quoi sert le + 2 qui est ajouté en fin de calcul sur le "Mean" avant de diviser par 4 ?

Ca sert à arrondir car je fais des calculs sur des entiers. Ca revient à ajouter "0.5" avant de faire la conversion en entier.

int mean = (int) ( (a+b+c+d)/4 + 0.5 )
int mean = (int) ( (a+b+c+d)/4 + 2/4 )
int mean = (int) ( (a+b+c+d+2)/4 )
int mean = (a+b+c+d+2)/4

Citation:

2) Il semblerait que les bordures de la carte ne soient pas prises en compte dans l'algo. Je m'en suis aperçu en décalant la carte pour centrer les continents. On voit dans ce cas apparaitre des lignes verticales et horizontales qui étaient les bordures droites et basses avant le décalage. Cela ne le faisait pas avec l'ancien algo. Une idée d'où cela peu provenir ?

Heu, non. La comme ca je ne vois pas pourquoi. Les deux codes ont l'air identiques. :koi:
18/07/2011, 09h51
zuulcoder

Bon je me suis débrouillé pour le problèmes des 2 lignes qui déconnes.
Je n'ai pas d'explication, si ce n'est que cela provient des premiers points calculés lors des premières itérations... Ce n'est pas bien grave de toute façon.

Par contre vaut t'il mieux utiliser pour générer un terrain l'ago du Diamond Square ou bien celui de perlin ? j'avoue que visuellement je ne vois pas de différences quant au résultat obtenu. L'un est t'il plus paramétrable que l'autre ? Y a t'il moyen avec le Diamond Square de faire en sorte qu'il y ait une plus grande homogénéité au niveau des pics ? Tel qu'il est codé là, on voit surtout 2 / 3 pics qui sortent du lot, pas plus.

Autre question : Quel algo utiliser pour compter / déterminer les continents ou iles ?
18/07/2011, 11h01
pseudocode

Citation:

Envoyé par zuulcoder

Par contre vaut t'il mieux utiliser pour générer un terrain l'ago du Diamond Square ou bien celui de perlin ? j'avoue que visuellement je ne vois pas de différences quant au résultat obtenu. L'un est t'il plus paramétrable que l'autre ? Y a t'il moyen avec le Diamond Square de faire en sorte qu'il y ait une plus grande homogénéité au niveau des pics ? Tel qu'il est codé là, on voit surtout 2 / 3 pics qui sortent du lot, pas plus.

Perlin génère un bruit aléatoire, ce n'est donc pas facilement contrôlable.

Le Diamond/Square modifie une grille de départ. C'est donc beaucoup plus simple de contrôler le résultat final.

Citation:

Autre question : Quel algo utiliser pour compter / déterminer les continents ou iles ?

Regarde du coté de l'ago Union/Find, dans la rubrique 'contribuez'.
18/07/2011, 11h38
zuulcoder

Citation:

Envoyé par pseudocode

Regarde du coté de l'ago Union/Find, dans la rubrique 'contribuez'.

En effet, l'algo Union/Find semble correspondre à ce que je cherche.
Je vais le convertir en Delphi et voir ce que ça donne. Merci du tuyau.

Encore une question (j'en profite ;) ) : La plupart des planètes telluriques sont criblées de cratères. Comment simuler ce type de surface ?
J'ai tenté de générer un cratère en 3D avec des fonctions du genre Cos(X²+Y²) / (1+X²+Y²) en prenant un range bien précis et en modifiant la valeur Z obtenue par la formule mais le résultat est loin d'être concluant.

Quelqu'un a déjà travaillé là dessus ?
18/07/2011, 11h48
souviron34

je ne travaille pas sur ce genre de choses, mais a priori une formule pour un cratère de rayon R et d'altitude Zmax à R me semblerait être du style :

Z(x,y) = Zmax * exp ( - (R-(x2+y2)) )

quiitte à ajouter une petite partie plus pentue de l'autre côté de R, non ?
19/07/2011, 16h58
zuulcoder

Citation:

Envoyé par souviron34

je ne travaille pas sur ce genre de choses, mais a priori une formule pour un cratère de rayon R et d'altitude Zmax à R me semblerait être du style :

Z(x,y) = Zmax * exp ( - (R-(x2+y2)) )

quiitte à ajouter une petite partie plus pentue de l'autre côté de R, non ?

Cela ressemble un peu à un panier dont on aurait surévelé les quatre bords.
J'ai utilisé la formule Z = 1 * exp (- (12-(x*x+y*y)) ) avec les ranges X,Y -3, +3.

http://imageshack.us/photo/my-images...mage1kfki.png/

Est-ce que finalement il ne faudrait pas plutôt utiliser une formule avec sin ou cos pour faire en sorte d'avoir un vrai dénivellé "montagneux" sur l'ensemble du cercle X,Y ?

Je me tate aussi pour utiliser la fonction Cos(X²+Y²) / (1+X²+Y²) et ne prendre que la partie qui donne la première "vague", virer le pic central, bref, modifier le résultat pour obtenir quelquechose qui se rapproche d'un cratère...
19/07/2011, 17h14
souviron34
D'une part je donnais ça comme indication seulement.. Il faudrait diminuer le coefficient (diviser par R ou R2 par exemple) pour que ce soit plus aplati..

Citation:

Envoyé par zuulcoder

Cela ressemble un peu à un panier dont on aurait surévelé les quatre bords.

Ben c'est bien la forme d'un cratère ;)

Citation:

Envoyé par zuulcoder

Est-ce que finalement il ne faudrait pas plutôt utiliser une formule avec sin ou cos pour faire en sorte d'avoir un vrai dénivellé "montagneux" sur l'ensemble du cercle X,Y ?

Ben tu peux, mais si tu regardes les cratères, il y en a 2 sortes :
- les cratères météoritiques : circulaires, avec pente forte de chaque côté du cercle, et éventuellement un ou 2 cercles de "vagues" concentriques de plus faible amplitude..
- les cratères volcaniques : en général à base sphérique, mais de forme conique tronquée, aussi bien intérieur qu'extérieur.
La formule que je donnais (en ajustant le coeff) te donnerait les cratères météoritiques (que tu peux compléter par un ou 2 "petits" cratères concentriques par exemple d'aititude Zmax/10 et ZMax/20 à R/2 et R/10)

Les formules pour les cratères volcaniques sont plus "simples" : un cercle pour la crète à Zmax. Un cercle intérieur a par exemple ZMax*0.9 et R=0.9, un cercle extérieur a ZMax/10 et R=10, avec interpolation linéaire entre chacun des cercles..
29/07/2011, 15h26
zuulcoder
Citation:
Envoyé par souviron34

D'une part je donnais ça comme indication seulement.. Il faudrait diminuer le coefficient (diviser par R ou R2 par exemple) pour que ce soit plus aplati..

Ben c'est bien la forme d'un cratère ;)
Ben tu peux, mais si tu regardes les cratères, il y en a 2 sortes :

les cratères météoritiques : circulaires, avec pente forte de chaque côté du cercle, et éventuellement un ou 2 cercles de "vagues" concentriques de plus faible amplitude..
les cratères volcaniques : en général à base sphérique, mais de forme conique tronquée, aussi bien intérieur qu'extérieur.

La formule que je donnais (en ajustant le coeff) te donnerait les cratères météoritiques (que tu peux compléter par un ou 2 "petits" cratères concentriques par exemple d'aititude Zmax/10 et ZMax/20 à R/2 et R/10)

Les formules pour les cratères volcaniques sont plus "simples" : un cercle pour la crète à Zmax. Un cercle intérieur a par exemple ZMax*0.9 et R=0.9, un cercle extérieur a ZMax/10 et R=10, avec interpolation linéaire entre chacun des cercles..
Bon j'ai implémenté quelques chose qui ressemble plus ou moins à des cratères. C'est pas la panacée mais j'ai du mal à obtenir quelque chose de plus "réaliste" en incrustant les cratères sur une carte préexistante.

le soucis vient aussi du mode de représentation. Les altitudes sont représentées par un dégradé de couleurs alors que dans la réalité les cratères que vous observons sont généralement ombrés, ce qui donne le relief que l'on ne voit pas sur ma carte.

Y a t'il moyen de faire une projection d'ombre sur une matrice 2D de hauteurs histoire de donner un peu de relief ?

http://imageshack.us/photo/my-images/14/image1cc.png/

http://imageshack.us/photo/my-images/64/cratres02.png/
29/07/2011, 15h37
pseudocode

Citation:

Envoyé par zuulcoder

Y a t'il moyen de faire une projection d'ombre sur une matrice 2D de hauteurs histoire de donner un peu de relief ?

Déjà, on peut utiliser des techniques d'ombrage (shading) usuelles, comme le "gouraud shading" (pour simuler une source lumineuse). Connaissant la carte 2D, il est possible d'estimer la normale en chaque point et ainsi obtenir des effets d'ombre/lumière

Ensuite, il y a des techniques plus poussées pour amplifier le réalisme comme le "bump mapping" et l' "occlusion mapping".

Voir 40 message(s) de cette discussion en une page