process_batch()

void MayaFlux::Nodes::Network::ModalNetwork::process_batch ( unsigned int  num_samples )

overridevirtual

Process the network for the given number of samples.

Parameters

num_samples

Number of samples/frames to process

Subclasses implement their specific processing logic:

1. Update internal state (physics, relationships, etc.)
2. Process individual nodes
3. Apply inter-node interactions
4. Aggregate outputs if needed

Called by NodeGraphManager during token processing.

Implements MayaFlux::Nodes::Network::NodeNetwork.

Definition at line 313 of file ModalNetwork.cpp.

{
    ensure_initialized();
 
    if (!is_enabled()) {
        while (m_audio_buffer_lock.test_and_set(std::memory_order_acquire))
            std::this_thread::yield();
 
        m_last_audio_buffer.assign(num_samples, 0.0);
        m_audio_buffer_lock.clear(std::memory_order_release);
        return;
    }
 
    thread_local std::vector<double> scratch;
    scratch.assign(num_samples, 0.0);
 
    update_mapped_parameters();
 
    m_node_buffers.assign(m_modes.size(), {});
    for (auto& nb : m_node_buffers)
        nb.reserve(num_samples);
 
    if (m_exciter_node) {
        extract_node_samples(m_exciter_node, m_exciter_node_buffer,
            m_exciter_node_buffer_pos, num_samples);
 
        if (m_exciter_type == ExciterType::CONTINUOUS) {
            const auto peaks = Kinesis::Discrete::peak_positions(m_exciter_node_buffer, 0.1);
            if (!peaks.empty()) {
                const double peak_scale = 1.0 / static_cast<double>(peaks.size());
                for (size_t peak_idx : peaks) {
                    const double strength = std::abs(m_exciter_node_buffer[peak_idx])
                        * m_exciter_strength * peak_scale;
                    for (auto& mode : m_modes) {
                        const double target = mode.initial_amplitude * strength;
                        mode.amplitude = std::max(mode.amplitude, target);
                    }
                }
            }
        } else if (m_exciter_type == ExciterType::NOISE_BURST
            || m_exciter_type == ExciterType::FILTERED_NOISE) {
            if (m_exciter_active) {
                const auto peaks = Kinesis::Discrete::peak_positions(m_exciter_node_buffer, 0.1);
                if (!peaks.empty()) {
                    const auto max_peak = *std::ranges::max_element(peaks,
                        [this](size_t a, size_t b) {
                            return std::abs(m_exciter_node_buffer[a]) < std::abs(m_exciter_node_buffer[b]);
                        });
                    const double strength = std::abs<double>(m_exciter_node_buffer[max_peak]) * m_exciter_strength;
                    for (auto& mode : m_modes) {
                        const double target = mode.initial_amplitude * strength;
                        mode.amplitude = std::max<double>(mode.amplitude, target);
                    }
                }
            }
        }
    }
 
    for (size_t i = 0; i < num_samples; ++i) {
        double exciter_signal = generate_exciter_sample();
 
        if (exciter_signal != 0.0) {
            if (m_exciter_type != ExciterType::CONTINUOUS) {
                for (auto& mode : m_modes) {
                    mode.amplitude += exciter_signal * mode.initial_amplitude
                        * m_exciter_strength;
                }
            }
        }
 
        if (m_coupling_enabled && !m_couplings.empty())
            compute_mode_coupling();
 
        for (size_t m = 0; m < m_modes.size(); ++m) {
            auto& mode = m_modes[m];
 
            if (mode.amplitude > 0.0001) {
                mode.amplitude *= mode.decay_coefficient;
            } else {
                mode.amplitude = 0.0;
            }
 
            double sample = mode.oscillator->process_sample(0.0) * mode.amplitude;
            m_node_buffers[m].push_back(sample);
            scratch[i] += sample;
        }
    }
 
    while (m_audio_buffer_lock.test_and_set(std::memory_order_acquire))
        std::this_thread::yield();
 
    m_last_audio_buffer.assign(scratch.begin(), scratch.end());
    apply_output_scale();
    m_audio_buffer_lock.clear(std::memory_order_release);
}

References a, MayaFlux::Nodes::Network::NodeNetwork::apply_output_scale(), b, compute_mode_coupling(), CONTINUOUS, MayaFlux::Nodes::Network::NodeNetwork::ensure_initialized(), MayaFlux::Nodes::Network::NodeNetwork::extract_node_samples(), FILTERED_NOISE, generate_exciter_sample(), MayaFlux::Nodes::Network::NodeNetwork::is_enabled(), MayaFlux::Nodes::Network::NodeNetwork::m_audio_buffer_lock, m_coupling_enabled, m_couplings, m_exciter_active, m_exciter_node, m_exciter_node_buffer, m_exciter_node_buffer_pos, m_exciter_strength, m_exciter_type, MayaFlux::Nodes::Network::NodeNetwork::m_last_audio_buffer, m_modes, m_node_buffers, NOISE_BURST, MayaFlux::Kinesis::Discrete::peak_positions(), and update_mapped_parameters().

Here is the call graph for this function: