route_network_to_channels()

void MayaFlux::Nodes::NodeGraphManager::route_network_to_channels	(	const std::shared_ptr< Network::NodeNetwork > &	network,
		const std::vector< uint32_t > &	target_channels,
		uint32_t	fade_cycles,
		ProcessingToken	token
	)

Routes a network's output to specific channels within a token domain.

Parameters

network	Network to route (must be an audio sink)
target_channels	Vector of channel indices to route the network's output to
fade_cycles	Number of cycles to fade in the routing (optional)
token	Processing domain to route within

This method registers the network and adds it to the specified channels' root nodes within the given processing domain. If fade_cycles is greater than 0, the routing will be smoothly faded in over that many processing cycles.

Definition at line 723 of file NodeGraphManager.cpp.

{
    if (network->get_output_mode() != Network::OutputMode::AUDIO_SINK) {
        MF_WARN(Journal::Component::Nodes,
            Journal::Context::NodeProcessing,
            "Attempted to route network that is not an audio sink. Operation ignored.");
        return;
    }
 
    register_network_global(network);
    network->set_enabled(true);
 
    auto& networks = m_audio_networks[token];
    if (std::ranges::find(networks, network) == networks.end()) {
        networks.push_back(network);
    }
 
    uint32_t current_channels = network->get_channel_mask();
 
    uint32_t target_bitmask = 0;
    for (auto ch : target_channels) {
        target_bitmask |= (1 << ch);
    }
 
    uint32_t combined_mask = current_channels | target_bitmask;
    network->set_channel_mask(combined_mask);
    for (auto ch : target_channels) {
        network->add_channel_usage(ch);
        ensure_root_exists(token, ch);
    }
 
    uint32_t fade_blocks = (fade_cycles + m_registered_block_size - 1) / m_registered_block_size;
    fade_blocks = std::max(1u, fade_blocks);
 
    RoutingState state;
    state.from_channels = current_channels;
    state.to_channels = target_bitmask;
    state.fade_cycles = fade_blocks;
    state.phase = RoutingState::ACTIVE;
 
    for (uint32_t ch = 0; ch < 32; ch++) {
        state.amount[ch] = (current_channels & (1 << ch)) ? 1.0 : 0.0;
    }
 
    network->get_routing_state() = state;
}

References MayaFlux::Nodes::RoutingState::ACTIVE, MayaFlux::Nodes::RoutingState::amount, MayaFlux::Nodes::Network::AUDIO_SINK, ensure_root_exists(), MayaFlux::Nodes::RoutingState::fade_cycles, MayaFlux::Nodes::RoutingState::from_channels, m_audio_networks, m_registered_block_size, MF_WARN, MayaFlux::Journal::NodeProcessing, MayaFlux::Journal::Nodes, register_network_global(), and MayaFlux::Nodes::RoutingState::to_channels.

Here is the call graph for this function: