Timer.h

#pragma once
 
#include "../FoundationBase.h"
 
#include <cstdint>
 
namespace Cogs
{
#if defined(__EMSCRIPTEN__)
  typedef double TimePerf;
  typedef int64_t Time;
#else
  typedef int64_t TimePerf;
  typedef int64_t Time;
#endif
 
  COGSFOUNDATION_API TimePerf perfTime();
  COGSFOUNDATION_API Time currentTime();
 
  COGSFOUNDATION_API TimePerf perfTimeReference();
  COGSFOUNDATION_API Time currentTimeReference();
 
  COGSFOUNDATION_API int64_t perfTimeToMicroseconds(TimePerf time);
  COGSFOUNDATION_API int64_t perfTimeToMilliseconds(TimePerf time);
  COGSFOUNDATION_API double perfTimeToSeconds(TimePerf time);
 
  COGSFOUNDATION_API int64_t currentTimeToMicroseconds(Time time);
  COGSFOUNDATION_API int64_t currentTimeToMilliseconds(Time time);
  COGSFOUNDATION_API double currentTimeToSeconds(Time time);
 
  class COGSFOUNDATION_API Timer
  {
  public:
    static inline Timer startNew()
    {
      Timer timer;
      timer.start();
      return timer;
    }
 
    void start()
    {
      running = true;
      startTime = Cogs::perfTime();
    }
    void stop()
    {
      running = false;
      stopTime = Cogs::perfTime();
    }
 
    int64_t elapsedMicroseconds() { if(running) stopTime = Cogs::perfTime(); return perfTimeToMicroseconds(scalePerfTime(stopTime - startTime)); }
    int64_t elapsedMilliseconds() { if(running) stopTime = Cogs::perfTime(); return perfTimeToMilliseconds(scalePerfTime(stopTime - startTime)); }
    double  elapsedSeconds()  { if(running) stopTime = Cogs::perfTime(); return perfTimeToSeconds(scalePerfTime(stopTime - startTime)); }
 
    static int64_t currentTimeMicroseconds()   { return currentTimeToMicroseconds(currentTime()); }
    static int64_t currentTimeMilliseconds()   { return currentTimeToMilliseconds(currentTime()); }
 
#if defined(__EMSCRIPTEN__)
    void setScale(int64_t s) { scale = static_cast<double>(s) / 1000.0; }
    void resetScale() { scale = 1.0; }
    int64_t getScale() const { return static_cast<int64_t>(1000.0 * scale); }
    TimePerf scalePerfTime(TimePerf time) { return time*scale; }
#else
    void    setScale(int64_t s)         { scale = s; }
    void    resetScale()                { scale = 1000; }
    int64_t getScale() const            { return scale; }
    TimePerf scalePerfTime(TimePerf time) { return time*scale/1000; }
#endif
 
  private:
    TimePerf startTime = {};
    TimePerf stopTime = {};
#if defined(__EMSCRIPTEN__)
    double scale = 1.0f;
#else
    int64_t scale = 1000;
#endif
    bool running = false;
  };
}