pump_feeds()

void MayaFlux::Buffers::ShaderProcessor::pump_feeds ( bool  early = true )

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.

Parameters

early

Only feeds registered with this timing are pulled.

Definition at line 320 of file ShaderProcessor.cpp.

{
    for (auto& [name, entry] : m_feeds) {
        if (entry.early != early) {
            continue;
        }
 
        FeedValue value = entry.source();
 
        if (!entry.is_storage) {
            if (const auto* typed = std::get_if<Kakshya::GpuValue>(&value)) {
                if (entry.format && *entry.format != Kakshya::gpu_value_format(*typed)) {
                    if (!entry.mismatch_logged) {
                        MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                            "feed '{}' returned a value of a different format than its push constant field", name);
                        entry.mismatch_logged = true;
                    }
                    continue;
                }
 
                std::array<std::byte, 64> bytes {};
                const size_t written = Kakshya::gpu_value_write(*typed, bytes);
 
                auto& data = get_push_constant_data();
                const size_t required = entry.offset + written;
                if (data.size() < required) {
                    data.resize(required);
                }
 
                std::memcpy(data.data() + entry.offset, bytes.data(), written);
                continue;
            }
 
            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 push constant value", 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, format, get_push_constant_data(), MayaFlux::Kakshya::DataAccess::gpu_buffer(), MayaFlux::Kakshya::gpu_value_format(), MayaFlux::Kakshya::gpu_value_write(), m_config, m_feeds, m_needs_descriptor_rebuild, MF_DEBUG, MF_ERROR, MF_RT_WARN, name, ptr, scalar, MayaFlux::Kakshya::UNKNOWN, MayaFlux::Buffers::upload_host_visible(), and value.

Referenced by MayaFlux::Buffers::ComputeProcessor::execute_shader(), and processing_function().

Here is the call graph for this function:

Here is the caller graph for this function: