Method generate_textures

samples/tooling/profiles/profiles.cpp:211–304

}

void Profiles::generate_textures()
{
	// Generate random textures to be sourced from a single descriptor

	// Image info is same for all textures
	const int32_t dim = 2;

	VkImageCreateInfo image_info = vkb::initializers::image_create_info();
	image_info.format            = VK_FORMAT_R8G8B8A8_UNORM;
	image_info.extent            = {dim, dim, 1};
	image_info.mipLevels         = 1;
	image_info.arrayLayers       = 1;
	image_info.initialLayout     = VK_IMAGE_LAYOUT_UNDEFINED;
	image_info.usage             = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
	image_info.imageType         = VK_IMAGE_TYPE_2D;
	image_info.samples           = VK_SAMPLE_COUNT_1_BIT;
	image_info.tiling            = VK_IMAGE_TILING_OPTIMAL;
	image_info.sharingMode       = VK_SHARING_MODE_EXCLUSIVE;

	VkImageViewCreateInfo image_view           = vkb::initializers::image_view_create_info();
	image_view.viewType                        = VK_IMAGE_VIEW_TYPE_2D;
	image_view.format                          = VK_FORMAT_R8G8B8A8_UNORM;
	image_view.subresourceRange.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
	image_view.subresourceRange.baseMipLevel   = 0;
	image_view.subresourceRange.levelCount     = 1;
	image_view.subresourceRange.baseArrayLayer = 0;
	image_view.subresourceRange.layerCount     = 1;

	auto staging_buffer = vkb::core::BufferC::create_staging_buffer(get_device(), image_info.extent.width * image_info.extent.height * sizeof(uint32_t), nullptr);

	textures.resize(32);
	for (size_t i = 0; i < textures.size(); i++)
	{
		VK_CHECK(vkCreateImage(get_device().get_handle(), &image_info, nullptr, &textures[i].image));
		VkMemoryAllocateInfo memory_allocation_info = vkb::initializers::memory_allocate_info();
		VkMemoryRequirements memory_requirements;
		vkGetImageMemoryRequirements(get_device().get_handle(), textures[i].image, &memory_requirements);
		memory_allocation_info.allocationSize  = memory_requirements.size;
		memory_allocation_info.memoryTypeIndex = get_device().get_gpu().get_memory_type(memory_requirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
		VK_CHECK(vkAllocateMemory(get_device().get_handle(), &memory_allocation_info, nullptr, &textures[i].memory));
		VK_CHECK(vkBindImageMemory(get_device().get_handle(), textures[i].image, textures[i].memory, 0));
		image_view.image = textures[i].image;
		VK_CHECK(vkCreateImageView(get_device().get_handle(), &image_view, nullptr, &textures[i].image_view));

		// Generate a random texture
		std::default_random_engine           rnd_engine(lock_simulation_speed ? static_cast<unsigned>(i) : std::random_device{}());
		std::uniform_int_distribution<short> rnd_dist(0, 255);
		const size_t                         buffer_size = dim * dim * 4;
		uint8_t                             *buffer      = staging_buffer.map();
		for (size_t i = 0; i < dim * dim; i++)
		{
			buffer[i * 4]     = static_cast<uint8_t>(rnd_dist(rnd_engine));
			buffer[i * 4 + 1] = static_cast<uint8_t>(rnd_dist(rnd_engine));
			buffer[i * 4 + 2] = static_cast<uint8_t>(rnd_dist(rnd_engine));
			buffer[i * 4 + 3] = 255;
		}

		staging_buffer.unmap();