pump_feeds()

void MayaFlux::Buffers::ShaderProcessor::pump_feeds ( )

protected

Pull every feed and write its result.

Called at the top of processing_function, before descriptors are rebuilt, so a storage feed creating its buffer binds the same cycle. Callables run on whichever thread drives the chain.

Definition at line 308 of file ShaderProcessor.cpp.

{
    for (auto& [name, entry] : m_feeds) {
        FeedValue value = entry.source();
 
        if (!entry.is_storage) {
            const auto* scalar = std::get_if<double>(&value);
            if (!scalar) {
                if (!entry.mismatch_logged) {
                    MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                        "feed '{}' writes a push constant but returned a DataVariant", name);
                    entry.mismatch_logged = true;
                }
                continue;
            }
 
            auto& data = get_push_constant_data();
            const size_t required = entry.offset + entry.size;
            if (data.size() < required) {
                data.resize(required);
            }
 
            if (entry.size == sizeof(float)) {
                const auto narrowed = static_cast<float>(*scalar);
                std::memcpy(data.data() + entry.offset, &narrowed, sizeof(float));
            } else {
                std::memcpy(data.data() + entry.offset, scalar, sizeof(double));
            }
            continue;
        }
 
        auto* variant = std::get_if<Kakshya::DataVariant>(&value);
        if (!variant) {
            if (!entry.mismatch_logged) {
                MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                    "feed '{}' writes a storage descriptor but returned a double", name);
                entry.mismatch_logged = true;
            }
            continue;
        }
 
        Kakshya::DataAccess accessor(*variant, {}, Kakshya::DataModality::UNKNOWN);
        auto [ptr, bytes, format] = accessor.gpu_buffer();
 
        if (!ptr || bytes == 0) {
            MF_RT_WARN(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "feed '{}' produced no bytes", name);
            continue;
        }
 
        if (!entry.buffer) {
            entry.buffer = std::make_shared<VKBuffer>(
                static_cast<size_t>(static_cast<float>(bytes) * 1.5F),
                m_config.bindings.at(entry.descriptor_name).type == vk::DescriptorType::eUniformBuffer
                    ? VKBuffer::Usage::UNIFORM
                    : VKBuffer::Usage::HOST_STORAGE,
                Kakshya::DataModality::UNKNOWN);
 
            bind_buffer(entry.descriptor_name, entry.buffer);
 
            MF_DEBUG(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "feed '{}' backing buffer created at {} bytes",
                name, entry.buffer->get_size_bytes());
        } else if (entry.buffer->get_size_bytes() < bytes) {
            const size_t grown = bytes * 3 / 2;
 
            MF_DEBUG(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "feed '{}' backing buffer resized {} to {} bytes",
                name, entry.buffer->get_size_bytes(), grown);
 
            entry.buffer->resize(grown, false);
            m_needs_descriptor_rebuild = true;
        }
 
        upload_host_visible(entry.buffer, *variant);
    }
}

References bind_buffer(), MayaFlux::Buffers::ShaderConfig::bindings, MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, get_push_constant_data(), MayaFlux::Kakshya::DataAccess::gpu_buffer(), m_config, m_feeds, m_needs_descriptor_rebuild, MF_DEBUG, MF_ERROR, MF_RT_WARN, ptr, MayaFlux::Kakshya::UNKNOWN, MayaFlux::Buffers::upload_host_visible(), and value.

Referenced by processing_function().

Here is the call graph for this function:

Here is the caller graph for this function: