MayaFlux::Kriya Namespace Reference

Namespaces
namespace	detail

Classes
class	BroadcastAwaiter
	Awaiter for suspending a coroutine until a BroadcastSource<T> fires. More...
class	BufferCapture
	Flexible data capture interface for buffer-based processing pipelines. More...
struct	BufferDelay
	Awaiter for suspending until a buffer cycle boundary. More...
class	BufferOperation
	Fundamental unit of operation in buffer processing pipelines. More...
class	BufferPipeline
	Coroutine-based execution engine for composable, multi-strategy buffer processing. More...
class	CaptureBuilder
	Fluent builder interface for constructing BufferCapture configurations. More...
class	Chimera
	Assembles the layers of a TextureArrayBuffer from whatever feeds them, so a fragment shader can build one picture out of many. More...
class	ChimeraBuilder
	Declares the layers of a Chimera, in order, and starts feeding them. More...
class	ConditionAwaiter
	Suspends a FreeRoutine until a caller-supplied predicate returns true. More...
class	EventAwaiter
	Abstract base for all event-driven awaiters. More...
class	EventChain
	A sequential chain of timed events with precise temporal control. More...
struct	FrameDelay
	graphics-domain awaiter for frame-accurate timing delays More...
struct	GetEventPromise
	Event-domain promise accessor with optional NetworkSource ownership transfer. More...
struct	GetPromiseBase
	Templated awaitable for accessing a coroutine's promise object. More...
struct	GetPromiseBase< Vruta::cross_promise >
	Promise accessor specialization for cross_promise. More...
struct	MultiRateDelay
class	NetworkAwaiter
	Awaiter for suspending a coroutine until a network message arrives. More...
struct	PatternTraits
	Types a pattern derives from its generator and index. More...
struct	SampleDelay
	Awaitable object for precise sample-accurate timing delays. More...
class	SamplingPipeline
	Pipeline-coordinated polyphonic playback of a bounded audio stream. More...
class	TapSet
	One stream read by several independent taps. More...
class	TapSetBuilder
	Describes a tap set one tap at a time, then starts it. More...
class	TemporalActivation
	Specialized timer for controlling computational nodes, buffers, and networks. More...
class	TimedAction
	Utility for executing actions with a start and end function over a duration. More...
class	Timer
	High-level utility for scheduling one-shot timed callbacks. More...
class	WindowEventAwaiter
	Awaiter for suspending on window input events with optional filtering. More...
struct	WindowFrame

Concepts
concept	PatternGenerator
	A callable from a step index to a value.
concept	PatternCallback
	A callable that accepts what the generator returns.
concept	PatternCondition
	A predicate on the step index.
concept	PatternDurationSource
	A callable from a pass number to the array of durations for that pass.

Typedefs
using	GetAudioPromise = GetPromiseBase< Vruta::audio_promise >
	Audio domain promise accessor.
using	GetCrossPromise = GetPromiseBase< Vruta::cross_promise >
using	GetGraphicsPromise = GetPromiseBase< Vruta::graphics_promise >
	Graphics domain promise accessor.
using	OperationFunction = std::function< void(Kakshya::DataVariant &, uint32_t)>
using	TransformationFunction = std::function< Kakshya::DataVariant(Kakshya::DataVariant &, uint32_t)>
using	TransformVectorFunction = std::function< Kakshya::DataVariant(std::vector< Kakshya::DataVariant > &, uint32_t)>

Enumerations
enum class	ExecutionStrategy : uint8_t { PHASED , STREAMING , PARALLEL , REACTIVE }
	Defines how operations in a pipeline are coordinated and executed. More...

Functions
Vruta::Event	any_key (std::shared_ptr< Core::Window > window, std::function< void(IO::Keys)> callback)
	Creates an Event coroutine that triggers on any key press.
std::shared_ptr< Vruta::BroadcastSource< bool > >	audio_output_tick ()
	Create a BroadcastSource<bool> ticking once per audio output cycle.
template<typename T >
void	frame_results (Vruta::TaskScheduler &scheduler, const std::shared_ptr< Vruta::BroadcastSource< T > > &source, std::function< std::optional< T >()> fn, const std::string &name="")
	Signal what fn returns into source once per graphics frame.
template<typename T >
std::shared_ptr< Vruta::BroadcastSource< T > >	frame_results (Vruta::TaskScheduler &scheduler, std::function< std::optional< T >()> fn, const std::string &name="")
	Broadcast of what fn returns, taken once per graphics frame.
Vruta::SoundRoutine	Gate (std::function< void()> callback, std::shared_ptr< Nodes::Generator::Logic > logic_node, bool open=true)
	Coroutine that executes callback continuously while logic node outputs true.
Vruta::Event	key_held (std::shared_ptr< Core::Window > window, IO::Keys key, std::function< void()> callback)
	Creates an Event coroutine that triggers on key press and repeats while held.
Vruta::Event	key_pressed (std::shared_ptr< Core::Window > window, IO::Keys key, std::function< void()> callback)
	Creates an Event coroutine that triggers on specific key press.
Vruta::Event	key_released (std::shared_ptr< Core::Window > window, IO::Keys key, std::function< void()> callback)
	Creates an Event coroutine that triggers on specific key release.
Vruta::SoundRoutine	line (float start_value, float end_value, float duration_seconds, uint32_t step_duration=5, bool restartable=false)
	Creates a continuous interpolation generator between two values over time.
std::shared_ptr< Vruta::Routine >	metro (double interval_seconds, std::function< void()> callback, Vruta::ProcessingToken token=Vruta::ProcessingToken::SAMPLE_ACCURATE)
	Creates a periodic event generator that executes a callback at regular intervals.
Vruta::Event	mouse_dragged (std::shared_ptr< Core::Window > window, IO::MouseButtons button, std::function< void(double, double)> callback)
	Creates an Event coroutine that triggers on mouse drag with specific button.
Vruta::Event	mouse_moved (std::shared_ptr< Core::Window > window, std::function< void(double, double)> callback)
	Creates an Event coroutine that triggers on mouse movement.
Vruta::Event	mouse_pressed (std::shared_ptr< Core::Window > window, IO::MouseButtons button, std::function< void(double, double)> callback)
	Creates an Event coroutine that triggers on specific mouse button press.
Vruta::Event	mouse_released (std::shared_ptr< Core::Window > window, IO::MouseButtons button, std::function< void(double, double)> callback)
	Creates an Event coroutine that triggers on specific mouse button release.
Vruta::Event	mouse_scrolled (std::shared_ptr< Core::Window > window, std::function< void(double, double)> callback)
	Creates an Event coroutine that triggers on mouse scroll.
Vruta::Event	on_message (std::shared_ptr< Vruta::NetworkSource > source, std::function< void(const Core::NetworkMessage &)> callback)
	Creates an Event coroutine that fires on every message received by a source.
Vruta::Event	on_message_from (std::shared_ptr< Vruta::NetworkSource > source, std::string sender_address, std::function< void(const Core::NetworkMessage &)> callback)
	Creates an Event coroutine that fires only for messages from a specific sender.
Vruta::Event	on_message_matching (std::shared_ptr< Vruta::NetworkSource > source, std::function< bool(const Core::NetworkMessage &)> predicate, std::function< void(const Core::NetworkMessage &)> callback)
	Creates an Event coroutine that fires only when a predicate matches.
template<typename T , typename Callback >
Vruta::Event	on_signal (std::shared_ptr< Vruta::BroadcastSource< T > > source, Callback callback)
	Creates an Event coroutine that fires on every signal from a BroadcastSource.
template<typename T , typename Predicate , typename Callback >
Vruta::Event	on_signal_matching (std::shared_ptr< Vruta::BroadcastSource< T > > source, Predicate predicate, Callback callback)
	Creates an Event coroutine that fires only when a predicate matches.
std::shared_ptr< BufferPipeline >	operator>> (std::shared_ptr< BufferPipeline > pipeline, BufferOperation &&operation)
std::shared_ptr< BufferPipeline >	operator>> (std::shared_ptr< BufferPipeline > pipeline, BufferOperation &operation)
template<std::incrementable Index = uint64_t, typename Generator , typename Callback , typename Condition > requires PatternGenerator<Generator, Index> && PatternCallback<Callback, typename PatternTraits<Generator, Index>::value_type> && PatternCondition<Condition, Index>
std::shared_ptr< Vruta::Routine >	pattern (Generator generator, Callback callback, Condition ready, Vruta::ProcessingToken token=Vruta::ProcessingToken::SAMPLE_ACCURATE)
	Creates a pattern whose next step runs when a condition holds.
template<std::incrementable Index = uint64_t, typename Generator , typename Callback , typename Source > requires PatternGenerator<Generator, Index> && PatternCallback<Callback, typename PatternTraits<Generator, Index>::value_type> && PatternDurationSource<Source>
std::shared_ptr< Vruta::Routine >	pattern (Generator generator, Callback callback, Source durations, Vruta::ProcessingToken token=Vruta::ProcessingToken::SAMPLE_ACCURATE)
	Creates a pattern whose durations come from a function that returns an array per pass.
template<std::incrementable Index = uint64_t, typename Generator , typename Callback > requires PatternGenerator<Generator, Index> && PatternCallback<Callback, typename PatternTraits<Generator, Index>::value_type>
std::shared_ptr< Vruta::Routine >	pattern (Generator generator, Callback callback, std::vector< double > durations, Vruta::ProcessingToken token=Vruta::ProcessingToken::SAMPLE_ACCURATE)
	Creates a pattern whose steps are spaced by a list of durations.
std::shared_ptr< Vruta::Routine >	pattern (std::function< std::any(uint64_t)> pattern_func, std::function< void(std::any)> callback, std::function< bool(uint64_t)> ready, Vruta::ProcessingToken token=Vruta::ProcessingToken::SAMPLE_ACCURATE)
	The std::any, uint64_t form of the condition driven pattern.
std::shared_ptr< Vruta::Routine >	sequence (std::vector< std::pair< double, std::function< void()> > > sequence, Vruta::ProcessingToken token=Vruta::ProcessingToken::SAMPLE_ACCURATE)
	Creates a temporal sequence that executes callbacks at specified time offsets.
template<typename T , typename Callback >
std::shared_ptr< Vruta::Event >	subscribe (Vruta::EventManager &events, std::shared_ptr< Vruta::BroadcastSource< T > > source, Callback callback, const std::string &name="")
	Call callback with every value source signals, registered on events.
Vruta::Event	text_input (std::shared_ptr< Core::Window > window, std::function< void(uint32_t)> callback)
	Creates an Event coroutine that triggers on resolved text input.
Vruta::SoundRoutine	Toggle (std::function< void()> callback, std::shared_ptr< Nodes::Generator::Logic > logic_node)
	Coroutine that executes callback on any logic node state change.
Vruta::SoundRoutine	Trigger (bool target_state, std::function< void()> callback, std::shared_ptr< Nodes::Generator::Logic > logic_node)
	Coroutine that executes callback when logic node changes to specific state.
Vruta::Event	window_closed (std::shared_ptr< Core::Window > window, std::function< void()> callback)
	Creates an Event coroutine that triggers on window close.
std::shared_ptr< Vruta::BroadcastSource< WindowFrame > >	window_frame_tick (const std::shared_ptr< Core::Window > &window)
	Create a BroadcastSource<bool> ticking once per captured window frame.
Vruta::Event	window_resized (std::shared_ptr< Core::Window > window, std::function< void(uint32_t, uint32_t)> callback)
	Creates an Event coroutine that triggers on window resize.