update_descriptor_from_node()

void MayaFlux::Buffers::DescriptorBindingsProcessor::update_descriptor_from_node ( DescriptorBinding &  binding )

private

Update descriptor from node context.

Definition at line 494 of file DescriptorBindingsProcessor.cpp.

{
    switch (binding.source_type) {
 
    case SourceType::NODE: {
        if (!binding.node) {
            MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Binding has null node");
            return;
        }
 
        float value {};
 
        if (binding.processing_mode.load(std::memory_order_acquire) == ProcessingMode::INTERNAL) {
            value = static_cast<float>(Buffers::extract_single_sample(binding.node));
        } else {
            value = static_cast<float>(binding.node->get_last_output());
        }
        Nodes::NodeContext& ctx = binding.node->get_last_context();
 
        switch (binding.binding_type) {
 
        case BindingType::SCALAR: {
            ensure_buffer_capacity(binding, sizeof(float));
            upload_to_gpu(&value, sizeof(float), binding.gpu_buffer, nullptr);
            break;
        }
 
        case BindingType::VECTOR: {
            auto* gpu_vec = dynamic_cast<Nodes::GpuVectorData*>(&ctx);
            if (!gpu_vec || !gpu_vec->has_gpu_data()) {
                MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                    "Node context does not provide GpuVectorData");
                return;
            }
 
            auto data = gpu_vec->gpu_data();
 
            ensure_buffer_capacity(binding, data.size_bytes());
            upload_to_gpu(data.data(), data.size_bytes(), binding.gpu_buffer, nullptr);
            break;
        }
 
        case BindingType::MATRIX: {
            auto* gpu_mat = dynamic_cast<Nodes::GpuMatrixData*>(&ctx);
            if (!gpu_mat || !gpu_mat->has_gpu_data()) {
                MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                    "Node context does not provide GpuMatrixData");
                return;
            }
 
            auto data = gpu_mat->gpu_data();
            ensure_buffer_capacity(binding, data.size_bytes());
            upload_to_gpu(data.data(), data.size_bytes(), binding.gpu_buffer, nullptr);
            break;
        }
 
        case BindingType::STRUCTURED: {
            auto* gpu_struct = dynamic_cast<Nodes::GpuStructuredData*>(&ctx);
            if (!gpu_struct || !gpu_struct->has_gpu_data()) {
                MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                    "Node context does not provide GpuStructuredData");
                return;
            }
 
            auto data = gpu_struct->gpu_data();
            ensure_buffer_capacity(binding, data.size_bytes());
            upload_to_gpu(data.data(), data.size_bytes(), binding.gpu_buffer, nullptr);
            break;
        }
        }
    }
 
    case SourceType::AUDIO_BUFFER: {
        auto audio = std::dynamic_pointer_cast<AudioBuffer>(binding.buffer);
        const auto& samples = audio->get_data();
        size_t required = samples.size() * sizeof(float);
        ensure_buffer_capacity(binding, required);
 
        thread_local std::vector<float> conv;
        conv.resize(samples.size());
        std::ranges::transform(samples, conv.begin(),
            [](double d) { return static_cast<float>(d); });
 
        upload_to_gpu(conv.data(), required, binding.gpu_buffer, nullptr);
        break;
    }
 
    case SourceType::HOST_VK_BUFFER: {
        auto vk = std::dynamic_pointer_cast<VKBuffer>(binding.buffer);
        auto data = vk->get_data();
        if (data.empty()) {
            MF_RT_WARN(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Host VKBuffer binding '{}' returned no data", binding.descriptor_name);
            return;
        }
        auto& raw = std::get<std::vector<uint8_t>>(data[0]);
        ensure_buffer_capacity(binding, raw.size());
        upload_to_gpu(raw.data(), raw.size(), binding.gpu_buffer, nullptr);
        break;
    }
 
    case SourceType::NETWORK_AUDIO: {
 
        auto data = binding.network->get_audio_buffer();
        if (!data) {
            MF_RT_WARN(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Network audio binding '{}' has no audio buffer", binding.descriptor_name);
            return;
        }
        const auto& samples = *data;
        size_t required = samples.size() * sizeof(float);
 
        thread_local std::vector<float> conv;
        conv.resize(samples.size());
 
        std::ranges::transform(samples, conv.begin(),
            [](double d) { return static_cast<float>(d); });
 
        upload_to_gpu(conv.data(), required, binding.gpu_buffer, nullptr);
        break;
    }
 
    case SourceType::NETWORK_GPU: {
        auto gpu_data = extract_network_gpu_data(binding.network, binding.descriptor_name);
        if (gpu_data.vertex_data.empty()) {
            return;
        }
        ensure_buffer_capacity(binding, gpu_data.vertex_data.size_bytes());
        upload_to_gpu(
            gpu_data.vertex_data.data(),
            gpu_data.vertex_data.size_bytes(),
            binding.gpu_buffer,
            nullptr);
        break;
    }
    }
}

References AUDIO_BUFFER, MayaFlux::Buffers::DescriptorBindingsProcessor::DescriptorBinding::binding_type, MayaFlux::Buffers::DescriptorBindingsProcessor::DescriptorBinding::buffer, MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, MayaFlux::Buffers::DescriptorBindingsProcessor::DescriptorBinding::descriptor_name, ensure_buffer_capacity(), MayaFlux::Buffers::extract_network_gpu_data(), MayaFlux::Buffers::extract_single_sample(), MayaFlux::Buffers::DescriptorBindingsProcessor::DescriptorBinding::gpu_buffer, HOST_VK_BUFFER, INTERNAL, MATRIX, MF_RT_ERROR, MF_RT_WARN, MayaFlux::Buffers::DescriptorBindingsProcessor::DescriptorBinding::network, NETWORK_AUDIO, NETWORK_GPU, NODE, MayaFlux::Buffers::DescriptorBindingsProcessor::DescriptorBinding::node, MayaFlux::Buffers::DescriptorBindingsProcessor::DescriptorBinding::processing_mode, SCALAR, MayaFlux::Buffers::DescriptorBindingsProcessor::DescriptorBinding::source_type, STRUCTURED, MayaFlux::Buffers::upload_to_gpu(), and VECTOR.

Referenced by execute_shader().

Here is the call graph for this function:

Here is the caller graph for this function: