generate_planes()

void MayaFlux::Buffers::LogicProcessor::generate_planes ( size_t  num_samples, const std::vector< double > &  input_data  )

private

Definition at line 102 of file LogicProcessor.cpp.

{
    const uint32_t bits = std::clamp(m_plane_bits, uint32_t { 1 }, uint32_t { 24 });
 
    if (m_plane_nodes.size() != bits || m_plane_template != m_logic) {
        m_plane_nodes.clear();
        for (uint32_t plane = 0; plane < bits; ++plane) {
            m_plane_nodes.push_back(m_logic->clone());
        }
        m_plane_template = m_logic;
    }
 
    const bool parallel = m_logic->get_mode() == Nodes::Generator::LogicMode::MULTI_INPUT;
 
    lock_keys();
    const size_t key_count = parallel ? m_live_keys.size() : 0;
    m_key_words.assign(key_count, 0);
    m_slots.assign(key_count + 1, 0.0);
 
    const size_t available = input_data.size();
    const uint32_t silence = Kinesis::Discrete::to_word(0.0, bits);
 
    for (size_t i = 0; i < num_samples; ++i) {
        const uint32_t own = Kinesis::Discrete::to_word(i < available ? input_data[i] : 0.0, bits);
        for (size_t k = 0; k < key_count; ++k) {
            const auto& key = m_live_keys[k];
            m_key_words[k] = (key && i < key->get_data().size())
                ? Kinesis::Discrete::to_word(key->get_data()[i], bits)
                : silence;
        }
 
        uint32_t word = 0;
        for (uint32_t plane = 0; plane < bits; ++plane) {
            const auto bit_of = [plane](uint32_t w) { return static_cast<double>((w >> plane) & 1U); };
 
            double out = 0.0;
            if (parallel) {
                for (size_t k = 0; k < key_count; ++k) {
                    m_slots[k] = bit_of(m_key_words[k]);
                }
                m_slots.back() = bit_of(own);
                out = m_plane_nodes[plane]->process_multi_input(m_slots);
            } else {
                out = m_plane_nodes[plane]->process_sample(bit_of(own));
            }
            word |= (out > 0.5 ? 1U : 0U) << plane;
        }
 
        m_logic_data[i] = Kinesis::Discrete::from_word(word, bits);
    }
}

References available, MayaFlux::Kinesis::Discrete::from_word(), lock_keys(), m_key_words, m_live_keys, m_logic, m_logic_data, m_plane_bits, m_plane_nodes, m_plane_template, m_slots, MayaFlux::Nodes::Generator::MULTI_INPUT, out, and MayaFlux::Kinesis::Discrete::to_word().

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function: