create()

bool MayaFlux::Core::VKGraphicsPipeline::create	(	vk::Device	device,
		const GraphicsPipelineConfig &	config
	)

Create graphics pipeline from configuration.

Parameters

device	Logical device
config	Pipeline configuration

Returns

true if creation succeeded

Validates shaders, creates pipeline layout, and creates pipeline.

Definition at line 195 of file VKGraphicsPipeline.cpp.

{
    if (!device) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "Cannot create graphics pipeline with null device");
        return false;
    }
 
    m_device = device;
    m_config = config;
 
    if (!validate_shaders(config)) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "Shader validation failed");
        return false;
    }
 
    m_layout = create_pipeline_layout(device, config);
    if (!m_layout) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "Failed to create pipeline layout");
        return false;
    }
 
    std::vector<vk::PipelineShaderStageCreateInfo> shader_stages;
    if (config.vertex_shader) {
        shader_stages.push_back(config.vertex_shader->get_stage_create_info());
    }
    if (config.fragment_shader) {
        shader_stages.push_back(config.fragment_shader->get_stage_create_info());
    }
    if (config.geometry_shader) {
        shader_stages.push_back(config.geometry_shader->get_stage_create_info());
    }
    if (config.tess_control_shader) {
        shader_stages.push_back(config.tess_control_shader->get_stage_create_info());
    }
    if (config.tess_evaluation_shader) {
        shader_stages.push_back(config.tess_evaluation_shader->get_stage_create_info());
    }
 
    std::vector<vk::VertexInputBindingDescription> vertex_bindings;
    std::vector<vk::VertexInputAttributeDescription> vertex_attributes;
    auto vertex_input_state = build_vertex_input_state(config, vertex_bindings, vertex_attributes);
 
    auto input_assembly_state = build_input_assembly_state(config);
    auto tessellation_state = build_tessellation_state(config);
 
    std::vector<vk::Viewport> viewports;
    std::vector<vk::Rect2D> scissors;
    auto viewport_state = build_viewport_state(config, viewports, scissors);
 
    auto rasterization_state = build_rasterization_state(config);
    auto multisample_state = build_multisample_state(config);
    auto depth_stencil_state = build_depth_stencil_state(config);
 
    std::vector<vk::PipelineColorBlendAttachmentState> blend_attachments;
    auto color_blend_state = build_color_blend_state(config, blend_attachments);
 
    auto dynamic_state = build_dynamic_state(config);
 
    vk::GraphicsPipelineCreateInfo pipeline_info;
    pipeline_info.stageCount = static_cast<uint32_t>(shader_stages.size());
    pipeline_info.pStages = shader_stages.data();
    pipeline_info.pVertexInputState = &vertex_input_state;
    pipeline_info.pInputAssemblyState = &input_assembly_state;
    pipeline_info.pTessellationState = (config.tess_control_shader || config.tess_evaluation_shader) ? &tessellation_state : nullptr;
    pipeline_info.pViewportState = &viewport_state;
    pipeline_info.pRasterizationState = &rasterization_state;
    pipeline_info.pMultisampleState = &multisample_state;
    pipeline_info.pDepthStencilState = &depth_stencil_state;
    pipeline_info.pColorBlendState = &color_blend_state;
    pipeline_info.pDynamicState = config.dynamic_states.empty() ? nullptr : &dynamic_state;
    pipeline_info.layout = m_layout;
    pipeline_info.renderPass = config.render_pass;
    pipeline_info.subpass = config.subpass;
    pipeline_info.basePipelineHandle = nullptr;
    pipeline_info.basePipelineIndex = -1;
 
    try {
        auto result = device.createGraphicsPipeline(config.cache, pipeline_info);
        if (result.result != vk::Result::eSuccess) {
            MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
                "Failed to create graphics pipeline: {}", vk::to_string(result.result));
            device.destroyPipelineLayout(m_layout);
            m_layout = nullptr;
            return false;
        }
        m_pipeline = result.value;
    } catch (const vk::SystemError& e) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "Failed to create graphics pipeline: {}", e.what());
        device.destroyPipelineLayout(m_layout);
        m_layout = nullptr;
        return false;
    }
 
    MF_INFO(Journal::Component::Core, Journal::Context::GraphicsBackend,
        "Graphics pipeline created ({} shader stages)", shader_stages.size());
 
    return true;
}

References build_color_blend_state(), build_depth_stencil_state(), build_dynamic_state(), build_input_assembly_state(), build_multisample_state(), build_rasterization_state(), build_tessellation_state(), build_vertex_input_state(), build_viewport_state(), MayaFlux::Core::GraphicsPipelineConfig::cache, MayaFlux::Journal::Core, create_pipeline_layout(), MayaFlux::Core::GraphicsPipelineConfig::dynamic_states, MayaFlux::Core::GraphicsPipelineConfig::fragment_shader, MayaFlux::Core::GraphicsPipelineConfig::geometry_shader, MayaFlux::Journal::GraphicsBackend, m_config, m_device, m_layout, m_pipeline, MF_ERROR, MF_INFO, MayaFlux::Core::GraphicsPipelineConfig::render_pass, MayaFlux::Core::GraphicsPipelineConfig::subpass, MayaFlux::Core::GraphicsPipelineConfig::tess_control_shader, MayaFlux::Core::GraphicsPipelineConfig::tess_evaluation_shader, validate_shaders(), and MayaFlux::Core::GraphicsPipelineConfig::vertex_shader.

Here is the call graph for this function: