start()

void MayaFlux::Kriya::EventChain::start

(

)

Starts executing the event chain.

This method begins the execution of the event chain, scheduling each event to occur at its specified time. The events are executed in the order they were added, with the specified delays between them.

The timing is sample-accurate, ensuring that each event occurs at precisely the right moment in the computational timeline.

Definition at line 55 of file Chain.cpp.

{
    if (m_events.empty())
        return;
 
    m_on_complete_fired = false;
 
    auto s_coro_func = [](std::vector<TimedEvent> events,
                           uint64_t rate,
                           std::function<void()> on_complete_callback,
                           size_t repeat_count) -> MayaFlux::Vruta::SoundRoutine {
        auto& promise = co_await Kriya::GetAudioPromise {};
 
        for (size_t iteration = 0; iteration < repeat_count; ++iteration) {
            for (const auto& event : events) {
                if (promise.should_terminate) {
                    break;
                }
 
                co_await SampleDelay { Vruta::seconds_to_samples(event.delay_seconds, rate) };
                try {
                    if (event.action) {
                        event.action();
                    }
                } catch (const std::exception& e) {
                    MF_RT_ERROR(
                        Journal::Component::Kriya,
                        Journal::Context::CoroutineScheduling,
                        "Exception in EventChain action: {}", e.what());
                } catch (...) {
                    MF_RT_ERROR(
                        Journal::Component::Kriya,
                        Journal::Context::CoroutineScheduling,
                        "Unknown exception in EventChain action");
                }
            }
 
            if (promise.should_terminate) {
                break;
            }
        }
 
        if (on_complete_callback) {
            try {
                on_complete_callback();
            } catch (const std::exception& e) {
                MF_RT_ERROR(
                    Journal::Component::Kriya,
                    Journal::Context::CoroutineScheduling,
                    "Exception in EventChain on_complete: {}", e.what());
            } catch (...) {
                MF_RT_ERROR(
                    Journal::Component::Kriya,
                    Journal::Context::CoroutineScheduling,
                    "Unknown exception in EventChain on_complete");
            }
        }
    };
 
    auto g_coro_func = [](std::vector<TimedEvent> events,
                           uint64_t rate,
                           std::function<void()> on_complete_callback,
                           size_t repeat_count) -> MayaFlux::Vruta::GraphicsRoutine {
        auto& promise = co_await Kriya::GetGraphicsPromise {};
 
        for (size_t iteration = 0; iteration < repeat_count; ++iteration) {
            for (const auto& event : events) {
                if (promise.should_terminate) {
                    break;
                }
 
                co_await FrameDelay { Vruta::seconds_to_frames(event.delay_seconds, rate) };
                try {
                    if (event.action) {
                        event.action();
                    }
                } catch (const std::exception& e) {
                    MF_RT_ERROR(
                        Journal::Component::Kriya,
                        Journal::Context::CoroutineScheduling,
                        "Exception in EventChain action: {}", e.what());
                } catch (...) {
                    MF_RT_ERROR(
                        Journal::Component::Kriya,
                        Journal::Context::CoroutineScheduling,
                        "Unknown exception in EventChain action");
                }
            }
 
            if (promise.should_terminate) {
                break;
            }
        }
 
        if (on_complete_callback) {
            try {
                on_complete_callback();
            } catch (const std::exception& e) {
                MF_RT_ERROR(
                    Journal::Component::Kriya,
                    Journal::Context::CoroutineScheduling,
                    "Exception in EventChain on_complete: {}", e.what());
            } catch (...) {
                MF_RT_ERROR(
                    Journal::Component::Kriya,
                    Journal::Context::CoroutineScheduling,
                    "Unknown exception in EventChain on_complete");
            }
        }
    };
 
    std::string task_name = m_name.empty() ? "EventChain_" + std::to_string(m_Scheduler.get_next_task_id()) : m_name;
 
    if (m_token == Vruta::ProcessingToken::SAMPLE_ACCURATE) {
        m_routine = std::make_shared<Vruta::SoundRoutine>(
            s_coro_func(m_events, m_default_rate, m_on_complete, m_repeat_count));
    } else {
        m_routine = std::make_shared<Vruta::GraphicsRoutine>(
            g_coro_func(m_events, m_default_rate, m_on_complete, m_repeat_count));
    }
 
    m_Scheduler.add_task(m_routine, task_name, true);
}

References MayaFlux::Vruta::TaskScheduler::add_task(), MayaFlux::Journal::CoroutineScheduling, MayaFlux::Vruta::TaskScheduler::get_next_task_id(), MayaFlux::Journal::Kriya, m_default_rate, m_events, m_name, m_on_complete, m_on_complete_fired, m_repeat_count, m_routine, m_Scheduler, m_token, MF_RT_ERROR, repeat_count(), MayaFlux::Vruta::SAMPLE_ACCURATE, MayaFlux::Vruta::seconds_to_frames(), and MayaFlux::Vruta::seconds_to_samples().

Here is the call graph for this function: