frame-scheduler.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2023  Christopher J. Howard
 *
 * This file is part of Antkeeper source code.
 *
 * Antkeeper source code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Antkeeper source code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef ANTKEEPER_UTILITY_FRAME_SCHEDULER_HPP
#define ANTKEEPER_UTILITY_FRAME_SCHEDULER_HPP
 
#include <chrono>
#include <functional>
#include <type_traits>
 
class frame_scheduler
{
public:
    using clock_type = std::conditional
    <
        std::chrono::high_resolution_clock::is_steady,
        std::chrono::high_resolution_clock, std::chrono::steady_clock
    >::type;
    
    using duration_type = clock_type::duration;
    
    using time_point_type = clock_type::time_point;
    
    using fixed_update_callback_type = std::function<void(duration_type, duration_type)>;
    
    using variable_update_callback_type = std::function<void(duration_type, duration_type, duration_type)>;
    
    frame_scheduler() noexcept;
    
    void tick();
    
    void refresh() noexcept;
    
    void reset() noexcept;
    
    inline void set_fixed_update_interval(duration_type interval) noexcept
    {
        m_fixed_update_interval = interval;
    }
    
    inline void set_min_frame_duration(duration_type duration) noexcept
    {
        m_min_frame_duration = duration;
    }
    
    inline void set_max_frame_duration(duration_type duration) noexcept
    {
        m_max_frame_duration = duration;
    }
    
    inline void set_fixed_update_callback(fixed_update_callback_type&& callback) noexcept
    {
        m_fixed_update_callback = callback;
    }
    inline void set_fixed_update_callback(const fixed_update_callback_type& callback) noexcept
    {
        m_fixed_update_callback = callback;
    }
 
    inline void set_variable_update_callback(variable_update_callback_type&& callback) noexcept
    {
        m_variable_update_callback = callback;
    }
    inline void set_variable_update_callback(const variable_update_callback_type& callback) noexcept
    {
        m_variable_update_callback = callback;
    }
    
    [[nodiscard]] inline duration_type get_fixed_update_time() const noexcept
    {
        return m_fixed_update_time;
    }
    
    [[nodiscard]] inline duration_type get_accumulated_time() const noexcept
    {
        return m_accumulated_time;
    }
    
    [[nodiscard]] inline duration_type get_frame_duration() const noexcept
    {
        return m_frame_duration;
    }
    
    [[nodiscard]] inline duration_type get_min_frame_duration() const noexcept
    {
        return m_min_frame_duration;
    }
    
    [[nodiscard]] inline duration_type get_max_frame_duration() const noexcept
    {
        return m_max_frame_duration;
    }
    
    [[nodiscard]] inline duration_type get_fixed_update_interval() const noexcept
    {
        return m_fixed_update_interval;
    }
    
    [[nodiscard]] inline const fixed_update_callback_type& get_fixed_update_callback() const noexcept
    {
        return m_fixed_update_callback;
    }
    
    [[nodiscard]] inline const variable_update_callback_type& get_variable_update_callback() const noexcept
    {
        return m_variable_update_callback;
    }
 
private:
    duration_type m_fixed_update_time{duration_type::zero()};
    duration_type m_accumulated_time{duration_type::zero()};
    
    time_point_type m_frame_start_time;
    time_point_type m_frame_end_time;
    duration_type m_frame_duration{duration_type::zero()};
    
    duration_type m_min_frame_duration{duration_type::zero()};
    duration_type m_max_frame_duration{duration_type::max()};
    
    duration_type m_fixed_update_interval{duration_type::zero()};
    
    fixed_update_callback_type m_fixed_update_callback;
    variable_update_callback_type m_variable_update_callback;
};
 
#endif // ANTKEEPER_UTILITY_FRAME_SCHEDULER_HPP