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

	void setupDescriptorSets()	{		VkDescriptorSetAllocateInfo allocInfo =			vkTools::initializers::descriptorSetAllocateInfo(				descriptorPool,				&descriptorSetLayout,				1);		// Occluder (plane)		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));		std::vector<VkWriteDescriptorSet> writeDescriptorSets =		{			// Binding 0 : Vertex shader uniform buffer			vkTools::initializers::writeDescriptorSet(				descriptorSet,				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				0,				&uniformData.vsScene.descriptor)		};		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);		// Teapot		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.teapot));		writeDescriptorSets[0].dstSet = descriptorSets.teapot;		writeDescriptorSets[0].pBufferInfo = &uniformData.teapot.descriptor;		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);		// Sphere		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.sphere));		writeDescriptorSets[0].dstSet = descriptorSets.sphere;		writeDescriptorSets[0].pBufferInfo = &uniformData.sphere.descriptor;		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);	}

	void setupDescriptorSet()	{		VkDescriptorSetAllocateInfo descriptorSetAllocInfo;		// Scene rendering		descriptorSetAllocInfo = vks::initializers::descriptorSetAllocateInfo(descriptorPool, &descriptorSetLayouts.scene, 1);		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &descriptorSetAllocInfo, &descriptorSets.scene));		std::vector<VkWriteDescriptorSet> offScreenWriteDescriptorSets = {			// Binding 0: Vertex shader uniform buffer			vks::initializers::writeDescriptorSet(descriptorSets.scene, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &uniformBuffers.scene.descriptor),			// Binding 1: Color gradient sampler			vks::initializers::writeDescriptorSet(descriptorSets.scene, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, &textures.gradient.descriptor),		};		vkUpdateDescriptorSets(device, offScreenWriteDescriptorSets.size(), offScreenWriteDescriptorSets.data(), 0, NULL);		// Fullscreen radial blur		descriptorSetAllocInfo = vks::initializers::descriptorSetAllocateInfo(descriptorPool, &descriptorSetLayouts.radialBlur, 1);		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &descriptorSetAllocInfo, &descriptorSets.radialBlur));		std::vector<VkWriteDescriptorSet> writeDescriptorSets = {			// Binding 0: Vertex shader uniform buffer			vks::initializers::writeDescriptorSet(descriptorSets.radialBlur, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &uniformBuffers.blurParams.descriptor),			// Binding 0: Fragment shader texture sampler			vks::initializers::writeDescriptorSet(descriptorSets.radialBlur, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,	1, &offscreenPass.descriptor),		};		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);	}

	void setupDescriptorSets()	{		VkDescriptorSetAllocateInfo allocInfo =			vkTools::initializers::descriptorSetAllocateInfo(				descriptorPool,				&descriptorSetLayouts.models,				1);		// 3D object descriptor set		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.object));		std::vector<VkWriteDescriptorSet> writeDescriptorSets = {			vkTools::initializers::writeDescriptorSet(descriptorSets.object, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &uniformBuffers.matrices.descriptor),			vkTools::initializers::writeDescriptorSet(descriptorSets.object, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, &textures.envmap.descriptor),			vkTools::initializers::writeDescriptorSet(descriptorSets.object, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 2, &uniformBuffers.params.descriptor),		};		vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);		// Sky box descriptor set		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.skybox));		writeDescriptorSets = {			vkTools::initializers::writeDescriptorSet(descriptorSets.skybox, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0,&uniformBuffers.matrices.descriptor),			vkTools::initializers::writeDescriptorSet(descriptorSets.skybox, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, &textures.envmap.descriptor),			vkTools::initializers::writeDescriptorSet(descriptorSets.skybox, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 2, &uniformBuffers.params.descriptor),		};		vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);		// Bloom filter 		allocInfo = vkTools::initializers::descriptorSetAllocateInfo(descriptorPool, &descriptorSetLayouts.bloomFilter, 1);		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.bloomFilter));		std::vector<VkDescriptorImageInfo> colorDescriptors = {			vkTools::initializers::descriptorImageInfo(offscreen.sampler, offscreen.color[0].view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),			vkTools::initializers::descriptorImageInfo(offscreen.sampler, offscreen.color[1].view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),		};		writeDescriptorSets = {			vkTools::initializers::writeDescriptorSet(descriptorSets.bloomFilter, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 0, &colorDescriptors[0]),			vkTools::initializers::writeDescriptorSet(descriptorSets.bloomFilter, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, &colorDescriptors[1]),		};		vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);		// Composition descriptor set		allocInfo =	vkTools::initializers::descriptorSetAllocateInfo(descriptorPool, &descriptorSetLayouts.composition, 1);		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.composition));		colorDescriptors = {			vkTools::initializers::descriptorImageInfo(offscreen.sampler, offscreen.color[0].view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),			vkTools::initializers::descriptorImageInfo(offscreen.sampler, filterPass.color[0].view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),		};		writeDescriptorSets = {			vkTools::initializers::writeDescriptorSet(descriptorSets.composition, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 0, &colorDescriptors[0]),			vkTools::initializers::writeDescriptorSet(descriptorSets.composition, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, &colorDescriptors[1]),		};		vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);	}

	void setupDescriptorSets()	{		// Image descriptor for the cube map texture		VkDescriptorImageInfo cubeMapDescriptor =			vkTools::initializers::descriptorImageInfo(				cubeMap.sampler,				cubeMap.view,				VK_IMAGE_LAYOUT_GENERAL);		VkDescriptorSetAllocateInfo allocInfo =			vkTools::initializers::descriptorSetAllocateInfo(				descriptorPool,				&descriptorSetLayout,				1);		// 3D object descriptor set		VkResult vkRes = vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.object);		assert(!vkRes);		std::vector<VkWriteDescriptorSet> writeDescriptorSets =		{			// Binding 0 : Vertex shader uniform buffer			vkTools::initializers::writeDescriptorSet(				descriptorSets.object, 				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 				0, 				&uniformData.objectVS.descriptor),			// Binding 1 : Fragment shader cubemap sampler			vkTools::initializers::writeDescriptorSet(				descriptorSets.object, 				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 				1, 				&cubeMapDescriptor)		};		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);		// Sky box descriptor set		vkRes = vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.skybox);		assert(!vkRes);		writeDescriptorSets =		{			// Binding 0 : Vertex shader uniform buffer			vkTools::initializers::writeDescriptorSet(				descriptorSets.skybox,				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				0,				&uniformData.skyboxVS.descriptor),			// Binding 1 : Fragment shader cubemap sampler			vkTools::initializers::writeDescriptorSet(				descriptorSets.skybox,				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,				1,				&cubeMapDescriptor)		};		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);	}

	void setupDescriptorSets()	{		// Image descriptor for the cube map texture		VkDescriptorImageInfo textureDescriptor =			vks::initializers::descriptorImageInfo(				cubeMap.sampler,				cubeMap.view,				cubeMap.imageLayout);		VkDescriptorSetAllocateInfo allocInfo =			vks::initializers::descriptorSetAllocateInfo(				descriptorPool,				&descriptorSetLayout,				1);		// 3D object descriptor set		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.object));		std::vector<VkWriteDescriptorSet> writeDescriptorSets =		{			// Binding 0 : Vertex shader uniform buffer			vks::initializers::writeDescriptorSet(				descriptorSets.object, 				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 				0, 				&uniformBuffers.object.descriptor),			// Binding 1 : Fragment shader cubemap sampler			vks::initializers::writeDescriptorSet(				descriptorSets.object, 				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 				1, 				&textureDescriptor)		};		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);		// Sky box descriptor set		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.skybox));		writeDescriptorSets =		{			// Binding 0 : Vertex shader uniform buffer			vks::initializers::writeDescriptorSet(				descriptorSets.skybox,				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				0,				&uniformBuffers.skybox.descriptor),			// Binding 1 : Fragment shader cubemap sampler			vks::initializers::writeDescriptorSet(				descriptorSets.skybox,				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,				1,				&textureDescriptor)		};		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);	}

//--------------------------------------------------------------------------------------------------// Actually write the binding info into the descriptor setvoid DescriptorSetUpdater::updateSetContents(VkDevice device, VkDescriptorSet set){  // For each resource type, set the actual pointers in the VkWriteDescriptorSet structures, and  // write the resulting structures into the descriptor set  m_buffers.setPointers();  vkUpdateDescriptorSets(device, static_cast<uint32_t>(m_buffers.writeDesc.size()), m_buffers.writeDesc.data(), 0, nullptr);  m_images.setPointers();  vkUpdateDescriptorSets(device, static_cast<uint32_t>(m_images.writeDesc.size()), m_images.writeDesc.data(), 0, nullptr);  m_accelerationStructures.setPointers();  vkUpdateDescriptorSets(device, static_cast<uint32_t>(m_accelerationStructures.writeDesc.size()),                         m_accelerationStructures.writeDesc.data(), 0, nullptr);}

	/*		[POI] Update descriptor sets at runtime	*/	void updateMaterials() {		// Setup random materials for every object in the scene		for (uint32_t i = 0; i < objects.size(); i++) {			objects[i].setRandomMaterial();		}		for (auto &object : objects) {			/*				[POI] New structure that defines size and data of the inline uniform block needs to be chained into the write descriptor set				We will be using this inline uniform block to pass per-object material information to the fragment shader			*/			VkWriteDescriptorSetInlineUniformBlockEXT writeDescriptorSetInlineUniformBlock{};			writeDescriptorSetInlineUniformBlock.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT;			writeDescriptorSetInlineUniformBlock.dataSize = sizeof(Object::Material);			// Uniform data for the inline block			writeDescriptorSetInlineUniformBlock.pData = &object.material;			/*				[POI] Update the object's inline uniform block			*/			VkWriteDescriptorSet writeDescriptorSet{};			writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;			writeDescriptorSet.descriptorType = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT;			writeDescriptorSet.dstSet = object.descriptorSet;			writeDescriptorSet.dstBinding = 0;			writeDescriptorSet.descriptorCount = sizeof(Object::Material);			writeDescriptorSet.pNext = &writeDescriptorSetInlineUniformBlock;			vkUpdateDescriptorSets(device, 1, &writeDescriptorSet, 0, nullptr);		}	}

	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);	}

VkBool32 Example::updateDescriptorSets(){	VkDescriptorImageInfo descriptorImageInfo;	memset(&descriptorImageInfo, 0, sizeof(VkDescriptorImageInfo));	descriptorImageInfo.sampler = sampler->getSampler();	descriptorImageInfo.imageView = imageView->getImageView();	descriptorImageInfo.imageLayout = VK_IMAGE_LAYOUT_GENERAL;	VkWriteDescriptorSet writeDescriptorSet;	memset(&writeDescriptorSet, 0, sizeof(writeDescriptorSet));	writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;	writeDescriptorSet.dstSet = descriptorSet;	writeDescriptorSet.dstBinding = 0;	writeDescriptorSet.dstArrayElement = 0;	writeDescriptorSet.descriptorCount = 1;	writeDescriptorSet.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;	writeDescriptorSet.pImageInfo = &descriptorImageInfo;	writeDescriptorSet.pBufferInfo = nullptr;	writeDescriptorSet.pTexelBufferView = nullptr;	vkUpdateDescriptorSets(device->getDevice(), 1, &writeDescriptorSet, 0, nullptr);	return VK_TRUE;}

	void setupDescriptorSet()	{		VkDescriptorSetAllocateInfo allocInfo =			vks::initializers::descriptorSetAllocateInfo(				descriptorPool,				&descriptorSetLayout,				1);		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));				VkDescriptorImageInfo texDescriptor =			vks::initializers::descriptorImageInfo(				textures.colorMap.sampler,				textures.colorMap.view,				VK_IMAGE_LAYOUT_GENERAL);		std::vector<VkWriteDescriptorSet> writeDescriptorSets =		{			// Binding 0 : Vertex shader uniform buffer			vks::initializers::writeDescriptorSet(			descriptorSet,				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				0,				&uniformBuffer.descriptor),			// Binding 1 : Color map 			vks::initializers::writeDescriptorSet(				descriptorSet,				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,				1,				&texDescriptor)		};		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);	}

	void setupDescriptorSet()	{		VkDescriptorSetAllocateInfo allocInfo = 			vkTools::initializers::descriptorSetAllocateInfo(				descriptorPool,				&descriptorSetLayout,				1);		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));		std::vector<VkWriteDescriptorSet> writeDescriptorSets =		{			// Binding 0 : Vertex shader uniform buffer			vkTools::initializers::writeDescriptorSet(				descriptorSet, 				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 				0, 				&uniformBufferVS.descriptor),			// Binding 1 : Fragment shader texture sampler			vkTools::initializers::writeDescriptorSet(				descriptorSet, 				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 				1, 				&texture.descriptor)		};		vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);	}

	void setupDescriptorSets()	{		// Descriptor Pool		std::vector<VkDescriptorPoolSize> poolSizes = {			vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 4),		};		VkDescriptorPoolCreateInfo descriptorPoolInfo =			vks::initializers::descriptorPoolCreateInfo(poolSizes, 2);		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));		// Descriptor sets		VkDescriptorSetAllocateInfo allocInfo =			vks::initializers::descriptorSetAllocateInfo(descriptorPool, &descriptorSetLayout, 1);		// 3D object descriptor set		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));		std::vector<VkWriteDescriptorSet> writeDescriptorSets = {			vks::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &uniformBuffers.object.descriptor),			vks::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, &uniformBuffers.params.descriptor),		};		vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);	}

	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);	}

WError WMaterial::Bind(WRenderTarget* rt, unsigned int num_vertex_buffers) {	if (!Valid())		return WError(W_NOTVALID);	VkDevice device = m_app->GetVulkanDevice();	VkCommandBuffer renderCmdBuffer = rt->GetCommnadBuffer();	if (!renderCmdBuffer)		return WError(W_NORENDERTARGET);	int curDSIndex = 0;	for (int i = 0; i < m_sampler_info.size(); i++) {		W_BOUND_RESOURCE* info = m_sampler_info[i].sampler_info;		if (m_sampler_info[i].img && m_sampler_info[i].img->Valid()) {			m_sampler_info[i].descriptor.imageView = m_sampler_info[i].img->GetView();			VkWriteDescriptorSet writeDescriptorSet = {};			writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;			writeDescriptorSet.dstSet = m_descriptorSet;			writeDescriptorSet.descriptorCount = 1;			writeDescriptorSet.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;			writeDescriptorSet.pImageInfo = &m_sampler_info[i].descriptor;			writeDescriptorSet.dstBinding = info->binding_index;			m_writeDescriptorSets[curDSIndex++] = writeDescriptorSet;		}	}	if (curDSIndex)		vkUpdateDescriptorSets(device, curDSIndex, m_writeDescriptorSets.data(), 0, NULL);	vkCmdBindDescriptorSets(renderCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_effect->GetPipelineLayout(), 0, 1, &m_descriptorSet, 0, NULL);	return m_effect->Bind(rt, num_vertex_buffers);}

	void setupDescriptorSet()	{		VkDescriptorSetAllocateInfo allocInfo =			vkTools::initializers::descriptorSetAllocateInfo(				descriptorPool,				&descriptorSetLayout,				1);		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));		// Image descriptor for the texture array		VkDescriptorImageInfo texArrayDescriptor =			vkTools::initializers::descriptorImageInfo(				textureArray.sampler,				textureArray.view,				VK_IMAGE_LAYOUT_GENERAL);		std::vector<VkWriteDescriptorSet> writeDescriptorSets =		{			// Binding 0 : Vertex shader uniform buffer			vkTools::initializers::writeDescriptorSet(				descriptorSet,				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				0,				&uniformData.vertexShader.descriptor),			// Binding 1 : Fragment shader cubemap sampler			vkTools::initializers::writeDescriptorSet(				descriptorSet,				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,				1,				&texArrayDescriptor)		};		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);	}

void HookGui::HGWidgetShader::CreateDescriptorSet(VulkanWrapper::Context* _graphicContext){	// Add our layout descriptors	VWShaderBase::AddDescriptorSetLayoutBinding(1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT);	// Create the set layout	m_DescriptorSetLayout = VWShaderBase::CreateDescriptorSetLayout(_graphicContext->GetGraphicInstance());	// Create the descriptor pool	m_DescriptorPool = VWShaderBase::CreateDescriptorPool(_graphicContext);	// Create the descriptor set	m_DescriptorSet = VWShaderBase::CreateDescriptorSet(_graphicContext, m_DescriptorPool, 1, &m_DescriptorSetLayout);	VkDescriptorBufferInfo bufferInfo = {};	bufferInfo.buffer = m_UniformBuffer.GetRawBuffer();	bufferInfo.offset = 0;	bufferInfo.range = sizeof(UniformBufferObject);	std::array<VkWriteDescriptorSet, 1> descriptorWrites = {};	descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;	descriptorWrites[0].dstSet = m_DescriptorSet;	descriptorWrites[0].dstBinding = 1;	descriptorWrites[0].dstArrayElement = 0;	descriptorWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;	descriptorWrites[0].descriptorCount = 1;	descriptorWrites[0].pBufferInfo = &bufferInfo;	vkUpdateDescriptorSets(_graphicContext->GetGraphicInstance()->GetDevice(), descriptorWrites.size(), descriptorWrites.data(), 0, nullptr);}

	void setupDescriptorSet()	{		VkDescriptorSetAllocateInfo allocInfo =			vkTools::initializers::descriptorSetAllocateInfo(				descriptorPool,				&descriptorSetLayout,				1);		VkResult vkRes = vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet);		assert(!vkRes);		std::vector<VkWriteDescriptorSet> writeDescriptorSets =		{			// Binding 0 : Vertex shader shader ubo			vkTools::initializers::writeDescriptorSet(				descriptorSet,				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				0,				&uniformData.VS.descriptor),			// Binding 1 : Geometry shader ubo			vkTools::initializers::writeDescriptorSet(				descriptorSet,				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				1,				&uniformData.GS.descriptor)		};		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);	}

	void setupDescriptorSet()	{		VkDescriptorSetAllocateInfo allocInfo =			vkTools::initializers::descriptorSetAllocateInfo(				descriptorPool,				&descriptorSetLayout,				1);		VkResult vkRes = vkAllocateDescriptorSets(device, &allocInfo, &descriptorSetPostCompute);		assert(!vkRes);		// Image descriptor for the color map texture		VkDescriptorImageInfo texDescriptor =			vkTools::initializers::descriptorImageInfo(				textureColorMap.sampler,				textureColorMap.view,				VK_IMAGE_LAYOUT_GENERAL);		std::vector<VkWriteDescriptorSet> writeDescriptorSets =		{			// Binding 1 : Fragment shader image sampler			vkTools::initializers::writeDescriptorSet(				descriptorSetPostCompute,				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,				0,				&texDescriptor)		};		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);	}

    void VulkanUniformBuffer::InitializeDescriptorSet ( VkDescriptorSet& aVkDescriptorSet, const VkDescriptorSetLayout& aVkDescriptorSetLayout, const VkDescriptorBufferInfo& aVkDescriptorBufferInfo )    {        VkDescriptorSetAllocateInfo descriptor_set_allocate_info{};        descriptor_set_allocate_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;        descriptor_set_allocate_info.descriptorPool = mVkDescriptorPool;        descriptor_set_allocate_info.descriptorSetCount = 1;        descriptor_set_allocate_info.pSetLayouts = &aVkDescriptorSetLayout;        if ( VkResult result = vkAllocateDescriptorSets ( mVulkanRenderer.GetDevice(), &descriptor_set_allocate_info, &aVkDescriptorSet ) )        {            std::ostringstream stream;            stream << "Allocate Descriptor Set failed: ( " << GetVulkanResultString ( result ) << " )";            throw std::runtime_error ( stream.str().c_str() );        }        VkWriteDescriptorSet write_descriptor_set{};        write_descriptor_set.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;        write_descriptor_set.pNext = nullptr;        write_descriptor_set.dstSet = aVkDescriptorSet;        write_descriptor_set.dstBinding = 0;        write_descriptor_set.dstArrayElement = 0;        write_descriptor_set.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;        write_descriptor_set.descriptorCount = 1;        write_descriptor_set.pBufferInfo = &aVkDescriptorBufferInfo;        write_descriptor_set.pImageInfo = nullptr;        write_descriptor_set.pTexelBufferView = nullptr;        vkUpdateDescriptorSets (            mVulkanRenderer.GetDevice(),            1,            &write_descriptor_set, 0, nullptr );    }

void TriangleVK::Render(VkCommandBuffer cmd_buf, Camera *pCam){    struct DATA    {        XMMATRIX mat;    } *pData;    VkDescriptorBufferInfo constantBuffer;    m_pConstantBufferRing->AllocConstantBuffer(4*4 * sizeof(float), (void**)&pData, &constantBuffer);    pData->mat = pCam->GetView() * pCam->GetProjection();    VkWriteDescriptorSet writes[1];    writes[0] = {};    writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;    writes[0].pNext = NULL;    writes[0].dstSet = m_descriptorSets[0];    writes[0].descriptorCount = 1;    writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;    writes[0].pBufferInfo = &constantBuffer;    writes[0].dstArrayElement = 0;    writes[0].dstBinding = 0;    vkUpdateDescriptorSets(m_pDevice->GetDevice(), 1, writes, 0, NULL);    const VkDeviceSize offsets[1] = { m_geometry.offset };    vkCmdBindVertexBuffers(cmd_buf, 0, 1, &m_geometry.buffer, offsets);    vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipeline);    vkCmdBindDescriptorSets(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipelineLayout, 0, (uint32_t)m_descriptorSets.size(), m_descriptorSets.data(), 0, NULL);    vkCmdDraw(cmd_buf, 12 * 3, 1, 0, 0);}

XCamReturnVKDevice::update_desc_set (const std::vector<VkWriteDescriptorSet> &sets){    XCAM_ASSERT (XCAM_IS_VALID_VK_ID (_dev_id));    vkUpdateDescriptorSets (_dev_id, sets.size (), sets.data (), 0, NULL);    return XCAM_RETURN_NO_ERROR;}

	void setupDescriptorSets()	{		VkDescriptorSetAllocateInfo allocInfo =			vks::initializers::descriptorSetAllocateInfo(descriptorPool, &descriptorSetLayout, 1);		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));		std::vector<VkWriteDescriptorSet> writeDescriptorSets = {			vks::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &uniformBuffers.VS.descriptor)		};		vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);	}

	void setupDescriptorSet()	{		VkDescriptorSetAllocateInfo allocInfo = 			vkTools::initializers::descriptorSetAllocateInfo(				descriptorPool,				&descriptorSetLayout,				1);		VkResult vkRes = vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet);		assert(!vkRes);		// Displacement map image descriptor		VkDescriptorImageInfo texDescriptorDisplacementMap =			vkTools::initializers::descriptorImageInfo(				textures.heightMap.sampler,				textures.heightMap.view,				VK_IMAGE_LAYOUT_GENERAL);		// Color map image descriptor		VkDescriptorImageInfo texDescriptorColorMap =			vkTools::initializers::descriptorImageInfo(				textures.colorMap.sampler,				textures.colorMap.view,				VK_IMAGE_LAYOUT_GENERAL);		std::vector<VkWriteDescriptorSet> writeDescriptorSets =		{			// Binding 0 : Tessellation control shader ubo			vkTools::initializers::writeDescriptorSet(				descriptorSet, 				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 				0, 				&uniformDataTC.descriptor),			// Binding 1 : Tessellation evaluation shader ubo			vkTools::initializers::writeDescriptorSet(				descriptorSet, 				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				1, 				&uniformDataTE.descriptor),			// Binding 2 : Displacement map			vkTools::initializers::writeDescriptorSet(				descriptorSet,				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,				2,				&texDescriptorDisplacementMap),			// Binding 3 : Color map			vkTools::initializers::writeDescriptorSet(				descriptorSet,				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,				3,				&texDescriptorColorMap),		};		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);	}

	void setupDescriptorSet()	{		VkDescriptorSetAllocateInfo allocInfo =			vkTools::initializers::descriptorSetAllocateInfo(				descriptorPool,				&descriptorSetLayout,				1);		VkResult vkRes = vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet);		assert(!vkRes);		// Color map image descriptor		VkDescriptorImageInfo texDescriptorColorMap =			vkTools::initializers::descriptorImageInfo(				textures.colorMap.sampler,				textures.colorMap.view,				VK_IMAGE_LAYOUT_GENERAL);		VkDescriptorImageInfo texDescriptorNormalHeightMap =			vkTools::initializers::descriptorImageInfo(				textures.normalHeightMap.sampler,				textures.normalHeightMap.view,				VK_IMAGE_LAYOUT_GENERAL);		std::vector<VkWriteDescriptorSet> writeDescriptorSets =		{			// Binding 0 : Vertex shader uniform buffer			vkTools::initializers::writeDescriptorSet(				descriptorSet,				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				0,				&uniformData.vertexShader.descriptor),			// Binding 1 : Fragment shader image sampler			vkTools::initializers::writeDescriptorSet(				descriptorSet,				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,				1,				&texDescriptorColorMap),			// Binding 2 : Combined normal and heightmap			vkTools::initializers::writeDescriptorSet(				descriptorSet,				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,				2,				&texDescriptorNormalHeightMap),			// Binding 3 : Fragment shader uniform buffer			vkTools::initializers::writeDescriptorSet(				descriptorSet,				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,				3,				&uniformData.fragmentShader.descriptor)		};		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);	}

		void program::bind_uniform(VkDescriptorBufferInfo buffer_descriptor, uint32_t binding_point, VkDescriptorSet &descriptor_set)		{			VkWriteDescriptorSet descriptor_writer = {};			descriptor_writer.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;			descriptor_writer.dstSet = descriptor_set;			descriptor_writer.descriptorCount = 1;			descriptor_writer.pBufferInfo = &buffer_descriptor;			descriptor_writer.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;			descriptor_writer.dstArrayElement = 0;			descriptor_writer.dstBinding = binding_point;			vkUpdateDescriptorSets(m_device, 1, &descriptor_writer, 0, nullptr);			attribute_location_mask |= (1ull << binding_point);		}

	void setupDescriptorSet()	{		VkDescriptorSetAllocateInfo allocInfo = 			vkTools::initializers::descriptorSetAllocateInfo(				descriptorPool,				&descriptorSetLayout,				1);		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));		std::vector<VkWriteDescriptorSet> writeDescriptorSets;		// Binding 0: Vertex shader uniform buffer		writeDescriptorSets.push_back(vkTools::initializers::writeDescriptorSet(			descriptorSet,			VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,			0,			&uniformBufferVS.descriptor));		// Binding 1: Sampled image		VkDescriptorImageInfo textureDescriptor = 			vkTools::initializers::descriptorImageInfo(				VK_NULL_HANDLE,				 				texture.view, 				texture.imageLayout);		writeDescriptorSets.push_back(vkTools::initializers::writeDescriptorSet(			descriptorSet,			VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,			1,			&textureDescriptor));		// Binding 2: Sampler array		std::vector<VkDescriptorImageInfo> samplerDescriptors;		for (auto i = 0; i < samplers.size(); i++)		{			samplerDescriptors.push_back(vkTools::initializers::descriptorImageInfo(samplers[i], VK_NULL_HANDLE, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL));		}		VkWriteDescriptorSet samplerDescriptorWrite{};		samplerDescriptorWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;		samplerDescriptorWrite.dstSet = descriptorSet;		samplerDescriptorWrite.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;		samplerDescriptorWrite.descriptorCount = static_cast<uint32_t>(samplerDescriptors.size());		samplerDescriptorWrite.pImageInfo = samplerDescriptors.data();		samplerDescriptorWrite.dstBinding = 2;		samplerDescriptorWrite.dstArrayElement = 0;		writeDescriptorSets.push_back(samplerDescriptorWrite);		vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);	}

            bool VKMaterial::setupDescriptorSet(VkDescriptorPool descriptorPool, VkDevice device)            {                VkResult err;                //Setup the descriptor sets                VkDescriptorSetAllocateInfo allocInfo = {};                allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;                allocInfo.descriptorPool = descriptorPool;                allocInfo.pSetLayouts = &m_materialLayout;                allocInfo.descriptorSetCount = 1;                err = vkAllocateDescriptorSets(device, &allocInfo, &m_materialSet);                assert(!err);                if (err != VK_SUCCESS)                {#ifdef _DEBUG                    Core::DebugPrintF("VKMaterial::VPrepare: Failed to allocate descriptor set/n");#endif                    return false;                }                std::vector<VkWriteDescriptorSet> descSetWrites = {};                VkWriteDescriptorSet uniformVSWrite = {};                uniformVSWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;                uniformVSWrite.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;                uniformVSWrite.dstSet = m_materialSet;                uniformVSWrite.dstBinding = 0;                uniformVSWrite.pBufferInfo = &m_uniformVSBuffer.descriptor;                uniformVSWrite.descriptorCount = 1;                //VkWriteDescriptorSet uniformFSWrite = {};                //uniformFSWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;                //uniformFSWrite.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;                //uniformFSWrite.dstSet = m_materialSet;                //uniformFSWrite.dstBinding = 1;                //uniformFSWrite.pBufferInfo = &m_uniformFSBuffer.descriptor;                //uniformFSWrite.descriptorCount = 1;                //TODO: Figure out the writes for the textures                descSetWrites.push_back(uniformVSWrite);                //descSetWrites.push_back(uniformFSWrite);                vkUpdateDescriptorSets(device, static_cast<uint32_t>(descSetWrites.size()), descSetWrites.data(), 0, nullptr);                return true;            }

void WireframeModel::UpdateDescriptorSet(VulkanInterface * vulkan, VulkanPipeline * pipeline){	VkWriteDescriptorSet descriptorWrite[1];	descriptorWrite[0] = {};	descriptorWrite[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;	descriptorWrite[0].pNext = NULL;	descriptorWrite[0].dstSet = pipeline->GetDescriptorSet();	descriptorWrite[0].descriptorCount = 1;	descriptorWrite[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;	descriptorWrite[0].pBufferInfo = vsUBO->GetBufferInfo();	descriptorWrite[0].dstArrayElement = 0;	descriptorWrite[0].dstBinding = 0;	vkUpdateDescriptorSets(vulkan->GetVulkanDevice()->GetDevice(), sizeof(descriptorWrite) / sizeof(descriptorWrite[0]), descriptorWrite, 0, NULL);}

	void setupDescriptorSet()	{		VkDescriptorSetAllocateInfo allocInfo =			vks::initializers::descriptorSetAllocateInfo(				descriptorPool,				&descriptorSetLayout,				1);		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));		std::vector<VkWriteDescriptorSet> writeDescriptorSets = {						vks::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &uniformBuffer.descriptor),	// Binding 0 : Vertex shader uniform buffer		};		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);	}

	void setupDescriptorSet()	{		VkDescriptorSetAllocateInfo allocInfo =			vkTools::initializers::descriptorSetAllocateInfo(				descriptorPool,				&descriptorSetLayout,				1);		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));		std::vector<VkWriteDescriptorSet> writeDescriptorSets = {						vkTools::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &uniformBuffer.descriptor),			vkTools::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, &textures.colormap.descriptor),		};		vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);	}