Function create_function_entry_descriptor_buffer

src/device/vulkan/vulkan_program.cpp:265–343

}

static bool create_function_entry_descriptor_buffer(vulkan_function_entry& entry,
													const device& dev,
													const VkShaderStageFlagBits stage,
													const std::string& func_name,
													const toolchain::function_info& info) {
	const auto& vk_dev = (const vulkan_device&)dev;
	auto& vk_ctx = *(vulkan_context*)vk_dev.context;
	const auto dev_queue = vk_ctx.get_device_default_queue(vk_dev);
	assert(dev_queue != nullptr);
	
	auto layout = build_descriptor_set_layout(dev, func_name, info, stage);
	if (!layout) {
		return false;
	}
	entry.desc_set_layout = layout->desc_set_layout;
	entry.constant_buffer_info = std::move(layout->constant_buffer_info);
	
	if (!layout->bindings.empty()) {
		// query required buffer size + ensure good alignment
		entry.desc_buffer.layout_size_in_bytes = layout->layout_size;
		entry.desc_buffer.layout_size_in_bytes = const_math::round_next_multiple(entry.desc_buffer.layout_size_in_bytes,
																				 uint64_t(std::max(256u, vk_dev.descriptor_buffer_offset_alignment)));
		
		// query offset for each binding/argument
		entry.desc_buffer.argument_offsets.reserve(layout->bindings.size());
		for (const auto& binding : layout->bindings) {
			VkDeviceSize offset = 0;
			vkGetDescriptorSetLayoutBindingOffsetEXT(vk_dev.device, entry.desc_set_layout, binding.binding, &offset);
			entry.desc_buffer.argument_offsets.emplace_back(offset);
		}
		
		// allocate descriptor buffers
		std::array<vulkan_descriptor_buffer_container::resource_type, vulkan_descriptor_buffer_container::descriptor_count> desc_buffers;
		for (uint32_t buf_idx = 0; buf_idx < vulkan_descriptor_buffer_container::descriptor_count; ++buf_idx) {
			// alloc with Vulkan flags: need host-visible/host-coherent and descriptor buffer usage flags
			desc_buffers[buf_idx].first = vk_ctx.create_buffer(*dev_queue, entry.desc_buffer.layout_size_in_bytes,
															   // NOTE: read-only on the device side (until writable argument buffers are implemented)
															   MEMORY_FLAG::READ |
															   MEMORY_FLAG::HOST_READ_WRITE |
															   MEMORY_FLAG::VULKAN_HOST_COHERENT |
															   MEMORY_FLAG::VULKAN_DESCRIPTOR_BUFFER |
															   MEMORY_FLAG::__EXP_HEAP_ALLOC);
			desc_buffers[buf_idx].first->set_debug_label("desc_buf:" + func_name + "#" + std::to_string(buf_idx));
			auto mapped_host_ptr = desc_buffers[buf_idx].first->map(*dev_queue, (MEMORY_MAP_FLAG::WRITE_INVALIDATE |
																				 MEMORY_MAP_FLAG::BLOCK));
			desc_buffers[buf_idx].second = { (uint8_t*)mapped_host_ptr, entry.desc_buffer.layout_size_in_bytes };
			entry.desc_buffer.desc_buffer_ptrs[buf_idx] = { desc_buffers[buf_idx].first.get(), mapped_host_ptr };
		}
		entry.desc_buffer.desc_buffer_container = std::make_unique<vulkan_descriptor_buffer_container>(std::move(desc_buffers));
		
		if (!allocate_constant_buffers(entry, dev, func_name, *layout)) {
			return false;
		}
	}
	// else: no function parameters/bindings
	
	// handle argument buffers -> need to create descriptor set layouts for these as well
	{