IntervalScheduler.h

#pragma once
 
#include <Core/CoreDLL.h>
#include <Foundation/Reflection/Reflection.h>
 
struct PL_CORE_DLL plUpdateRate
{
  using StorageType = plUInt8;
 
  enum Enum
  {
    EveryFrame,
    Max30fps,
    Max20fps,
    Max10fps,
    Max5fps,
    Max2fps,
    Max1fps,
    Never,
 
    Default = Max30fps
  };
 
  static plTime GetInterval(Enum updateRate);
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_CORE_DLL, plUpdateRate);
 
 
class PL_CORE_DLL plIntervalSchedulerBase
{
protected:
  plIntervalSchedulerBase(plTime minInterval, plTime maxInterval);
  ~plIntervalSchedulerBase();
 
  plUInt32 GetHistogramIndex(plTime value);
  plTime GetHistogramSlotValue(plUInt32 uiIndex);
 
  static float GetRandomZeroToOne(int pos, plUInt32& seed);
  static plTime GetRandomTimeJitter(int pos, plUInt32& seed);
 
  plTime m_MinInterval;
  plTime m_MaxInterval;
  double m_fInvIntervalRange;
 
  plTime m_CurrentTime;
 
  plUInt32 m_uiSeed = 0;
 
  static constexpr plUInt32 HistogramSize = 32;
  plUInt32 m_Histogram[HistogramSize] = {};
  plTime m_HistogramSlotValues[HistogramSize] = {};
};
 
 
template <typename T>
class plIntervalScheduler : public plIntervalSchedulerBase
{
  using SUPER = plIntervalSchedulerBase;
 
public:
  PL_ALWAYS_INLINE plIntervalScheduler(plTime minInterval = plTime::MakeFromMilliseconds(1), plTime maxInterval = plTime::MakeFromSeconds(1))
    : SUPER(minInterval, maxInterval)
  {
  }
 
  void AddOrUpdateWork(const T& work, plTime interval);
  void RemoveWork(const T& work);
 
  plTime GetInterval(const T& work) const;
 
  // reference to the work that should be run and time passed since this work has been last run.
  using RunWorkCallback = plDelegate<void(const T&, plTime)>;
 
  void Update(plTime deltaTime, RunWorkCallback runWorkCallback);
 
  void Clear();
 
private:
  struct Data
  {
    T m_Work;
    plTime m_Interval;
    plTime m_DueTime;
    plTime m_LastScheduledTime;
 
    bool IsValid() const;
    void MarkAsInvalid();
  };
 
  using DataMap = plMap<plTime, Data>;
  DataMap m_Data;
  plHashTable<T, typename DataMap::Iterator> m_WorkIdToData;
 
  typename DataMap::Iterator InsertData(Data& data);
  plDynamicArray<typename DataMap::Iterator> m_ScheduledWork;
};
 
#include <Core/Utils/Implementation/IntervalScheduler_inl.h>