La synchronisation des mises à jour OpenGL avec le retracement vertical sera communiquée de manière spécifique à chaque plateforme, car elle dépend de la manière dont votre plateforme a intégré OpenGL. Il s'agit donc d'une case à cocher dans le concepteur d'interface sur Mac, d'une extension WGL appelée WGL_EXT_swap_control sur Windows et d'une extension GLX dans X11.
En supposant que vous disposiez d'un moyen d'installer un rappel qui est déclenché lors d'un retracement vertical (par exemple via un CVDisplayLink sur Mac ; malheureusement, je ne connais pas les équivalents Windows/Linux), et que vous voulez que votre physique fonctionne à un nombre constant de pas par seconde, vous pourriez écrire quelque chose comme :
void myRetraceFunction()
{
static unsigned int timeError = 0;
static unsigned int timeOfLastFrame = 0;
unsigned int timeNow = getTimeNow(); // assume this returns in ms
// Get time since last frame.
// Since we ignore overflow here, we don't care that the result of
// getTimeNow presumably overflows.
unsigned int timeSinceLastFrame = timeNow - timeOfLastFrame;
// Store this so that we get correct results next time around.
timeOfLastFrame = timeNow;
// Establish the number of times to update physics per second, as the
// name says. So supposing it has been 0.5 of a second since we last
// drew, we'd want to perform 0.5*200 physics updates
const unsigned int numberOfTimesToUpdatePhysicsPerSecond = 200;
// calculate updates as (updatesPerSecond * timeSinceLastFrame / 1000),
// because we're assuming time is in milliseconds and there are 1000
// of them in a second. What we'll do though is preserve any amount we'd
// lose by dividing here, so that errors balance themselves.
//
// We assume that timeSinceLastFrame will be small enough that we won't
// overflow here.
unsigned int timeSinceLastFrameNumerator =
timeSinceLastFrame * numberOfTimesToUpdatePhysicsPerSecond
+ timeError;
// calculate how much of the numerator we're going to lose to
// truncation, so that we add it next frame and don't lose time
timeError = timeSinceLastFrameNumerator % 1000;
// calculate how many physics updates to perform
unsigned int physicsUpdatesToPerform = timeSinceLastFrameNumerator / 1000;
// do the physics work...
while(physicsUpdatesToPerform--)
updatePhysics();
// ... and draw a frame
drawFrame();
}
L'erreur temporelle sert à éviter les problèmes d'arrondi. Supposons que vous tourniez à une vitesse constante de 70 images par seconde et que vous vouliez des mises à jour physiques 60 fois par seconde. Si vous ignorez l'erreur qui s'accumule, vous n'aurez en fait aucune mise à jour physique par seconde car à chaque instant, le code conclura que le temps écoulé depuis le dernier dessin d'image n'est pas assez long pour qu'une mise à jour physique soit nécessaire. Et vous auriez aussi des problèmes d'aliasing si vous alliez dans l'autre sens, avec n'importe quelle fréquence d'images qui n'est pas un diviseur entier de la fréquence de mise à jour de la physique.
Si vous ne disposez pas d'une fonction de retraçage explicite, mais d'une boucle perpétuelle qui produit des images mais se bloque sur le retraçage vertical, vous écrirez le même genre de chose.
Si vous n'avez aucun moyen de bloquer le retracement vertical, vous pouvez installer un timer à une fréquence d'images cible et prétendre qu'il s'agit d'une synchronisation de retracement vertical. Vous pourriez simplement pousser les images aussi vite que possible, mais vous aurez probablement des plaintes de la part de ceux qui ont un ordinateur portable ou une autre machine où il est assez évident que les ventilateurs se mettent en marche.
