Méthodes de simulation physique pour les grands deltas?

Quelles méthodes de simulation physique conviennent le mieux aux temps de delta très importants (heures à semaines)?

De plus, aurais-je des problèmes à combiner différentes méthodes pour les grands et les petits deltas?

Vous utiliserez probablement une accélération constante pour ces grandes périodes de temps (qui pourraient être une accélération nulle). La dérivée de l'accélération constante par rapport au temps est 0. Cela signifie qu'elle ne change pas par rapport au temps, donc peu importe la taille de votre temps delta.

Cette petite intégration par rapport au temps fournit les équations dont vous avez besoin.

a = a
v = at + v0
s = .5at^2 + v0*t + s0

Où: a = accélération, v = vitesse, v0 = vitesse initiale, s = position, s0 = position initiale, t = temps

En utilisant cette stratégie, vous pouvez utiliser des délais allant de quelques millisecondes à plusieurs semaines si vous le souhaitez. Leur combinaison serait prise en compte dans les paramètres v0et s0de l'équation.

Pour gérer les collisions, vous devrez mettre en œuvre des stratégies similaires à celles utilisées pour les petits objets à grande vitesse . Calculez d'abord la nouvelle position à l'aide de l'équation ci-dessus, puis balayez entre l'ancienne et la nouvelle position pour tous les objets. Étant donné que l'un de ces objets aurait pu se croiser (quelques minutes ou jours avant), cela peut devenir très complexe. Il est probable que, comme vous avez des temps de delta si importants, nous espérons que vous aurez beaucoup de temps pour traiter ces collisions potentielles.

Prenons un exemple avec gravité.

Dans la fonction ci-dessous, supposons que nous ayons des variables de membre de classe pour la position et la vitesse. Nous devons les mettre à jour en raison de la force de gravité toutes les dt secondes.

void update( float dt )
{
   acceleration = G * m / r^2;
   velocity = velocity + acceleration * dt;
   position = position + velocity * dt;
}

À mesure dtque la taille diminue, notre simulation devient de plus en plus précise (bien que si elle dtdevient trop petite, nous pouvons rencontrer des erreurs de précision lors de l'ajout de petits nombres à de grands nombres).

Fondamentalement, vous devez décider du maximum que dtvotre simulation peut gérer pour obtenir des résultats suffisamment bons. Et si celui dtqui arrive est trop grand, décomposez simplement la simulation en étapes plus petites, où chaque étape est le maximum dtque vous autorisez.

void update( float dt )
{
   acceleration = G * m / r^2;
   velocity = velocity + acceleration * dt;
   position = position + velocity * dt;
}

// this is the function we call. The above function is a helper to this function.
void updateLargeDt( float dt )
{
    const float timeStep = 0.1;
    while( dt > timeStep   )
    {
        update( timeStep  );
        dt -= timeStep ;
    }

    update( dt );  // update with whatever dt is left over from above
}

Donc, avec cette stratégie, vous pouvez simplement vous ajuster timeStep à la fidélité dont vous avez besoin (faites-en une seconde, une minute, une heure ou tout ce qui est nécessaire pour obtenir une représentation précise de la physique.

La plupart des jeux ont tendance à utiliser la méthode simple d'intégration d' Euler (c'est-à-dire intégrer la vitesse dans la position au fil du temps et intégrer l'accélération dans la vitesse). Malheureusement, la méthode Euler ne convient que pour de très petites échelles de temps et de courtes séries.

Il existe des méthodes plus complexes et plus précises sur de très longues échelles de temps. Runge-Kutte-4 est le plus populaire et le plus facile à implémenter . RK4 détermine la position dans le futur en échantillonnant quatre positions et vitesses dans le passé et en interpolant. Elle a tendance à être beaucoup plus précise que la méthode d'Euler sur des échelles de temps plus longues, mais elle est plus coûteuse en termes de calcul.

Par exemple, si vous souhaitez calculer la physique d'une planète en orbite réelle en mettant à jour tous les quelques jours en temps réel, la méthode Euler fera décoller la planète dans l'espace après seulement quelques orbites en raison d'erreurs numériques. RK4 maintiendra généralement la planète en orbite à peu près dans la même forme plusieurs milliers de fois avant d'accumuler trop d'erreurs.

Cependant, la mise en œuvre des collisions dans RK4 peut être très difficile ...