TestbedPipeline.hh

#ifndef VTESTBED_GUI_TESTBEDPIPELINE_HH
#define VTESTBED_GUI_TESTBEDPIPELINE_HH

#include <atomic>
#include <chrono>
#include <mutex>
#include <thread>

#include <vtestbed/core/testbed.hh>
#include <vtestbed/gui/types.hh>

namespace vtb {

    namespace gui {

        template <class T>
        class TestbedPipeline {

        public:
            using testbed_type = vtb::core::Testbed<T,3>;
            using testbed_gui_type = TestbedGUI<T>;
            using clock_type = std::chrono::high_resolution_clock;
            using time_point = clock_type::time_point;
            using duration = clock_type::duration;
            using float_duration = std::chrono::duration<T>;
            using mutex_type = std::recursive_mutex;
            using thread_type = std::thread;
            using statistics_type = vtb::core::Statistics<T>;
            using Record = typename statistics_type::Record;
            using callback_type = std::function<void(testbed_type&)>;
            using gui_callback_type = std::function<void(testbed_gui_type&)>;
            using callback_array = std::vector<callback_type>;
            using gui_callback_array = std::vector<gui_callback_type>;
            using lock_type = std::lock_guard<mutex_type>;

        private:
            enum class state_type {initial, started, stopped};

        private:
            testbed_type _testbed;
            testbed_gui_type* _testbed_gui;
            callback_array _callbacks;
            gui_callback_array _gui_callbacks;
            thread_type _thread;
            mutex_type _mutex;
            std::atomic<state_type> _state{state_type::initial};
            T _min_time_step{T{1} / T{60}};
            T _max_time_step{T{1} / T{5}};
            T _speed{1};
            T _dt_accumulator;
            std::atomic<bool> _fixed_time_step{false};

        public:

            TestbedPipeline() = default;
            ~TestbedPipeline() = default;

            void
            start();

            inline void stop() { this->_state = state_type::stopped; }
            void reset();

            inline void
            wait() {
                if (this->_thread.joinable()) {
                    this->_thread.join();
                }
            }

            inline bool initial() const { return this->_state == state_type::initial; }
            inline bool stopped() const { return this->_state == state_type::stopped; }
            inline bool started() const { return this->_state == state_type::started; }

            inline void testbed_gui(testbed_gui_type* rhs) { this->_testbed_gui = rhs; }
            inline testbed_gui_type* testbed_gui() { return this->_testbed_gui; }
            void testbed(testbed_type&& rhs);
            inline testbed_type* testbed() { return &this->_testbed; }

            inline T min_time_step() const { return this->_min_time_step; }
            inline void min_time_step(T rhs) { this->_min_time_step = rhs; }
            inline T max_time_step() const { return this->_max_time_step; }
            inline void max_time_step(T rhs) { this->_max_time_step = rhs; }
            inline T speed() const { return this->_speed; }
            inline void speed(T rhs) { this->_speed = rhs; }
            inline T time_step() const { return this->_dt_accumulator; }
            inline void fixed_time_step(bool rhs) { this->_fixed_time_step = rhs; }
            inline bool fixed_time_step() const { return this->_fixed_time_step; }

            inline T
            frame_rate() const {
                auto len = time_step();
                return len == T{} ? T{0} : (T{1} / len);
            }

            inline void
            accumulate_dt(T dt) {
                const T w1 = 0.25;
                const T w2 = T{1} - w1;
                _dt_accumulator = w1*dt + w2*_dt_accumulator;
            }

            template <class Callback>
            inline void
            call(Callback&& cb) {
                lock_type lock(this->_mutex);
                this->_callbacks.emplace_back(std::move(cb));
            }

            template <class Callback>
            inline void
            gui_call(Callback&& cb) {
                this->_gui_callbacks.emplace_back(std::move(cb));
            }

            void do_gui_callbacks();

        private:

            void do_callbacks();
            void loop();

        };

    }

}

#endif // vim:filetype=cpp