◆ initialize_pipeline()

void MayaFlux::Buffers::RenderProcessor::initialize_pipeline ( const std::shared_ptr< VKBuffer > & buffer )
overrideprotectedvirtual
Implements MayaFlux::Buffers::ShaderProcessor.
Definition at line 266 of file RenderProcessor.cpp.
{
    if (m_shader_id == Portal::Graphics::INVALID_SHADER) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "Vertex shader not loaded");
        return;
    }
 
    if (m_fragment_shader_id == Portal::Graphics::INVALID_SHADER) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "Fragment shader not loaded");
        return;
    }
 
    if (!m_target_window) {
        MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "Target window not set");
        return;
    }
 
    const auto* state = get_or_cache_buffer_state(buffer);
    if (!state) {
        MF_DEBUG(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "initialize_pipeline: layout not yet available, deferring");
        m_needs_pipeline_rebuild = true;
        return;
    }
 
    auto& flow = Portal::Graphics::get_render_flow();
 
    Portal::Graphics::get_render_flow().register_window_for_rendering(m_target_window);
 
    Portal::Graphics::RenderPipelineConfig pipeline_config;
    pipeline_config.vertex_shader = m_shader_id;
    pipeline_config.fragment_shader = m_fragment_shader_id;
    pipeline_config.geometry_shader = m_geometry_shader_id;
    pipeline_config.tess_control_shader = m_tess_control_shader_id;
    pipeline_config.tess_eval_shader = m_tess_eval_shader_id;
 
    pipeline_config.topology = pipeline_topology();
    pipeline_config.rasterization.polygon_mode = m_polygon_mode;
    pipeline_config.rasterization.cull_mode = m_cull_mode;
 
    if (m_blend_attachment.has_value()) {
        pipeline_config.blend_attachments.push_back(m_blend_attachment.value());
    } else {
        pipeline_config.blend_attachments.emplace_back();
    }
 
    pipeline_config.depth_stencil = m_depth_stencil;
 
    pipeline_config.semantic_vertex_layout = state->semantic_layout;
    pipeline_config.use_vertex_shader_reflection = state->use_reflection;
 
    pipeline_config.push_constant_size = resolve_push_constant_size(buffer);
 
    auto& descriptor_bindings = buffer->get_pipeline_context().descriptor_buffer_bindings;
    std::map<std::pair<uint32_t, uint32_t>, Portal::Graphics::DescriptorBindingInfo> unified_bindings;
 
    for (const auto& binding : descriptor_bindings) {
        unified_bindings[{ binding.set, binding.binding }] = binding;
    }
 
    for (const auto& [name, binding] : m_config.bindings) {
        auto key = std::make_pair(binding.set, binding.binding);
        if (unified_bindings.find(key) == unified_bindings.end()) {
            unified_bindings[key] = Portal::Graphics::DescriptorBindingInfo {
                .set = binding.set,
                .binding = binding.binding,
                .type = binding.type,
                .buffer_info = {},
                .name = name,
                .count = binding.count
            };
        }
    }
 
    std::vector<Portal::Graphics::DescriptorBindingInfo> unregistered;
    for (const Portal::Graphics::ShaderID shader_id : { m_shader_id, m_fragment_shader_id, m_geometry_shader_id, m_tess_control_shader_id, m_tess_eval_shader_id }) {
        if (shader_id == Portal::Graphics::INVALID_SHADER) {
            continue;
        }
        for (const auto& used : Portal::Graphics::get_shader_foundry().get_active_descriptor_bindings(shader_id)) {
            if (used.set == 0 || unified_bindings.contains({ used.set, used.binding })) {
                continue;
            }
            unregistered.push_back(used);
        }
    }
 
    for (auto it = m_awaited_bindings.begin(); it != m_awaited_bindings.end();) {
        const auto slot = *it;
        const bool pending = std::ranges::any_of(unregistered, [&slot](const auto& used) {
            return used.set == slot.first && used.binding == slot.second;
        });
        if (pending) {
            ++it;
            continue;
        }
        MF_INFO(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "Set {} binding {} is now registered, the shader's binding is supplied",
            slot.first, slot.second);
        it = m_awaited_bindings.erase(it);
    }
 
    if (!unregistered.empty()) {
        constexpr uint32_t k_binding_grace_ticks = 30;
        const bool waiting = m_pipeline_id == Portal::Graphics::INVALID_RENDER_PIPELINE
            && m_binding_wait_ticks < k_binding_grace_ticks;
 
        for (const auto& used : unregistered) {
            const bool first_seen = m_awaited_bindings.emplace(used.set, used.binding).second;
            if (waiting && first_seen) {
                MF_INFO(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                    "Waiting for set {} binding {} ({}), which the shader uses, to be registered before creating the pipeline",
                    used.set, used.binding, vk::to_string(used.type));
            }
        }
 
        if (waiting) {
            ++m_binding_wait_ticks;
            m_needs_pipeline_rebuild = true;
            return;
        }
 
        for (const auto& used : unregistered) {
            MF_WARN(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Set {} binding {} ({}), which the shader uses, is not registered. "
                "Creating the pipeline with an empty slot that is filled once a processor registers it",
                used.set, used.binding, vk::to_string(used.type));
            unified_bindings.emplace(std::make_pair(used.set, used.binding),
                Portal::Graphics::DescriptorBindingInfo {
                    .set = used.set,
                    .binding = used.binding,
                    .type = used.type,
                    .buffer_info = {},
                    .name = used.name });
        }
    }
    m_binding_wait_ticks = 0;
 
    std::map<uint32_t, std::vector<Portal::Graphics::DescriptorBindingInfo>> bindings_by_set;
    for (const auto& [key, binding] : unified_bindings) {
        bindings_by_set[binding.set].push_back(binding);
    }
 
    for (const auto& [set_index, set_bindings] : bindings_by_set) {
        pipeline_config.descriptor_sets.push_back(set_bindings);
    }
 
    vk::Format swapchain_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;
 
    retire_current_pipeline();
 
    m_pipeline_id = flow.create_pipeline(pipeline_config, { swapchain_format }, depth_format);
 
    if (m_pipeline_id == Portal::Graphics::INVALID_RENDER_PIPELINE) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "Failed to create render pipeline");
        return;
    }
 
    if (m_depth_enabled) {
        buffer->set_needs_depth_attachment(true);
    }
 
    m_needs_descriptor_rebuild = m_descriptor_set_ids.empty();
    m_needs_pipeline_rebuild = false;
 
    on_pipeline_created(m_pipeline_id);
}
Here is the call graph for this function: