process_sample()

double MayaFlux::Nodes::Generator::Counter::process_sample ( double  input = 0.0 )

overridevirtual

Processes a single data sample.

Parameters

input

The input sample value

Returns

The processed output sample value

This is the core processing method that all nodes must implement. It takes a single input value, applies the node's transformation algorithm, and returns the resulting output value.

For generator nodes that don't require input (like oscillators or stochastic generators), the input parameter may be ignored. Note: This method does NOT mark the node as processed. That responsibility belongs to the caller, typically a chained parent node or the root node.

Implements MayaFlux::Nodes::Node.

Definition at line 59 of file Counter.cpp.

{
    if (m_reset_trigger) {
        atomic_inc_modulator_count(m_reset_trigger->m_modulator_count, 1);
        uint32_t state = m_reset_trigger->m_state.load();
 
        double trigger_val = 0.0;
        if (state & NodeState::PROCESSED) {
            trigger_val = m_reset_trigger->get_last_output();
        } else {
            trigger_val = m_reset_trigger->process_sample(0.0);
            atomic_add_flag(m_reset_trigger->m_state, NodeState::PROCESSED);
        }
 
        if (trigger_val != 0.0 && m_last_trigger_value == 0.0) {
            m_count = 0;
        }
        m_last_trigger_value = trigger_val;
    }
 
    m_wrapped = false;
    if (m_modulo > 0) {
        auto prev = static_cast<int32_t>(m_count);
        int32_t next = (prev + m_step);
        int32_t wrapped = ((next % static_cast<int32_t>(m_modulo)) + static_cast<int32_t>(m_modulo)) % static_cast<int32_t>(m_modulo);
        m_wrapped = (wrapped < prev && m_step > 0) || (wrapped > prev && m_step < 0);
        m_count = static_cast<uint32_t>(wrapped);
    } else {
        m_count += static_cast<uint32_t>(m_step);
    }
 
    double output = (m_modulo > 1)
        ? static_cast<double>(m_count) / static_cast<double>(m_modulo - 1)
        : static_cast<double>(m_count);
 
    output *= m_amplitude;
    m_last_output = output;
 
    if ((!m_state_saved || (m_state_saved && m_fire_events_during_snapshot))
        && !m_networked_node) {
        notify_tick(output);
    }
 
    if (m_reset_trigger) {
        atomic_dec_modulator_count(m_reset_trigger->m_modulator_count, 1);
        try_reset_processed_state(m_reset_trigger);
    }
 
    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_count, MayaFlux::Nodes::Node::m_fire_events_during_snapshot, MayaFlux::Nodes::Node::m_last_output, m_last_trigger_value, m_modulo, MayaFlux::Nodes::Node::m_networked_node, m_reset_trigger, MayaFlux::Nodes::Node::m_state_saved, m_step, m_wrapped, notify_tick(), MayaFlux::Nodes::PROCESSED, and MayaFlux::Nodes::try_reset_processed_state().

Referenced by process_batch().

Here is the call graph for this function:

Here is the caller graph for this function: