time.hpp

Go to the documentation of this file.

 
#pragma once
#include <atomic>
#include <chrono>
#include <cstdint>
#include <toast/export.hpp>
 
namespace toast {
class Engine;
}
 
struct TOAST_API TimeSnapshot {
  double delta = 0.0;
  double raw_delta = 0.0;
  double render_delta = 0.0;
  double uptime = 0.0;
  uint64_t frame = 0;
  uint64_t render_frame = 0;
  bool paused = false;
};

class TOAST_API Time final {
  using clock_t = std::chrono::high_resolution_clock;
  using time_point_t = clock_t::time_point;
  friend struct toast::Engine;
 
public:
  Time(const Time&) = delete;
  auto operator=(const Time&) -> Time& = delete;
  Time(Time&&) = delete;
  auto operator=(Time&&) -> Time& = delete;
 
  ~Time();
 
  static auto get() noexcept -> Time&;                
 
  void tick() noexcept;                               
  void renderTick() noexcept;                         
 
  static auto delta() noexcept -> double;             
  static auto rawDelta() noexcept -> double;          
  static auto renderDelta() noexcept -> double;       
 
  static auto frame() noexcept -> uint64_t;           
  static auto renderFrame() noexcept -> uint64_t;     
 
  static auto snapshot() noexcept -> TimeSnapshot;    
 
  static auto scale() noexcept -> double;             
  static void scale(double value);                    
 
  static void pause() noexcept;                       
  static void resume() noexcept;                      
  static auto paused() noexcept -> bool;              
 
  static auto tps() noexcept -> double;               
  static auto fps() noexcept -> double;               
 
  static auto uptime() noexcept -> double;            
  static auto system() noexcept -> double;            
  static void setMaxDelta(double delta);              
 
private:
  Time();
  static inline Time* instance = nullptr;
 
  std::atomic<double> m_max_delta {1.0 / 15.0};
  std::atomic<double> m_delta_scale {1.0};
 
  // main thread state
  time_point_t m_now;
  time_point_t m_previous;
  time_point_t m_start_time;
  uint64_t m_sim_frame = 0;
 
  // render thread state
  time_point_t m_now_render;
  time_point_t m_previous_render;
  uint64_t m_render_count = 0;
 
  // published state
  alignas(64) std::atomic<double> m_pub_delta {0.0};
  std::atomic<double> m_pub_raw_delta {0.0};
  std::atomic<uint64_t> m_pub_frame {0};
  std::atomic<bool> m_pub_paused {false};
  std::atomic<bool> m_paused {false};
  std::atomic<uint32_t> m_sim_seq {0};
 
  alignas(64) std::atomic<double> m_pub_render_delta {0.0};
  std::atomic<uint64_t> m_pub_render_frame {0};
  std::atomic<uint32_t> m_render_seq {0};
};