record_draw() [2/2]

void MayaFlux::Buffers::RenderProcessor::record_draw ( const std::shared_ptr< VKBuffer > &  buffer, const BufferState &  state  )

private

Record an already validated attachment without repeating its lookup.

Definition at line 828 of file RenderProcessor.cpp.

{
    buffer->set_pipeline_window(m_pipeline_id, m_target_window);
 
    auto& foundry = Portal::Graphics::get_shader_foundry();
    auto& flow = Portal::Graphics::get_render_flow();
 
    vk::Format color_format = static_cast<vk::Format>(
        m_display_service->get_swapchain_format(m_target_window));
 
    vk::Format depth_format = m_depth_enabled
        ? vk::Format::eD32Sfloat
        : vk::Format::eUndefined;
 
    auto cmd_id = foundry.begin_secondary_commands(color_format, depth_format);
    auto cmd = foundry.get_command_buffer(cmd_id);
 
    uint32_t width = 0, height = 0;
    m_display_service->get_swapchain_extent(m_target_window, width, height);
 
    if (width > 0 && height > 0) {
        auto cmd = foundry.get_command_buffer(cmd_id);
 
        vk::Viewport viewport {
            0.0F,
            static_cast<float>(height),
            static_cast<float>(width),
            -static_cast<float>(height),
            0.0F,
            1.0F
        };
        cmd.setViewport(0, 1, &viewport);
 
        const vk::Rect2D scissor = resolve_scissor_rect(width, height);
        cmd.setScissor(0, 1, &scissor);
    }
 
    flow.bind_pipeline(cmd_id, m_pipeline_id);
 
    auto& engine_bindings = buffer->get_engine_context().ssbo_bindings;
    for (const auto& binding : engine_bindings) {
        if (binding.set == 0 && binding.binding == 0) {
            MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Engine SSBO at binding=0 is reserved for RenderTransform UBO");
            continue;
        }
        if (m_render_transform_descriptor_set_id == Portal::Graphics::INVALID_DESCRIPTOR_SET) {
            MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Engine SSBO binding {} skipped: engine descriptor set not allocated", binding.binding);
            continue;
        }
        foundry.update_descriptor_buffer(
            m_render_transform_descriptor_set_id,
            binding.binding,
            binding.type,
            binding.buffer_info.buffer,
            binding.buffer_info.offset,
            binding.buffer_info.range);
    }
 
    auto& descriptor_bindings = buffer->get_pipeline_context().descriptor_buffer_bindings;
    if (!descriptor_bindings.empty()) {
        for (const auto& binding : descriptor_bindings) {
            auto ds_index = resolve_ds_index(binding.set);
            if (!ds_index) {
                MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                    "Descriptor set index {} out of range or reserved", binding.set);
                continue;
            }
 
            foundry.update_descriptor_buffer(
                m_descriptor_set_ids[*ds_index],
                binding.binding,
                binding.type,
                binding.buffer_info.buffer,
                binding.buffer_info.offset,
                binding.buffer_info.range);
        }
    }
 
    if (!m_descriptor_set_ids.empty()) {
        flow.bind_descriptor_sets(cmd_id, m_pipeline_id, m_descriptor_set_ids);
    }
 
    if (m_render_transform_descriptor_set_id != Portal::Graphics::INVALID_DESCRIPTOR_SET) {
        flow.bind_descriptor_sets(
            cmd_id, m_pipeline_id,
            { m_render_transform_descriptor_set_id },
            0);
    }
 
    if (!m_descriptor_set_ids.empty()) {
        flow.bind_descriptor_sets(
            cmd_id, m_pipeline_id,
            m_descriptor_set_ids,
            1);
    }
 
    const auto push_data = resolve_push_constants(buffer);
    if (!push_data.empty()) {
        flow.push_constants(
            cmd_id, m_pipeline_id, push_data.data(), push_data.size());
    }
 
    on_before_execute(cmd_id, buffer);
 
    flow.bind_vertex_buffers(cmd_id, { state.draw_source });
 
    if (state.vertex_count > 0) {
        if (state.draw_source->has_index_buffer()) {
            flow.bind_index_buffer(cmd_id, state.draw_source);
            flow.draw_indexed(cmd_id, state.index_count, m_instance_count, 0, 0, 0);
        } else if (!m_triangulate && m_runs.size() > 1
            && std::ranges::all_of(m_runs, [this](const Portal::Graphics::DrawRun& run) {
                   return run.topology == m_primitive_topology;
               })) {
            for (const auto& run : m_runs) {
                if (run.vertex_count > 0) {
                    flow.draw(cmd_id, run.vertex_count, m_instance_count, run.vertex_offset, 0);
                }
            }
        } else {
            flow.draw(cmd_id, state.vertex_count, m_instance_count, state.first_vertex, 0);
        }
    }
 
    foundry.end_commands(cmd_id);
 
    buffer->set_pipeline_command(m_pipeline_id, cmd_id);
    m_target_window->track_frame_command(cmd_id);
 
    MF_RT_TRACE(Journal::Component::Buffers, Journal::Context::BufferProcessing,
        "Recorded secondary command buffer {} for window '{}'",
        cmd_id, m_target_window->get_create_info().title);
}

References buffer, MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, cmd, MayaFlux::Buffers::RenderProcessor::BufferState::draw_source, MayaFlux::Buffers::RenderProcessor::BufferState::first_vertex, MayaFlux::Portal::Graphics::get_render_flow(), MayaFlux::Portal::Graphics::get_shader_foundry(), height, MayaFlux::Buffers::RenderProcessor::BufferState::index_count, MayaFlux::Portal::Graphics::INVALID_DESCRIPTOR_SET, MF_RT_ERROR, MF_RT_TRACE, run(), MayaFlux::Buffers::RenderProcessor::BufferState::vertex_count, and width.

Here is the call graph for this function: