Livre de développement de jeu SFML - Comprendre le calcul FPS

Question

Ceci est mon premier article, donc j'espère que je comprends bien. Je travaille actuellement sur le livre de développement de jeu SFML. J'essaie de comprendre comment le FPS est calculé dans l'exemple d'intro.

Ma classe de jeu ressemble à ceci:

#include "Game.h" 

const sf::Time Game::TIME_PER_FRAME = sf::seconds(1.f/60.f); 
const float Game::PLAYER_SPEED = 100.f; 

Game::Game() : Window(sf::VideoMode(640,480), "ORGELLA") {   

    isMovingUp = false; 
    isMovingDown = false; 
    isMovingLeft = false; 
    isMovingRight = false; 

    Player.setRadius(40.f); 
    Player.setPosition(100.f, 100.f); 
    Player.setFillColor(sf::Color::Cyan); 

    font.loadFromFile(resourcePath() + "sansation.ttf"); 
    statsText.setFont(font); 
    statsText.setPosition(5.f, 5.f); 
    statsText.setCharacterSize(10); 
} 

void Game::run() { 
    sf::Clock clock; 
    sf::Time timeSinceLastUpdate = sf::Time::Zero; 


    while (Window.isOpen()) { 
     sf::Time dt = clock.restart(); 
     timeSinceLastUpdate += dt; 

     while (timeSinceLastUpdate > TIME_PER_FRAME) { 
      timeSinceLastUpdate -= TIME_PER_FRAME; 

      handleEvents(); 
      update(TIME_PER_FRAME); 
     } 

     updateGameStats(dt); 
     render(); 
    } 
} 

void Game::handleEvents() { 
    sf::Event event; 
    while (Window.pollEvent(event)) { 
     switch (event.type) { 
      case sf::Event::KeyPressed: 
       handlePlayerInput(event.key.code, true); 
       break; 
      case sf::Event::KeyReleased: 
       handlePlayerInput(event.key.code, false); 
       break; 
      case sf::Event::Closed: 
       Window.close(); 
       break; 
     } 
    } 
} 

void Game::update(sf::Time dt) { 
    sf::Vector2f movement(0.f, 0.f); 

    if (isMovingUp) 
     movement.y -= PLAYER_SPEED; 
    if (isMovingDown) 
     movement.y += PLAYER_SPEED; 
    if(isMovingLeft) 
     movement.x -= PLAYER_SPEED; 
    if (isMovingRight) 
     movement.x += PLAYER_SPEED; 

    Player.move(movement * dt.asSeconds()); 
} 

void Game::render() { 
    Window.clear(); 
    Window.draw(Player); 
    Window.draw(statsText); 
    Window.display(); 
} 

void Game::handlePlayerInput(sf::Keyboard::Key key, bool isPressed) { 
    switch (key) { 
     case sf::Keyboard::W: 
      isMovingUp = isPressed; 
      break; 
     case sf::Keyboard::S: 
      isMovingDown = isPressed; 
      break; 
     case sf::Keyboard::A: 
      isMovingLeft = isPressed; 
      break; 
     case sf::Keyboard::D: 
      isMovingRight = isPressed; 
      break; 
    } 
} 

void Game::updateGameStats(sf::Time dt) { 
    statsTotalTimeElapsed += dt ; 
    statsNumberOfFrames += 1; 

    if (statsTotalTimeElapsed >= sf::seconds(1.0f)) { 
     statsText.setString(
      "FPS = " + to_string(statsNumberOfFrames) + "\n" + 
      "Time/Update = " + to_string(statsTotalTimeElapsed.asMicroseconds()/statsNumberOfFrames) + "us"); 

     statsTotalTimeElapsed -= sf::seconds(1.0f); 
     statsNumberOfFrames = 0; 
    } 
} 

Maintenant, ma question est la suivante. Comment est calculé le FPS qui est rendu à mon écran. D'après ce que je peux comprendre le FPS est plafonné à 60fps mais encore quand je cours l'application le FPS qui est affiché est d'environ 500 - 1200 FPS. Est-ce que je calcule ce problème ou que je ne comprends pas cela correctement?

J'espère que ce post est correct, je n'arrive pas à trouver une question similaire.

Un conseil ou une aide sera grandement appréciée.

Answer 1

donné une framerate (par exemple 60 FPS):

auto framerate = 60; // FPS 
auto elapsedMillisecondsExpected = 1000/framerate; // in milliseconds 

Dans SFML vous utilisez un sf::Clock et à chaque image que vous couronner le:

sf::Clock clock; 

// frame logic 

auto elapsedMilliseconds = clock.getElapsedTime().asMilliseconds(); 
if (elapsedMilliseconds < elapsedMillisecondsExpected) { 
    auto sleepMilliseconds = elapsedMillisecondsExpected - elapsedMilliseconds; 
    // sleep for sleepMilliseconds 
} 

Answer 2

Figured celui-ci! Je regardais les images totales par seconde et pas les images mises à jour par seconde. Lorsque je connecte le nombre de fois que la méthode de mise à jour s'exécute par seconde, je reçois un 60FPS stable.

Appréciez l'aide.

Nick