Updated graphics pipeline library sample

data/shaders/glsl/graphicspipelinelibrary/shared.vert

@@ -0,0 +1,33 @@
+#version 450 
+
+layout (location = 0) in vec3 inPos;
+layout (location = 1) in vec3 inNormal;
+layout (location = 2) in vec3 inColor;
+
+layout (binding = 0) uniform UBO 
+{
+	mat4 projection;
+	mat4 model;
+	vec4 lightPos;
+} ubo;
+
+layout (location = 0) out vec3 outNormal;
+layout (location = 1) out vec3 outColor;
+layout (location = 2) out vec3 outViewVec;
+layout (location = 3) out vec3 outLightVec;
+layout (location = 4) flat out vec3 outFlatNormal;
+
+void main() 
+{
+	outNormal = inNormal;
+	outColor = inColor;
+	vec4 pos = vec4(inPos.xyz, 1.0);
+
+	gl_Position = ubo.projection * ubo.model * pos;
+	
+	pos = ubo.model * pos;
+	outNormal = mat3(ubo.model) * inNormal;
+	vec3 lPos = ubo.lightPos.xyz;
+	outLightVec = lPos - pos.xyz;
+	outViewVec = -pos.xyz;		
+}

data/shaders/glsl/graphicspipelinelibrary/uber.frag

@@ -0,0 +1,61 @@
+#version 450
+layout (location = 0) in vec3 inNormal;
+layout (location = 1) in vec3 inColor;
+layout (location = 2) in vec3 inViewVec;
+layout (location = 3) in vec3 inLightVec;
+layout (location = 4) flat in vec3 inFlatNormal;
+
+layout (constant_id = 0) const int LIGHTING_MODEL = 0;
+
+layout (location = 0) out vec4 outFragColor;
+
+void main() 
+{
+	switch (LIGHTING_MODEL) {
+		case 0: // Phong			
+		{
+			vec3 ambient = inColor * vec3(0.25);
+			vec3 N = normalize(inNormal);
+			vec3 L = normalize(inLightVec);
+			vec3 V = normalize(inViewVec);
+			vec3 R = reflect(-L, N);
+			vec3 diffuse = max(dot(N, L), 0.0) * inColor;
+			vec3 specular = pow(max(dot(R, V), 0.0), 32.0) * vec3(0.75);
+			outFragColor = vec4(ambient + diffuse * 1.75 + specular, 1.0);		
+			break;
+		}
+		case 1: // Toon
+		{
+
+			vec3 N = normalize(inNormal);
+			vec3 L = normalize(inLightVec);
+			float intensity = dot(N,L);
+			vec3 color;
+			if (intensity > 0.98)
+				color = inColor * 1.5;
+			else if  (intensity > 0.9)
+				color = inColor * 1.0;
+			else if (intensity > 0.5)
+				color = inColor * 0.6;
+			else if (intensity > 0.25)
+				color = inColor * 0.4;
+			else
+				color = inColor * 0.2;
+			outFragColor.rgb = color;
+			break;
+		}
+		case 2: // No shading
+		{
+			outFragColor.rgb = inColor;
+			break;
+		}
+		case 3: // Greyscale
+		{
+			outFragColor.rgb = vec3(dot(inColor.rgb, vec3(0.299, 0.587, 0.114)));
+			break;
+		}
+	}
+
+	// Scene is dark, brigthen up a bit
+	outFragColor.rgb *= 1.25;
+}

examples/graphicspipelinelibrary/graphicspipelinelibrary.cpp

@@ -1,8 +1,6 @@
 /*
 * Vulkan Example - Using VK_EXT_graphics_pipeline_library
 * 
-* Important note: Work-in-progress, sample is not finished yet
-*
 * Copyright (C) 2022 by Sascha Willems - www.saschawillems.de
 *
 * This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
@@ -10,6 +8,7 @@
 
 #include "vulkanexamplebase.h"
 #include "VulkanglTFModel.h"
+#include <mutex>
 
 #define ENABLE_VALIDATION false
 
@@ -18,14 +17,12 @@ class VulkanExample: public VulkanExampleBase
 public:
 	vkglTF::Model scene;
 
-	vks::Buffer uniformBuffer;
-
-	// Same uniform buffer layout as shader
 	struct UBOVS {
 		glm::mat4 projection;
 		glm::mat4 modelView;
 		glm::vec4 lightPos = glm::vec4(0.0f, 2.0f, 1.0f, 0.0f);
 	} uboVS;
+	vks::Buffer uniformBuffer;
 
 	VkPipelineLayout pipelineLayout;
 	VkDescriptorSet descriptorSet;
@@ -33,25 +30,37 @@ public:
 
 	VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT graphicsPipelineLibraryFeatures{};
 
-	struct {
+	struct PipelineLibrary {
-		VkPipeline phong;
+		VkPipeline vertexInputInterface;
-		VkPipeline wireframe;
+		VkPipeline preRasterizationShaders;
-		VkPipeline toon;
+		VkPipeline fragmentOutputInterface;
-	} pipelines;
+	} pipelineLibrary;
+
+	std::vector<VkPipeline> pipelines{};
 
 	struct ShaderInfo {
 		uint32_t* code;
 		size_t size;
 	};
 
+	std::mutex mutex;
+	VkPipelineCache threadPipelineCache{ VK_NULL_HANDLE };
+
+	bool  newPipelineCreated = false;
+
+	uint32_t splitX{ 2 };
+	uint32_t splitY{ 2 };
+
+	std::vector<glm::vec3> colors{};
+	float rotation{ 0.0f };
+
 	VulkanExample() : VulkanExampleBase(ENABLE_VALIDATION)
 	{
 		title = "Graphics pipeline library";
 		camera.type = Camera::CameraType::lookat;
-		camera.setPosition(glm::vec3(0.0f, 0.0f, -10.5f));
+		camera.setPosition(glm::vec3(0.0f, 0.0f, -2.0f));
 		camera.setRotation(glm::vec3(-25.0f, 15.0f, 0.0f));
 		camera.setRotationSpeed(0.5f);
-		camera.setPerspective(60.0f, (float)(width / 3.0f) / (float)height, 0.1f, 256.0f);
 
 		// Enable required extensions
 		enabledInstanceExtensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
@@ -66,32 +75,14 @@ public:
 
 	~VulkanExample()
 	{
-		// Clean up used Vulkan resources
+		if (device) {
-		// Note : Inherited destructor cleans up resources stored in base class
+			for (auto pipeline : pipelines) {
-		vkDestroyPipeline(device, pipelines.phong, nullptr);
+				vkDestroyPipeline(device, pipeline, nullptr);
-		if (deviceFeatures.fillModeNonSolid)
-		{
-			vkDestroyPipeline(device, pipelines.wireframe, nullptr);
-		}
-		vkDestroyPipeline(device, pipelines.toon, nullptr);
-
-		vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
-		vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
-
-		uniformBuffer.destroy();
-	}
-
-	// Enable physical device features required for this example
-	virtual void getEnabledFeatures()
-	{
-		// Fill mode non solid is required for wireframe display
-		if (deviceFeatures.fillModeNonSolid) {
-			enabledFeatures.fillModeNonSolid = VK_TRUE;
-			// Wide lines must be present for line width > 1.0f
-			if (deviceFeatures.wideLines) {
-				enabledFeatures.wideLines = VK_TRUE;
 			}
-		};
+			vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
+			vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
+			uniformBuffer.destroy();
+		}
 	}
 
 	void buildCommandBuffers()
@@ -113,45 +104,44 @@ public:
 
 		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)
 		{
-			// Set target frame buffer
 			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);
 			scene.bindBuffers(drawCmdBuffers[i]);
 
-			// Left : Solid colored
+			// Render a viewport for each pipeline
-			viewport.width = (float)width / 3.0;
+			float w = (float)width / (float)splitX;
-			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
+			float h = (float)height / (float)splitY;
-			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.phong);
+			uint32_t idx = 0;
-			scene.draw(drawCmdBuffers[i]);
+			for (uint32_t y = 0; y < splitX; y++) {
+				for (uint32_t x = 0; x < splitY; x++) {
+					VkViewport viewport{};
+					viewport.x = w * (float)x;
+					viewport.y = h * (float)y;
+					viewport.width = w;
+					viewport.height = h;
+					viewport.minDepth = 0.0f;
+					viewport.maxDepth = 1.0f;
+					vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
 
-			// Center : Toon
+					VkRect2D scissor{};
-			viewport.x = (float)width / 3.0;
+					scissor.extent.width = (uint32_t)w;
-			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
+					scissor.extent.height = (uint32_t)h;
-			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.toon);
+					scissor.offset.x = (uint32_t)w * x;
-			// Line width > 1.0f only if wide lines feature is supported
+					scissor.offset.y = (uint32_t)h * y;
-			if (deviceFeatures.wideLines) {
+					vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);
-				vkCmdSetLineWidth(drawCmdBuffers[i], 2.0f);
-			}
-			scene.draw(drawCmdBuffers[i]);
 
-			if (deviceFeatures.fillModeNonSolid)
+					if (pipelines.size() > idx) {
-			{
+						vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines[idx]);
-				// Right : Wireframe
+						scene.draw(drawCmdBuffers[i]);
-				viewport.x = (float)width / 3.0 + (float)width / 3.0;
+					}
-				vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
+
-				vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.wireframe);
+					idx++;
-				scene.draw(drawCmdBuffers[i]);
+				}
 			}
 
 			drawUI(drawCmdBuffers[i]);
@@ -165,108 +155,58 @@ public:
 	void loadAssets()
 	{
 		const uint32_t glTFLoadingFlags = vkglTF::FileLoadingFlags::PreTransformVertices | vkglTF::FileLoadingFlags::PreMultiplyVertexColors | vkglTF::FileLoadingFlags::FlipY;
-		scene.loadFromFile(getAssetPath() + "models/treasure_smooth.gltf", vulkanDevice, queue, glTFLoadingFlags);
+		scene.loadFromFile(getAssetPath() + "models/color_teapot_spheres.gltf", vulkanDevice, queue, glTFLoadingFlags);
 	}
 
 	void setupDescriptorPool()
 	{
-		std::vector<VkDescriptorPoolSize> poolSizes =
+		std::vector<VkDescriptorPoolSize> poolSizes = {
-		{
 			vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1)
 		};
-
+		VkDescriptorPoolCreateInfo descriptorPoolInfo = vks::initializers::descriptorPoolCreateInfo(poolSizes, 2);
-		VkDescriptorPoolCreateInfo descriptorPoolInfo =
-			vks::initializers::descriptorPoolCreateInfo(
-				poolSizes.size(),
-				poolSizes.data(),
-				2);
-
 		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));
 	}
 
 	void setupDescriptorSetLayout()
 	{
-		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings =
+		std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = {
-		{
+			vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT, 0)
-			// Binding 0 : Vertex shader uniform buffer
-			vks::initializers::descriptorSetLayoutBinding(
-				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-				VK_SHADER_STAGE_VERTEX_BIT,
-				0)
 		};
-
+		VkDescriptorSetLayoutCreateInfo descriptorLayout = vks::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings);
-		VkDescriptorSetLayoutCreateInfo descriptorLayout =
-			vks::initializers::descriptorSetLayoutCreateInfo(
-				setLayoutBindings.data(),
-				setLayoutBindings.size());
-
 		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));
 
-		VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =
+		VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = vks::initializers::pipelineLayoutCreateInfo(&descriptorSetLayout, 1);
-			vks::initializers::pipelineLayoutCreateInfo(
-				&descriptorSetLayout,
-				1);
-
 		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout));
 	}
 
 	void setupDescriptorSet()
 	{
-		VkDescriptorSetAllocateInfo allocInfo =
+		VkDescriptorSetAllocateInfo allocInfo = vks::initializers::descriptorSetAllocateInfo(descriptorPool, &descriptorSetLayout, 1);
-			vks::initializers::descriptorSetAllocateInfo(
-				descriptorPool,
-				&descriptorSetLayout,
-				1);
-
 		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));
 
-		std::vector<VkWriteDescriptorSet> writeDescriptorSets =
+		std::vector<VkWriteDescriptorSet> writeDescriptorSets = {
-		{
+			vks::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &uniformBuffer.descriptor)
-			// Binding 0 : Vertex shader uniform buffer
-			vks::initializers::writeDescriptorSet(
-				descriptorSet,
-				VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-				0,
-				&uniformBuffer.descriptor)
 		};
-
+		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, nullptr);
-		vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);
 	}
 
 	// With VK_EXT_graphics_pipeline_library we don't need to create the shader module when loading it, but instead have the driver create it at linking time
 	// So we use a custom function that only loads the required shader information without actually creating the shader module
-
+	bool loadShaderFile(std::string fileName, ShaderInfo &shaderInfo)
-#if defined(__ANDROID__)
-	// Android shaders are stored as assets in the apk so they need to be loaded via the asset manager
-	bool loadShader(AAssetManager* assetManager, std::string fileName, const uint32_t** pShaderCode, size_t& shaderSize)
 	{
+#if defined(__ANDROID__)
 		// Load shader from compressed asset
-		AAsset* asset = AAssetManager_open(assetManager, fileName, AASSET_MODE_STREAMING);
+		// @todo
+		AAsset* asset = AAssetManager_open(androidApp->activity->assetManager, fileName, AASSET_MODE_STREAMING);
 		assert(asset);
 		size_t size = AAsset_getLength(asset);
 		assert(size > 0);
 
-		char* shaderCode = new char[size];
+		shaderInfo.size = size;
+		shaderInfo.code = new uint32_t[size / 4];
 		AAsset_read(asset, shaderCode, size);
 		AAsset_close(asset);
-
-		VkShaderModule shaderModule;
-		VkShaderModuleCreateInfo moduleCreateInfo;
-		moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
-		moduleCreateInfo.pNext = NULL;
-		moduleCreateInfo.codeSize = size;
-		moduleCreateInfo.pCode = (uint32_t*)shaderCode;
-		moduleCreateInfo.flags = 0;
-
-		VK_CHECK_RESULT(vkCreateShaderModule(device, &moduleCreateInfo, NULL, &shaderModule));
-
-		delete[] shaderCode;
-
-		return shaderModule;
-	}
 #else
-	bool loadShaderFile(std::string fileName, ShaderInfo &shaderInfo)
-	{
 		std::ifstream is(fileName, std::ios::binary | std::ios::in | std::ios::ate);
 
 		if (is.is_open())
@@ -279,223 +219,209 @@ public:
 			return true;
 		} else {
 			std::cerr << "Error: Could not open shader file \"" << fileName << "\"" << "\n";
+			throw std::runtime_error("Could open shader file");
 			return false;
 		}
-	}
 #endif
-
-	VkPipeline createVertexInputState(VkDevice device, VkPipelineCache vertexShaderCache, VkPipelineLayout layout)
-	{
-		VkGraphicsPipelineLibraryCreateInfoEXT libraryInfo{};
-		libraryInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
-		libraryInfo.flags = VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT;
-
-		VkPipelineVertexInputStateCreateInfo vertexInputState = *vkglTF::Vertex::getPipelineVertexInputState({ vkglTF::VertexComponent::Position, vkglTF::VertexComponent::Normal, vkglTF::VertexComponent::Color });
-		VkPipelineInputAssemblyStateCreateInfo inputAssemblyState = vks::initializers::pipelineInputAssemblyStateCreateInfo(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE);
-
-		VkGraphicsPipelineCreateInfo pipelineCI{};
-		pipelineCI.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
-		pipelineCI.pNext = &libraryInfo;
-		pipelineCI.pInputAssemblyState = &inputAssemblyState;
-		pipelineCI.pVertexInputState = &vertexInputState;
-
-		VkPipeline library = VK_NULL_HANDLE;
-		VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, vertexShaderCache, 1, &pipelineCI, nullptr, &library));
-		return library;
 	}
 
-	VkPipeline createVertexShader(VkDevice device, const ShaderInfo shaderInfo, VkPipelineCache vertexShaderCache, VkPipelineLayout layout)
+	// Create the shared pipeline parts up-front
+	void preparePipelineLibrary()
 	{
-		VkGraphicsPipelineLibraryCreateInfoEXT libraryInfo{};
+		// Create a pipeline library for the vertex input interface
-		libraryInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
+		{
-		libraryInfo.flags = VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT;
+			VkGraphicsPipelineLibraryCreateInfoEXT libraryInfo{};
+			libraryInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
+			libraryInfo.flags = VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT;
 
-		VkDynamicState vertexDynamicStates[2] = {
+			VkPipelineVertexInputStateCreateInfo vertexInputState = *vkglTF::Vertex::getPipelineVertexInputState({ vkglTF::VertexComponent::Position, vkglTF::VertexComponent::Normal, vkglTF::VertexComponent::Color });
-			VK_DYNAMIC_STATE_VIEWPORT,
+			VkPipelineInputAssemblyStateCreateInfo inputAssemblyState = vks::initializers::pipelineInputAssemblyStateCreateInfo(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE);
-			VK_DYNAMIC_STATE_SCISSOR };
 
-		VkPipelineDynamicStateCreateInfo dynamicInfo{};
+			VkGraphicsPipelineCreateInfo pipelineCI{};
-		dynamicInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+			pipelineCI.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
-		dynamicInfo.dynamicStateCount = 2;
+			pipelineCI.flags = VK_PIPELINE_CREATE_LIBRARY_BIT_KHR | VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT;
-		dynamicInfo.pDynamicStates = vertexDynamicStates;
+			pipelineCI.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+			pipelineCI.pNext = &libraryInfo;
+			pipelineCI.pInputAssemblyState = &inputAssemblyState;
+			pipelineCI.pVertexInputState = &vertexInputState;
+			VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCI, nullptr, &pipelineLibrary.vertexInputInterface));
+		}
 
-		VkPipelineViewportStateCreateInfo viewportState = {};
+		// Creata a pipeline library for the vertex shader stage
-		viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+		{
-		viewportState.viewportCount = 1;
+			VkGraphicsPipelineLibraryCreateInfoEXT libraryInfo{};
-		viewportState.scissorCount = 1;
+			libraryInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
+			libraryInfo.flags = VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT;
 
-		VkPipelineRasterizationStateCreateInfo rasterizationState = vks::initializers::pipelineRasterizationStateCreateInfo(VK_POLYGON_MODE_FILL, VK_CULL_MODE_BACK_BIT, VK_FRONT_FACE_COUNTER_CLOCKWISE, 0);
+			VkDynamicState vertexDynamicStates[2] = {
+				VK_DYNAMIC_STATE_VIEWPORT,
+				VK_DYNAMIC_STATE_SCISSOR };
 
-		VkShaderModuleCreateInfo shaderModuleCreateInfo{};
+			VkPipelineDynamicStateCreateInfo dynamicInfo{};
-		shaderModuleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+			dynamicInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
-		shaderModuleCreateInfo.codeSize = shaderInfo.size;
+			dynamicInfo.dynamicStateCount = 2;
-		shaderModuleCreateInfo.pCode = shaderInfo.code;
+			dynamicInfo.pDynamicStates = vertexDynamicStates;
 
-		VkPipelineShaderStageCreateInfo shaderStageCreateInfo{};
+			VkPipelineViewportStateCreateInfo viewportState = {};
-		shaderStageCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+			viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
-		shaderStageCreateInfo.pNext = &shaderModuleCreateInfo;
+			viewportState.viewportCount = 1;
-		shaderStageCreateInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
+			viewportState.scissorCount = 1;
-		shaderStageCreateInfo.pName = "main";
 
-		VkGraphicsPipelineCreateInfo pipelineCI{};
+			VkPipelineRasterizationStateCreateInfo rasterizationState = vks::initializers::pipelineRasterizationStateCreateInfo(VK_POLYGON_MODE_FILL, VK_CULL_MODE_BACK_BIT, VK_FRONT_FACE_COUNTER_CLOCKWISE, 0);
-		pipelineCI.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
-		pipelineCI.pNext = &libraryInfo;
-		pipelineCI.renderPass = renderPass;
-		pipelineCI.flags = VK_PIPELINE_CREATE_LIBRARY_BIT_KHR | VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT;
-		pipelineCI.stageCount = 1;
-		pipelineCI.pStages = &shaderStageCreateInfo;
-		pipelineCI.layout = layout;
-		pipelineCI.pDynamicState = &dynamicInfo;
-		pipelineCI.pViewportState = &viewportState;
-		pipelineCI.pRasterizationState = &rasterizationState;
 
-		VkPipeline library = VK_NULL_HANDLE;
+			// @todo: we can skip the pipeline shader module info and directly consume the shader module
-		VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, vertexShaderCache, 1, &pipelineCI, nullptr, &library));
+			ShaderInfo shaderInfo{};
-		return library;
+			loadShaderFile(getShadersPath() + "graphicspipelinelibrary/shared.vert.spv", shaderInfo);
+
+			VkShaderModuleCreateInfo shaderModuleCI{};
+			shaderModuleCI.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+			shaderModuleCI.codeSize = shaderInfo.size;
+			shaderModuleCI.pCode = shaderInfo.code;
+
+			VkPipelineShaderStageCreateInfo shaderStageCI{};
+			shaderStageCI.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+			shaderStageCI.pNext = &shaderModuleCI;
+			shaderStageCI.stage = VK_SHADER_STAGE_VERTEX_BIT;
+			shaderStageCI.pName = "main";
+
+			VkGraphicsPipelineCreateInfo pipelineCI{};
+			pipelineCI.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+			pipelineCI.pNext = &libraryInfo;
+			pipelineCI.renderPass = renderPass;
+			pipelineCI.flags = VK_PIPELINE_CREATE_LIBRARY_BIT_KHR | VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT;
+			pipelineCI.stageCount = 1;
+			pipelineCI.pStages = &shaderStageCI;
+			pipelineCI.layout = pipelineLayout;
+			pipelineCI.pDynamicState = &dynamicInfo;
+			pipelineCI.pViewportState = &viewportState;
+			pipelineCI.pRasterizationState = &rasterizationState;
+			VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCI, nullptr, &pipelineLibrary.preRasterizationShaders));
+		}
+
+		// Create a pipeline library for the fragment output interface
+		{
+			VkGraphicsPipelineLibraryCreateInfoEXT libraryInfo{};
+			libraryInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
+			libraryInfo.flags = VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT;
+
+			VkPipelineColorBlendAttachmentState  blendAttachmentSstate = vks::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE);
+			VkPipelineColorBlendStateCreateInfo  colorBlendState = vks::initializers::pipelineColorBlendStateCreateInfo(1, &blendAttachmentSstate);
+			VkPipelineMultisampleStateCreateInfo multisampleState = vks::initializers::pipelineMultisampleStateCreateInfo(VK_SAMPLE_COUNT_1_BIT);
+
+			VkGraphicsPipelineCreateInfo pipelineLibraryCI{};
+			pipelineLibraryCI.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+			pipelineLibraryCI.pNext = &libraryInfo;
+			pipelineLibraryCI.layout = pipelineLayout;
+			pipelineLibraryCI.renderPass = renderPass;
+			pipelineLibraryCI.pColorBlendState = &colorBlendState;
+			pipelineLibraryCI.pMultisampleState = &multisampleState;
+			VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineLibraryCI, nullptr, &pipelineLibrary.fragmentOutputInterface));
+		}
 	}
 
-	VkPipeline createFragmentShader(VkDevice device, const ShaderInfo shaderInfo, VkPipelineCache vertexShaderCache, VkPipelineLayout layout)
+	void threadFn()
 	{
+		const std::lock_guard<std::mutex> lock(mutex);
+
+		auto start = std::chrono::steady_clock::now();
+
+		prepareNewPipeline();
+		newPipelineCreated = true;
+
+		// Change viewport/draw count
+		if (pipelines.size() > splitX * splitY) {
+			splitX++;
+			splitY++;
+		}
+
+		auto delta = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - start);
+		std::cout << "Pipeline created in " << delta.count() << " microseconds\n";
+	}
+
+	// Create a new pipeline using the pipeline library and a customized fragment shader
+	// Used from a thread
+	void prepareNewPipeline()
+	{
+		// Create the fragment shader part of the pipeline library with some random options
 		VkGraphicsPipelineLibraryCreateInfoEXT libraryInfo{};
 		libraryInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
 		libraryInfo.flags = VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT;
 
 		VkPipelineDepthStencilStateCreateInfo depthStencilState = vks::initializers::pipelineDepthStencilStateCreateInfo(VK_TRUE, VK_TRUE, VK_COMPARE_OP_LESS_OR_EQUAL);
-		VkPipelineMultisampleStateCreateInfo multisampleState = vks::initializers::pipelineMultisampleStateCreateInfo(VK_SAMPLE_COUNT_1_BIT);
+		VkPipelineMultisampleStateCreateInfo  multisampleState = vks::initializers::pipelineMultisampleStateCreateInfo(VK_SAMPLE_COUNT_1_BIT);
 
-		VkShaderModuleCreateInfo shaderModuleCreateInfo{};
+		// Using the pipeline library extension, we can skip the pipeline shader module creation and directly pass the shader code to the pipeline
-		shaderModuleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+		ShaderInfo shaderInfo{};
-		shaderModuleCreateInfo.codeSize = shaderInfo.size;
+		loadShaderFile(getShadersPath() + "graphicspipelinelibrary/uber.frag.spv", shaderInfo);
-		shaderModuleCreateInfo.pCode = shaderInfo.code;
 
-		VkPipelineShaderStageCreateInfo shaderStageCreateInfo{};
+		VkShaderModuleCreateInfo shaderModuleCI{};
-		shaderStageCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+		shaderModuleCI.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
-		shaderStageCreateInfo.pNext = &shaderModuleCreateInfo;
+		shaderModuleCI.codeSize = shaderInfo.size;
-		shaderStageCreateInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
+		shaderModuleCI.pCode = shaderInfo.code;
-		shaderStageCreateInfo.pName = "main";
+
+		VkPipelineShaderStageCreateInfo shaderStageCI{};
+		shaderStageCI.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+		shaderStageCI.pNext = &shaderModuleCI;
+		shaderStageCI.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
+		shaderStageCI.pName = "main";
+
+		// Select lighting model using a specialization constant
+		srand((unsigned int)time(NULL));
+		uint32_t lighting_model = (int)(rand() % 4);
+
+		// Each shader constant of a shader stage corresponds to one map entry
+		VkSpecializationMapEntry specializationMapEntry{};
+		specializationMapEntry.constantID = 0;
+		specializationMapEntry.size = sizeof(uint32_t);
+
+		VkSpecializationInfo specializationInfo{};
+		specializationInfo.mapEntryCount = 1;
+		specializationInfo.pMapEntries = &specializationMapEntry;
+		specializationInfo.dataSize = sizeof(uint32_t);
+		specializationInfo.pData = &lighting_model;
+
+		shaderStageCI.pSpecializationInfo = &specializationInfo;
 
 		VkGraphicsPipelineCreateInfo pipelineCI{};
 		pipelineCI.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
 		pipelineCI.pNext = &libraryInfo;
 		pipelineCI.flags = VK_PIPELINE_CREATE_LIBRARY_BIT_KHR | VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT;
 		pipelineCI.stageCount = 1;
-		pipelineCI.pStages = &shaderStageCreateInfo;
+		pipelineCI.pStages = &shaderStageCI;
-		pipelineCI.layout = layout;
+		pipelineCI.layout = pipelineLayout;
 		pipelineCI.renderPass = renderPass;
 		pipelineCI.pDepthStencilState = &depthStencilState;
 		pipelineCI.pMultisampleState = &multisampleState;
+		VkPipeline fragment_shader = VK_NULL_HANDLE;
+		VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, threadPipelineCache, 1, &pipelineCI, nullptr, &fragment_shader));
 
-		VkPipeline library = VK_NULL_HANDLE;
+		// Create the pipeline using the pre-built pipeline library parts
-		VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, vertexShaderCache, 1, &pipelineCI, nullptr, &library));
+		// Except for above fragment shader part all parts have been pre-built and will be re-used
-		return library;
+		std::vector<VkPipeline> libraries = {
-	}
+			pipelineLibrary.vertexInputInterface,
+			pipelineLibrary.preRasterizationShaders,
+			fragment_shader,
+			pipelineLibrary.fragmentOutputInterface };
 
-	VkPipeline createFragmentOutputState(VkDevice device, VkPipelineCache vertexShaderCache, VkPipelineLayout layout)
+		// Link the library parts into a graphics pipeline
-	{
+		VkPipelineLibraryCreateInfoKHR pipelineLibraryCI{};
-		VkGraphicsPipelineLibraryCreateInfoEXT libraryInfo{};
+		pipelineLibraryCI.sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
-		libraryInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
+		pipelineLibraryCI.libraryCount = static_cast<uint32_t>(libraries.size());
-		libraryInfo.flags = VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT;
+		pipelineLibraryCI.pLibraries = libraries.data();
 
-		VkPipelineColorBlendAttachmentState blendAttachmentState = vks::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE);
+		// If set to true, we pass VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT which will let the implementation do additional optimizations at link time
-		VkPipelineColorBlendStateCreateInfo colorBlendState = vks::initializers::pipelineColorBlendStateCreateInfo(1, &blendAttachmentState);
+		// This trades in pipeline creation time for run-time performance
-		VkPipelineMultisampleStateCreateInfo multisampleState = vks::initializers::pipelineMultisampleStateCreateInfo(VK_SAMPLE_COUNT_1_BIT);
+		bool optimized = true;
 
-		VkGraphicsPipelineCreateInfo pipelineCI{};
+		VkGraphicsPipelineCreateInfo executablePipelineCI{};
-		pipelineCI.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+		executablePipelineCI.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
-		pipelineCI.pNext = &libraryInfo;
+		executablePipelineCI.pNext = &pipelineLibraryCI;
-		pipelineCI.flags = VK_PIPELINE_CREATE_LIBRARY_BIT_KHR | VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT;
+		executablePipelineCI.flags |= optimized ? VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT : 0;
-		pipelineCI.layout = layout;
-		pipelineCI.renderPass = renderPass;
-		pipelineCI.pColorBlendState = &colorBlendState;
-		pipelineCI.pMultisampleState = &multisampleState;
-
-		VkPipeline library = VK_NULL_HANDLE;
-		VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, vertexShaderCache, 1, &pipelineCI, nullptr, &library));
-		return library;
-	}
-
-	VkPipeline linkExecutable(VkDevice device, const std::vector<VkPipeline> libraries, VkPipelineCache executableCache, bool optimized)
-	{
-		VkPipelineLibraryCreateInfoKHR linkingInfo{};
-		linkingInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
-		linkingInfo.libraryCount = static_cast<uint32_t>(libraries.size());
-		linkingInfo.pLibraries = libraries.data();
-
-		VkGraphicsPipelineCreateInfo executablePipelineCreateInfo{};
-		executablePipelineCreateInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
-		executablePipelineCreateInfo.pNext = &linkingInfo;
-		executablePipelineCreateInfo.flags |= optimized ? VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT : 0;
 
 		VkPipeline executable = VK_NULL_HANDLE;
-		VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, executableCache, 1, &executablePipelineCreateInfo, nullptr, &executable));
+		VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, threadPipelineCache, 1, &executablePipelineCI, nullptr, &executable));
-		return executable;
-	}
 
-	void preparePipelines()
+		pipelines.push_back(executable);
-	{
-		struct Shaders {
-			ShaderInfo phongVS;
-			ShaderInfo phongFS;
-		} shaders;		
-		loadShaderFile(getShadersPath() + "pipelines/phong.vert.spv", shaders.phongVS);
-		loadShaderFile(getShadersPath() + "pipelines/phong.frag.spv", shaders.phongFS);
-		VkPipelineShaderStageCreateInfo vsShader = loadShader(getShadersPath() + "pipelines/phong.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
-		VkPipelineShaderStageCreateInfo fsShader = loadShader(getShadersPath() + "pipelines/phong.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
-		std::vector<VkPipeline> libraries = {
-			createVertexInputState(device, pipelineCache, pipelineLayout),
-			createVertexShader(device, shaders.phongVS, pipelineCache, pipelineLayout),
-			createFragmentShader(device, shaders.phongFS, pipelineCache, pipelineLayout),
-			createFragmentOutputState(device, pipelineCache, pipelineLayout),
-		};
-		VkPipeline compiledPipeline = linkExecutable(device, libraries, pipelineCache, true);
-
-		VkPipelineInputAssemblyStateCreateInfo inputAssemblyState = vks::initializers::pipelineInputAssemblyStateCreateInfo(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE);
-		VkPipelineRasterizationStateCreateInfo rasterizationState = vks::initializers::pipelineRasterizationStateCreateInfo(VK_POLYGON_MODE_FILL, VK_CULL_MODE_BACK_BIT, VK_FRONT_FACE_COUNTER_CLOCKWISE, 0);
-		VkPipelineColorBlendAttachmentState blendAttachmentState = vks::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE);
-		VkPipelineColorBlendStateCreateInfo colorBlendState = vks::initializers::pipelineColorBlendStateCreateInfo(1, &blendAttachmentState);
-		VkPipelineDepthStencilStateCreateInfo depthStencilState = vks::initializers::pipelineDepthStencilStateCreateInfo(VK_TRUE, VK_TRUE, VK_COMPARE_OP_LESS_OR_EQUAL);
-		VkPipelineViewportStateCreateInfo viewportState = vks::initializers::pipelineViewportStateCreateInfo(1, 1, 0);
-		VkPipelineMultisampleStateCreateInfo multisampleState = vks::initializers::pipelineMultisampleStateCreateInfo(VK_SAMPLE_COUNT_1_BIT);
-		std::vector<VkDynamicState> dynamicStateEnables = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_LINE_WIDTH, };
-		VkPipelineDynamicStateCreateInfo dynamicState = vks::initializers::pipelineDynamicStateCreateInfo(dynamicStateEnables);
-		std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
-
-		VkGraphicsPipelineCreateInfo pipelineCI = vks::initializers::pipelineCreateInfo(pipelineLayout, renderPass);
-		pipelineCI.pInputAssemblyState = &inputAssemblyState;
-		pipelineCI.pRasterizationState = &rasterizationState;
-		pipelineCI.pColorBlendState = &colorBlendState;
-		pipelineCI.pMultisampleState = &multisampleState;
-		pipelineCI.pViewportState = &viewportState;
-		pipelineCI.pDepthStencilState = &depthStencilState;
-		pipelineCI.pDynamicState = &dynamicState;
-		pipelineCI.stageCount = shaderStages.size();
-		pipelineCI.pStages = shaderStages.data();
-		pipelineCI.pVertexInputState  = vkglTF::Vertex::getPipelineVertexInputState({vkglTF::VertexComponent::Position, vkglTF::VertexComponent::Normal, vkglTF::VertexComponent::Color});
-
-		// Create the graphics pipeline state objects
-
-		// Textured pipeline
-		// Phong shading pipeline
-		//shaderStages[0] = loadShader(getShadersPath() + "pipelines/phong.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
-		//shaderStages[1] = loadShader(getShadersPath() + "pipelines/phong.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
-		//VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCI, nullptr, &pipelines.phong));
-
-		pipelines.phong = compiledPipeline;
-
-		// Toon shading pipeline
-		shaderStages[0] = loadShader(getShadersPath() + "pipelines/toon.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
-		shaderStages[1] = loadShader(getShadersPath() + "pipelines/toon.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
-		VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCI, nullptr, &pipelines.toon));
-
-		// Pipeline for wire frame rendering
-		// Non solid rendering is not a mandatory Vulkan feature
-		if (deviceFeatures.fillModeNonSolid)
-		{
-			rasterizationState.polygonMode = VK_POLYGON_MODE_LINE;
-			shaderStages[0] = loadShader(getShadersPath() + "pipelines/wireframe.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
-			shaderStages[1] = loadShader(getShadersPath() + "pipelines/wireframe.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
-			VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCI, nullptr, &pipelines.wireframe));
-		}
 	}
 
 	// Prepare and initialize uniform buffer containing shader uniforms
@@ -516,8 +442,12 @@ public:
 
 	void updateUniformBuffers()
 	{
+		if (!paused) {
+			rotation += frameTimer * 0.1f;
+		}
+		camera.setPerspective(45.0f, ((float)width / (float)splitX) / ((float)height / (float)splitY), 0.1f, 256.0f);
 		uboVS.projection = camera.matrices.perspective;
-		uboVS.modelView = camera.matrices.view;
+		uboVS.modelView = camera.matrices.view * glm::rotate(glm::mat4(1.0f), glm::radians(rotation * 360.0f), glm::vec3(0.0f, 1.0f, 0.0f));
 		memcpy(uniformBuffer.mapped, &uboVS, sizeof(uboVS));
 	}
 
@@ -538,10 +468,20 @@ public:
 		loadAssets();
 		prepareUniformBuffers();
 		setupDescriptorSetLayout();
-		preparePipelines();
+		preparePipelineLibrary();
 		setupDescriptorPool();
 		setupDescriptorSet();
 		buildCommandBuffers();
+
+		// Create a separate pipeline cache for the pipeline creation thread
+		VkPipelineCacheCreateInfo pipelineCachCI = {};
+		pipelineCachCI.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
+		vkCreatePipelineCache(device, &pipelineCachCI, nullptr, &threadPipelineCache);
+
+		// Create first pipeline using a background thread
+		std::thread pipelineGenerationThread(&VulkanExample::threadFn, this);
+		pipelineGenerationThread.detach();
+
 		prepared = true;
 	}
 
@@ -549,18 +489,22 @@ public:
 	{
 		if (!prepared)
 			return;
-		draw();
+		if (newPipelineCreated)
-		if (camera.updated) {
+		{
-			updateUniformBuffers();
+			newPipelineCreated = false;
+			vkQueueWaitIdle(queue);
+			buildCommandBuffers();
 		}
+		draw();
+		updateUniformBuffers();
 	}
 
 	virtual void OnUpdateUIOverlay(vks::UIOverlay *overlay)
 	{
-		if (!deviceFeatures.fillModeNonSolid) {
+		if (overlay->button("New pipeline")) {
-			if (overlay->header("Info")) {
+			// Spwan a thread to create a new pipeline in the background
-				overlay->text("Non solid fill modes not supported!");
+			std::thread pipelineGenerationThread(&VulkanExample::threadFn, this);
-			}
+			pipelineGenerationThread.detach();
 		}
 	}
 };