execute_shader()

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

overrideprotectedvirtual

Implements MayaFlux::Buffers::ShaderProcessor.

Definition at line 472 of file RenderProcessor.cpp.

{
    if (m_buffer_info.find(buffer) == m_buffer_info.end()) {
        if (buffer->has_vertex_layout()) {
            auto vertex_layout = buffer->get_vertex_layout();
            if (vertex_layout.has_value()) {
                m_buffer_info[buffer] = {
                    .semantic_layout = vertex_layout.value(),
                    .use_reflection = false
                };
            }
        }
    }
 
    if (!m_target_window->is_graphics_registered()) {
        return;
    }
 
    if (m_pipeline_id == Portal::Graphics::INVALID_RENDER_PIPELINE) {
        return;
    }
 
    const Kakshya::VertexLayout* local_layout = get_or_cache_vertex_layout(m_buffer_info, buffer);
    if (!local_layout) {
        MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "VKBuffer has no vertex layout set. Use buffer->set_vertex_layout()");
        return;
    }
 
    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);
 
        vk::Rect2D scissor { { 0, 0 }, { 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 ViewTransform UBO");
            continue;
        }
        if (m_view_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_view_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);
    }
 
    {
        Kinesis::ViewTransform vt;
        if (m_view_transform_active) {
            vt = m_view_transform_source
                ? m_view_transform_source()
                : m_view_transform.value_or(Kinesis::ViewTransform {});
        }
 
        if (m_view_transform_ubo && m_view_transform_ubo->get_mapped_ptr()) {
            std::memcpy(
                m_view_transform_ubo->get_mapped_ptr(),
                &vt,
                sizeof(Kinesis::ViewTransform));
        }
    }
 
    if (m_view_transform_descriptor_set_id != Portal::Graphics::INVALID_DESCRIPTOR_SET) {
        flow.bind_descriptor_sets(
            cmd_id, m_pipeline_id,
            { m_view_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& staging = buffer->get_pipeline_context();
    if (!staging.push_constant_staging.empty()) {
        flow.push_constants(
            cmd_id,
            m_pipeline_id,
            staging.push_constant_staging.data(),
            staging.push_constant_staging.size());
    } else if (!m_push_constant_data.empty()) {
        flow.push_constants(
            cmd_id,
            m_pipeline_id,
            m_push_constant_data.data(),
            m_push_constant_data.size());
    }
 
    on_before_execute(cmd_id, buffer);
 
    flow.bind_vertex_buffers(cmd_id, { buffer });
 
    uint32_t draw_count = 0;
    if (m_vertex_count > 0) {
        draw_count = m_vertex_count;
    } else {
        auto current_layout = buffer->get_vertex_layout();
        if (!current_layout.has_value() || current_layout->vertex_count == 0) {
            MF_RT_DEBUG(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Vertex layout has zero vertices, skipping draw");
            return;
        }
        draw_count = current_layout->vertex_count;
    }
 
    if (buffer->has_index_buffer()) {
        const auto index_count = static_cast<uint32_t>(
            buffer->get_index_buffer_size() / sizeof(uint32_t));
        flow.bind_index_buffer(cmd_id, buffer);
        flow.draw_indexed(cmd_id, index_count, m_instance_count, 0, 0, 0);
    } else {
        flow.draw(cmd_id, draw_count, m_instance_count, m_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 MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, cmd, get_or_cache_vertex_layout(), MayaFlux::Portal::Graphics::get_render_flow(), MayaFlux::Portal::Graphics::get_shader_foundry(), MayaFlux::Registry::Service::DisplayService::get_swapchain_extent, MayaFlux::Registry::Service::DisplayService::get_swapchain_format, MayaFlux::Portal::Graphics::INVALID_DESCRIPTOR_SET, MayaFlux::Portal::Graphics::INVALID_RENDER_PIPELINE, m_buffer_info, m_depth_enabled, MayaFlux::Buffers::ShaderProcessor::m_descriptor_set_ids, m_display_service, m_first_vertex, m_instance_count, m_pipeline_id, MayaFlux::Buffers::ShaderProcessor::m_push_constant_data, m_target_window, m_vertex_count, m_view_transform, m_view_transform_active, m_view_transform_descriptor_set_id, m_view_transform_source, m_view_transform_ubo, MF_RT_DEBUG, MF_RT_ERROR, MF_RT_TRACE, on_before_execute(), MayaFlux::Buffers::ShaderProcessor::resolve_ds_index(), and width.

Here is the call graph for this function: