try_resume_with_context()

bool MayaFlux::Vruta::CrossRoutine::try_resume_with_context ( uint64_t  current_value, DelayContext    )

overridevirtual

Attempts to resume the coroutine with explicit temporal context.

Parameters

current_value	Current position in the timeline (samples, frames, cycles, etc.)
context	The temporal context being processed

Returns

True if the coroutine was resumed, false otherwise

This context-aware resume method allows different temporal mechanisms to coexist within the same processing token. For example, both sample-based and buffer-cycle-based delays can use SAMPLE_ACCURATE token without interfering with each other.

The default implementation delegates to try_resume(uint64_t) for backward compatibility. Derived classes can override to implement context-specific resumption logic.

Reimplemented from MayaFlux::Vruta::Routine.

Definition at line 468 of file Routine.cpp.

{
    if (!is_active())
        return false;
 
    auto& promise_ref = m_handle.promise();
 
    if (promise_ref.should_terminate || !promise_ref.auto_resume) {
        return false;
    }
 
    const DelayContext active = promise_ref.active_delay_context.load(std::memory_order_acquire);
 
    if (context != DelayContext::NONE && active == DelayContext::AWAIT) {
        return initialize_state(current_value);
    }
 
    if (active != DelayContext::MULTIPLE) {
        return false;
    }
 
    if (context == DelayContext::SAMPLE_BASED) {
        if (promise_ref.sample_delay_amount > 0
            && current_value >= promise_ref.next_sample.load(std::memory_order_acquire)) {
            promise_ref.sample_satisfied.store(true, std::memory_order_release);
        }
    } else if (context == DelayContext::FRAME_BASED) {
        if (promise_ref.frame_delay_amount > 0
            && current_value >= promise_ref.next_frame.load(std::memory_order_acquire)) {
            promise_ref.frame_satisfied.store(true, std::memory_order_release);
        }
    }
 
    bool sample_required = promise_ref.sample_delay_amount > 0;
    bool frame_required = promise_ref.frame_delay_amount > 0;
 
    if (sample_required && !promise_ref.sample_satisfied.load(std::memory_order_acquire)) {
        return false;
    }
    if (frame_required && !promise_ref.frame_satisfied.load(std::memory_order_acquire)) {
        return false;
    }
 
    DelayContext expected = DelayContext::MULTIPLE;
    if (!promise_ref.active_delay_context.compare_exchange_strong(
            expected, DelayContext::NONE,
            std::memory_order_acq_rel, std::memory_order_acquire)) {
        return false;
    }
 
    promise_ref.sample_satisfied.store(false, std::memory_order_release);
    promise_ref.frame_satisfied.store(false, std::memory_order_release);
 
    m_handle.resume();
    return true;
}

References MayaFlux::Vruta::AWAIT, MayaFlux::Vruta::FRAME_BASED, initialize_state(), is_active(), m_handle, MayaFlux::Vruta::MULTIPLE, MayaFlux::Vruta::NONE, and MayaFlux::Vruta::SAMPLE_BASED.

Referenced by try_resume().

Here is the call graph for this function:

Here is the caller graph for this function: