process_sample()

double MayaFlux::Nodes::Generator::Sine::process_sample ( double  input = 0. )

overridevirtual

Processes a single input sample and generates a sine wave sample.

Parameters

input

Input sample (used for modulation when modulators are connected)

Returns

Generated sine wave sample

This method advances the oscillator's phase and computes the next sample of the sine wave, applying any modulation from connected nodes.

Implements MayaFlux::Nodes::Node.

Definition at line 73 of file Sine.cpp.

{
    if (m_frequency_modulator) {
        atomic_inc_modulator_count(m_frequency_modulator->m_modulator_count, 1);
        uint32_t state = m_frequency_modulator->m_state.load();
        double current_freq = m_frequency;
 
        if (state & NodeState::PROCESSED) {
            current_freq += m_frequency_modulator->get_last_output();
        } else {
            current_freq += m_frequency_modulator->process_sample(0.F);
            atomic_add_flag(m_frequency_modulator->m_state, NodeState::PROCESSED);
        }
        update_phase_increment(current_freq);
    }
 
    double current_sample = std::sin(m_phase + m_offset);
    m_phase += m_phase_inc;
 
    if (m_phase > 2 * M_PI) {
        m_phase -= 2 * M_PI;
    } else if (m_phase < -2 * M_PI) {
        m_phase += 2 * M_PI;
    }
 
    double current_amplitude = m_amplitude;
    if (m_amplitude_modulator) {
        atomic_inc_modulator_count(m_amplitude_modulator->m_modulator_count, 1);
        uint32_t state = m_amplitude_modulator->m_state.load();
 
        if (state & NodeState::PROCESSED) {
            current_amplitude += m_amplitude_modulator->get_last_output();
            if (!(state & NodeState::ACTIVE)) {
                atomic_remove_flag(m_amplitude_modulator->m_state, NodeState::PROCESSED);
            }
        } else {
            current_amplitude += m_amplitude_modulator->process_sample(0.F);
            atomic_add_flag(m_amplitude_modulator->m_state, NodeState::PROCESSED);
        }
    }
    current_sample *= current_amplitude;
 
    if (input != 0.0) {
        current_sample += input;
        current_sample *= 0.5F;
    }
 
    m_last_output = current_sample;
 
    if ((!m_state_saved || (m_state_saved && m_fire_events_during_snapshot))
        && !m_networked_node) {
        notify_tick(current_sample);
    }
 
    if (m_frequency_modulator) {
        atomic_dec_modulator_count(m_frequency_modulator->m_modulator_count, 1);
        try_reset_processed_state(m_frequency_modulator);
    }
    if (m_amplitude_modulator) {
        atomic_dec_modulator_count(m_amplitude_modulator->m_modulator_count, 1);
        try_reset_processed_state(m_amplitude_modulator);
    }
    return current_sample;
}

References MayaFlux::Nodes::ACTIVE, MayaFlux::Nodes::atomic_add_flag(), MayaFlux::Nodes::atomic_dec_modulator_count(), MayaFlux::Nodes::atomic_inc_modulator_count(), MayaFlux::Nodes::atomic_remove_flag(), MayaFlux::Nodes::Generator::Generator::m_amplitude, m_amplitude_modulator, MayaFlux::Nodes::Node::m_fire_events_during_snapshot, MayaFlux::Nodes::Generator::Generator::m_frequency, m_frequency_modulator, MayaFlux::Nodes::Node::m_last_output, MayaFlux::Nodes::Node::m_networked_node, m_offset, MayaFlux::Nodes::Generator::Generator::m_phase, m_phase_inc, MayaFlux::Nodes::Node::m_state_saved, notify_tick(), MayaFlux::Nodes::PROCESSED, MayaFlux::Nodes::try_reset_processed_state(), and update_phase_increment().

Referenced by process_batch().

Here is the call graph for this function:

Here is the caller graph for this function: