Clock.h

#pragma once
 
 
#include <Foundation/Basics.h>
#include <Foundation/Communication/Event.h>
#include <Foundation/IO/Stream.h>
#include <Foundation/Reflection/Reflection.h>
#include <Foundation/Time/Time.h>
 
class plTimeStepSmoothing;
 
class PL_FOUNDATION_DLL plClock
{
public:
  static plClock* GetGlobalClock() { return s_pGlobalClock; }
 
public:
  plClock(plStringView sName); // [tested]
 
  void Reset(bool bEverything); // [tested]
 
  void Update(); // [tested]
 
  void SetTimeStepSmoothing(plTimeStepSmoothing* pSmoother);
 
  plTimeStepSmoothing* GetTimeStepSmoothing() const; // [tested]
 
  void SetPaused(bool bPaused); // [tested]
 
  bool GetPaused() const; // [tested]
 
  void SetFixedTimeStep(plTime diff = plTime()); // [tested]
 
  plTime GetFixedTimeStep() const; // [tested]
 
  void SetAccumulatedTime(plTime t); // [tested]
 
  plTime GetAccumulatedTime() const; // [tested]
 
  plTime GetTimeDiff() const; // [tested]
 
  void SetSpeed(double fFactor); // [tested]
 
  double GetSpeed() const; // [tested]
 
  void SetMinimumTimeStep(plTime min); // [tested]
 
  void SetMaximumTimeStep(plTime max); // [tested]
 
  plTime GetMinimumTimeStep() const; // [tested]
 
  plTime GetMaximumTimeStep() const; // [tested]
 
  void Save(plStreamWriter& inout_stream) const;
 
  void Load(plStreamReader& inout_stream);
 
  void SetClockName(plStringView sName);
 
  plStringView GetClockName() const;
 
 
public:
  struct EventData
  {
    plStringView m_sClockName;
 
    plTime m_RawTimeStep;
    plTime m_SmoothedTimeStep;
  };
 
  using Event = plEvent<const EventData&, plMutex>;
 
  static void AddEventHandler(Event::Handler handler) { s_TimeEvents.AddEventHandler(handler); }
 
  static void RemoveEventHandler(Event::Handler handler) { s_TimeEvents.RemoveEventHandler(handler); }
 
 
private:
  PL_MAKE_SUBSYSTEM_STARTUP_FRIEND(Foundation, Clock);
 
  static Event s_TimeEvents;
  static plClock* s_pGlobalClock;
 
  plString m_sName;
 
  plTime m_AccumulatedTime;
  plTime m_LastTimeDiff;
  plTime m_FixedTimeStep;
  plTime m_LastTimeUpdate;
  plTime m_MinTimeStep;
  plTime m_MaxTimeStep;
 
  double m_fSpeed;
  bool m_bPaused;
 
  plTimeStepSmoothing* m_pTimeStepSmoother;
};
 
 
class PL_FOUNDATION_DLL plTimeStepSmoothing
{
public:
  virtual ~plTimeStepSmoothing() = default;
 
  virtual plTime GetSmoothedTimeStep(plTime rawTimeStep, const plClock* pClock) = 0;
 
  virtual void Reset(const plClock* pClock) = 0;
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_FOUNDATION_DLL, plClock);
 
#include <Foundation/Time/Implementation/Clock_inl.h>