execute_frame_phased()

Vruta::GraphicsRoutine MayaFlux::Kriya::BufferPipeline::execute_frame_phased ( uint64_t  max_cycles, uint64_t  frames_per_operation  )

private

Definition at line 258 of file BufferPipelineExecution.cpp.

{
    auto& promise = co_await Kriya::GetGraphicsPromise {};
 
    if (m_operations.empty()) {
        co_return;
    }
 
    m_data_states.resize(m_operations.size(), DataState::EMPTY);
    uint32_t cycles_executed = 0;
 
    while ((max_cycles == 0 || cycles_executed < max_cycles) && (m_continuous_execution || cycles_executed < max_cycles)) {
 
        if (promise.should_terminate) {
            break;
        }
 
        bool waited = false;
 
        start_cycle();
        reset_cycle_state();
 
        for (size_t i = 0; i < m_operations.size(); ++i) {
            auto& op = m_operations[i];
 
            if (!BufferOperation::is_capture_phase_operation(op) || !operation_due(op)) {
                continue;
            }
 
            const uint32_t op_iterations = operation_iterations(op);
 
            for (uint32_t iter = 0; iter < op_iterations; ++iter) {
                process_operation(op, m_current_cycle + iter);
                waited = true;
                co_await FrameDelay { .frames_to_wait = 1 };
            }
 
            m_data_states[i] = DataState::READY;
        }
 
        for (size_t i = 0; i < m_operations.size(); ++i) {
            auto& op = m_operations[i];
 
            if (!BufferOperation::is_process_phase_operation(op)) {
                continue;
            }
 
            if (m_data_states[i] == DataState::CONSUMED) {
                continue;
            }
 
            if (!operation_due(op)) {
                continue;
            }
 
            process_operation(op, m_current_cycle);
            m_data_states[i] = DataState::READY;
 
            if (frames_per_operation > 0) {
                waited = true;
                co_await FrameDelay { .frames_to_wait = frames_per_operation };
            }
        }
 
        const auto synchronous_tasks = dispatch_cycle_branches(true);
 
        while (any_active(synchronous_tasks)) {
            waited = true;
            co_await FrameDelay { .frames_to_wait = 1 };
        }
 
        finish_cycle();
 
        m_current_cycle++;
        cycles_executed++;
 
        if (!waited) {
            co_await FrameDelay { .frames_to_wait = 1 };
        }
    }
 
    if (m_on_complete)
        m_on_complete();
}

References any_active(), CONSUMED, dispatch_cycle_branches(), EMPTY, finish_cycle(), MayaFlux::Kriya::FrameDelay::frames_to_wait, MayaFlux::Kriya::BufferOperation::is_capture_phase_operation(), MayaFlux::Kriya::BufferOperation::is_process_phase_operation(), m_continuous_execution, m_current_cycle, m_data_states, m_on_complete, m_operations, operation_due(), operation_iterations(), process_operation(), READY, reset_cycle_state(), and start_cycle().

Referenced by execute_frame_internal().

Here is the call graph for this function:

Here is the caller graph for this function: