Chain.cpp

Go to the documentation of this file.

#include "Chain.hpp"
#include "MayaFlux/API/Chronie.hpp"
#include "MayaFlux/API/Graph.hpp"
#include "MayaFlux/Kriya/Awaiters.hpp"
#include "MayaFlux/Nodes/NodeGraphManager.hpp"
#include "MayaFlux/Vruta/Scheduler.hpp"
 
static const auto node_token = MayaFlux::Nodes::ProcessingToken::AUDIO_RATE;
 
namespace MayaFlux::Kriya {
 
EventChain::EventChain()
    : m_Scheduler(*MayaFlux::get_scheduler())
{
}
 
EventChain::EventChain(Vruta::TaskScheduler& scheduler)
    : m_Scheduler(scheduler)
{
}
 
EventChain& EventChain::then(std::function<void()> action, double delay_seconds)
{
    m_events.push_back({ std::move(action), delay_seconds });
    return *this;
}
 
void EventChain::start()
{
    if (m_events.empty())
        return;
 
    auto shared_this = std::make_shared<EventChain>(*this);
 
    auto coroutine_func = [](Vruta::TaskScheduler& scheduler, std::shared_ptr<EventChain> chain) -> MayaFlux::Vruta::SoundRoutine {
        for (const auto& event : chain->m_events) {
            co_await SampleDelay { scheduler.seconds_to_samples(event.delay_seconds) };
            try {
                if (event.action) {
                    event.action();
                }
            } catch (const std::exception& e) {
                std::cerr << "Exception in EventChain action: " << e.what() << '\n';
            } catch (...) {
                std::cerr << "Unknown exception in EventChain action" << '\n';
            }
        }
    };
 
    m_routine = std::make_shared<Vruta::SoundRoutine>(coroutine_func(m_Scheduler, shared_this));
    m_Scheduler.add_task(m_routine);
}
 
ActionToken::ActionToken(std::shared_ptr<Nodes::Node> _node)
    : type(Utils::ActionType::NODE)
    , node(std::move(_node))
{
}
 
ActionToken::ActionToken(double _seconds)
    : type(Utils::ActionType::TIME)
    , seconds(_seconds)
{
}
 
ActionToken::ActionToken(std::function<void()> _func)
    : type(Utils::ActionType::FUNCTION)
    , func(std::move(_func))
{
}
 
Sequence& Sequence::operator>>(const ActionToken& token)
{
    tokens.push_back(token);
    return *this;
}
 
void Sequence::execute()
{
    execute(MayaFlux::get_node_graph_manager(), MayaFlux::get_scheduler());
}
 
void Sequence::execute(const std::shared_ptr<Nodes::NodeGraphManager>& node_manager, const std::shared_ptr<Vruta::TaskScheduler>& scheduler)
{
    EventChain chain(*scheduler);
    double accumulated_time = 0.F;
 
    for (const auto& token : tokens) {
        if (token.type == Utils::ActionType::NODE) {
            chain.then([node = token.node, node_manager]() {
                auto& root = node_manager->get_root_node(node_token, 0);
                root.register_node(node);
            },
                accumulated_time);
            accumulated_time = 0.F;
        } else if (token.type == Utils::ActionType::TIME) {
            accumulated_time += token.seconds;
        } else if (token.type == Utils::ActionType::FUNCTION) {
            chain.then(token.func, accumulated_time);
            accumulated_time = 0.F;
        }
    }
    chain.start();
}
}