line()

MAYAFLUX_API Vruta::SoundRoutine MayaFlux::Kriya::line	(	Vruta::TaskScheduler &	scheduler,
		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.

Parameters

scheduler	The task scheduler that will manage this generator
start_value	Initial value of the interpolation
end_value	Final value of the interpolation
duration_seconds	Total duration of the interpolation in seconds
step_duration	Number of samples between value updates (default: 5)
restartable	Whether the interpolation can be restarted after completion (default: false)

Returns

A SoundRoutine that implements the interpolation behavior

The line task generates a linear interpolation between two numerical values over a specified duration. This creates continuous, gradual transitions that can be applied to any parameter in a computational system - from audio parameters to visual properties, physical simulation values, or data transformation coefficients.

The current value of the interpolation is stored in the task's state under the key "current_value" and can be accessed by external code using get_state<float>.

Example usage:

// Create a 2-second interpolation from 0.0 to 1.0
auto transition = Kriya::line(*scheduler, 0.0f, 1.0f, 2.0f);
auto task_ptr = std::make_shared<SoundRoutine>(std::move(transition));
scheduler->add_task(task_ptr);
 
// In the processing loop:
float* value = task_ptr->get_state<float>("current_value");
if (value) {
    // Apply to any parameter in any domain
    apply_parameter(*value);
}

If restartable is true, the interpolation task will remain active after reaching the end value and can be restarted by calling restart() on the SoundRoutine.

Definition at line 31 of file Tasks.cpp.

{
    auto& promise_ref = co_await GetAudioPromise {};
 
    promise_ref.set_state("current_value", start_value);
    promise_ref.set_state("end_value", end_value);
    promise_ref.set_state("restart", false);
 
    const unsigned int sample_rate = scheduler.get_rate();
    if (step_duration < 1) {
        step_duration = 1;
    }
 
    uint64_t total_samples = duration_seconds * sample_rate;
    float per_sample_step = (end_value - start_value) / total_samples;
    float sample_step = per_sample_step * step_duration;
 
    promise_ref.set_state("step", sample_step);
 
    for (;;) {
        float* current_value = promise_ref.get_state<float>("current_value");
        float* last_value = promise_ref.get_state<float>("end_value");
        float* step = promise_ref.get_state<float>("step");
 
        if (!current_value || !last_value || !step) {
            std::cerr << "Error: line task state not properly initialized" << std::endl;
            co_return;
        }
 
        *current_value = start_value;
 
        uint64_t samples_elapsed = 0;
 
        co_await SampleDelay { 1 };
 
        while (samples_elapsed < total_samples) {
            *current_value += *step;
 
            if ((*step > 0 && *current_value >= *last_value) || (*step < 0 && *current_value <= *last_value)) {
                *current_value = *last_value;
            }
 
            samples_elapsed += step_duration;
            co_await SampleDelay { step_duration };
        }
 
        if (!restartable)
            break;
 
        bool* restart_requested = promise_ref.get_state<bool>("restart");
        if (restart_requested && *restart_requested) {
            *restart_requested = false;
            continue;
        }
 
        promise_ref.auto_resume = false;
        co_await std::suspend_always {};
    }
}

References MayaFlux::Vruta::TaskScheduler::get_rate().

Referenced by MayaFlux::create_line().

Here is the call graph for this function:

Here is the caller graph for this function: