¿Se puede representar con precisión el sistema solar en el espacio 3D usando dobles (o largos)?

Me gustaría saber cómo manejar mejor las coordenadas en un juego 3D cuyo objetivo es modelar de manera realista todo el sistema solar, pero ser capaz de manejar los movimientos más pequeños en un "barco" (es decir: tal vez podamos considerar que 1 cm es el más pequeño movimiento aceptable para un marco). ¿Soportan esto los dobles de 64 bits (o los largos de 64 bits) o tenemos problemas de desbordamiento? Si no es así, entonces se deben usar largos o dobles, o si es así, ¿qué enfoque alternativo crees que es el más adecuado para modelar posiciones en el sistema solar en un juego 3D? (es decir: solo mantener un poco del sistema en la pantalla a la vez en función de la distancia a la que se envía, o tener el sistema representado de alguna manera en un espacio de coordenadas diferente, etc.)

Ya hay una buena respuesta sobre los enteros, pero siento que los puntos flotantes no deberían eliminarse. En su respuesta, Byte56 tomó la opción de ir a la órbita máxima de Plutón, probablemente tomada de esta hoja de Excel , así que me quedaré con eso.

Eso coloca los límites del sistema solar en:

7,376,000,000 km = 7.376x10 ^ 9 km = 7.376x10 ^ 14 cm ≈ 7.4x10 ^ 14 cm

El formato de coma flotante de doble precisión ofrece una precisión máxima de 15 decimales significativos. Así que tienes suerte: si tu origen está en el centro del Sol y usas una posición alrededor de Plutón, puedes representar todos los centímetros, por ejemplo, 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

Entonces, si puedes limitar tu juego a la órbita de Plutón, ¡felicidades! Tienes la precisión suficiente con dobles para representarlo.

Sin embargo, tenga cuidado, eso es suficiente para representarlo en una simulación , pero no espere renderizar esto sin dolor. Tendrá que convertir a flotadores de 32 bits, tal vez cambie su origen para obtener suficiente precisión en los objetos cercanos, y probablemente tendrá que confiar en algunos trucos Z-buffer y trucos de cámara para obtener todo esto para renderizar correctamente .

Ahora, si quieres que tus astronautas visiten algunos cometas lejanos en la nube de Oort , que es mucho más grande, entonces se acabó. Alrededor de 10 ^ 16 cm, comienza a perder precisión:

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

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

Y empeora aún más, por supuesto.

Entonces, si está en este caso, es posible que desee probar algunas soluciones más avanzadas. Le sugiero que eche un vistazo al artículo de Peter Freeze en Game Programming Gems 4: "2.3 Resolución de problemas de precisión en grandes coordenadas mundiales". IIRC, sugirió un sistema que podría adaptarse a sus necesidades, de hecho, es una especie de múltiples espacios de coordenadas diferentes.

Esas son solo algunas pistas, probablemente tengas que usar alguna receta tuya para que esto funcione. Alguien que ya implementó ese tipo de cosas podría ayudarlo más. ¿Por qué no enviar un correo electrónico a los chicos detrás del Programa espacial Kerbal, por ejemplo?

¡Buena suerte con tu juego!

Suponiendo que Plutón sea el "borde" del sistema solar (aunque algunos dicen que está a 3 años luz de distancia). Plutón, en su órbita máxima, está a unos 7,376,000,000 kilómetros del sol. Eso es 7.37600 × 10 ^ 14 centímetros. Duplique eso para obtener el diámetro y obtendrá 1,475,200,000,000,000 centímetros. Eso está dentro del tamaño máximo de 64 bits de largo. Dado que la altura del sistema solar es insignificante en comparación con su diámetro, podemos ignorar eso.

Entonces, sí, podría usar un largo para representar su posición en el sistema solar. De hecho, podría tener posiciones de hasta 9.75 años luz con un largo firmado (doble para sin firmar).

Tenga en cuenta que este no es el caso para encontrar distancias. La distancia máxima que puede encontrar es la raíz cuadrada de la distancia máxima a la que puede viajar. Esto se puede superar mediante el uso de un sistema de nivel de detalle para encontrar distancias. Puede hacer algunas comprobaciones simples para adivinar qué tan lejos están las distancias (compare sus valores x e y), luego use incrementos de 1,000,000 de kilómetros para distancias grandes hasta incrementos de centímetro para distancias pequeñas.

Por supuesto, está la cuestión de, ¿realmente quieres hacerlo? El 99.999% del sistema solar es un espacio vacío totalmente desinteresado. Si representa con precisión el sistema solar, espero que no esté representando con precisión la física. Lleva mucho tiempo moverse por el sistema solar. Demasiado tiempo para que la mayoría de la gente se mantenga interesada.

¿Y por qué incluso tener una precisión tan fina a menos que también va a modelar los objetos en el sistema solar con esa precisión? Ahí es donde te meterás en problemas. El volumen del sol es 1.40900 × 10 ^ 18 kilómetros cúbicos. En la escala de centímetros cúbicos, el uso de un solo bit para representar que ese espacio está "ocupado" ocupa 1.4 × 10 ^ 33 bits o 1.6 × 10 ^ 23 gigabytes. Creo que no tienes tanta RAM.

Puede usarlo BigInteger, como lo llame su lenguaje de programación. Es un número entero de tamaño ilimitado; se escala bien, generalmente usando log(n)almacenamiento para un número entero de tamaño n.

Java y C # lo tienen; Estoy seguro de que otros idiomas lo hacen. Si no, puede descompilarlo y reimplementarlo sin demasiadas dificultades.