pattern()

MAYAFLUX_API std::shared_ptr< Vruta::Routine > MayaFlux::Kriya::pattern	(	std::function< std::any(uint64_t)>	pattern_func,
		std::function< void(std::any)>	callback,
		double	interval_seconds,
		Vruta::ProcessingToken	token = Vruta::ProcessingToken::SAMPLE_ACCURATE
	)

Creates a generative algorithm that produces values based on a pattern function.

Parameters

pattern_func	Function that generates values based on a step index
callback	Function to execute with each generated value
interval_seconds	Time between pattern steps in seconds

Returns

A Routine shared_ptr of type determined by the processing token of the scheduler (SoundRoutine, GraphicsRoutine, etc.)

The pattern task provides a powerful framework for algorithmic generation of values according to any computational pattern or rule system. At regular intervals, it calls the pattern_func with the current step index, then passes the returned value to the callback function.

This mechanism enables the creation of generative algorithms, procedural sequences, emergent behaviors, and rule-based systems that can influence any aspect of a computational environment - from audio parameters to visual elements, data transformations, or cross-domain mappings.

Example usage:

// Create a generative algorithm based on a mathematical sequence
std::vector<int> fibonacci = {0, 1, 1, 2, 3, 5, 8, 13, 21};
auto generator = Kriya::pattern(
    // Pattern function - apply algorithmic rules
    [&fibonacci](uint64_t step) -> std::any {
        return fibonacci[step % fibonacci.size()];
    },
    // Callback - apply the generated value
    [](std::any value) {
        int result = std::any_cast<int>(value);
        // Can be applied to any domain - audio, visual, data, etc.
        apply_generated_value(result);
    },
    0.125 // Generate 8 values per second
);
scheduler->add_task(generator);

The pattern task continues indefinitely until explicitly cancelled, creating an ongoing generative process within the computational system.

Definition at line 116 of file Tasks.cpp.

{
    if (token == Vruta::ProcessingToken::FRAME_ACCURATE) {
        auto coro = [](std::function<std::any(uint64_t)> fn, std::function<void(std::any)> cb, double interval) -> Vruta::GraphicsRoutine {
            uint64_t units = Vruta::seconds_to_frames(interval);
            uint64_t step = 0;
            while (true) {
                cb(fn(step++));
                co_await FrameDelay { .frames_to_wait = units };
            }
        };
        return std::make_shared<Vruta::GraphicsRoutine>(coro(std::move(pattern_func), std::move(callback), interval_seconds));
    }
 
    auto coro = [](std::function<std::any(uint64_t)> fn, std::function<void(std::any)> cb, double interval) -> Vruta::SoundRoutine {
        uint64_t units = Vruta::seconds_to_samples(interval);
        uint64_t step = 0;
        while (true) {
            cb(fn(step++));
            co_await SampleDelay { units };
        }
    };
    return std::make_shared<Vruta::SoundRoutine>(coro(std::move(pattern_func), std::move(callback), interval_seconds));
}

References MayaFlux::Vruta::FRAME_ACCURATE, MayaFlux::Kriya::FrameDelay::frames_to_wait, MayaFlux::Vruta::seconds_to_frames(), and MayaFlux::Vruta::seconds_to_samples().

Referenced by MayaFlux::schedule_pattern().

Here is the call graph for this function:

Here is the caller graph for this function: