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
ProcessingToken	get_processing_token () const override
	Get the processing token that determines how this routine should be scheduled.

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

	GraphicsRoutine (const GraphicsRoutine &other)
	Copy constructor.

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

	GraphicsRoutine (GraphicsRoutine &&other) noexcept
	Move constructor.

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

	~GraphicsRoutine () override

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Public Member Functions inherited from MayaFlux::Vruta::Routine
virtual	~Routine ()=default
	Destructor.

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

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

template<typename T >
T *	get_state (const std::string &key)
	Gets a named state value from the coroutine.

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

void *	get_state_impl_raw (const std::string &key) 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 504 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