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

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

VkBool32 Example::buildDescriptorSetPool(){	VkResult result;	//	VkDescriptorPoolSize descriptorTypeCount;	memset(&descriptorTypeCount, 0, sizeof(VkDescriptorPoolSize));	descriptorTypeCount.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;	descriptorTypeCount.descriptorCount = 1;	VkDescriptorPoolCreateInfo descriptorPoolCreateInfo;	memset(&descriptorPoolCreateInfo, 0, sizeof(VkDescriptorPoolCreateInfo));	descriptorPoolCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;	descriptorPoolCreateInfo.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;	descriptorPoolCreateInfo.maxSets = 1;	descriptorPoolCreateInfo.poolSizeCount = 1;	descriptorPoolCreateInfo.pPoolSizes = &descriptorTypeCount;	result = vkCreateDescriptorPool(device->getDevice(), &descriptorPoolCreateInfo, nullptr, &descriptorPool);	if (result != VK_SUCCESS)	{		vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not create descriptor pool.");		return VK_FALSE;	}	return VK_TRUE;}

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

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

/* Please see header for specification */void Anvil::DescriptorPool::bake(){    VkDescriptorPoolCreateInfo descriptor_pool_create_info;    VkDescriptorPoolSize       descriptor_pool_sizes[VK_DESCRIPTOR_TYPE_RANGE_SIZE];    uint32_t                   n_descriptor_types_used = 0;    VkResult                   result_vk;    if (m_pool != VK_NULL_HANDLE)    {        vkDestroyDescriptorPool(m_device_ptr->get_device_vk(),                                m_pool,                                nullptr /* pAllocator */);        m_pool = VK_NULL_HANDLE;    }    /* Convert the counters to an arrayed, linear representation */    for (uint32_t n_descriptor_type = 0;                  n_descriptor_type < VK_DESCRIPTOR_TYPE_RANGE_SIZE;                ++n_descriptor_type)    {        if (m_descriptor_count[n_descriptor_type] > 0)        {            uint32_t current_index = n_descriptor_types_used;            descriptor_pool_sizes[current_index].descriptorCount = m_descriptor_count[n_descriptor_type];            descriptor_pool_sizes[current_index].type            = (VkDescriptorType) n_descriptor_type;            n_descriptor_types_used++;        }    }    if (n_descriptor_types_used == 0)    {        /* If an empty pool is needed, request space for a single dummy descriptor. */        descriptor_pool_sizes[0].descriptorCount = 1;        descriptor_pool_sizes[0].type            = VK_DESCRIPTOR_TYPE_SAMPLER;        n_descriptor_types_used = 1;    }    /* Set up the descriptor pool instance */    descriptor_pool_create_info.flags         = (m_releaseable_sets) ? VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT                                                                     : 0;    descriptor_pool_create_info.maxSets       = m_n_max_sets;    descriptor_pool_create_info.pNext         = nullptr;    descriptor_pool_create_info.poolSizeCount = n_descriptor_types_used;    descriptor_pool_create_info.pPoolSizes    = descriptor_pool_sizes;    descriptor_pool_create_info.sType         = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;    result_vk = vkCreateDescriptorPool(m_device_ptr->get_device_vk(),                                      &descriptor_pool_create_info,                                       nullptr, /* pAllocator */                                      &m_pool);    anvil_assert_vk_call_succeeded(result_vk);    m_baked = true;}

	void setupDescriptorPool()	{		std::vector<VkDescriptorPoolSize> poolSizes = {			vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 3)		};		VkDescriptorPoolCreateInfo descriptorPoolInfo =			vks::initializers::descriptorPoolCreateInfo(poolSizes, 3);		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));	}

	void setupDescriptorPool()	{		std::vector<VkDescriptorPoolSize> poolSizes = {			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 4),			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 6)		};		uint32_t numDescriptorSets = 4;		VkDescriptorPoolCreateInfo descriptorPoolInfo = 			vkTools::initializers::descriptorPoolCreateInfo(static_cast<uint32_t>(poolSizes.size()), poolSizes.data(), numDescriptorSets);		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));	}

VkDescriptorPoolVKDevice::create_desc_pool (const VkDescriptorPoolCreateInfo &info){    XCAM_ASSERT (XCAM_IS_VALID_VK_ID (_dev_id));    VkDescriptorPool pool_id;    XCAM_VK_CHECK_RETURN (        ERROR,        vkCreateDescriptorPool (_dev_id, &info, _allocator.ptr (), &pool_id),        VK_NULL_HANDLE,        "vkdevice create desriptor pool failed");    return pool_id;}

DescriptorPool::DescriptorPool(std::shared_ptr<Device> p_Device, bool p_bAllowIndividualFree, uint32 p_uiMaxSets, const std::vector<VkDescriptorPoolSize>& p_PoolSizes): m_Handle(VK_NULL_HANDLE), m_Device(p_Device), m_bAllowsIndividualFree(p_bAllowIndividualFree){	VkDescriptorPoolCreateInfo l_Info = {};	l_Info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;	l_Info.flags |= m_bAllowsIndividualFree ? VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT : 0;	l_Info.maxSets = p_uiMaxSets; // Maximum number of sets that can be allocated from pool (requesting more results in an error)	l_Info.pPoolSizes = p_PoolSizes.data();	l_Info.poolSizeCount = (uint32)p_PoolSizes.size();	VK_THROW_IF_NOT_SUCCESS(vkCreateDescriptorPool(m_Device->GetHandle(), &l_Info, nullptr, &m_Handle), "Failed to create descriptor pool");}

    void setupDescriptorPool()    {        std::vector<VkDescriptorPoolSize> poolSizes;        poolSizes.push_back(vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1));        VkDescriptorPoolCreateInfo descriptorPoolInfo =            vkTools::initializers::descriptorPoolCreateInfo(                poolSizes.size(),                poolSizes.data(),                2);        VkResult vkRes = vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool);        assert(!vkRes);    }

	void setupDescriptorPool()	{		// Example uses two ubos and two image sampler		std::vector<VkDescriptorPoolSize> poolSizes =		{			vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 2),			vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 2)		};		VkDescriptorPoolCreateInfo descriptorPoolInfo =			vks::initializers::descriptorPoolCreateInfo(poolSizes, 2);		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));	}

void VkeDrawCall::initDescriptorPool(){	VulkanDC *dc = VulkanDC::Get();	VulkanDC::Device *device = dc->getDefaultDevice();	VkDescriptorPoolSize poolSize = { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1 };	VkDescriptorPoolCreateInfo poolInfo = { VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };	poolInfo.maxSets = 1;	poolInfo.poolSizeCount = 1;	poolInfo.pPoolSizes = &poolSize;	poolInfo.flags = 0;	VKA_CHECK_ERROR(vkCreateDescriptorPool(device->getVKDevice(), &poolInfo, NULL, &m_descriptor_pool), "Could not create descriptor pool./n");}

	void setupDescriptorPool()	{		// Example uses one ubo and one image sampler		std::vector<VkDescriptorPoolSize> poolSizes = {			vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1),		};		VkDescriptorPoolCreateInfo descriptorPoolInfo =			vks::initializers::descriptorPoolCreateInfo(				poolSizes.size(),				poolSizes.data(),				2);		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));	}

void Renderer::_InitDescriptorPool() {	std::array<VkDescriptorPoolSize, 2> pool_sizes {};	pool_sizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;	pool_sizes[0].descriptorCount = 1;	pool_sizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;	pool_sizes[1].descriptorCount = 1;	VkDescriptorPoolCreateInfo pool_create_info {};	pool_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;	pool_create_info.poolSizeCount = (uint32_t)pool_sizes.size();	pool_create_info.pPoolSizes = pool_sizes.data();	pool_create_info.maxSets = 1;	ErrorCheck(vkCreateDescriptorPool(_device, &pool_create_info, nullptr, &_descriptor_pool));}

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 setupDescriptorPool()	{		std::vector<VkDescriptorPoolSize> poolSizes =		{			// One uniform buffer block for each mesh			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 3)		};		VkDescriptorPoolCreateInfo descriptorPoolInfo =			vkTools::initializers::descriptorPoolCreateInfo(				poolSizes.size(),				poolSizes.data(),				3);		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));	}

	void setupDescriptorPool()	{		std::vector<VkDescriptorPoolSize> poolSizes =		{			vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 2),			vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 2)		};		VkDescriptorPoolCreateInfo descriptorPoolInfo = 			vks::initializers::descriptorPoolCreateInfo(				poolSizes.size(),				poolSizes.data(),				2);		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));	}

	void setupDescriptorPool()	{		// Example uses one ubo and one combined image sampler		std::vector<VkDescriptorPoolSize> poolSizes =		{			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1),			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1),		};		VkDescriptorPoolCreateInfo descriptorPoolInfo =			vkTools::initializers::descriptorPoolCreateInfo(				poolSizes.size(),				poolSizes.data(),				2);		vkTools::checkResult(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));	}

	void setupDescriptorPool()	{		// Example uses two ubos		std::vector<VkDescriptorPoolSize> poolSizes =		{			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 2),		};		VkDescriptorPoolCreateInfo descriptorPoolInfo =			vkTools::initializers::descriptorPoolCreateInfo(				poolSizes.size(),				poolSizes.data(),				2);		VkResult vkRes = vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool);		assert(!vkRes);	}

VulkanDescriptorPool::VulkanDescriptorPool(VkDevice& device){    VkDescriptorPoolSize poolSizes[2];    poolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;    poolSizes[1].descriptorCount = 1;    poolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;    poolSizes[1].descriptorCount = 1;    VkDescriptorPoolCreateInfo poolInfo = {};    poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;    poolInfo.maxSets = 2;    poolInfo.poolSizeCount = 2;    poolInfo.pPoolSizes = poolSizes;    auto err = vkCreateDescriptorPool(device, &poolInfo, nullptr, &pool);    assert(!err);}

	void setupDescriptorPool()	{		// One UBO for each gear		std::vector<VkDescriptorPoolSize> poolSizes =		{			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 3),		};		VkDescriptorPoolCreateInfo descriptorPoolInfo =			vkTools::initializers::descriptorPoolCreateInfo(				poolSizes.size(),				poolSizes.data(),				// Three descriptor sets (for each gear)				3);		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));	}

	void setupDescriptorPool()	{		// Example uses one ubo and one image sampler		std::vector<VkDescriptorPoolSize> poolSizes =		{			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1),			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1)		};		VkDescriptorPoolCreateInfo descriptorPoolInfo = 			vkTools::initializers::descriptorPoolCreateInfo(				static_cast<uint32_t>(poolSizes.size()),				poolSizes.data(),				2);		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));	}

	void setupDescriptorPool()	{		std::vector<VkDescriptorPoolSize> poolSizes =		{			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1),	// Vertex shader UBO			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1),		// Sampled image			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_SAMPLER, 3),			// 3 samplers (array)		};		VkDescriptorPoolCreateInfo descriptorPoolInfo = 			vkTools::initializers::descriptorPoolCreateInfo(				static_cast<uint32_t>(poolSizes.size()),				poolSizes.data(),				1);		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));	}

Arguments::Arguments(Program &function, std::vector<Buffer> resources) : Program(function){    // how many of each type    VkDescriptorPoolSize descriptorPoolSizes[] = {        {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, (uint32_t) resources.size()}    };    VkDescriptorPoolCreateInfo descriptorPoolCreateInfo = {VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO};    descriptorPoolCreateInfo.poolSizeCount = 1;    descriptorPoolCreateInfo.maxSets = 1;    descriptorPoolCreateInfo.pPoolSizes = descriptorPoolSizes;    if (VK_SUCCESS != vkCreateDescriptorPool(device, &descriptorPoolCreateInfo, nullptr, &descriptorPool)) {        throw ERROR_SHADER;    }    // allocate the descriptor set (according to the function's layout)    VkDescriptorSetAllocateInfo descriptorSetAllocateInfo = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};    descriptorSetAllocateInfo.descriptorSetCount = 1; // 1?    descriptorSetAllocateInfo.pSetLayouts = &descriptorSetLayout;    descriptorSetAllocateInfo.descriptorPool = descriptorPool;    if (VK_SUCCESS != vkAllocateDescriptorSets(device, &descriptorSetAllocateInfo, &descriptorSet)) {        throw ERROR_SHADER;    }    // bind to this    // buffers to bind    VkDescriptorBufferInfo *descriptorBufferInfo = new VkDescriptorBufferInfo[resources.size()];    for (uint32_t i = 0; i < resources.size(); i++) {        descriptorBufferInfo[i].buffer = resources[i];        descriptorBufferInfo[i].offset = 0;        descriptorBufferInfo[i].range = VK_WHOLE_SIZE;    }    // bind stuff here    VkWriteDescriptorSet writeDescriptorSet = {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};    writeDescriptorSet.dstSet = descriptorSet;//pipeline.getDescriptorSet();    writeDescriptorSet.dstBinding = 0;    writeDescriptorSet.descriptorCount = resources.size();    writeDescriptorSet.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;    writeDescriptorSet.pBufferInfo = descriptorBufferInfo;    vkUpdateDescriptorSets(device, 1, &writeDescriptorSet, 0, nullptr);    delete [] descriptorBufferInfo;}

	void setupDescriptorPool()	{		std::vector<VkDescriptorPoolSize> poolSizes =		{			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1),			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1),			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1)		};		VkDescriptorPoolCreateInfo descriptorPoolInfo =			vkTools::initializers::descriptorPoolCreateInfo(				poolSizes.size(),				poolSizes.data(),				3);		VkResult vkRes = vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool);		assert(!vkRes);	}

    void VulkanUniformBuffer::InitializeDescriptorPool()    {        VkDescriptorPoolSize descriptor_pool_size{};        descriptor_pool_size.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;        descriptor_pool_size.descriptorCount = 1;        VkDescriptorPoolCreateInfo descriptor_pool_create_info{};        descriptor_pool_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;        descriptor_pool_create_info.pNext = nullptr;        descriptor_pool_create_info.flags = 0;        descriptor_pool_create_info.maxSets = 1;        descriptor_pool_create_info.poolSizeCount = 1;        descriptor_pool_create_info.pPoolSizes = &descriptor_pool_size;        if ( VkResult result = vkCreateDescriptorPool ( mVulkanRenderer.GetDevice(), &descriptor_pool_create_info, nullptr, &mVkDescriptorPool ) )        {            std::ostringstream stream;            stream << "vkCreateDescriptorPool failed. error code: ( " << GetVulkanResultString ( result ) << " )";            throw std::runtime_error ( stream.str().c_str() );        }    }

pair<VkDescriptorSet, bool> DescriptorSetAllocator::find(Hash hash){	auto *node = set_nodes.request(hash);	if (node)		return { node->set, true };	node = set_nodes.request_vacant(hash);	if (node)		return { node->set, false };	VkDescriptorPool pool;	VkDescriptorPoolCreateInfo info = { VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };	info.maxSets = VULKAN_NUM_SETS_PER_POOL;	if (!pool_size.empty())	{		info.poolSizeCount = pool_size.size();		info.pPoolSizes = pool_size.data();	}	if (vkCreateDescriptorPool(device->get_device(), &info, nullptr, &pool) != VK_SUCCESS)		LOG("Failed to create descriptor pool./n");	VkDescriptorSet sets[VULKAN_NUM_SETS_PER_POOL];	VkDescriptorSetLayout layouts[VULKAN_NUM_SETS_PER_POOL];	fill(begin(layouts), end(layouts), set_layout);	VkDescriptorSetAllocateInfo alloc = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO };	alloc.descriptorPool = pool;	alloc.descriptorSetCount = VULKAN_NUM_SETS_PER_POOL;	alloc.pSetLayouts = layouts;	if (vkAllocateDescriptorSets(device->get_device(), &alloc, sets) != VK_SUCCESS)		LOG("Failed to allocate descriptor sets./n");	pools.push_back(pool);	for (auto set : sets)		set_nodes.make_vacant(set);	return { set_nodes.request_vacant(hash)->set, false };}

		vertices.inputState.vertexAttributeDescriptionCount = vertices.attributeDescriptions.size();		vertices.inputState.pVertexAttributeDescriptions = vertices.attributeDescriptions.data();	}	void setupDescriptorPool()	{		// Example uses three ubos and two image samplers		std::vector<VkDescriptorPoolSize> poolSizes =		{			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 6),			vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 4)		};		VkDescriptorPoolCreateInfo descriptorPoolInfo =			vkTools::initializers::descriptorPoolCreateInfo(				poolSizes.size(),				poolSizes.data(),				3);