Finished descriptor indexing example

data/shaders/glsl/descriptorindexing/descriptorindexing.vert

@@ -17,10 +17,7 @@ layout (location = 1) flat out int outTexIndex;
 void main() 
 {
 	outUV = inUV;
-	outTexIndex = 0;
 	outTexIndex = inTextureIndex;
-	outTexIndex = gl_InstanceIndex;
 	vec4 pos = vec4(inPos, 1.0f);
-	pos.y += gl_InstanceIndex;
 	gl_Position = matrices.projection * matrices.view * matrices.model * pos;
 }

examples/descriptorindexing/descriptorindexing.cpp

@@ -1,30 +1,24 @@
 /*
 * Vulkan Example - Descriptor indexing (VK_EXT_descriptor_indexing)
 *
+* Demonstrates use of descriptor indexing to dynamically index into a variable sized array of samples
+* 
 * Relevant code parts are marked with [POI]
 *
-* Copyright (C) Sascha Willems - www.saschawillems.de
+* Copyright (C) 2021 Sascha Willems - www.saschawillems.de
 *
 * This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 */
 
+
 #include "vulkanexamplebase.h"
 
 #define ENABLE_VALIDATION false
 
-// Vertex layout for this example
-struct Vertex {
-	float pos[3];
-	float uv[2];
-	int32_t textureIndex;
-};
-
 class VulkanExample : public VulkanExampleBase
 {
 public:
-	// Number of array layers in texture array
+	// We will be dynamically indexing into an array of samplers
-	// Also used as instance count
-	uint32_t layerCount;
 	std::vector<vks::Texture2D> textures;
 
 	vks::Buffer vertexBuffer;
@@ -45,25 +39,27 @@ public:
 
 	VkPhysicalDeviceDescriptorIndexingFeaturesEXT physicalDeviceDescriptorIndexingFeatures{};
 
+	struct Vertex {
+		float pos[3];
+		float uv[2];
+		int32_t textureIndex;
+	};
+
 	VulkanExample() : VulkanExampleBase(ENABLE_VALIDATION)
 	{
 		title = "Descriptor indexing";
 		settings.overlay = true;
 		camera.type = Camera::CameraType::lookat;
-		camera.setPosition(glm::vec3(0.0f, 0.0f, -7.5f));
+		camera.setPosition(glm::vec3(0.0f, 0.0f, -10.0f));
 		camera.setRotation(glm::vec3(-35.0f, 0.0f, 0.0f));
 		camera.setPerspective(45.0f, (float)width / (float)height, 0.1f, 256.0f);
 
-		/*
+		// [POI] Enable required extensions
-			[POI] Enable required extensions
-		*/
 		enabledInstanceExtensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
 		enabledDeviceExtensions.push_back(VK_KHR_MAINTENANCE3_EXTENSION_NAME);
 		enabledDeviceExtensions.push_back(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME);
 
-		/*
+		// [POI] Enable required extension features
-			[POI] Enable required extension features
-		*/
 		physicalDeviceDescriptorIndexingFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT;
 		physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing = VK_TRUE;
 		physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray = VK_TRUE;
@@ -74,10 +70,9 @@ public:
 
 	~VulkanExample()
 	{
-		//vkDestroyImageView(device, textureArray.view, nullptr);
+		for (auto &texture : textures) {
-		//vkDestroyImage(device, textureArray.image, nullptr);
+			texture.destroy();
-		//vkDestroySampler(device, textureArray.sampler, nullptr);
+		}
-		//vkFreeMemory(device, textureArray.deviceMemory, nullptr);
 		vkDestroyPipeline(device, pipeline, nullptr);
 		vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
 		vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
@@ -86,136 +81,103 @@ public:
 		uniformBufferVS.destroy();
 	}
 
-	void loadAssets()
+	struct V {
-	{
+		uint8_t r;
-		textures.resize(7);
+		uint8_t g;
-		for (uint32_t i = 0; i < 7; i++) {
+		uint8_t b;
-			textures[i].loadFromFile(getAssetPath() + "textures/array/" + std::to_string(i) + ".ktx", VK_FORMAT_R8G8B8A8_UNORM, vulkanDevice, queue);
+		uint8_t a;
-		}
-	}
-
-	void buildCommandBuffers()
-	{
-		VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();
-
-		VkClearValue clearValues[2];
-		clearValues[0].color = defaultClearColor;
-		clearValues[1].depthStencil = { 1.0f, 0 };
-
-		VkRenderPassBeginInfo renderPassBeginInfo = vks::initializers::renderPassBeginInfo();
-		renderPassBeginInfo.renderPass = renderPass;
-		renderPassBeginInfo.renderArea.offset.x = 0;
-		renderPassBeginInfo.renderArea.offset.y = 0;
-		renderPassBeginInfo.renderArea.extent.width = width;
-		renderPassBeginInfo.renderArea.extent.height = height;
-		renderPassBeginInfo.clearValueCount = 2;
-		renderPassBeginInfo.pClearValues = clearValues;
-
-		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)
-		{
-			renderPassBeginInfo.framebuffer = frameBuffers[i];
-
-			VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));
-
-			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
-
-			VkViewport viewport = vks::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);
-			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
-
-			VkRect2D scissor = vks::initializers::rect2D(width, height, 0, 0);
-			vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);
-
-			vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, NULL);
-			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
-
-			VkDeviceSize offsets[1] = { 0 };
-			vkCmdBindVertexBuffers(drawCmdBuffers[i], 0, 1, &vertexBuffer.buffer, offsets);
-			vkCmdBindIndexBuffer(drawCmdBuffers[i], indexBuffer.buffer, 0, VK_INDEX_TYPE_UINT32);
-
-			vkCmdDrawIndexed(drawCmdBuffers[i], indexCount, layerCount, 0, 0, 0);
-
-			drawUI(drawCmdBuffers[i]);
-
-			vkCmdEndRenderPass(drawCmdBuffers[i]);
-
-			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));
-		}
-	}
-
-	void generateCube(glm::vec3 pos, float scale, std::vector<Vertex> &vertices, std::vector<uint32_t> &indices)
-	{
-		// Generate random per-face texture indices
-		std::random_device mch;
-		std::default_random_engine generator(mch());
-		std::uniform_int_distribution<int32_t> rndTextureIndex(0, layerCount - 1);
-
-		std::vector<int32_t> faceTextureIndex(6);
-		for (auto &textureIndex : faceTextureIndex) {
-			textureIndex = rndTextureIndex(generator);
-		}
-
-		std::cout << faceTextureIndex[0] << std::endl;
-
-		std::vector<Vertex> cubeVertices = {
-			{ { -scale, -scale,  scale }, { 0.0f, 0.0f }, faceTextureIndex[0] },
-			{ {  scale, -scale,  scale }, { 1.0f, 0.0f }, faceTextureIndex[0] },
-			{ {  scale,  scale,  scale }, { 1.0f, 1.0f }, faceTextureIndex[0] },
-			{ { -scale,  scale,  scale }, { 0.0f, 1.0f }, faceTextureIndex[0] },
-
-			{ {  scale,  scale,  scale }, { 0.0f, 0.0f }, faceTextureIndex[1] },
-			{ {  scale,  scale, -scale }, { 1.0f, 0.0f }, faceTextureIndex[1] },
-			{ {  scale, -scale, -scale }, { 1.0f, 1.0f }, faceTextureIndex[1] },
-			{ {  scale, -scale,  scale }, { 0.0f, 1.0f }, faceTextureIndex[1] },
-
-			{ { -scale, -scale, -scale }, { 0.0f, 0.0f }, faceTextureIndex[2] },
-			{ {  scale, -scale, -scale }, { 1.0f, 0.0f }, faceTextureIndex[2] },
-			{ {  scale,  scale, -scale }, { 1.0f, 1.0f }, faceTextureIndex[2] },
-			{ { -scale,  scale, -scale }, { 0.0f, 1.0f }, faceTextureIndex[2] },
-
-			{ { -scale, -scale, -scale }, { 0.0f, 0.0f }, faceTextureIndex[3] },
-			{ { -scale, -scale,  scale }, { 1.0f, 0.0f }, faceTextureIndex[3] },
-			{ { -scale,  scale,  scale }, { 1.0f, 1.0f }, faceTextureIndex[3] },
-			{ { -scale,  scale, -scale }, { 0.0f, 1.0f }, faceTextureIndex[3] },
-
-			{ {  scale,  scale,  scale }, { 0.0f, 0.0f }, faceTextureIndex[4] },
-			{ { -scale,  scale,  scale }, { 1.0f, 0.0f }, faceTextureIndex[4] },
-			{ { -scale,  scale, -scale }, { 1.0f, 1.0f }, faceTextureIndex[4] },
-			{ {  scale,  scale, -scale }, { 0.0f, 1.0f }, faceTextureIndex[4] },
-
-			{ { -scale, -scale, -scale }, { 0.0f, 0.0f }, faceTextureIndex[5] },
-			{ {  scale, -scale, -scale }, { 1.0f, 0.0f }, faceTextureIndex[5] },
-			{ {  scale, -scale,  scale }, { 1.0f, 1.0f }, faceTextureIndex[5] },
-			{ { -scale, -scale,  scale }, { 0.0f, 1.0f }, faceTextureIndex[5] },
-
 	};
-		for (auto &vertex : cubeVertices) {
+
-			vertex.pos[0] += pos.x;
+	// Generate some random textures
-			vertex.pos[1] += pos.y;
+	void generateTextures()
-			vertex.pos[2] += pos.z;
+	{
+		textures.resize(32);
+		for (size_t i = 0; i < textures.size(); i++) {
+			std::random_device rndDevice;
+			std::default_random_engine rndEngine(rndDevice());
+			std::uniform_int_distribution<short> rndDist(50, 255);
+			const int32_t dim = 3;
+			const size_t bufferSize = dim * dim * 4;
+			std::vector<uint8_t> texture(bufferSize);
+			for (size_t i = 0; i < dim * dim; i++) {
+				texture[i * 4]     = rndDist(rndEngine);
+				texture[i * 4 + 1] = rndDist(rndEngine);
+				texture[i * 4 + 2] = rndDist(rndEngine);
+				texture[i * 4 + 3] = 255;
+			}
+			textures[i].fromBuffer(texture.data(), bufferSize, VK_FORMAT_R8G8B8A8_UNORM, dim, dim, vulkanDevice, queue, VK_FILTER_NEAREST);
+		}
 	}
 
-		std::vector<uint32_t> cubeIndices = {
+	// Generates a line of cubes with randomized per-face texture indices
-			0,1,2, 0,2,3, 4,5,6, 4,6,7, 8,9,10, 8,10,11, 12,13,14, 12,14,15, 16,17,18, 16,18,19, 20,21,22, 20,22,23
+	void generateCubes()
-		};
-		for (auto &index : cubeIndices) {
-			index += vertices.size();
-		}
-
-		vertices.insert(vertices.end(), cubeVertices.begin(), cubeVertices.end());
-		indices.insert(indices.end(), cubeIndices.begin(), cubeIndices.end());
-	}
-
-	void generateBuffers()
 	{
 		std::vector<Vertex> vertices;
 		std::vector<uint32_t> indices;
 
-		float offset = -1.5f;
+		// Generate random per-face texture indices
-		float center = (layerCount * offset) / 2.0f - (offset * 0.5f);
+		std::random_device rndDevice;
-		//for (uint32_t i = 0; i < 7; i++) {
+		std::default_random_engine rndEngine(rndDevice());
-			//generateCube(glm::vec3(i * offset - center, 0.0f, 0.0f), 0.5f, vertices, indices);
+		std::uniform_int_distribution<int32_t> rndDist(0, static_cast<uint32_t>(textures.size()) - 1);
-		//}
+
-		generateCube(glm::vec3(0.0f, 0.0f, 0.0f), 0.5f, vertices, indices);
+		// Generate cubes with random per-face texture indices
+		const uint32_t count = 6;
+		for (uint32_t i = 0; i < count; i++) {
+			// Get random per-Face texture indices that the shader will sample from
+			int32_t textureIndices[6];
+			for (uint32_t j = 0; j < 6; j++) {
+				textureIndices[j] = rndDist(rndEngine);
+			}
+			// Push vertices to buffer
+			float pos = 2.5f * i - (count * 2.5f / 2.0f);
+			const std::vector<Vertex> cube = {
+				{ { -1.0f + pos, -1.0f,  1.0f }, { 0.0f, 0.0f }, textureIndices[0] },
+				{ {  1.0f + pos, -1.0f,  1.0f }, { 1.0f, 0.0f }, textureIndices[0] },
+				{ {  1.0f + pos,  1.0f,  1.0f }, { 1.0f, 1.0f }, textureIndices[0] },
+				{ { -1.0f + pos,  1.0f,  1.0f }, { 0.0f, 1.0f }, textureIndices[0] },
+
+				{ {  1.0f + pos,  1.0f,  1.0f }, { 0.0f, 0.0f }, textureIndices[1] },
+				{ {  1.0f + pos,  1.0f, -1.0f }, { 1.0f, 0.0f }, textureIndices[1] },
+				{ {  1.0f + pos, -1.0f, -1.0f }, { 1.0f, 1.0f }, textureIndices[1] },
+				{ {  1.0f + pos, -1.0f,  1.0f }, { 0.0f, 1.0f }, textureIndices[1] },
+
+				{ { -1.0f + pos, -1.0f, -1.0f }, { 0.0f, 0.0f }, textureIndices[2] },
+				{ {  1.0f + pos, -1.0f, -1.0f }, { 1.0f, 0.0f }, textureIndices[2] },
+				{ {  1.0f + pos,  1.0f, -1.0f }, { 1.0f, 1.0f }, textureIndices[2] },
+				{ { -1.0f + pos,  1.0f, -1.0f }, { 0.0f, 1.0f }, textureIndices[2] },
+
+				{ { -1.0f + pos, -1.0f, -1.0f }, { 0.0f, 0.0f }, textureIndices[3] },
+				{ { -1.0f + pos, -1.0f,  1.0f }, { 1.0f, 0.0f }, textureIndices[3] },
+				{ { -1.0f + pos,  1.0f,  1.0f }, { 1.0f, 1.0f }, textureIndices[3] },
+				{ { -1.0f + pos,  1.0f, -1.0f }, { 0.0f, 1.0f }, textureIndices[3] },
+
+				{ {  1.0f + pos,  1.0f,  1.0f }, { 0.0f, 0.0f }, textureIndices[4] },
+				{ { -1.0f + pos,  1.0f,  1.0f }, { 1.0f, 0.0f }, textureIndices[4] },
+				{ { -1.0f + pos,  1.0f, -1.0f }, { 1.0f, 1.0f }, textureIndices[4] },
+				{ {  1.0f + pos,  1.0f, -1.0f }, { 0.0f, 1.0f }, textureIndices[4] },
+
+				{ { -1.0f + pos, -1.0f, -1.0f }, { 0.0f, 0.0f }, textureIndices[5] },
+				{ {  1.0f + pos, -1.0f, -1.0f }, { 1.0f, 0.0f }, textureIndices[5] },
+				{ {  1.0f + pos, -1.0f,  1.0f }, { 1.0f, 1.0f }, textureIndices[5] },
+				{ { -1.0f + pos, -1.0f,  1.0f }, { 0.0f, 1.0f }, textureIndices[5] },
+			};
+			for (auto& vertex : cube) {
+				vertices.push_back(vertex);
+			}
+			// Push indices to buffer
+			const std::vector<uint32_t> cubeIndices = {
+				0,1,2,0,2,3,
+				4,5,6,4,6,7,
+				8,9,10,8,10,11,
+				12,13,14,12,14,15,
+				16,17,18,16,18,19,
+				20,21,22,20,22,23
+			};
+			for (auto& index : cubeIndices) {
+				indices.push_back(index + static_cast<uint32_t>(vertices.size()));
+			}
+		}
+
 		indexCount = static_cast<uint32_t>(indices.size());
 
 		// For the sake of simplicity we won't stage the vertex data to the gpu memory
@@ -233,37 +195,30 @@ public:
 			indices.data()));
 	}
 
-	/*
+	// [POI] Set up descriptor sets and set layout
-		[POI] Set up descriptor sets and set layout
-	*/
 	void setupDescriptorSets()
 	{
-		/*
+		// Descriptor pool
-			Descriptor set layout
+		std::vector<VkDescriptorPoolSize> poolSizes = {
-		*/
+			vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1),
+			vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, static_cast<uint32_t>(textures.size()))
+		};
+		VkDescriptorPoolCreateInfo descriptorPoolInfo = vks::initializers::descriptorPoolCreateInfo(poolSizes, 2);
+		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));
 
+		// Descriptor set layout
 		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = {
 			// Binding 0 : Vertex shader uniform buffer
 			vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT, 0),
-			/*
+			// [POI] Binding 1 contains a texture array that is dynamically non-uniform sampled from
-				[POI]
+			// In the fragment shader:
-
+			//	outFragColor = texture(textures[nonuniformEXT(inTexIndex)], inUV);
-				Binding 1 contains a texture array that is dynamically non-uniform sampled from
-
-				FS:
-					outFragColor = texture(textures[nonuniformEXT(inTexIndex)], inUV);
-			*/
 			vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, 1, static_cast<uint32_t>(textures.size()))
 		};
 
-		/*
+		// [POI] The fragment shader will be using an unsized array of samplers, which has to be marked with the VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT
-			[POI]
+		// In the fragment shader:
-
+		//	layout (set = 0, binding = 1) uniform sampler2D textures[];
-			The fragment shader will be using an unsized array, which has to be marked with a certain flag
-
-			FS:
-				layout (set = 0, binding = 1) uniform sampler2D textures[];
-		*/
 		VkDescriptorSetLayoutBindingFlagsCreateInfoEXT setLayoutBindingFlags{};
 		setLayoutBindingFlags.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT;
 		setLayoutBindingFlags.bindingCount = 2;
@@ -273,28 +228,14 @@ public:
 		};
 		setLayoutBindingFlags.pBindingFlags = descriptorBindingFlags.data();
 
-		VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCI = vks::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings.data(), setLayoutBindings.size());
+		VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCI = vks::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings);
 		descriptorSetLayoutCI.pNext = &setLayoutBindingFlags;
 		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorSetLayoutCI, nullptr, &descriptorSetLayout));
 
-		/*
+		// Descriptor sets
-			Descriptor pool
-		*/
-
-		std::vector<VkDescriptorPoolSize> poolSizes = {
-			vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1),
-			vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, textures.size())
-		};
-		VkDescriptorPoolCreateInfo descriptorPoolInfo = vks::initializers::descriptorPoolCreateInfo(poolSizes.size(), poolSizes.data(), 2);
-		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));
-
-		/*
-			Descriptor sets
-		*/
-
 		VkDescriptorSetVariableDescriptorCountAllocateInfoEXT variableDescriptorCountAllocInfo = {};
 
-		uint32_t variableDescCounts[] = {textures.size()};
+		uint32_t variableDescCounts[] = { static_cast<uint32_t>(textures.size())};
 
 		variableDescriptorCountAllocInfo.sType              = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT;
 		variableDescriptorCountAllocInfo.descriptorSetCount = 1;
@@ -317,13 +258,8 @@ public:
 			textureDescriptors[i].imageView = textures[i].view;
 		}
 
-		/*
+		// [POI] Second and final descriptor is a texture array
-			[POI]
+		// Unlike an array texture, these are adressed like typical arrays
-
-			Second and final descriptor is a texture array
-
-			Unlike an array texture, these are adressed like typical arrays
-		*/
 		writeDescriptorSets[1] = {};
 		writeDescriptorSets[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
 		writeDescriptorSets[1].dstBinding = 1;
@@ -334,7 +270,7 @@ public:
 		writeDescriptorSets[1].dstSet = descriptorSet;
 		writeDescriptorSets[1].pImageInfo = textureDescriptors.data();
 
-		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);
+		vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, nullptr);
 	}
 
 	void preparePipelines()
@@ -351,7 +287,7 @@ public:
 		VkPipelineViewportStateCreateInfo viewportStateCI = vks::initializers::pipelineViewportStateCreateInfo(1, 1, 0);
 		VkPipelineMultisampleStateCreateInfo multisampleStateCI = vks::initializers::pipelineMultisampleStateCreateInfo(VK_SAMPLE_COUNT_1_BIT, 0);
 		std::vector<VkDynamicState> dynamicStateEnables = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
-		VkPipelineDynamicStateCreateInfo dynamicStateCI = vks::initializers::pipelineDynamicStateCreateInfo(dynamicStateEnables.data(), dynamicStateEnables.size(), 0);
+		VkPipelineDynamicStateCreateInfo dynamicStateCI = vks::initializers::pipelineDynamicStateCreateInfo(dynamicStateEnables);
 
 		// Vertex bindings and attributes
 		VkVertexInputBindingDescription vertexInputBinding = { 0, sizeof(Vertex), VK_VERTEX_INPUT_RATE_VERTEX };
@@ -370,6 +306,7 @@ public:
 		std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
 
 		shaderStages[0] = loadShader(getShadersPath() + "descriptorindexing/descriptorindexing.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
+		// [POI] The fragment shader does non-uniform access into our sampler array, so we need to use nonuniformEXT: texture(textures[nonuniformEXT(inTexIndex)], inUV)
 		shaderStages[1] = loadShader(getShadersPath() + "descriptorindexing/descriptorindexing.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
 
 		VkGraphicsPipelineCreateInfo pipelineCI = vks::initializers::pipelineCreateInfo(pipelineLayout, renderPass, 0);
@@ -381,7 +318,7 @@ public:
 		pipelineCI.pViewportState = &viewportStateCI;
 		pipelineCI.pDepthStencilState = &depthStencilStateCI;
 		pipelineCI.pDynamicState = &dynamicStateCI;
-		pipelineCI.stageCount = shaderStages.size();
+		pipelineCI.stageCount = static_cast<uint32_t>(shaderStages.size());
 		pipelineCI.pStages = shaderStages.data();
 
 		VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCI, nullptr, &pipeline));
@@ -406,23 +343,57 @@ public:
 		memcpy(uniformBufferVS.mapped, &uboVS, sizeof(uboVS));
 	}
 
+	void buildCommandBuffers()
+	{
+		VkClearValue clearValues[2];
+		clearValues[0].color = defaultClearColor;
+		clearValues[1].depthStencil = { 1.0f, 0 };
+
+		VkRenderPassBeginInfo renderPassBeginInfo = vks::initializers::renderPassBeginInfo();
+		renderPassBeginInfo.renderPass = renderPass;
+		renderPassBeginInfo.renderArea.offset.x = 0;
+		renderPassBeginInfo.renderArea.offset.y = 0;
+		renderPassBeginInfo.renderArea.extent.width = width;
+		renderPassBeginInfo.renderArea.extent.height = height;
+		renderPassBeginInfo.clearValueCount = 2;
+		renderPassBeginInfo.pClearValues = clearValues;
+
+		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)
+		{
+			renderPassBeginInfo.framebuffer = frameBuffers[i];
+			VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();
+			VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));
+			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
+			VkViewport viewport = vks::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);
+			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
+			VkRect2D scissor = vks::initializers::rect2D(width, height, 0, 0);
+			vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);
+			vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, NULL);
+			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
+			VkDeviceSize offsets[1] = { 0 };
+			vkCmdBindVertexBuffers(drawCmdBuffers[i], 0, 1, &vertexBuffer.buffer, offsets);
+			vkCmdBindIndexBuffer(drawCmdBuffers[i], indexBuffer.buffer, 0, VK_INDEX_TYPE_UINT32);
+			vkCmdDrawIndexed(drawCmdBuffers[i], indexCount, 1, 0, 0, 0);
+			drawUI(drawCmdBuffers[i]);
+			vkCmdEndRenderPass(drawCmdBuffers[i]);
+			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));
+		}
+	}
+
 	void draw()
 	{
 		VulkanExampleBase::prepareFrame();
-
 		submitInfo.commandBufferCount = 1;
 		submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
 		VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
-
 		VulkanExampleBase::submitFrame();
 	}
 
 	void prepare()
 	{
 		VulkanExampleBase::prepare();
-		loadAssets();
+		generateTextures();
-		layerCount = textures.size();
+		generateCubes();
-		generateBuffers();
 		prepareUniformBuffers();
 		setupDescriptorSets();
 		preparePipelines();