SFML的精确事件计时

Question

Question

If a user wanted to know the "precise" time a key was pressed for using an event polling loop within SFML, one possible method would be to query timestamp data which comes bundled with every sf::Event .

However I haven't found anything in the documentation to suggest such data exists within the sf::Event class.

Question 1: Does this data exist within an sf::Event . I have a vague recollection that it did either in an earlier version of sfml or in another window toolkit perhaps?

Question 2: If not then it is possible to accurately measure how long a key was pressed for?

Question 3: Are there any other window toolkits which will allow this?

Code

At the moment I am doing the following:

double time_pressed = 0.0;

sf::Clock clock;
clock.restart();

while(window.isOpen())
{

    // Timing control
    const double delay_time = 1.0 / 100.0;
    double current_delay_time = clock.restart().asSeconds();
    if(current_delay_time < delay_time)
    {
        sf::sleep(sf::seconds(delay_time - current_delay_time));
    }

    sf::Event event;
    while(window.pollEvent(event))
    {

        if(sf::Keyboard::isKeyPressed(sf::Keyboard::A))
        {
            time_pressed += current_delay_time; // !
        }
    }

    // Other code

    window.display();

}

Is there a better or improved way of doing this?

I am aware that this may be OS dependent, considering that Linux is not a RTOS and I believe that Windows is? (?) Both are "Operating Systems" in the sense that they manage multiple tasks, so presumably the "most accurate theoretically possible method" extends from the OS itself logging the timestamps of keypresses? Could one access that data if it exists?

I use Linux, but this is actually for a Windows project - something I know little about.

Answer 1

This solution needs a sf::Clock be instantiated for every key you want to measure, because a key can be pressed while you're already measuring another. So it's assumed here that you want to measure time for just a particular key. Otherwise, you could implement a system which would push an sf::Clock in a container each time a new key is pressed while another one is already pressed, and delete this clock from the container after use. You would need to save the position of the clock in the container somehow.

Here is a solution for the key K, arbitrarily :

sf::Clock kKeyClock;
bool kKeyPressed = false;
sf::Time kKeyTime;

while (window.isOpen())
{
    sf::Event event;
    while (window.pollEvent(event))
    {
        if ( event.type == sf::Event::KeyReleased )
            if ( event.key.code == sf::Keyboard::K )
            {
                kKeyTime = kKeyClock.getElapsedTime();
                kKeyPressed = false;
            }
    }

    if (sf::Keyboard::isKeyPressed(sf::Keyboard::K))
    {
        if ( !kKeyPressed )
        {
            kKeyClock.restart();
            kKeyPressed = true;
        }
    }
}

Does this solution seem accurate enough, or may I have misunderstood the question ?

I think sf::Event doesn't provide time information, but you could be sure if you look in the doc. I don't know for other window library.