◆ 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.mesh_shader) {
        shader_stages.push_back(config.mesh_shader->get_stage_create_info());
        if (config.task_shader) {
            shader_stages.push_back(config.task_shader->get_stage_create_info());
        }
    } else {
        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.basePipelineHandle = nullptr;
    pipeline_info.basePipelineIndex = -1;
 
    vk::PipelineRenderingCreateInfo rendering_create_info;
    rendering_create_info.colorAttachmentCount = static_cast<uint32_t>(config.color_attachment_formats.size());
    rendering_create_info.pColorAttachmentFormats = config.color_attachment_formats.data();
    rendering_create_info.depthAttachmentFormat = config.depth_attachment_format;
    rendering_create_info.stencilAttachmentFormat = config.stencil_attachment_format;
 
    pipeline_info.pNext = &rendering_create_info;
    pipeline_info.renderPass = nullptr;
    pipeline_info.subpass = 0;
 
    MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
        "Creating pipeline for dynamic rendering ({} color attachments)",
        config.color_attachment_formats.size());
 
    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;
}
Here is the call graph for this function: