Le système solaire peut-il être représenté avec précision dans l'espace 3D à l'aide de doubles (ou longs)?

Je voudrais savoir comment gérer au mieux les coordonnées dans un jeu 3D dont le but est de modéliser de façon réaliste l'ensemble du système solaire, tout en étant capable de gérer les plus petits mouvements dans un "vaisseau" (c'est-à-dire: on peut peut-être considérer 1cm comme le plus petit mouvement acceptable pour un cadre). Les doubles 64 bits (ou longs 64 bits) prennent-ils en charge cela, ou rencontrons-nous des problèmes de débordement? Si ce n'est pas le cas, alors les longs ou les doubles devraient-ils être utilisés, ou si c'est le cas, quelle approche alternative pensez-vous la plus judicieuse pour modéliser les positions dans le système solaire dans un jeu 3D? (c.-à-d. en ne tenant qu'un peu du système à l'écran à un moment basé sur la distance à expédier, ou en ayant le système représenté d'une manière ou d'une autre dans un espace de coordonnées différent, etc.)

Il y a déjà une bonne réponse à propos des entiers, mais je pense que les virgules flottantes ne devraient pas être éliminées. Dans sa réponse, Byte56 a pris l'option d'opter pour l'orbite maximale de Pluton, probablement tirée de cette feuille Excel , donc je m'en tiendrai à cela.

Cela place les limites du système solaire à:

7,376,000,000 km = 7,376x10 ^ 9 km = 7,376x10 ^ 14 cm cm 7,4x10 ^ 14 cm

Le format à virgule flottante double précision offre une précision maximale de 15 décimales significatives. Vous avez donc de la chance: si votre origine est au centre du Soleil et que vous utilisez une position autour de Pluton, vous pouvez représenter tous les centimètres, par exemple en C ++:

printf("%.0Lf\n", 7.4e14);
printf("%.0Lf\n", 7.4e14 + 1.0);
printf("%.0Lf\n", 7.4e14 + 2.0);

Output:
-------
740000000000000
740000000000001
740000000000002

Donc, si vous pouvez limiter votre jeu à l'orbite de Pluton, alors félicitations! Vous avez juste assez de précision avec des doubles pour le représenter.

Attention cependant, cela suffit pour le représenter dans une simulation , mais ne vous attendez pas à rendre sans douleur. Vous devrez convertir en flottants 32 bits, peut-être changer votre origine pour obtenir suffisamment de précision sur les objets proches, et vous devrez probablement compter sur un tampon Z et une tromperie de tronc de caméra pour obtenir tout cela pour un rendu correct .

Maintenant, si vous voulez que vos astronautes visitent des comètes lointaines dans le nuage d'Oort , qui est bien plus grand, alors c'est fini. Vers 10 ^ 16 cm, vous commencez à perdre de la précision:

printf("%.0Lf\n", 1.0e16);
printf("%.0Lf\n", 1.0e16 + 1.0);
printf("%.0Lf\n", 1.0e16 + 2.0);

Output:
-------
10000000000000000
10000000000000000 <-- oops
10000000000000002

Et cela empire plus loin, bien sûr.

Donc, si vous êtes dans ce cas, vous voudrez peut-être essayer des solutions plus avancées. Je vous suggère de lire l'article de Peter Freeze dans Game Programming Gems 4: "2.3 Résolution des problèmes de précision dans les grandes coordonnées mondiales". IIRC, il suggère un système qui pourrait répondre à vos besoins, c'est en fait une sorte de multiples espaces de coordonnées différents.

Ce ne sont que quelques conseils, vous devrez probablement utiliser une de vos recettes pour que cela fonctionne. Quelqu'un qui a déjà implémenté ce genre de choses pourrait vous aider davantage. Pourquoi ne pas envoyer un e-mail aux gars derrière Kerbal Space Program par exemple?

Bonne chance avec votre jeu!

En supposant Pluton pour le «bord» du système solaire (bien que certains disent que c'est jusqu'à 3 années-lumière). Pluton, à son orbite maximale, est à environ 7 376 000 000 kilomètres du soleil. Cela représente 7,37600 × 10 ^ 14 centimètres. Doublez cela pour obtenir le diamètre et vous obtiendrez 1 475 200 000 000 000 centimètres. C'est bien dans la taille maximale d'un 64 bits de long. Puisque la hauteur du système solaire est négligeable par rapport à son diamètre, nous pouvons l'ignorer.

Alors oui, vous pouvez utiliser un long pour représenter votre position dans le système solaire. En fait, vous pourriez avoir des positions allant jusqu'à 9,75 années-lumière avec un long signé (double pour non signé).

Notez que ce n'est pas le cas pour trouver des distances. La distance maximale que vous pouvez trouver est la racine carrée de la distance maximale que vous pouvez parcourir. Cela peut être surmonté en utilisant un système de niveau de détail pour trouver les distances. Vous pouvez faire quelques vérifications simples pour deviner à quelle distance sont les distances (comparer leurs valeurs x et valeurs y), puis utiliser des incréments de 1 000 000 kilomètres pour les grandes distances jusqu'à des incréments en centimètres pour les petites distances.

Bien sûr, il y a la question de, voulez-vous vraiment? 99,999% du système solaire est un espace vide totalement inintéressant. Si vous représentez avec précision le système solaire, j'espère bien que vous ne représentez pas avec précision la physique. Il faut beaucoup de temps pour contourner le système solaire. Beaucoup trop de temps pour que la plupart des gens restent intéressés.

Et pourquoi avoir une précision aussi fine, à moins que vous ne modélisiez également les objets du système solaire avec cette précision? C'est là que vous aurez des ennuis. Le volume du soleil est de 1,40900 × 10 ^ 18 kilomètres cubes. À l'échelle du centimètre cube, l'utilisation d'un seul bit pour indiquer que cet espace est "occupé" occupe 1,4 × 10 ^ 33 bits ou 1,6 × 10 ^ 23 gigaoctets. Je pense que vous n'avez pas beaucoup de RAM.

Vous pouvez l'utiliser BigInteger, quel que soit votre langage de programmation. C'est un entier de taille illimitée; il évolue bien - généralement en utilisant le log(n)stockage pour un entier de taille n.

Java et C # l'ont; Je suis sûr que d'autres langues le font. Sinon, vous pouvez le décompiler et le réimplémenter sans trop de difficultés.