bind_network()

void MayaFlux::Buffers::DescriptorBindingsProcessor::bind_network	(	const std::string &	name,
		const std::shared_ptr< Nodes::Network::NodeNetwork > &	network,
		const std::string &	descriptor_name,
		uint32_t	set,
		Portal::Graphics::DescriptorRole	role = Portal::Graphics::DescriptorRole::STORAGE
	)

Bind a NodeNetwork to a descriptor.

Resolves source type at bind time:

• Networks with get_audio_buffer() output → NETWORK_AUDIO (VECTOR binding)
• Networks with a GraphicsOperator → NETWORK_GPU (STRUCTURED binding)

Fails hard if the network satisfies neither condition.

Parameters

name	Logical binding name
network	NodeNetwork to read from
descriptor_name	Name in shader config bindings
set	Descriptor set index
role	Descriptor role (default: STORAGE)

Definition at line 319 of file DescriptorBindingsProcessor.cpp.

{
    if (!network) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "Cannot bind null network '{}'", name);
        return;
    }
 
    if (m_config.bindings.find(descriptor_name) == m_config.bindings.end()) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "Descriptor '{}' not found in shader config", descriptor_name);
        return;
    }
 
    SourceType resolved {};
    BindingType binding_type {};
    size_t initial_size {};
 
    auto network_mode = network->get_output_mode();
    if (network_mode == Nodes::Network::OutputMode::AUDIO_SINK || network_mode == Nodes::Network::OutputMode::AUDIO_COMPUTE) {
        resolved = SourceType::NETWORK_AUDIO;
        binding_type = BindingType::VECTOR;
        auto probe = network->get_audio_buffer();
        if (probe) {
            initial_size = probe->size() * sizeof(float);
        } else {
            MF_WARN(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Network '{}' is configured for audio output but has no audio buffer. "
                "Binding will be created with default size of 4096 samples (16 KB).",
                name);
            initial_size = 4096 * sizeof(float);
        }
    } else if (network->has_operator() && dynamic_cast<Nodes::Network::GraphicsOperator*>(network->get_operator())) {
        resolved = SourceType::NETWORK_GPU;
        binding_type = BindingType::STRUCTURED;
        initial_size = static_cast<size_t>(1024) * 64;
    } else {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "Network '{}' produces neither audio nor GPU geometry. "
            "Bind is only valid for networks with audio output or a GraphicsOperator.",
            name);
        return;
    }
 
    const auto& binding_config = m_config.bindings[descriptor_name];
    auto gpu_buffer = create_descriptor_buffer(initial_size, role);
 
    auto [it, inserted] = m_bindings.try_emplace(name);
    auto& binding = it->second;
 
    binding.network = network;
    binding.descriptor_name = descriptor_name;
    binding.set_index = set;
    binding.binding_index = binding_config.binding;
    binding.role = role;
    binding.binding_type = binding_type;
    binding.source_type = resolved;
    binding.gpu_buffer = gpu_buffer;
    binding.buffer_offset = 0;
    binding.buffer_size = initial_size;
 
    bind_buffer(descriptor_name, gpu_buffer);
    m_needs_descriptor_rebuild = true;
 
    MF_DEBUG(Journal::Component::Buffers, Journal::Context::BufferProcessing,
        "Bound network '{}' to descriptor '{}' (source: {})",
        name, descriptor_name,
        resolved == SourceType::NETWORK_AUDIO ? "NETWORK_AUDIO" : "NETWORK_GPU");
}

References MayaFlux::Nodes::Network::AUDIO_COMPUTE, MayaFlux::Nodes::Network::AUDIO_SINK, MayaFlux::Buffers::ShaderProcessor::bind_buffer(), MayaFlux::Buffers::ShaderConfig::bindings, MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, create_descriptor_buffer(), m_bindings, MayaFlux::Buffers::ShaderProcessor::m_config, MayaFlux::Buffers::ShaderProcessor::m_needs_descriptor_rebuild, MF_DEBUG, MF_ERROR, MF_WARN, NETWORK_AUDIO, NETWORK_GPU, STRUCTURED, and VECTOR.

Here is the call graph for this function: