execute_shader()

void MayaFlux::Buffers::ComputeProcessor::execute_shader ( const std::shared_ptr< VKBuffer > &  buffer )

overrideprivatevirtual

Implements MayaFlux::Buffers::ShaderProcessor.

Definition at line 216 of file ComputeProcessor.cpp.

{
    if (m_pipeline_id == Portal::Graphics::INVALID_COMPUTE_PIPELINE || m_descriptor_set_ids.empty()) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "Cannot dispatch without pipeline and descriptors");
        return;
    }
 
    if (m_descriptor_set_ids.empty()) {
        MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "Descriptor sets not initialized");
        return;
    }
 
    auto& foundry = Portal::Graphics::get_shader_foundry();
    auto& compute_press = Portal::Graphics::get_compute_press();
 
    auto cmd_id = foundry.begin_commands(Portal::Graphics::ShaderFoundry::CommandBufferType::COMPUTE);
 
    m_last_command_buffer = cmd_id;
    m_last_processed_buffer = buffer;
 
    compute_press.bind_pipeline(cmd_id, m_pipeline_id);
 
    auto& descriptor_bindings = buffer->get_pipeline_context().descriptor_buffer_bindings;
    if (!descriptor_bindings.empty()) {
        for (const auto& binding : descriptor_bindings) {
            if (binding.set >= m_descriptor_set_ids.size()) {
                MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                    "Descriptor set index {} out of range", binding.set);
                continue;
            }
 
            foundry.update_descriptor_buffer(
                m_descriptor_set_ids[binding.set],
                binding.binding,
                binding.type,
                binding.buffer_info.buffer,
                binding.buffer_info.offset,
                binding.buffer_info.range);
        }
    }
 
    if (!m_descriptor_set_ids.empty()) {
        compute_press.bind_descriptor_sets(cmd_id, m_pipeline_id, m_descriptor_set_ids);
    }
 
    on_before_execute(cmd_id, buffer);
    pump_feeds(false);
 
    const uint32_t iterations = std::max(1U, m_dispatch_config.iteration_count);
    const auto dispatch_size = calculate_dispatch_size(buffer);
 
    for (uint32_t i = 0; i < iterations; ++i) {
        if (!on_iteration(cmd_id, buffer, i)) {
            continue;
        }
 
        resolve_push_constants_into(m_push_constant_scratch, buffer);
 
        if (!m_push_constant_scratch.empty()) {
            compute_press.push_constants(
                cmd_id, m_pipeline_id,
                m_push_constant_scratch.data(),
                m_push_constant_scratch.size());
        }
 
        compute_press.dispatch(cmd_id, dispatch_size[0], dispatch_size[1], dispatch_size[2]);
 
        if (i + 1 < iterations) {
            on_iteration_barrier(cmd_id, buffer, i);
        }
    }
 
    on_after_execute(cmd_id, buffer);
 
    foundry.buffer_barrier(
        cmd_id,
        buffer->get_buffer(),
        vk::AccessFlagBits::eShaderWrite,
        vk::AccessFlagBits::eShaderRead | vk::AccessFlagBits::eTransferRead,
        vk::PipelineStageFlagBits::eComputeShader,
        vk::PipelineStageFlagBits::eComputeShader | vk::PipelineStageFlagBits::eTransfer);
 
    submit_recorded(cmd_id, buffer);
}

References buffer, MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, calculate_dispatch_size(), MayaFlux::Portal::Graphics::ShaderFoundry::COMPUTE, MayaFlux::Portal::Graphics::get_compute_press(), MayaFlux::Portal::Graphics::get_shader_foundry(), MayaFlux::Portal::Graphics::INVALID_COMPUTE_PIPELINE, MayaFlux::Buffers::ShaderDispatchConfig::iteration_count, MayaFlux::Buffers::ShaderProcessor::m_descriptor_set_ids, m_dispatch_config, MayaFlux::Buffers::ShaderProcessor::m_last_command_buffer, MayaFlux::Buffers::ShaderProcessor::m_last_processed_buffer, m_pipeline_id, m_push_constant_scratch, MF_ERROR, MF_RT_ERROR, MayaFlux::Buffers::ShaderProcessor::on_after_execute(), MayaFlux::Buffers::ShaderProcessor::on_before_execute(), on_iteration(), on_iteration_barrier(), MayaFlux::Buffers::ShaderProcessor::pump_feeds(), MayaFlux::Buffers::ShaderProcessor::resolve_push_constants_into(), and MayaFlux::Buffers::ShaderProcessor::submit_recorded().

Here is the call graph for this function: