Copy cube map texture faces from host visible buffer instead of linear image (Refs #140)

texturecubemap/texturecubemap.cpp

@@ -127,109 +127,89 @@ public:
 		cubeMap.width = texCube[0].dimensions().x;
 		cubeMap.height = texCube[0].dimensions().y;
 
-		// Get device properites for the requested texture format
-		VkFormatProperties formatProperties;
-		vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &formatProperties);
-
-		VkImageCreateInfo imageCreateInfo = vkTools::initializers::imageCreateInfo();
-		imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
-		imageCreateInfo.format = format;
-		imageCreateInfo.extent = { cubeMap.width, cubeMap.height, 1 };
-		imageCreateInfo.mipLevels = 1;
-		imageCreateInfo.arrayLayers = 1;
-		imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
-		imageCreateInfo.tiling = VK_IMAGE_TILING_LINEAR;
-		imageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
-		imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-		imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
-		imageCreateInfo.flags = 0;
-
 		VkMemoryAllocateInfo memAllocInfo = vkTools::initializers::memoryAllocateInfo();
 		VkMemoryRequirements memReqs;
 
-		struct {
+		// Create a host-visible staging buffer that contains the raw image data
-			VkImage image;
+		VkBuffer stagingBuffer;
-			VkDeviceMemory memory;
+		VkDeviceMemory stagingMemory;
-		} cubeFace[6];
 
-		// Allocate command buffer for image copies and layouts
+		VkBufferCreateInfo bufferCreateInfo = vkTools::initializers::bufferCreateInfo();
-		VkCommandBuffer cmdBuffer;
+		bufferCreateInfo.size = texCube.size();
-		VkCommandBufferAllocateInfo cmdBufAlllocatInfo =
+		// This buffer is used as a transfer source for the buffer copy
-			vkTools::initializers::commandBufferAllocateInfo(
+		bufferCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
-				cmdPool,
+		bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-				VK_COMMAND_BUFFER_LEVEL_PRIMARY,
-				1);
-		VkResult err = vkAllocateCommandBuffers(device, &cmdBufAlllocatInfo, &cmdBuffer);
-		assert(!err);
 
-		VkCommandBufferBeginInfo cmdBufInfo =
+		vkTools::checkResult(vkCreateBuffer(device, &bufferCreateInfo, nullptr, &stagingBuffer));
-			vkTools::initializers::commandBufferBeginInfo();
 
-		err = vkBeginCommandBuffer(cmdBuffer, &cmdBufInfo);
+		// Get memory requirements for the staging buffer (alignment, memory type bits)
-		assert(!err);
+		vkGetBufferMemoryRequirements(device, stagingBuffer, &memReqs);
 
-		// Load separate cube map faces into linear tiled textures
+		memAllocInfo.allocationSize = memReqs.size;
-		for (uint32_t face = 0; face < 6; ++face)
+		// Get memory type index for a host visible buffer
+		memAllocInfo.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
+
+		vkTools::checkResult(vkAllocateMemory(device, &memAllocInfo, nullptr, &stagingMemory));
+		vkTools::checkResult(vkBindBufferMemory(device, stagingBuffer, stagingMemory, 0));
+
+		// Copy texture data into staging buffer
+		uint8_t *data;
+		vkTools::checkResult(vkMapMemory(device, stagingMemory, 0, memReqs.size, 0, (void **)&data));
+		memcpy(data, texCube.data(), texCube.size());
+		vkUnmapMemory(device, stagingMemory);
+
+		// Setup buffer copy regions for all cube faces
+		std::vector<VkBufferImageCopy> bufferCopyRegions;
+		uint32_t offset = 0;
+
+		for (uint32_t face = 0; face < 6; face++)
 		{
-			err = vkCreateImage(device, &imageCreateInfo, nullptr, &cubeFace[face].image);
+			VkBufferImageCopy bufferCopyRegion = {};
-			assert(!err);
+			bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+			bufferCopyRegion.imageSubresource.mipLevel = 0;
+			bufferCopyRegion.imageSubresource.baseArrayLayer = face;
+			bufferCopyRegion.imageSubresource.layerCount = 1;
+			bufferCopyRegion.imageExtent.width = texCube[face].dimensions().x;
+			bufferCopyRegion.imageExtent.height = texCube[face].dimensions().y;
+			bufferCopyRegion.imageExtent.depth = 1;
+			bufferCopyRegion.bufferOffset = offset;
 
-			vkGetImageMemoryRequirements(device, cubeFace[face].image, &memReqs);
+			bufferCopyRegions.push_back(bufferCopyRegion);
-			memAllocInfo.allocationSize = memReqs.size;
-			getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &memAllocInfo.memoryTypeIndex);
-			err = vkAllocateMemory(device, &memAllocInfo, nullptr, &cubeFace[face].memory);
-			assert(!err);
-			err = vkBindImageMemory(device, cubeFace[face].image, cubeFace[face].memory, 0);
-			assert(!err);
 
-			VkImageSubresource subRes = {};
+			offset += texCube[face].size();
-			subRes.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-
-			VkSubresourceLayout subResLayout;
-			void *data;
-
-			vkGetImageSubresourceLayout(device, cubeFace[face].image, &subRes, &subResLayout);
-			assert(!err);
-			err = vkMapMemory(device, cubeFace[face].memory, 0, memReqs.size, 0, &data);
-			assert(!err);
-			memcpy(data, texCube[face][subRes.mipLevel].data(), texCube[face][subRes.mipLevel].size());
-			vkUnmapMemory(device, cubeFace[face].memory);
-
-			// Image barrier for linear image (base)
-			// Linear image will be used as a source for the copy
-			vkTools::setImageLayout(
-				cmdBuffer,
-				cubeFace[face].image,
-				VK_IMAGE_ASPECT_COLOR_BIT,
-				VK_IMAGE_LAYOUT_PREINITIALIZED,
-				VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
 		}
-		
+	
-		// Transfer cube map faces to optimal tiling
+		// Create optimal tiled target image
-
+		VkImageCreateInfo imageCreateInfo = vkTools::initializers::imageCreateInfo();
-		// Setup texture as blit target with optimal tiling
+		imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
+		imageCreateInfo.format = format;
+		imageCreateInfo.mipLevels = 1;
+		imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
 		imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+		imageCreateInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
+		imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+		imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
+		imageCreateInfo.extent = { cubeMap.width, cubeMap.height, 1 };
 		imageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
-		imageCreateInfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
+		// Cube faces count as array layers in Vulkan
 		imageCreateInfo.arrayLayers = 6;
+		// This flag is required for cube map images
+		imageCreateInfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
 
-		err = vkCreateImage(device, &imageCreateInfo, nullptr, &cubeMap.image);
+		VK_CHECK_RESULT(vkCreateImage(device, &imageCreateInfo, nullptr, &cubeMap.image));
-		assert(!err);
 
 		vkGetImageMemoryRequirements(device, cubeMap.image, &memReqs);
 
 		memAllocInfo.allocationSize = memReqs.size;
+		memAllocInfo.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
 
-		getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &memAllocInfo.memoryTypeIndex);
+		VK_CHECK_RESULT(vkAllocateMemory(device, &memAllocInfo, nullptr, &cubeMap.deviceMemory));
-		err = vkAllocateMemory(device, &memAllocInfo, nullptr, &cubeMap.deviceMemory);
+		VK_CHECK_RESULT(vkBindImageMemory(device, cubeMap.image, cubeMap.deviceMemory, 0));
-		assert(!err);
+
-		err = vkBindImageMemory(device, cubeMap.image, cubeMap.deviceMemory, 0);
+		VkCommandBuffer copyCmd = VulkanExampleBase::createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
-		assert(!err);
 
 		// Image barrier for optimal image (target)
-		// Optimal image will be used as destination for the copy
+		// Set initial layout for all array layers (faces) of the optimal (target) tiled texture
-
-		// Set initial layout for all array layers of the optimal (target) tiled texture
 		VkImageSubresourceRange subresourceRange = {};
 		subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
 		subresourceRange.baseMipLevel = 0;
@@ -237,70 +217,34 @@ public:
 		subresourceRange.layerCount = 6;
 
 		vkTools::setImageLayout(
-			cmdBuffer,
+			copyCmd,
 			cubeMap.image,
 			VK_IMAGE_ASPECT_COLOR_BIT,
 			VK_IMAGE_LAYOUT_PREINITIALIZED,
 			VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
 			subresourceRange);
 
-		// Copy cube map faces one by one
+		// Copy the cube map faces from the staging buffer to the optimal tiled image
-		for (uint32_t face = 0; face < 6; ++face)
+		vkCmdCopyBufferToImage(
-		{
+			copyCmd,
-			// Copy region for image blit
+			stagingBuffer,
-			VkImageCopy copyRegion = {};
+			cubeMap.image,
-
+			VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-			copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+			bufferCopyRegions.size(),
-			copyRegion.srcSubresource.baseArrayLayer = 0;
+			bufferCopyRegions.data()
-			copyRegion.srcSubresource.mipLevel = 0;
+			);
-			copyRegion.srcSubresource.layerCount = 1;
-			copyRegion.srcOffset = { 0, 0, 0 };
-
-			copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-			copyRegion.dstSubresource.baseArrayLayer = face;
-			copyRegion.dstSubresource.mipLevel = 0;
-			copyRegion.dstSubresource.layerCount = 1;
-			copyRegion.dstOffset = { 0, 0, 0 };
-
-			copyRegion.extent.width = cubeMap.width;
-			copyRegion.extent.height = cubeMap.height;
-			copyRegion.extent.depth = 1;
-
-			// Put image copy into command buffer
-			vkCmdCopyImage(
-				cmdBuffer,
-				cubeFace[face].image, 
-				VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-				cubeMap.image, 
-				VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-				1, &copyRegion);
-		}
 
 		// Change texture image layout to shader read after all faces have been copied
 		cubeMap.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 		vkTools::setImageLayout(
-			cmdBuffer,
+			copyCmd,
 			cubeMap.image,
 			VK_IMAGE_ASPECT_COLOR_BIT,
 			VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
 			cubeMap.imageLayout,
 			subresourceRange);
 
-		err = vkEndCommandBuffer(cmdBuffer);
+		VulkanExampleBase::flushCommandBuffer(copyCmd, queue, true);
-		assert(!err);
-
-		VkFence nullFence = { VK_NULL_HANDLE };
-
-		// Submit command buffer to graphis queue
-		VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
-		submitInfo.commandBufferCount = 1;
-		submitInfo.pCommandBuffers = &cmdBuffer;
-
-		err = vkQueueSubmit(queue, 1, &submitInfo, nullFence);
-		assert(!err);
-
-		err = vkQueueWaitIdle(queue);
-		assert(!err);
 
 		// Create sampler
 		VkSamplerCreateInfo sampler = vkTools::initializers::samplerCreateInfo();
@@ -316,27 +260,23 @@ public:
 		sampler.minLod = 0.0f;
 		sampler.maxLod = 0.0f;
 		sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
-		err = vkCreateSampler(device, &sampler, nullptr, &cubeMap.sampler);
+		VK_CHECK_RESULT(vkCreateSampler(device, &sampler, nullptr, &cubeMap.sampler));
-		assert(!err);
 
 		// Create image view
 		VkImageViewCreateInfo view = vkTools::initializers::imageViewCreateInfo();
-		view.image = VK_NULL_HANDLE;
+		// Cube map view type
 		view.viewType = VK_IMAGE_VIEW_TYPE_CUBE;
 		view.format = format;
 		view.components = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
 		view.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+		// 6 array layers (faces)
 		view.subresourceRange.layerCount = 6;
 		view.image = cubeMap.image;
-		err = vkCreateImageView(device, &view, nullptr, &cubeMap.view);
+		VK_CHECK_RESULT(vkCreateImageView(device, &view, nullptr, &cubeMap.view));
-		assert(!err);
 
-		// Cleanup
+		// Clean up staging resources
-		for (auto& face : cubeFace)
+		vkFreeMemory(device, stagingMemory, nullptr);
-		{
+		vkDestroyBuffer(device, stagingBuffer, nullptr);
-			vkDestroyImage(device, face.image, nullptr);
-			vkFreeMemory(device, face.memory, nullptr);
-		}
 	}
 
 	void buildCommandBuffers()
@@ -356,30 +296,19 @@ public:
 		renderPassBeginInfo.clearValueCount = 2;
 		renderPassBeginInfo.pClearValues = clearValues;
 
-		VkResult err;
-
 		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)
 		{
 			// Set target frame buffer
 			renderPassBeginInfo.framebuffer = frameBuffers[i];
 
-			err = vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo);
+			VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));
-			assert(!err);
 
 			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
 
-			VkViewport viewport = vkTools::initializers::viewport(
+			VkViewport viewport = vkTools::initializers::viewport((float)width,	(float)height, 0.0f, 1.0f);
-				(float)width,
-				(float)height,
-				0.0f,
-				1.0f);
 			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
 
-			VkRect2D scissor = vkTools::initializers::rect2D(
+			VkRect2D scissor = vkTools::initializers::rect2D(width,	height,	0, 0);
-				width,
-				height,
-				0,
-				0);
 			vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);
 
 			VkDeviceSize offsets[1] = { 0 };
@@ -400,18 +329,14 @@ public:
 
 			vkCmdEndRenderPass(drawCmdBuffers[i]);
 
-			err = vkEndCommandBuffer(drawCmdBuffers[i]);
+			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));
-			assert(!err);
 		}
 	}
 
 	void draw()
 	{
-		VkResult err;
-
 		// Get next image in the swap chain (back/front buffer)
-		err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
+		VK_CHECK_RESULT(swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer));
-		assert(!err);
 
 		submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
 
@@ -420,16 +345,13 @@ public:
 		submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
 
 		// Submit to queue
-		err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
+		VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
-		assert(!err);
 
 		submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
 
-		err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
+		VK_CHECK_RESULT(swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete));
-		assert(!err);
 
-		err = vkQueueWaitIdle(queue);
+		VK_CHECK_RESULT(vkQueueWaitIdle(queue));
-		assert(!err);
 	}
 
 	void loadMeshes()
@@ -494,8 +416,7 @@ public:
 				poolSizes.data(),
 				2);
 
-		VkResult vkRes = vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool);
+		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));
-		assert(!vkRes);
 	}
 
 	void setupDescriptorSetLayout()
@@ -519,16 +440,14 @@ public:
 				setLayoutBindings.data(),
 				setLayoutBindings.size());
 
-		VkResult err = vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout);
+		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));
-		assert(!err);
 
 		VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =
 			vkTools::initializers::pipelineLayoutCreateInfo(
 				&descriptorSetLayout,
 				1);
 
-		err = vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout);
+		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout));
-		assert(!err);
 	}
 
 	void setupDescriptorSets()
@@ -547,8 +466,7 @@ public:
 				1);
 
 		// 3D object descriptor set
-		VkResult vkRes = vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.object);
+		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.object));
-		assert(!vkRes);
 
 		std::vector<VkWriteDescriptorSet> writeDescriptorSets =
 		{
@@ -568,8 +486,7 @@ public:
 		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);
 
 		// Sky box descriptor set
-		vkRes = vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.skybox);
+		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.skybox));
-		assert(!vkRes);
 
 		writeDescriptorSets =
 		{
@@ -661,15 +578,13 @@ public:
 		pipelineCreateInfo.stageCount = shaderStages.size();
 		pipelineCreateInfo.pStages = shaderStages.data();
 
-		VkResult err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.skybox);
+		VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.skybox));
-		assert(!err);
 
 		// Cube map reflect pipeline
 		shaderStages[0] = loadShader(getAssetPath() + "shaders/cubemap/reflect.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
 		shaderStages[1] = loadShader(getAssetPath() + "shaders/cubemap/reflect.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
 		depthStencilState.depthWriteEnable = VK_TRUE;
-		err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.reflect);
+		VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.reflect));
-		assert(!err);
 	}
 
 	// Prepare and initialize uniform buffer containing shader uniforms
@@ -708,8 +623,7 @@ public:
 		uboVS.model = glm::rotate(uboVS.model, glm::radians(rotation.z), glm::vec3(0.0f, 0.0f, 1.0f));
 
 		uint8_t *pData;
-		VkResult err = vkMapMemory(device, uniformData.objectVS.memory, 0, sizeof(uboVS), 0, (void **)&pData);
+		VK_CHECK_RESULT(vkMapMemory(device, uniformData.objectVS.memory, 0, sizeof(uboVS), 0, (void **)&pData));
-		assert(!err);
 		memcpy(pData, &uboVS, sizeof(uboVS));
 		vkUnmapMemory(device, uniformData.objectVS.memory);
 
@@ -723,8 +637,7 @@ public:
 		uboVS.model = glm::rotate(uboVS.model, glm::radians(rotation.y), glm::vec3(0.0f, 1.0f, 0.0f));
 		uboVS.model = glm::rotate(uboVS.model, glm::radians(rotation.z), glm::vec3(0.0f, 0.0f, 1.0f));
 
-		err = vkMapMemory(device, uniformData.skyboxVS.memory, 0, sizeof(uboVS), 0, (void **)&pData);
+		VK_CHECK_RESULT(vkMapMemory(device, uniformData.skyboxVS.memory, 0, sizeof(uboVS), 0, (void **)&pData));
-		assert(!err);
 		memcpy(pData, &uboVS, sizeof(uboVS));
 		vkUnmapMemory(device, uniformData.skyboxVS.memory);
 	}