create_pipeline()

RenderPipelineID MayaFlux::Portal::Graphics::RenderFlow::create_pipeline	(	const RenderPipelineConfig &	config,
		const std::vector< vk::Format > &	color_formats,
		vk::Format	depth_format = vk::Format::eUndefined
	)

Create graphics pipeline for dynamic rendering (no render pass object)

Parameters

config	Pipeline configuration
color_formats	Color attachment formats for dynamic rendering
depth_format	Depth attachment format

Returns

Pipeline ID or INVALID_RENDER_PIPELINE on error

Definition at line 261 of file RenderFlow.cpp.

{
    if (!is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::Rendering,
            "RenderFlow not initialized");
        return INVALID_RENDER_PIPELINE;
    }
 
    if (config.mesh_shader == INVALID_SHADER && config.vertex_shader == INVALID_SHADER) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::Rendering,
            "Pipeline requires either mesh shader or vertex shader");
        return INVALID_RENDER_PIPELINE;
    }
 
    if (color_formats.empty()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::Rendering,
            "At least one color format required for dynamic rendering pipeline");
        return INVALID_RENDER_PIPELINE;
    }
 
    Core::GraphicsPipelineConfig vk_config;
 
    vk_config.vertex_shader = m_shader_foundry->get_vk_shader_module(config.vertex_shader);
    if (config.fragment_shader != INVALID_SHADER) {
        vk_config.fragment_shader = m_shader_foundry->get_vk_shader_module(config.fragment_shader);
    }
    if (config.geometry_shader != INVALID_SHADER) {
        vk_config.geometry_shader = m_shader_foundry->get_vk_shader_module(config.geometry_shader);
    }
    if (config.tess_control_shader != INVALID_SHADER) {
        vk_config.tess_control_shader = m_shader_foundry->get_vk_shader_module(config.tess_control_shader);
    }
    if (config.tess_eval_shader != INVALID_SHADER) {
        vk_config.tess_evaluation_shader = m_shader_foundry->get_vk_shader_module(config.tess_eval_shader);
    }
 
    vk_config.mesh_shader = m_shader_foundry->get_vk_shader_module(config.mesh_shader);
    if (config.task_shader != INVALID_SHADER) {
        vk_config.task_shader = m_shader_foundry->get_vk_shader_module(config.task_shader);
    }
 
    if (config.fragment_shader != INVALID_SHADER) {
        vk_config.fragment_shader = m_shader_foundry->get_vk_shader_module(config.fragment_shader);
    }
 
    if (config.semantic_vertex_layout.has_value()) {
        MF_INFO(Journal::Component::Portal, Journal::Context::Rendering,
            "Pipeline using semantic VertexLayout ({} vertices, {} attributes)",
            config.semantic_vertex_layout->vertex_count,
            config.semantic_vertex_layout->attributes.size());
 
        auto [vk_bindings, vk_attributes] = translate_semantic_layout(
            config.semantic_vertex_layout.value());
 
        vk_config.vertex_bindings = vk_bindings;
        vk_config.vertex_attributes = vk_attributes;
        vk_config.use_vertex_shader_reflection = false;
 
    } else if (!config.vertex_bindings.empty() || !config.vertex_attributes.empty()) {
        MF_INFO(Journal::Component::Portal, Journal::Context::Rendering,
            "Pipeline using explicit vertex config ({} bindings, {} attributes)",
            config.vertex_bindings.size(), config.vertex_attributes.size());
 
        for (const auto& binding : config.vertex_bindings) {
            Core::VertexBinding vk_binding {};
            vk_binding.binding = binding.binding;
            vk_binding.stride = binding.stride;
            vk_binding.input_rate = binding.per_instance ? vk::VertexInputRate::eInstance : vk::VertexInputRate::eVertex;
            vk_config.vertex_bindings.push_back(vk_binding);
        }
 
        for (const auto& attr : config.vertex_attributes) {
            Core::VertexAttribute vk_attr {};
            vk_attr.location = attr.location;
            vk_attr.binding = attr.binding;
            vk_attr.format = attr.format;
            vk_attr.offset = attr.offset;
            vk_config.vertex_attributes.push_back(vk_attr);
        }
 
        vk_config.use_vertex_shader_reflection = false;
    } else {
        MF_DEBUG(Journal::Component::Portal, Journal::Context::Rendering,
            "Pipeline will use shader reflection for vertex input");
        vk_config.use_vertex_shader_reflection = config.use_vertex_shader_reflection;
    }
 
    vk_config.topology = to_vk_topology(config.topology);
    vk_config.primitive_restart_enable = false;
 
    vk_config.polygon_mode = to_vk_polygon_mode(config.rasterization.polygon_mode);
    vk_config.cull_mode = to_vk_cull_mode(config.rasterization.cull_mode);
    vk_config.front_face = config.rasterization.front_face_ccw ? vk::FrontFace::eCounterClockwise : vk::FrontFace::eClockwise;
    vk_config.line_width = config.rasterization.line_width;
    vk_config.depth_clamp_enable = config.rasterization.depth_clamp;
    vk_config.depth_bias_enable = config.rasterization.depth_bias;
 
    vk_config.depth_test_enable = config.depth_stencil.depth_test_enable;
    vk_config.depth_write_enable = config.depth_stencil.depth_write_enable;
    vk_config.depth_compare_op = to_vk_compare_op(config.depth_stencil.depth_compare_op);
    vk_config.stencil_test_enable = config.depth_stencil.stencil_test_enable;
 
    for (const auto& blend : config.blend_attachments) {
        Core::ColorBlendAttachment vk_blend;
        vk_blend.blend_enable = blend.blend_enable;
        vk_blend.src_color_blend_factor = to_vk_blend_factor(blend.src_color_factor);
        vk_blend.dst_color_blend_factor = to_vk_blend_factor(blend.dst_color_factor);
        vk_blend.color_blend_op = to_vk_blend_op(blend.color_blend_op);
        vk_blend.src_alpha_blend_factor = to_vk_blend_factor(blend.src_alpha_factor);
        vk_blend.dst_alpha_blend_factor = to_vk_blend_factor(blend.dst_alpha_factor);
        vk_blend.alpha_blend_op = to_vk_blend_op(blend.alpha_blend_op);
        vk_config.color_blend_attachments.push_back(vk_blend);
    }
 
    std::vector<vk::DescriptorSetLayout> layouts;
    vk::DescriptorSetLayout state_vt_layout {};
 
    {
        std::vector<vk::DescriptorSetLayoutBinding> set0_bindings;
 
        vk::DescriptorSetLayoutBinding vt_b;
        vt_b.binding = 0;
        vt_b.descriptorType = vk::DescriptorType::eUniformBuffer;
        vt_b.descriptorCount = 1;
        vt_b.stageFlags = vk::ShaderStageFlagBits::eVertex;
        set0_bindings.push_back(vt_b);
 
        if (!config.descriptor_sets.empty()) {
            for (const auto& binding : config.descriptor_sets[0]) {
                if (binding.set == 0 && binding.binding != 0) {
                    vk::DescriptorSetLayoutBinding vk_b;
                    vk_b.binding = binding.binding;
                    vk_b.descriptorType = binding.type;
                    vk_b.descriptorCount = binding.count > 0 ? binding.count : 1;
                    vk_b.stageFlags = vk::ShaderStageFlagBits::eVertex
                        | vk::ShaderStageFlagBits::eFragment;
                    set0_bindings.push_back(vk_b);
                }
            }
        }
 
        vk::DescriptorSetLayoutCreateInfo layout_info;
        layout_info.bindingCount = static_cast<uint32_t>(set0_bindings.size());
        layout_info.pBindings = set0_bindings.data();
        vk::DescriptorSetLayout vt_layout = m_shader_foundry->get_device().createDescriptorSetLayout(layout_info);
        layouts.push_back(vt_layout);
        state_vt_layout = vt_layout;
    }
 
    for (const auto& desc_set : config.descriptor_sets) {
        bool all_set_zero = std::ranges::all_of(desc_set,
            [](const auto& b) { return b.set == 0; });
        if (all_set_zero)
            continue;
 
        std::vector<vk::DescriptorSetLayoutBinding> bindings;
        for (const auto& binding : desc_set) {
            if (binding.set == 0)
                continue;
            vk::DescriptorSetLayoutBinding vk_b;
            vk_b.binding = binding.binding;
            vk_b.descriptorType = binding.type;
            vk_b.descriptorCount = binding.count > 0 ? binding.count : 1;
            vk_b.stageFlags = vk::ShaderStageFlagBits::eVertex
                | vk::ShaderStageFlagBits::eFragment;
            bindings.push_back(vk_b);
        }
 
        if (bindings.empty())
            continue;
 
        vk::DescriptorSetLayoutCreateInfo layout_info;
        layout_info.bindingCount = static_cast<uint32_t>(bindings.size());
        layout_info.pBindings = bindings.data();
        layouts.push_back(
            m_shader_foundry->get_device().createDescriptorSetLayout(layout_info));
    }
 
    vk_config.descriptor_set_layouts = layouts;
 
    vk::ShaderStageFlags push_constant_stages;
 
    if (config.mesh_shader != INVALID_SHADER) {
        push_constant_stages = vk::ShaderStageFlagBits::eMeshEXT;
        if (config.task_shader != INVALID_SHADER) {
            push_constant_stages |= vk::ShaderStageFlagBits::eTaskEXT;
        }
        if (config.fragment_shader != INVALID_SHADER) {
            push_constant_stages |= vk::ShaderStageFlagBits::eFragment;
        }
    } else {
        push_constant_stages = vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment;
        if (config.geometry_shader != INVALID_SHADER) {
            push_constant_stages |= vk::ShaderStageFlagBits::eGeometry;
        }
        if (config.tess_control_shader != INVALID_SHADER) {
            push_constant_stages |= vk::ShaderStageFlagBits::eTessellationControl;
        }
        if (config.tess_eval_shader != INVALID_SHADER) {
            push_constant_stages |= vk::ShaderStageFlagBits::eTessellationEvaluation;
        }
    }
 
    if (config.push_constant_size > 0) {
        vk::PushConstantRange range;
        range.stageFlags = push_constant_stages;
        range.offset = 0;
        range.size = static_cast<uint32_t>(config.push_constant_size);
        vk_config.push_constant_ranges.push_back(range);
    }
 
    vk_config.color_attachment_formats = color_formats;
    vk_config.depth_attachment_format = depth_format;
 
    vk_config.dynamic_states = {
        vk::DynamicState::eViewport,
        vk::DynamicState::eScissor
    };
 
    auto pipeline = std::make_shared<Core::VKGraphicsPipeline>();
    if (!pipeline->create(m_shader_foundry->get_device(), vk_config)) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::Rendering,
            "Failed to create VKGraphicsPipeline for dynamic rendering");
 
        for (auto layout : layouts) {
            m_shader_foundry->get_device().destroyDescriptorSetLayout(layout);
        }
        return INVALID_RENDER_PIPELINE;
    }
 
    auto pipeline_id = m_next_pipeline_id.fetch_add(1);
    PipelineState state;
    state.shader_ids = { config.vertex_shader, config.fragment_shader };
    state.pipeline = pipeline;
    state.layouts = layouts;
    state.view_transform_layout = state_vt_layout;
    state.layout = pipeline->get_layout();
    state.push_constant_stages = push_constant_stages;
    m_pipelines[pipeline_id] = std::move(state);
 
    MF_INFO(Journal::Component::Portal, Journal::Context::Rendering,
        "Dynamic rendering pipeline created (ID: {}, {} color attachments)",
        pipeline_id, color_formats.size());
 
    return pipeline_id;
}

References MayaFlux::Core::ColorBlendAttachment::alpha_blend_op, b, MayaFlux::Core::VertexBinding::binding, MayaFlux::Portal::Graphics::RenderPipelineConfig::blend_attachments, MayaFlux::Core::ColorBlendAttachment::blend_enable, MayaFlux::Core::GraphicsPipelineConfig::color_attachment_formats, MayaFlux::Core::GraphicsPipelineConfig::color_blend_attachments, MayaFlux::Core::ColorBlendAttachment::color_blend_op, MayaFlux::Core::GraphicsPipelineConfig::cull_mode, MayaFlux::Portal::Graphics::RasterizationConfig::cull_mode, MayaFlux::Core::GraphicsPipelineConfig::depth_attachment_format, MayaFlux::Portal::Graphics::RasterizationConfig::depth_bias, MayaFlux::Core::GraphicsPipelineConfig::depth_bias_enable, MayaFlux::Portal::Graphics::RasterizationConfig::depth_clamp, MayaFlux::Core::GraphicsPipelineConfig::depth_clamp_enable, MayaFlux::Core::GraphicsPipelineConfig::depth_compare_op, MayaFlux::Portal::Graphics::DepthStencilConfig::depth_compare_op, MayaFlux::Portal::Graphics::RenderPipelineConfig::depth_stencil, MayaFlux::Core::GraphicsPipelineConfig::depth_test_enable, MayaFlux::Portal::Graphics::DepthStencilConfig::depth_test_enable, MayaFlux::Core::GraphicsPipelineConfig::depth_write_enable, MayaFlux::Portal::Graphics::DepthStencilConfig::depth_write_enable, MayaFlux::Core::GraphicsPipelineConfig::descriptor_set_layouts, MayaFlux::Portal::Graphics::RenderPipelineConfig::descriptor_sets, MayaFlux::Core::ColorBlendAttachment::dst_alpha_blend_factor, MayaFlux::Core::ColorBlendAttachment::dst_color_blend_factor, MayaFlux::Core::GraphicsPipelineConfig::dynamic_states, MayaFlux::Core::GraphicsPipelineConfig::fragment_shader, MayaFlux::Portal::Graphics::RenderPipelineConfig::fragment_shader, MayaFlux::Core::GraphicsPipelineConfig::front_face, MayaFlux::Portal::Graphics::RasterizationConfig::front_face_ccw, MayaFlux::Core::GraphicsPipelineConfig::geometry_shader, MayaFlux::Portal::Graphics::RenderPipelineConfig::geometry_shader, MayaFlux::Portal::Graphics::ShaderFoundry::get_device(), MayaFlux::Portal::Graphics::ShaderFoundry::get_vk_shader_module(), MayaFlux::Portal::Graphics::INVALID_RENDER_PIPELINE, MayaFlux::Portal::Graphics::INVALID_SHADER, is_initialized(), MayaFlux::Portal::Graphics::RenderFlow::PipelineState::layout, MayaFlux::Portal::Graphics::RenderFlow::PipelineState::layouts, MayaFlux::Core::GraphicsPipelineConfig::line_width, MayaFlux::Portal::Graphics::RasterizationConfig::line_width, MayaFlux::Core::VertexAttribute::location, m_next_pipeline_id, m_pipelines, m_shader_foundry, MayaFlux::Core::GraphicsPipelineConfig::mesh_shader, MayaFlux::Portal::Graphics::RenderPipelineConfig::mesh_shader, MF_DEBUG, MF_ERROR, MF_INFO, MayaFlux::Portal::Graphics::RenderFlow::PipelineState::pipeline, MayaFlux::Core::GraphicsPipelineConfig::polygon_mode, MayaFlux::Portal::Graphics::RasterizationConfig::polygon_mode, MayaFlux::Journal::Portal, MayaFlux::Core::GraphicsPipelineConfig::primitive_restart_enable, MayaFlux::Core::GraphicsPipelineConfig::push_constant_ranges, MayaFlux::Portal::Graphics::RenderPipelineConfig::push_constant_size, MayaFlux::Portal::Graphics::RenderFlow::PipelineState::push_constant_stages, MayaFlux::Portal::Graphics::RenderPipelineConfig::rasterization, MayaFlux::Journal::Rendering, MayaFlux::Portal::Graphics::RenderPipelineConfig::semantic_vertex_layout, MayaFlux::Portal::Graphics::RenderFlow::PipelineState::shader_ids, MayaFlux::Core::ColorBlendAttachment::src_alpha_blend_factor, MayaFlux::Core::ColorBlendAttachment::src_color_blend_factor, MayaFlux::Core::GraphicsPipelineConfig::stencil_test_enable, MayaFlux::Portal::Graphics::DepthStencilConfig::stencil_test_enable, MayaFlux::Core::GraphicsPipelineConfig::task_shader, MayaFlux::Portal::Graphics::RenderPipelineConfig::task_shader, MayaFlux::Core::GraphicsPipelineConfig::tess_control_shader, MayaFlux::Portal::Graphics::RenderPipelineConfig::tess_control_shader, MayaFlux::Portal::Graphics::RenderPipelineConfig::tess_eval_shader, MayaFlux::Core::GraphicsPipelineConfig::tess_evaluation_shader, MayaFlux::Core::GraphicsPipelineConfig::topology, MayaFlux::Portal::Graphics::RenderPipelineConfig::topology, MayaFlux::Core::GraphicsPipelineConfig::use_vertex_shader_reflection, MayaFlux::Portal::Graphics::RenderPipelineConfig::use_vertex_shader_reflection, MayaFlux::Core::GraphicsPipelineConfig::vertex_attributes, MayaFlux::Portal::Graphics::RenderPipelineConfig::vertex_attributes, MayaFlux::Core::GraphicsPipelineConfig::vertex_bindings, MayaFlux::Portal::Graphics::RenderPipelineConfig::vertex_bindings, MayaFlux::Core::GraphicsPipelineConfig::vertex_shader, MayaFlux::Portal::Graphics::RenderPipelineConfig::vertex_shader, and MayaFlux::Portal::Graphics::RenderFlow::PipelineState::view_transform_layout.

Here is the call graph for this function: