try_resume_with_context()

bool MayaFlux::Vruta::SoundRoutine::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 112 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;
    }
 
    if (context != DelayContext::NONE && promise_ref.active_delay_context == DelayContext::AWAIT) {
        return initialize_state(current_value);
    }
 
    if (promise_ref.active_delay_context != DelayContext::NONE && promise_ref.active_delay_context != context) {
        return false;
    }
 
    bool should_resume = false;
 
    switch (context) {
    case DelayContext::SAMPLE_BASED:
        if (promise_ref.active_delay_context == DelayContext::SAMPLE_BASED) {
            should_resume = (current_value >= promise_ref.next_sample);
            if (should_resume) {
                promise_ref.next_sample = current_value + promise_ref.delay_amount;
            }
        } else {
            should_resume = false;
        }
        break;
 
    case DelayContext::BUFFER_BASED:
        if (promise_ref.active_delay_context == DelayContext::BUFFER_BASED) {
            should_resume = (current_value >= promise_ref.next_buffer_cycle);
 
            if (should_resume) {
                promise_ref.next_buffer_cycle = current_value + promise_ref.delay_amount;
            }
        } else {
            should_resume = false;
        }
        break;
 
    case DelayContext::NONE:
        should_resume = true;
        break;
 
    default:
        return false;
    }
 
    if (should_resume) {
        m_handle.resume();
        return true;
    }
 
    return false;
}

References MayaFlux::Vruta::AWAIT, MayaFlux::Vruta::BUFFER_BASED, initialize_state(), is_active(), m_handle, 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: