Discussion :

[Invité]

Salut!

std::chrono étant très pratique et plus précise que SFML, mais bien plus complexe à utiliser, j'ai décidé de créer mes propres classes Time et Chrono, après tout cela ne peut être que bénéfique.

Cependant il y a encore un point qui me chagrine, je souhaiterai créer un "time point" à partir d'une duration arbitraire, j'ai vu que il est possible de créer n'importe quel type de duration exprimée de n'importe quelle façon. (grâce à std::ratio)

Cependant, quand j'essaye de la convertir en un "time point" j'ai une erreur de compilation, je suis obligé à chaque fois d'utilise std::chrono::seconds sinon ça ne compile pas donc ce code compile :

Code cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
Time seconds (long int amount) {
        Time time;
        time.time = std::chrono::time_point<std::chrono::high_resolution_clock>(std::chrono::seconds(amount));
        return time;
}

Par contre celui-ci ne compile pas!

Code cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
Time seconds (float amount) {
        Time time;
        std::chrono::duration<float, std::ratio<1, 1000000>> dur (amount);
        time.time = std::chrono::time_point<std::chrono::high_resolution_clock, std::chrono::duration<float, std::ratio<1, 1000000>>>(dur);
        return time;
}

Faut t'il faire un cast ou quelque chose du genre ?

Merci d'avance pour l'aide.

[ternel]

La, c'est une question de physique standard:

Un time point, c'est une position temporelle.
Une duration, c'est une distance temporelle (entre deux positions temporelles donc).

Ta question, c'est essayer de convertir "812m" en "Cathédrale de Notre dame, Paris, France".

Par contre, tu peux parfaitement définir une position comme étant une autre position plus une distance.
Il suffit d'avoir un temps de référence, et d'ajouter une durée (opérator +, a tous les coups).

[Invité]

Ok, je comprends ce que tu veux dire.

[Iradrille]

Hello,

std::chrono étant très pratique et plus précise que SFML

A moins que tu n’ai besoin de durées avec une précision de <1 µs, la SFML devrait faire l'affaire.

std::chrono n'est pas magique, il utilisera ce que fourni le système. Sous Windows, pour un std::chrono::high_resolution_clock ce sera QueryPerformanceCounter.
Si on regarde l'implémentation de la SFML (SFML-2.2/src/SFML/System/Win32/ClockImpl.cpp)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Time ClockImpl::getCurrentTime()
{
    // Force the following code to run on first core
    // (see http://msdn.microsoft.com/en-us/library/windows/desktop/ms644904(v=vs.85).aspx)
    HANDLE currentThread = GetCurrentThread();
    DWORD_PTR previousMask = SetThreadAffinityMask(currentThread, 1);
 
    // Get the frequency of the performance counter
    // (it is constant across the program lifetime)
    static LARGE_INTEGER frequency = getFrequency();
 
    // Get the current time
    LARGE_INTEGER time;
    QueryPerformanceCounter(&time);
 
    // Restore the thread affinity
    SetThreadAffinityMask(currentThread, previousMask);
 
    // Return the current time as microseconds
    return sf::microseconds(1000000 * time.QuadPart / frequency.QuadPart);
}

Même précision donc, mais la SFML ne garde que les µs. (Et c'est pareil sous Linux / MacOS).

[ternel]

Pour le détail, ca marche avec des secondes, parce qu'il s'agit d'un timestamp, c'est à dire un nombre de secondes depuis EPOCH.

[Invité]

Ok, je vois, std::chrono va jusqu'au nanosecondes.

Les micros secondes me suffisent, cependant, je ne suis pas sûr que avec SFML, le temps soit aussi juste que avec std::chrono.

J'ai parfois des temps négatifs lors de la synchronisation de l'horloge client avec l'horloge serveur. (Hors que je ne devrai avoir que des temps positif vu que l'horloge client au moment ou le serveur reçoit le message devrait avoir un temps plus grand que l'horloge client au moment ou le client envoie le message hors que ce n'est pas toujours le cas avec SFML. :/ )

Bref, ici je vais essayer avec std::chrono, on va voir, pour information je suis sous linux et pas sous windows donc peut être que ça, ça joue. (Tout comme les fabriquant de drivers qui ont plutôt tendance à privilégier les plate-formes commerciales)

[LittleWhite]

J'ai parfois des temps négatifs lors de la synchronisation de l'horloge client avec l'horloge serveur. (Hors que je ne devrai avoir que des temps positif vu que l'horloge client au moment ou le serveur reçoit le message devrait avoir un temps plus grand que l'horloge client au moment ou le client envoie le message hors que ce n'est pas toujours le cas avec SFML. :/ )

Si le serveur à un décalage de dix minutes en arrière, pour X raison alors il y aura des temps négatifs.

[Invité]

Arf, pourtant je fais des synchronisations régulières des deux horloges. (celle de l'application cliente et celle de l'application serveur)

Afin que celles-ci soient toujours à la même heure.

[white_tentacle]

Si tes deux machines sont synchronisée via ntp, il ne devrait pas y avoir de problème. À moins que tu ne fasse des différences sur des temps à la microseconde, où là effectivement tu es au-delà de la précision de ntp à ma connaissance.

Par curiosité, pourquoi as-tu besoin de descendre aussi bas ? Énormément de contextes se satisfont très bien d’une précision de l’ordre de 1ms. Je suis étonné que pour du jeu, tu aies besoin d’aller en dessous. Ça ne me semble pas correspondre à une réalité de la perception humaine.