A C++20 coroutine-based graphics processing task with frame-accurate timing. More...

#include <Routine.hpp>

Inheritance diagram for MayaFlux::Vruta::GraphicsRoutine:

Collaboration diagram for MayaFlux::Vruta::GraphicsRoutine:

Public Types
using	promise_type = MayaFlux::Vruta::graphics_promise
	Promise type used by this coroutine.

Public Member Functions
bool	force_resume () override
	Force resume the coroutine, bypassing all checks Used only during shutdown to push coroutines to final_suspend.

bool	get_auto_resume () const override
	Get auto_resume flag from promise.

DelayContext	get_delay_context () const override
	Get the active delay context for this routine.

uint64_t	get_next_frame () const override
	Get next frame execution time (graphics domain)

uint64_t	get_next_sample () const override
	Get next sample execution time (audio domain)

ProcessingToken	get_processing_token () const override
	Get the processing token that determines how this routine should be scheduled.

bool	get_should_terminate () const override
	Get should_terminate flag from promise.

bool	get_sync_to_clock () const override
	Get sync_to_clock flag from promise.

	GraphicsRoutine (const GraphicsRoutine &other)
	Copy constructor.

	GraphicsRoutine (GraphicsRoutine &&other) noexcept
	Move constructor.

	GraphicsRoutine (std::coroutine_handle< promise_type > h)
	Constructs a GraphicsRoutine from a coroutine handle.

bool	initialize_state (uint64_t current_frame=0U) override
	Initializes the coroutine's state for execution.

bool	is_active () const override
	Checks if the coroutine is still active.

uint64_t	next_execution () const override
	Gets the sample position when this routine should next execute.

GraphicsRoutine &	operator= (const GraphicsRoutine &other)
	Copy assignment operator.

GraphicsRoutine &	operator= (GraphicsRoutine &&other) noexcept
	Move assignment operator.

bool	requires_clock_sync () const override
	Check if the routine should synchronize with a clock.

bool	restart () override
	Restarts the coroutine from the beginning.

void	set_auto_resume (bool auto_resume) override
	Set auto_resume flag in promise.

void	set_delay_context (DelayContext context) override
	Set the active delay context for this routine.

void	set_next_frame (uint64_t next_frame) override
	Set next frame execution time (graphics domain)

void	set_next_sample (uint64_t) override
	Set next sample execution time (audio domain)

void	set_should_terminate (bool should_terminate) override
	Set should_terminate flag in promise.

bool	try_resume (uint64_t current_context) override
	Attempts to resume the coroutine if it's ready to execute.

bool	try_resume_with_context (uint64_t current_value, DelayContext context) override
	Attempts to resume the coroutine with explicit temporal context.

	~GraphicsRoutine () override

Public Member Functions inherited from MayaFlux::Vruta::Routine
template<typename T >
T *	get_state (const std::string &key)
	Gets a named state value from the coroutine.

template<typename T >
void	set_state (const std::string &key, T value)
	Sets a named state value in the coroutine.

template<typename... Args>
void	update_params (Args... args)
	Updates multiple named parameters in the coroutine's state.

virtual	~Routine ()=default
	Destructor.

Protected Member Functions
void *	get_state_impl_raw (const std::string &key) override

void	set_state_impl (const std::string &key, std::any value) override

Protected Member Functions inherited from MayaFlux::Vruta::Routine
template<typename T >
T *	get_state_impl (const std::string &key)
	Implementation helper for get_state.

virtual void	update_params_impl ()
	brief Implementation helper for update_params

template<typename T , typename... Args>
void	update_params_impl (const std::string &key, T value, Args... args)
	Implementation helper for update_params.

Private Attributes
std::coroutine_handle< promise_type >	m_handle
	Handle to the underlying coroutine.

Detailed Description

A C++20 coroutine-based graphics processing task with frame-accurate timing.

GraphicsRoutine encapsulates a coroutine that can execute visual processing logic with frame-accurate timing. It provides the graphics-domain equivalent to SoundRoutine, enabling time-based visual code that appears sequential but executes asynchronously in perfect sync with the frame timeline.

Key architectural differences from SoundRoutine:

Timing source: FrameClock (self-driven) vs SampleClock (hardware-driven)
The routine doesn't care HOW the clock advances, only that it gets tick updates
GraphicsRoutine synchronized to frame positions, not sample positions
Works with FrameDelay awaiters instead of SampleDelay

Key features:

Frame-accurate timing for precise visual scheduling
State persistence between suspensions and resumptions
Automatic management of coroutine lifetime
Ability to restart and reschedule tasks
Dynamic parameter updates during execution
Named state storage for flexible data management

This implementation leverages C++20 coroutines to create a cooperative multitasking system specifically designed for visual processing. Each routine can suspend itself at precise frame positions and be resumed exactly when needed, enabling complex temporal behaviors for animations, visual effects, and data-driven visuals without blocking the graphics thread.

Example usage:

auto fade_animation = [](TaskScheduler& scheduler) -> GraphicsRoutine {
    float opacity = 0.0f;
    for (int i = 0; i < 60; i++) {  // 60 frames at 60fps = 1 second
        opacity += 1.0f / 60.0f;
        set_shader_opacity(opacity);
        co_await FrameDelay{1};  // Wait exactly 1 frame
    }
};

Definition at line 513 of file Routine.hpp.

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Protected Member Functions

Private Attributes

Detailed Description