process_sample()

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

overridevirtual

Processes a single input sample through the logic function.

Parameters

input

Input value to evaluate

Returns

1.0 for true result, 0.0 for false result

Evaluates the input according to the configured logic operation and computational model, producing a binary output (0.0 or 1.0).

Implements MayaFlux::Nodes::Node.

Definition at line 195 of file Logic.cpp.

{
    bool result = false;
    m_edge_detected = false;
 
    if (m_input_node) {
        atomic_inc_modulator_count(m_input_node->m_modulator_count, 1);
        uint32_t state = m_input_node->m_state.load();
        if (state & NodeState::PROCESSED) {
            input += m_input_node->get_last_output();
        } else {
            input = m_input_node->process_sample(input);
            atomic_add_flag(m_input_node->m_state, NodeState::PROCESSED);
        }
    }
 
    const bool pulled = m_mode == LogicMode::MULTI_INPUT && !m_input_nodes.empty();
    if (pulled) {
        pull_input_nodes();
    }
 
    bool current_bool = input > m_threshold;
    bool previous_bool = m_last_output > 0.5;
 
    switch (m_mode) {
    case LogicMode::DIRECT:
        switch (m_operator) {
        case LogicOperator::THRESHOLD:
            result = current_bool;
            break;
 
        case LogicOperator::HYSTERESIS:
            if (input > m_high_threshold) {
                m_hysteresis_state = true;
            } else if (input < m_low_threshold) {
                m_hysteresis_state = false;
            }
            result = m_hysteresis_state;
            break;
 
        case LogicOperator::EDGE: {
            bool previous_bool_input = m_input > m_threshold;
            if (current_bool != previous_bool_input) {
                switch (m_edge_type) {
                case EdgeType::RISING:
                    m_edge_detected = current_bool && !previous_bool_input;
                    break;
                case EdgeType::FALLING:
                    m_edge_detected = !current_bool && previous_bool_input;
                    break;
                case EdgeType::BOTH:
                    m_edge_detected = true;
                    break;
                }
            }
            result = m_edge_detected;
            break;
        }
 
        case LogicOperator::AND:
            result = current_bool && previous_bool;
            break;
 
        case LogicOperator::OR:
            result = current_bool || previous_bool;
            break;
 
        case LogicOperator::XOR:
            result = current_bool != previous_bool;
            break;
 
        case LogicOperator::NOT:
            result = !current_bool;
            break;
 
        case LogicOperator::NAND:
            result = !(current_bool && previous_bool);
            break;
 
        case LogicOperator::NOR:
            result = !(current_bool || previous_bool);
            break;
 
        case LogicOperator::CUSTOM:
            result = m_direct_function(input);
            break;
 
        default:
            result = current_bool;
        }
        break;
 
    case LogicMode::SEQUENTIAL: {
        bool current_bool = input > m_threshold;
        history_push(current_bool);
        auto view = history_linearized_view();
        result = m_sequential_function(view);
        break;
    }
 
    case LogicMode::TEMPORAL: {
        m_temporal_time += 1.0 / m_sample_rate;
        result = m_temporal_function(input, m_temporal_time);
        break;
    }
 
    case LogicMode::MULTI_INPUT: {
        if (!pulled) {
            add_input(input, 0);
        } else if (m_input_count > m_input_nodes.size()) {
            add_input(input, m_input_nodes.size());
        }
        result = m_multi_input_function(m_input_buffer);
        break;
    }
    }
 
    m_input = input;
    auto current = result ? 1.0 : 0.0;
 
    if ((!m_state_saved || (m_state_saved && m_fire_events_during_snapshot))
        && !m_networked_node) {
        notify_tick(current);
    }
 
    if (pulled) {
        release_input_nodes();
    }
 
    if (m_input_node) {
        atomic_dec_modulator_count(m_input_node->m_modulator_count, 1);
        try_reset_processed_state(m_input_node);
    }
 
    m_last_output = current;
    return m_last_output;
}

References add_input(), MayaFlux::Nodes::Generator::AND, MayaFlux::Nodes::atomic_add_flag(), MayaFlux::Nodes::atomic_dec_modulator_count(), MayaFlux::Nodes::atomic_inc_modulator_count(), MayaFlux::Nodes::Generator::BOTH, current, MayaFlux::Nodes::Generator::CUSTOM, MayaFlux::Nodes::Generator::DIRECT, MayaFlux::Nodes::Generator::EDGE, MayaFlux::Nodes::Generator::FALLING, history_linearized_view(), history_push(), MayaFlux::Nodes::Generator::HYSTERESIS, input, m_direct_function, m_edge_detected, m_edge_type, MayaFlux::Nodes::Node::m_fire_events_during_snapshot, m_high_threshold, m_hysteresis_state, m_input, m_input_buffer, m_input_count, m_input_node, m_input_nodes, MayaFlux::Nodes::Node::m_last_output, m_low_threshold, m_mode, m_multi_input_function, MayaFlux::Nodes::Node::m_networked_node, m_operator, MayaFlux::Nodes::Node::m_sample_rate, m_sequential_function, MayaFlux::Nodes::Node::m_state_saved, m_temporal_function, m_temporal_time, m_threshold, MayaFlux::Nodes::Generator::MULTI_INPUT, MayaFlux::Nodes::Generator::NAND, MayaFlux::Nodes::Generator::NOR, MayaFlux::Nodes::Generator::NOT, notify_tick(), MayaFlux::Nodes::Generator::OR, MayaFlux::Nodes::PROCESSED, pull_input_nodes(), release_input_nodes(), MayaFlux::Nodes::Generator::RISING, MayaFlux::Nodes::Generator::SEQUENTIAL, MayaFlux::Nodes::Generator::TEMPORAL, MayaFlux::Nodes::Generator::THRESHOLD, MayaFlux::Nodes::try_reset_processed_state(), and MayaFlux::Nodes::Generator::XOR.

Referenced by process_batch().

Here is the call graph for this function:

Here is the caller graph for this function: