process_sample()

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

overridevirtual

Processes a single input sample and generates an impulse sample.

Parameters

input

Input sample (used for modulation when modulators are connected)

Returns

Generated impulse sample (1.0 at the start of each cycle, 0.0 elsewhere)

This method advances the generator's phase and computes the next sample of the impulse train, applying any modulation from connected nodes.

Implements MayaFlux::Nodes::Node.

Definition at line 77 of file Impulse.cpp.

{
    double output = 0.0;
    m_impulse_occurred = false;
 
    double effective_freq = m_frequency;
    if (m_frequency_modulator) {
        atomic_inc_modulator_count(m_frequency_modulator->m_modulator_count, 1);
        uint32_t state = m_frequency_modulator->m_state.load();
        if (state & Nodes::NodeState::PROCESSED) {
            effective_freq += m_frequency_modulator->get_last_output();
        } else {
            effective_freq = m_frequency_modulator->process_sample(0.F);
            atomic_add_flag(m_frequency_modulator->m_state, Nodes::NodeState::PROCESSED);
        }
 
        if (effective_freq <= 0) {
            effective_freq = 0.001;
        }
        update_phase_increment(effective_freq);
    }
 
    if (m_phase < m_phase_inc) {
        output = m_amplitude;
        m_impulse_occurred = true;
    } else {
        output = 0.0;
    }
 
    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();
        } else {
            current_amplitude += m_amplitude_modulator->process_sample(0.F);
            atomic_add_flag(m_amplitude_modulator->m_state, NodeState::PROCESSED);
        }
    }
 
    output *= current_amplitude;
    m_amplitude = current_amplitude;
    output += m_offset;
 
    m_phase += m_phase_inc;
    if (m_phase >= 1.0) {
        m_phase -= 1.0;
    }
 
    m_last_output = output;
 
    if ((!m_state_saved || (m_state_saved && m_fire_events_during_snapshot))
        && !m_networked_node) {
        notify_tick(output);
    }
 
    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 output;
}

References MayaFlux::Nodes::atomic_add_flag(), MayaFlux::Nodes::atomic_dec_modulator_count(), MayaFlux::Nodes::atomic_inc_modulator_count(), 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, m_impulse_occurred, 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: