Method GraphicsPipeline

framework/core/pipeline.cpp:126–306

}

GraphicsPipeline::GraphicsPipeline(vkb::core::DeviceC             &device,
                                   VkPipelineCache                 pipeline_cache,
                                   vkb::rendering::PipelineStateC &pipeline_state) :
    Pipeline{device}
{
	std::vector<VkShaderModule> shader_modules;

	std::vector<VkPipelineShaderStageCreateInfo> stage_create_infos;

	// Create specialization info from tracked state. This is shared by all shaders.
	std::vector<uint8_t>                  data{};
	std::vector<VkSpecializationMapEntry> map_entries{};

	const auto specialization_constant_state = pipeline_state.get_specialization_constant_state().get_specialization_constant_state();

	for (const auto specialization_constant : specialization_constant_state)
	{
		map_entries.push_back({specialization_constant.first, to_u32(data.size()), specialization_constant.second.size()});
		data.insert(data.end(), specialization_constant.second.begin(), specialization_constant.second.end());
	}

	VkSpecializationInfo specialization_info{};
	specialization_info.mapEntryCount = to_u32(map_entries.size());
	specialization_info.pMapEntries   = map_entries.data();
	specialization_info.dataSize      = data.size();
	specialization_info.pData         = data.data();

	for (const ShaderModule *shader_module : pipeline_state.get_pipeline_layout().get_shader_modules())
	{
		VkPipelineShaderStageCreateInfo stage_create_info{VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO};

		stage_create_info.stage = shader_module->get_stage();
		stage_create_info.pName = shader_module->get_entry_point().c_str();

		// Create the Vulkan handle
		VkShaderModuleCreateInfo vk_create_info{VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO};

		vk_create_info.codeSize = shader_module->get_binary().size() * sizeof(uint32_t);
		vk_create_info.pCode    = shader_module->get_binary().data();

		VkResult result = vkCreateShaderModule(device.get_handle(), &vk_create_info, nullptr, &stage_create_info.module);
		if (result != VK_SUCCESS)
		{
			throw VulkanException{result};
		}

		device.get_debug_utils().set_debug_name(device.get_handle(),
		                                        VK_OBJECT_TYPE_SHADER_MODULE, reinterpret_cast<uint64_t>(stage_create_info.module),
		                                        shader_module->get_debug_name().c_str());

		stage_create_info.pSpecializationInfo = &specialization_info;

		stage_create_infos.push_back(stage_create_info);
		shader_modules.push_back(stage_create_info.module);
	}

	VkGraphicsPipelineCreateInfo create_info{VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO};