timing.h

Go to the documentation of this file.

#ifndef YAZE_APP_CORE_TIMING_H
#define YAZE_APP_CORE_TIMING_H
 
#include "app/platform/sdl_compat.h"
 
#include <cstdint>
 
namespace yaze {
 
class TimingManager {
 public:
  static TimingManager& Get() {
    static TimingManager instance;
    return instance;
  }
 
  float Update() {
    uint64_t current_time = SDL_GetPerformanceCounter();
    float delta_time = 0.0f;
 
    if (last_time_ > 0) {
      delta_time = (current_time - last_time_) / static_cast<float>(frequency_);
 
      // Clamp delta time to prevent huge jumps (e.g., when debugging)
      if (delta_time > 0.1f) {
        delta_time = 0.1f;
      }
 
      accumulated_time_ += delta_time;
      frame_count_++;
 
      // Update FPS counter once per second
      if (accumulated_time_ >= 1.0f) {
        fps_ = static_cast<float>(frame_count_) / accumulated_time_;
        frame_count_ = 0;
        accumulated_time_ = 0.0f;
      }
    }
 
    last_time_ = current_time;
    last_delta_time_ = delta_time;
    return delta_time;
  }
 
  float GetDeltaTime() const { return last_delta_time_; }
 
  float GetFPS() const { return fps_; }
 
  float GetElapsedTime() const {
    if (last_time_ == 0)
      return 0.0f;
    uint64_t current_time = SDL_GetPerformanceCounter();
    return (current_time - first_time_) / static_cast<float>(frequency_);
  }
 
  void Reset() {
    last_time_ = 0;
    first_time_ = SDL_GetPerformanceCounter();
    accumulated_time_ = 0.0f;
    frame_count_ = 0;
    fps_ = 0.0f;
    last_delta_time_ = 0.0f;
    frame_start_time_ = 0;
  }
 
  void BeginFrame() {
    frame_start_time_ = SDL_GetPerformanceCounter();
  }
 
  float GetFrameElapsedMs() const {
    if (frame_start_time_ == 0) return 0.0f;
    uint64_t current = SDL_GetPerformanceCounter();
    return ((current - frame_start_time_) * 1000.0f) / static_cast<float>(frequency_);
  }
 
  float GetFrameBudgetRemainingMs() const {
    constexpr float kTargetFrameTimeMs = 16.67f;  // 60fps target
    return kTargetFrameTimeMs - GetFrameElapsedMs();
  }
 
 private:
  TimingManager() {
    frequency_ = SDL_GetPerformanceFrequency();
    first_time_ = SDL_GetPerformanceCounter();
    last_time_ = 0;
    accumulated_time_ = 0.0f;
    frame_count_ = 0;
    fps_ = 0.0f;
    last_delta_time_ = 0.0f;
  }
 
  uint64_t frequency_;
  uint64_t first_time_;
  uint64_t last_time_;
  uint64_t frame_start_time_ = 0;
  float accumulated_time_;
  uint32_t frame_count_;
  float fps_;
  float last_delta_time_;
 
  TimingManager(const TimingManager&) = delete;
  TimingManager& operator=(const TimingManager&) = delete;
};
 
}  // namespace yaze
 
#endif  // YAZE_APP_CORE_TIMING_H