自学教程：C++ vkCreatePipelineLayout函数代码示例

	void setupDescriptorSetLayout()	{		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings;		VkDescriptorSetLayoutCreateInfo descriptorLayout;		VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo;		// Scene rendering		setLayoutBindings = {			// Binding 0: Vertex shader uniform buffer			vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT, 0),			// Binding 1: Fragment shader image sampler			vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, 1),			// Binding 2: Fragment shader uniform buffer			vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_FRAGMENT_BIT, 2)		};		descriptorLayout = vks::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings.data(), static_cast<uint32_t>(setLayoutBindings.size()));		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayouts.scene));		pipelineLayoutCreateInfo = vks::initializers::pipelineLayoutCreateInfo(&descriptorSetLayouts.scene, 1);		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayouts.scene));		// Fullscreen radial blur		setLayoutBindings = {			// Binding 0 : Vertex shader uniform buffer			vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_FRAGMENT_BIT, 0),			// Binding 0: Fragment shader image sampler			vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, 1)		};		descriptorLayout = vks::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings.data(), static_cast<uint32_t>(setLayoutBindings.size()));		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayouts.radialBlur));		pipelineLayoutCreateInfo = vks::initializers::pipelineLayoutCreateInfo(&descriptorSetLayouts.radialBlur, 1);		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayouts.radialBlur));	}

	void setupDescriptorSetLayout()	{		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings =		{			// Binding 0 : Fragment shader image sampler			vkTools::initializers::descriptorSetLayoutBinding(				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,				VK_SHADER_STAGE_FRAGMENT_BIT,				0)		};		VkDescriptorSetLayoutCreateInfo descriptorLayout =			vkTools::initializers::descriptorSetLayoutCreateInfo(				setLayoutBindings.data(),				setLayoutBindings.size());		VkResult err = vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout);		assert(!err);		VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =			vkTools::initializers::pipelineLayoutCreateInfo(				&descriptorSetLayout,				1);		err = vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout);		assert(!err);	}

	VkPipelineLayout VulkanDescriptorManager::getPipelineLayout(VulkanDescriptorLayout** layouts, UINT32 numLayouts)	{		VulkanPipelineLayoutKey key(layouts, numLayouts);		auto iterFind = mPipelineLayouts.find(key);		if (iterFind != mPipelineLayouts.end())			return iterFind->second;		// Create new		VkDescriptorSetLayout* setLayouts = (VkDescriptorSetLayout*)bs_stack_alloc(sizeof(VkDescriptorSetLayout) * numLayouts);		for(UINT32 i = 0; i < numLayouts; i++)			setLayouts[i] = layouts[i]->getHandle();		VkPipelineLayoutCreateInfo layoutCI;		layoutCI.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;		layoutCI.pNext = nullptr;		layoutCI.flags = 0;		layoutCI.pushConstantRangeCount = 0;		layoutCI.pPushConstantRanges = nullptr;		layoutCI.setLayoutCount = numLayouts;		layoutCI.pSetLayouts = setLayouts;		VkPipelineLayout pipelineLayout;		VkResult result = vkCreatePipelineLayout(mDevice.getLogical(), &layoutCI, gVulkanAllocator, &pipelineLayout);		assert(result == VK_SUCCESS);		bs_stack_free(setLayouts);		key.layouts = (VulkanDescriptorLayout**)bs_alloc(sizeof(VulkanDescriptorLayout*) * numLayouts);		memcpy(key.layouts, layouts, sizeof(VulkanDescriptorLayout*) * numLayouts);		mPipelineLayouts.insert(std::make_pair(key, pipelineLayout));		return pipelineLayout;	}

	void setupDescriptorSets()	{		std::vector<VkDescriptorPoolSize> poolSizes = {			vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1),		};		VkDescriptorPoolCreateInfo descriptorPoolCI = vks::initializers::descriptorPoolCreateInfo(poolSizes.size(), poolSizes.data(), 1);		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolCI, nullptr, &descriptorPool));		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = {			vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT, 0),		};		VkDescriptorSetLayoutCreateInfo descriptorLayoutCI{};		descriptorLayoutCI.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;		descriptorLayoutCI.bindingCount = static_cast<uint32_t>(setLayoutBindings.size());		descriptorLayoutCI.pBindings = setLayoutBindings.data();		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayoutCI, nullptr, &descriptorSetLayout));		std::array<VkDescriptorSetLayout, 2> setLayouts = {			descriptorSetLayout, scene.descriptorSetLayout		};		VkPipelineLayoutCreateInfo pipelineLayoutCI = vks::initializers::pipelineLayoutCreateInfo(setLayouts.data(), 2);		VkPushConstantRange pushConstantRange = vks::initializers::pushConstantRange(VK_SHADER_STAGE_VERTEX_BIT, sizeof(glm::vec4) * 2,	0);		pipelineLayoutCI.pushConstantRangeCount = 1;		pipelineLayoutCI.pPushConstantRanges = &pushConstantRange;		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pipelineLayoutCI, nullptr, &pipelineLayout));		VkDescriptorSetAllocateInfo descriptorSetAllocateInfo = vks::initializers::descriptorSetAllocateInfo(descriptorPool, &descriptorSetLayout, 1);		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &descriptorSetAllocateInfo, &descriptorSet));		std::vector<VkWriteDescriptorSet> writeDescriptorSets = {			vks::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &uniformBuffer.descriptor)		};		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);	}

	void setupDescriptorSetLayout()	{		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings =		{			// Binding 0 : Tessellation control shader ubo			vkTools::initializers::descriptorSetLayoutBinding(				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,				0),			// Binding 1 : Tessellation evaluation shader ubo			vkTools::initializers::descriptorSetLayoutBinding(				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,				1),			// Binding 2 : Fragment shader combined sampler			vkTools::initializers::descriptorSetLayoutBinding(				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,				VK_SHADER_STAGE_FRAGMENT_BIT,				2),		};		VkDescriptorSetLayoutCreateInfo descriptorLayout =			vkTools::initializers::descriptorSetLayoutCreateInfo(				setLayoutBindings.data(),				setLayoutBindings.size());		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));		VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =			vkTools::initializers::pipelineLayoutCreateInfo(				&descriptorSetLayout,				1);		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout));	}

	void setupDescriptors()	{		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = {			vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, 0)		};		VkDescriptorSetLayoutCreateInfo descriptorLayoutCI = vks::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings);		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayoutCI, nullptr, &descriptorSetLayout));		VkPipelineLayoutCreateInfo pipelineLayoutCI = vks::initializers::pipelineLayoutCreateInfo(&descriptorSetLayout, 1);		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pipelineLayoutCI, nullptr, &pipelineLayout));		VkDescriptorPoolSize poolSize = vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 2);		VkDescriptorPoolCreateInfo descriptorPoolCI = vks::initializers::descriptorPoolCreateInfo(1, &poolSize, 2);		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolCI, nullptr, &descriptorPool));		VkDescriptorSetAllocateInfo descriptorSetAI = vks::initializers::descriptorSetAllocateInfo(descriptorPool, &descriptorSetLayout, 1);				VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &descriptorSetAI, &descriptorSets.CW));		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &descriptorSetAI, &descriptorSets.CCW));				std::vector<VkWriteDescriptorSet> writeDescriptorSets = {			vks::initializers::writeDescriptorSet(descriptorSets.CW, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 0, &textures.CW.descriptor),			vks::initializers::writeDescriptorSet(descriptorSets.CCW, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 0, &textures.CCW.descriptor)		};		vkUpdateDescriptorSets(device, 2, &writeDescriptorSets[0], 0, nullptr);	}

VkBool32 Example::buildPipelineLayout(){	VkResult result;	//	VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo;	memset(&pipelineLayoutCreateInfo, 0, sizeof(VkPipelineLayoutCreateInfo));	pipelineLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;	pipelineLayoutCreateInfo.flags = 0;	pipelineLayoutCreateInfo.setLayoutCount = 0;	pipelineLayoutCreateInfo.pSetLayouts = nullptr;	pipelineLayoutCreateInfo.pushConstantRangeCount = 0;	pipelineLayoutCreateInfo.pPushConstantRanges = nullptr;	result = vkCreatePipelineLayout(device->getDevice(), &pipelineLayoutCreateInfo, nullptr, &pipelineLayout);	if (result != VK_SUCCESS)	{		vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not create pipeline layout.");		return VK_FALSE;	}	return VK_TRUE;}

	void setupDescriptorSetLayout()	{		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = {			vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0),			vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_FRAGMENT_BIT, 1),		};		VkDescriptorSetLayoutCreateInfo descriptorLayout =			vks::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings);		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));		VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =			vks::initializers::pipelineLayoutCreateInfo(&descriptorSetLayout, 1);		std::vector<VkPushConstantRange> pushConstantRanges = {			vks::initializers::pushConstantRange(VK_SHADER_STAGE_VERTEX_BIT, sizeof(glm::vec3), 0),			vks::initializers::pushConstantRange(VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(Material::PushBlock), sizeof(glm::vec3)),		};		pipelineLayoutCreateInfo.pushConstantRangeCount = 2;		pipelineLayoutCreateInfo.pPushConstantRanges = pushConstantRanges.data();		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout));	}

	void setupDescriptorSetLayout()	{		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings;		// Binding 0 : Particle color map		setLayoutBindings.push_back(vkTools::initializers::descriptorSetLayoutBinding(			VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,			VK_SHADER_STAGE_FRAGMENT_BIT,			0));		// Binding 1 : Particle gradient ramp		setLayoutBindings.push_back(vkTools::initializers::descriptorSetLayoutBinding(			VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,			VK_SHADER_STAGE_FRAGMENT_BIT,			1));		VkDescriptorSetLayoutCreateInfo descriptorLayout =			vkTools::initializers::descriptorSetLayoutCreateInfo(				setLayoutBindings.data(),				setLayoutBindings.size());		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));		VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =			vkTools::initializers::pipelineLayoutCreateInfo(				&descriptorSetLayout,				1);		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout));	}

	void setupDescriptorSetLayout()	{		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings =		{			// Binding 0 : Vertex shader ubo			vkTools::initializers::descriptorSetLayoutBinding(				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				VK_SHADER_STAGE_VERTEX_BIT,				0),			// Binding 1 : Geometry shader ubo			vkTools::initializers::descriptorSetLayoutBinding(				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				VK_SHADER_STAGE_GEOMETRY_BIT,				1)		};		VkDescriptorSetLayoutCreateInfo descriptorLayout =			vkTools::initializers::descriptorSetLayoutCreateInfo(				setLayoutBindings.data(),				setLayoutBindings.size());		VkResult err = vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout);		assert(!err);		VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =			vkTools::initializers::pipelineLayoutCreateInfo(				&descriptorSetLayout,				1);		err = vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout);		assert(!err);	}

	void setupDescriptorSetLayout()	{		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = 		{			// Binding 0 : Vertex shader uniform buffer			vks::initializers::descriptorSetLayoutBinding(				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 				VK_SHADER_STAGE_VERTEX_BIT, 				0),			// Binding 1 : Fragment shader image sampler			vks::initializers::descriptorSetLayoutBinding(				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 				VK_SHADER_STAGE_FRAGMENT_BIT, 				1)		};		VkDescriptorSetLayoutCreateInfo descriptorLayout = 			vks::initializers::descriptorSetLayoutCreateInfo(				setLayoutBindings.data(),				setLayoutBindings.size());		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));		VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =			vks::initializers::pipelineLayoutCreateInfo(				&descriptorSetLayout,				1);		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout));	}

bool ObjectCache::CreatePipelineLayouts(){  VkResult res;  // Descriptor sets for each pipeline layout  VkDescriptorSetLayout standard_sets[] = {      m_descriptor_set_layouts[DESCRIPTOR_SET_LAYOUT_UNIFORM_BUFFERS],      m_descriptor_set_layouts[DESCRIPTOR_SET_LAYOUT_PIXEL_SHADER_SAMPLERS]};  VkDescriptorSetLayout bbox_sets[] = {      m_descriptor_set_layouts[DESCRIPTOR_SET_LAYOUT_UNIFORM_BUFFERS],      m_descriptor_set_layouts[DESCRIPTOR_SET_LAYOUT_PIXEL_SHADER_SAMPLERS],      m_descriptor_set_layouts[DESCRIPTOR_SET_LAYOUT_SHADER_STORAGE_BUFFERS]};  VkDescriptorSetLayout texture_conversion_sets[] = {      m_descriptor_set_layouts[DESCRIPTOR_SET_LAYOUT_UNIFORM_BUFFERS],      m_descriptor_set_layouts[DESCRIPTOR_SET_LAYOUT_PIXEL_SHADER_SAMPLERS],      m_descriptor_set_layouts[DESCRIPTOR_SET_LAYOUT_TEXEL_BUFFERS]};  VkDescriptorSetLayout compute_sets[] = {m_descriptor_set_layouts[DESCRIPTOR_SET_LAYOUT_COMPUTE]};  VkPushConstantRange push_constant_range = {      VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, PUSH_CONSTANT_BUFFER_SIZE};  VkPushConstantRange compute_push_constant_range = {VK_SHADER_STAGE_COMPUTE_BIT, 0,                                                     PUSH_CONSTANT_BUFFER_SIZE};  // Info for each pipeline layout  VkPipelineLayoutCreateInfo pipeline_layout_info[NUM_PIPELINE_LAYOUTS] = {      // Standard      {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0,       static_cast<u32>(ArraySize(standard_sets)), standard_sets, 0, nullptr},      // BBox      {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0,       static_cast<u32>(ArraySize(bbox_sets)), bbox_sets, 0, nullptr},      // Push Constant      {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0,       static_cast<u32>(ArraySize(standard_sets)), standard_sets, 1, &push_constant_range},      // Texture Conversion      {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0,       static_cast<u32>(ArraySize(texture_conversion_sets)), texture_conversion_sets, 1,       &push_constant_range},      // Compute      {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0,       static_cast<u32>(ArraySize(compute_sets)), compute_sets, 1, &compute_push_constant_range}};  for (size_t i = 0; i < NUM_PIPELINE_LAYOUTS; i++)  {    if ((res = vkCreatePipelineLayout(g_vulkan_context->GetDevice(), &pipeline_layout_info[i],                                      nullptr, &m_pipeline_layouts[i])) != VK_SUCCESS)    {      LOG_VULKAN_ERROR(res, "vkCreatePipelineLayout failed: ");      return false;    }  }  return true;}

	void setupDescriptorSetLayout()	{		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = {			vkTools::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT, 0),			vkTools::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, 1),			vkTools::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_FRAGMENT_BIT, 2),		};		VkDescriptorSetLayoutCreateInfo descriptorLayoutInfo = 			vkTools::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings.data(), static_cast<uint32_t>(setLayoutBindings.size()));		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayoutInfo, nullptr, &descriptorSetLayouts.models));		VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =			vkTools::initializers::pipelineLayoutCreateInfo(				&descriptorSetLayouts.models,				1);		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayouts.models));		// Bloom filter		setLayoutBindings = {			vkTools::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, 0),			vkTools::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, 1),		};		descriptorLayoutInfo = vkTools::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings.data(), static_cast<uint32_t>(setLayoutBindings.size()));		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayoutInfo, nullptr, &descriptorSetLayouts.bloomFilter));		pipelineLayoutCreateInfo = vkTools::initializers::pipelineLayoutCreateInfo(&descriptorSetLayouts.bloomFilter, 1);		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayouts.bloomFilter));		// G-Buffer composition		setLayoutBindings = {			vkTools::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, 0),			vkTools::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, 1),		};		descriptorLayoutInfo = vkTools::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings.data(), static_cast<uint32_t>(setLayoutBindings.size()));		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayoutInfo, nullptr, &descriptorSetLayouts.composition));		pipelineLayoutCreateInfo = vkTools::initializers::pipelineLayoutCreateInfo(&descriptorSetLayouts.composition, 1);		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayouts.composition));	}

PipelineLayout::PipelineLayout(std::shared_ptr<Device> p_Device, const std::vector<VkDescriptorSetLayout>& p_SetLayouts): m_Handle(VK_NULL_HANDLE), m_Device(p_Device){	VkPipelineLayoutCreateInfo l_Info = {};	l_Info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;	l_Info.setLayoutCount = (uint32)p_SetLayouts.size();	l_Info.pSetLayouts = p_SetLayouts.data();	// TODO: Push constants	VK_THROW_IF_NOT_SUCCESS(vkCreatePipelineLayout(m_Device->GetHandle(), &l_Info, nullptr, &m_Handle), "Failed to create pipeline layout");}

		VkResult vkRes = vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool);		assert(!vkRes);	}	void setupDescriptorSetLayout()	{		// Textured quad pipeline layout		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings =		{			// Binding 0 : Vertex shader uniform buffer			vkTools::initializers::descriptorSetLayoutBinding(			VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				VK_SHADER_STAGE_VERTEX_BIT,				0),			// Binding 1 : Fragment shader image sampler			vkTools::initializers::descriptorSetLayoutBinding(				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,				VK_SHADER_STAGE_FRAGMENT_BIT,				1)		};		VkDescriptorSetLayoutCreateInfo descriptorLayout =			vkTools::initializers::descriptorSetLayoutCreateInfo(				setLayoutBindings.data(),				setLayoutBindings.size());		VkResult err = vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout);		assert(!err);		VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =			vkTools::initializers::pipelineLayoutCreateInfo(				&descriptorSetLayout,				1);		err = vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayouts.quad);		assert(!err);

void Copy_To_Swapchain::create() {    set_layout = Descriptor_Set_Layout()        .sampler        (0, VK_SHADER_STAGE_COMPUTE_BIT)        .sampled_image  (1, VK_SHADER_STAGE_COMPUTE_BIT)        .storage_image  (2, VK_SHADER_STAGE_COMPUTE_BIT)        .create         ("copy_to_swapchain_set_layout");    // pipeline layout    {        VkPushConstantRange range;        range.stageFlags    = VK_SHADER_STAGE_COMPUTE_BIT;        range.offset        = 0;        range.size          = 8; // uint32 width + uint32 height        VkPipelineLayoutCreateInfo create_info { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };        create_info.setLayoutCount          = 1;        create_info.pSetLayouts             = &set_layout;        create_info.pushConstantRangeCount  = 1;        create_info.pPushConstantRanges     = ⦥        VK_CHECK(vkCreatePipelineLayout(vk.device, &create_info, nullptr, &pipeline_layout));    }    // pipeline    {        VkShaderModule copy_shader = vk_load_spirv("spirv/copy_to_swapchain.comp.spv");        VkPipelineShaderStageCreateInfo compute_stage { VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO };        compute_stage.stage    = VK_SHADER_STAGE_COMPUTE_BIT;        compute_stage.module   = copy_shader;        compute_stage.pName    = "main";        VkComputePipelineCreateInfo create_info{ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO };        create_info.stage = compute_stage;        create_info.layout = pipeline_layout;        VK_CHECK(vkCreateComputePipelines(vk.device, VK_NULL_HANDLE, 1, &create_info, nullptr, &pipeline));        vkDestroyShaderModule(vk.device, copy_shader, nullptr);    }    // point sampler    {        VkSamplerCreateInfo create_info { VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };        VK_CHECK(vkCreateSampler(vk.device, &create_info, nullptr, &point_sampler));        vk_set_debug_name(point_sampler, "point_sampler");    }}

Vulkan2D::Vulkan2D(VulkanContext *vulkan) : vulkan_(vulkan) {	// All resources we need for PSP drawing. Usually only bindings 0 and 2-4 are populated.	VkDescriptorSetLayoutBinding bindings[2] = {};	bindings[0].descriptorCount = 1;	bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;	bindings[0].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;	bindings[0].binding = 0;	bindings[1].descriptorCount = 1;	bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;	bindings[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;	bindings[1].binding = 1;	VkDevice device = vulkan_->GetDevice();	VkDescriptorSetLayoutCreateInfo dsl = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO };	dsl.bindingCount = 2;	dsl.pBindings = bindings;	VkResult res = vkCreateDescriptorSetLayout(device, &dsl, nullptr, &descriptorSetLayout_);	assert(VK_SUCCESS == res);	VkDescriptorPoolSize dpTypes[1];	dpTypes[0].descriptorCount = 200;	dpTypes[0].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;	VkDescriptorPoolCreateInfo dp = { VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };	dp.flags = 0;   // Don't want to mess around with individually freeing these, let's go fixed each frame and zap the whole array. Might try the dynamic approach later.	dp.maxSets = 200;	dp.pPoolSizes = dpTypes;	dp.poolSizeCount = ARRAY_SIZE(dpTypes);	for (int i = 0; i < 2; i++) {		VkResult res = vkCreateDescriptorPool(vulkan_->GetDevice(), &dp, nullptr, &frameData_[i].descPool);		assert(VK_SUCCESS == res);	}	VkPushConstantRange push = {};	push.offset = 0;	push.size = 32;	push.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;	VkPipelineLayoutCreateInfo pl = { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };	pl.pPushConstantRanges = &push;	pl.pushConstantRangeCount = 1;	pl.setLayoutCount = 1;	pl.pSetLayouts = &descriptorSetLayout_;	pl.flags = 0;	res = vkCreatePipelineLayout(device, &pl, nullptr, &pipelineLayout_);	assert(VK_SUCCESS == res);}

void Shadow::SetupPipelineLayout(){	//VkPushConstantRange vertexPushConstantRange;	//vertexPushConstantRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;	//vertexPushConstantRange.offset = 0u;	//vertexPushConstantRange.size = 64u; // mat4	auto pipelineLayoutCreateInfo = vkstruct<VkPipelineLayoutCreateInfo>();	pipelineLayoutCreateInfo.setLayoutCount = GlobalDescriptorSets::CB_COUNT;	pipelineLayoutCreateInfo.pSetLayouts = GlobalDescriptorSets::descriptorSetLayouts;	pipelineLayoutCreateInfo.pushConstantRangeCount = 0u;	pipelineLayoutCreateInfo.pPushConstantRanges = nullptr;	gVkLastRes = vkCreatePipelineLayout(gDevice.VkHandle(), &pipelineLayoutCreateInfo, nullptr, &mPipelineLayout);	VKFN_LAST_RES_SUCCESS_OR_QUIT(vkCreatePipelineLayout);}

	void setupDescriptorSetLayout()	{		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = {			vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT, 0)		};		VkDescriptorSetLayoutCreateInfo descriptorLayout =			vks::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings);		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));		VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =			vks::initializers::pipelineLayoutCreateInfo(&descriptorSetLayout, 1);		VkPushConstantRange pushConstantRange = vks::initializers::pushConstantRange(VK_SHADER_STAGE_VERTEX_BIT, sizeof(glm::vec3), 0);		pipelineLayoutCreateInfo.pushConstantRangeCount = 1;		pipelineLayoutCreateInfo.pPushConstantRanges = &pushConstantRange;		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout));	}

pipeline_layout_type create(const type::supplier<device::device_type> &device,		const std::vector<type::supplier<vcc::descriptor_set_layout::descriptor_set_layout_type>> &set_layouts,		const std::vector<VkPushConstantRange> &push_constant_ranges) {	VkPipelineLayoutCreateInfo create = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, NULL, 0};	create.setLayoutCount = (uint32_t) set_layouts.size();	std::vector<VkDescriptorSetLayout> converted_set_layouts;	converted_set_layouts.reserve(set_layouts.size());	std::transform(set_layouts.begin(), set_layouts.end(), std::back_inserter(converted_set_layouts),			[](const type::supplier<vcc::descriptor_set_layout::descriptor_set_layout_type> &set_layout){		return vcc::internal::get_instance(*set_layout);	});	create.pSetLayouts = set_layouts.empty() ? NULL : &converted_set_layouts.front();	create.pushConstantRangeCount = (uint32_t) push_constant_ranges.size();	create.pPushConstantRanges = push_constant_ranges.empty() ? NULL : &push_constant_ranges.front();	VkPipelineLayout pipeline_layout;	VKCHECK(vkCreatePipelineLayout(vcc::internal::get_instance(*device), &create, NULL, &pipeline_layout));	return pipeline_layout_type(pipeline_layout, device);}

	void setupPipelineLayout()	{		VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =			vkTools::initializers::pipelineLayoutCreateInfo(nullptr, 0);		// Push constants for model matrices		VkPushConstantRange pushConstantRange =			vkTools::initializers::pushConstantRange(				VK_SHADER_STAGE_VERTEX_BIT,				sizeof(ThreadPushConstantBlock),				0);		// Push constant ranges are part of the pipeline layout		pPipelineLayoutCreateInfo.pushConstantRangeCount = 1;		pPipelineLayoutCreateInfo.pPushConstantRanges = &pushConstantRange;		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout));	}

	void setupDescriptorSetLayout()	{		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings =		{			// Binding 0 : Vertex shader uniform buffer			vkTools::initializers::descriptorSetLayoutBinding(				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				VK_SHADER_STAGE_VERTEX_BIT,				0),		};		VkDescriptorSetLayoutCreateInfo descriptorLayout =			vkTools::initializers::descriptorSetLayoutCreateInfo(				setLayoutBindings.data(),				setLayoutBindings.size());		VkResult err = vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout);		assert(!err);		VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =			vkTools::initializers::pipelineLayoutCreateInfo(				&descriptorSetLayout,				1);		// Define push constant		// Example uses six light positions as push constants		// 6 * 4 * 4 = 96 bytes		// Spec requires a minimum of 128 bytes, bigger values		// need to be checked against maxPushConstantsSize		// But even at only 128 bytes, lots of stuff can fit 		// inside push constants		VkPushConstantRange pushConstantRange =			vkTools::initializers::pushConstantRange(				VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,				sizeof(pushConstants),				0);		// Push constant ranges are part of the pipeline layout		pipelineLayoutCreateInfo.pushConstantRangeCount = 1;		pipelineLayoutCreateInfo.pPushConstantRanges = &pushConstantRange;		err = vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout);		assert(!err);	}

	PipelineLayout::PipelineLayout(const FunctionCallbackInfo<Value>& args) {		Isolate* isolate = args.GetIsolate();		HandleScope handle_scope(isolate);		Wrap(args.This());		parent_device.Reset(isolate, getELitObjectFromArgN(0, parent_device));				vkCreatePipelineLayout = reinterpret_cast<PFN_vkCreatePipelineLayout>(vkGetDeviceProcAddr(ObjectWrap::Unwrap<Device>(parent_device.Get(isolate))->vulkan_handle,"vkCreatePipelineLayout"));		vkDestroyPipelineLayout = reinterpret_cast<PFN_vkDestroyPipelineLayout>(vkGetDeviceProcAddr(ObjectWrap::Unwrap<Device>(parent_device.Get(isolate))->vulkan_handle,"vkDestroyPipelineLayout"));					VkPipelineLayoutCreateInfo pCreateInfo;		memset(&pCreateInfo, 0, sizeof(VkPipelineLayoutCreateInfo));		pCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;		vkCreatePipelineLayout(ObjectWrap::Unwrap<Device>(parent_device.Get(isolate))->vulkan_handle, &pCreateInfo, nullptr, &vulkan_handle);		setELitPtr(args.This(), vulkan_handle, vulkan_handle);	}

  Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout> Tutorial03::CreatePipelineLayout() {    VkPipelineLayoutCreateInfo layout_create_info = {      VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,  // VkStructureType                sType      nullptr,                                        // const void                    *pNext      0,                                              // VkPipelineLayoutCreateFlags    flags      0,                                              // uint32_t                       setLayoutCount      nullptr,                                        // const VkDescriptorSetLayout   *pSetLayouts      0,                                              // uint32_t                       pushConstantRangeCount      nullptr                                         // const VkPushConstantRange     *pPushConstantRanges    };    VkPipelineLayout pipeline_layout;    if( vkCreatePipelineLayout( GetDevice(), &layout_create_info, nullptr, &pipeline_layout ) != VK_SUCCESS ) {      std::cout << "Could not create pipeline layout!" << std::endl;      return Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout>();    }    return Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout>( pipeline_layout, vkDestroyPipelineLayout, GetDevice() );  }

	void setupDescriptorSetLayout()	{		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings =		{			// Binding 0 : Vertex shader uniform buffer			vkTools::initializers::descriptorSetLayoutBinding(				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				VK_SHADER_STAGE_VERTEX_BIT,				0),			// Binding 1 : Fragment shader color map image sampler			vkTools::initializers::descriptorSetLayoutBinding(				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,				VK_SHADER_STAGE_FRAGMENT_BIT,				1),			// Binding 2 : Fragment combined normal and heightmap			vkTools::initializers::descriptorSetLayoutBinding(				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,				VK_SHADER_STAGE_FRAGMENT_BIT,				2),			// Binding 3 : Fragment shader uniform buffer			vkTools::initializers::descriptorSetLayoutBinding(				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				VK_SHADER_STAGE_FRAGMENT_BIT,				3)		};		VkDescriptorSetLayoutCreateInfo descriptorLayout =			vkTools::initializers::descriptorSetLayoutCreateInfo(				setLayoutBindings.data(),				setLayoutBindings.size());		VkResult err = vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout);		assert(!err);		VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =			vkTools::initializers::pipelineLayoutCreateInfo(				&descriptorSetLayout,				1);		err = vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout);		assert(!err);	}

	void setupDescriptorSetLayout()	{		// Scene		{			std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = {				vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0),			};			VkDescriptorSetLayoutCreateInfo descriptorLayoutCI = vks::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings);			VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayoutCI, nullptr, &descriptorSetLayouts.scene));		}		// Objects		{			std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = {				/*					[POI] Setup inline uniform block for set 1 at binding 0 (see fragment shader)					Descriptor count for an inline uniform block contains data sizes of the block (last parameter)				*/				vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(Object::Material)),			};			VkDescriptorSetLayoutCreateInfo descriptorLayoutCI = vks::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings);			VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayoutCI, nullptr, &descriptorSetLayouts.object));		}		/*			[POI] Pipeline layout		*/		std::vector<VkDescriptorSetLayout> setLayouts = {			descriptorSetLayouts.scene, // Set 0 = Scene matrices			descriptorSetLayouts.object // Set 1 = Object inline uniform block		};		VkPipelineLayoutCreateInfo pipelineLayoutCI = vks::initializers::pipelineLayoutCreateInfo(setLayouts.data(), static_cast<uint32_t>(setLayouts.size()));		std::vector<VkPushConstantRange> pushConstantRanges = {			vks::initializers::pushConstantRange(VK_SHADER_STAGE_VERTEX_BIT, sizeof(glm::vec3), 0),		};		pipelineLayoutCI.pushConstantRangeCount = 1;		pipelineLayoutCI.pPushConstantRanges = pushConstantRanges.data();		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pipelineLayoutCI, nullptr, &pipelineLayout));	}

	void setupDescriptorSetLayout()	{		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings ={						vkTools::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT, 0),			vkTools::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, 1),		};		VkDescriptorSetLayoutCreateInfo descriptorLayout =			vkTools::initializers::descriptorSetLayoutCreateInfo(				setLayoutBindings.data(),				static_cast<uint32_t>(setLayoutBindings.size()));		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));		VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =			vkTools::initializers::pipelineLayoutCreateInfo(				&descriptorSetLayout,				1);		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout));	}

	void setupDescriptorSetLayout()	{		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings =		{			// Binding 0 : Vertex shader uniform buffer			vkTools::initializers::descriptorSetLayoutBinding(				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				VK_SHADER_STAGE_VERTEX_BIT,				0)		};		VkDescriptorSetLayoutCreateInfo descriptorLayout =			vkTools::initializers::descriptorSetLayoutCreateInfo(				setLayoutBindings.data(),				setLayoutBindings.size());		VkResult err = vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout);		assert(!err);		VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =			vkTools::initializers::pipelineLayoutCreateInfo(				&descriptorSetLayout,				1);		// Push constants for model matrices		VkPushConstantRange pushConstantRange =			vkTools::initializers::pushConstantRange(				VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,				sizeof(glm::mat4),				0);		// Push constant ranges are part of the pipeline layout		pPipelineLayoutCreateInfo.pushConstantRangeCount = 1;		pPipelineLayoutCreateInfo.pPushConstantRanges = &pushConstantRange;		err = vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout);		assert(!err);	}

	void setupDescriptorSetLayout()	{		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings;		// Binding 0: Vertex shader uniform buffer		setLayoutBindings.push_back(vkTools::initializers::descriptorSetLayoutBinding(			VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,			VK_SHADER_STAGE_VERTEX_BIT,			0));		// Binding 1: Sampled image		setLayoutBindings.push_back(vkTools::initializers::descriptorSetLayoutBinding(			VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,			VK_SHADER_STAGE_FRAGMENT_BIT,			1));		// Binding 2: Sampler array (3 descriptors)		setLayoutBindings.push_back(vkTools::initializers::descriptorSetLayoutBinding(			VK_DESCRIPTOR_TYPE_SAMPLER,			VK_SHADER_STAGE_FRAGMENT_BIT,			2,			3));		VkDescriptorSetLayoutCreateInfo descriptorLayout = 			vkTools::initializers::descriptorSetLayoutCreateInfo(				setLayoutBindings.data(),				static_cast<uint32_t>(setLayoutBindings.size()));		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));		VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =			vkTools::initializers::pipelineLayoutCreateInfo(				&descriptorSetLayout,				1);		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout));	}

VkPipelineLayoutVKPipeline::create_pipeline_layout (    VkDescriptorSetLayout desc_layout,    const VKConstRange::VKConstantArray &consts){    VkPipelineLayoutCreateInfo pipe_layout_create_info = {};    pipe_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;    pipe_layout_create_info.flags = 0;    pipe_layout_create_info.setLayoutCount = 1;    pipe_layout_create_info.pSetLayouts = &desc_layout;    if (!consts.empty()) {        pipe_layout_create_info.pushConstantRangeCount = consts.size ();        pipe_layout_create_info.pPushConstantRanges = consts.data ();    }    VkPipelineLayout layout = NULL;    XCAM_VK_CHECK_RETURN (        ERROR,        vkCreatePipelineLayout (            _dev->get_dev_id (), &pipe_layout_create_info, NULL, &layout),        NULL, "VkPipeline create descriptor set layout failed");    return layout;}