clock.h

#pragma once
 
#include <chrono>
#include <cstdint>
 
#include <glm/glm.hpp>
 
#include "core/engine_config.h"
 
namespace Vkm::Engine {

class Clock {
    public:
        Clock() = default;
        ~Clock() = default;
 
        Clock(const Clock& other) = default;
        Clock& operator=(const Clock& other) = default;
 
        Clock(Clock && other) = default;
        Clock& operator=(Clock && other) = default;
 
    public:
        void beginFrame();

        bool consumeFixedStep();

        void setTickRate(uint32_t ticksPerSecond) {
            m_fixedStep = 1.0f / static_cast<float>(Config::clampTickRate(ticksPerSecond));
        }

        void setPaused(bool paused) { m_paused = paused; }

        void setTimeScale(float scale) { m_timeScale = scale < 0.0f ? 0.0f : scale; }

        void setPacing(float scale) { m_pacing = scale < 0.0f ? 0.0f : scale; }

        void requestStep(int steps = 1) { if (steps > 0) m_pendingSteps += steps; }
 
        float getDeltaTime() const { return m_deltaTime; }
        float getSimDelta() const  { return m_simDelta; }
        float getFixedStep() const { return m_fixedStep; }

        float getFixedAlpha() const {
            return m_fixedStep > 0.0f ? glm::clamp(m_accumulator / m_fixedStep, 0.0f, 1.0f) : 0.0f;
        }

        float getFrameRate() const { return m_smoothedDelta > 0.0f ? 1.0f / m_smoothedDelta : 0.0f; }

        float getFrameTime() const { return m_smoothedDelta * 1000.0f; }
 
        bool isPaused() const { return m_paused; }

        bool isSimulationStill() const { return m_simDelta <= 0.0f; }
 
        float getTimeScale() const { return m_timeScale; }
        float getPacing() const    { return m_pacing; }

        uint32_t getTick() const { return m_tick; }
 
    private:
        std::chrono::steady_clock::time_point m_last{};
        bool  m_started = false;
 
        float m_fixedStep = 1.0f / static_cast<float>(Config::DEFAULT_TICK_RATE);
 
        float m_deltaTime     = 0.0f;
        float m_simDelta      = 0.0f;
        float m_accumulator   = 0.0f;
        float m_smoothedDelta = 0.0f;   
 
        bool  m_paused       = false;
        int   m_pendingSteps = 0;
        float m_timeScale    = 1.0f;
        float m_pacing       = 1.0f;
 
        uint32_t m_tick = 0;
};
 
} // namespace Vkm::Engine