foray_renderloop.hpp

Go to the documentation of this file.

#pragma once
#include "../foray_basics.hpp"
#include <functional>
#include <limits>
#include <list>
#include <vector>
 
namespace foray::base {
 
    enum class ELifetimeState
    {
        PreInit,
        Initializing,
        Running,
        StopRequested,
        Destroying,
        Finalized
    };
 
    void PrintStateChange(ELifetimeState oldState, ELifetimeState newState);
 
    class AppFrameTiming
    {
      public:
        inline void SetFramesPerSecond(float value) { mSecondsPerFrame = 1.f / value; }
        inline void SetSecondsPerFrame(float value) { mSecondsPerFrame = value; }
        inline float GetFramesPerSecond() const { return 1.f / mSecondsPerFrame; }
        inline float GetSecondsPerFrame() const { return mSecondsPerFrame; }
 
        inline void Set60Fps() { mSecondsPerFrame = 1.f / 60.f; }
        inline void DisableFpsLimit() { mSecondsPerFrame = 0; }
 
      protected:
        fp32_t mSecondsPerFrame = 1.f / 60.f;
    };
 
    class RenderLoop
    {
      public:
        struct RenderInfo
        {
            fp32_t   Delta           = 0.f;
            fp32_t   TargetDelta     = 0.f;
            uint64_t LoopFrameNumber = 0;
            fp64_t   SinceStart      = 0.0;
        };
 
        using InitFunctionPointer = std::function<void()>;
        using RenderFunctionPointer = std::function<void(RenderInfo&)>;
        using RenderReadyFunctionPointer = std::function<bool()>;
        using DestroyFunctionPointer = std::function<void()>;
        using PollEventsFunctionPointer = std::function<void()>;
        using OnStateChangedFunctionPointer = std::function<void(ELifetimeState, ELifetimeState)>;
 
        inline RenderLoop() = default;
        inline RenderLoop(InitFunctionPointer           initFunc,
                          RenderFunctionPointer         renderFunc,
                          RenderReadyFunctionPointer    renderReadyFunc,
                          DestroyFunctionPointer        destroyFunc,
                          PollEventsFunctionPointer     pollEventsFunc,
                          OnStateChangedFunctionPointer onStateChangedFunc)
            : mInitFunc{initFunc}
            , mRenderFunc{renderFunc}
            , mRenderReadyFunc{renderReadyFunc}
            , mDestroyFunc{destroyFunc}
            , mPollEventsFunc{pollEventsFunc}
            , mOnStateChangedFunc{onStateChangedFunc} {};
 
        int32_t Run();
        void RequestStop(int32_t runResult = 0);
        bool IsRunning() const;
 
        struct FrameTimeAnalysis
        {
            fp32_t TotalTime = 0.f;
            uint32_t Count = 0;
            fp32_t MinFrameTime = std::numeric_limits<fp32_t>::infinity();
            fp32_t MaxFrameTime = 0.f;
            fp32_t AvgFrameTime = 0.f;
        };
 
        FrameTimeAnalysis AnalyseFrameTimes() const;
        void GetFrameTimes(std::vector<fp32_t>& outFrameTimes) const;
 
        RenderLoop& SetInitFunc(InitFunctionPointer func);
        RenderLoop& SetRenderFunc(RenderFunctionPointer func);
        RenderLoop& SetRenderReadyFunc(RenderReadyFunctionPointer func);
        RenderLoop& SetDestroyFunc(DestroyFunctionPointer func);
        RenderLoop& SetPollEventsFunc(PollEventsFunctionPointer func);
        RenderLoop& SetOnStateChangedFunc(OnStateChangedFunctionPointer func);
 
        FORAY_GETTER_V(State)
 
        FORAY_GETTER_MR(FrameTiming)
        FORAY_PROPERTY_V(MaxFrameTimeAge)
 
      protected:
        void AdvanceState();
 
        InitFunctionPointer           mInitFunc           = nullptr;
        RenderFunctionPointer         mRenderFunc         = nullptr;
        RenderReadyFunctionPointer    mRenderReadyFunc    = nullptr;
        DestroyFunctionPointer        mDestroyFunc        = nullptr;
        PollEventsFunctionPointer     mPollEventsFunc     = nullptr;
        OnStateChangedFunctionPointer mOnStateChangedFunc = nullptr;
 
        ELifetimeState mState     = ELifetimeState::PreInit;
        int32_t        mRunResult = 0;
 
        AppFrameTiming mFrameTiming;
        uint64_t       mRenderedFrameCount = 0;
 
 
        struct FrameTime
        {
            fp32_t Delta     = 0.f;
            fp64_t Timestamp = 0;
        };
 
        std::list<FrameTime> mFrameTimes;
        fp32_t               mMaxFrameTimeAge = 1.f;
    };
}  // namespace foray::base