Context Navigation

source: opengl-game/vulkan-ref.cpp@ b794178

feature/imgui-sdl points-test

Last change on this file since b794178 was b794178, checked in by Dmitry Portnoy <dmitry.portnoy@…>, 5 years ago
In vulkangame, add the ability to create vulkan resoirces and descriptor sets for shader uniforms (images and ubos)
Property mode set to `100644`
File size: 85.7 KB

Rev	Line
[f00ee54]	1	#define STB_IMAGE_IMPLEMENTATION
	2	#include "stb_image.h" // TODO: Probably switch to SDL_image
[826df16]	3
	4	//#define _USE_MATH_DEFINES // Will be needed when/if I need to # include <cmath>
[03f4c64]	5
	6	#define GLM_FORCE_RADIANS
[fba08f2]	7	#define GLM_FORCE_DEPTH_ZERO_TO_ONE
[f00ee54]	8
[80edd70]	9	#include <glm/glm.hpp>
[de32fda]	10	#include <glm/gtc/matrix_transform.hpp>
[03f4c64]	11
	12	#include <iostream>
[80edd70]	13	#include <fstream>
	14	#include <algorithm>
	15	#include <vector>
	16	#include <array>
[0e6ecf3]	17	#include <set>
[80edd70]	18	#include <optional>
[de32fda]	19	#include <chrono>
[03f4c64]	20
[7fc5e27]	21	#include "consts.hpp"
[203ab1b]	22	#include "utils.hpp"
[03f4c64]	23
[f00ee54]	24	#include "game-gui-sdl.hpp"
	25
	26	using namespace std;
	27	using namespace glm;
[e1a7f5a]	28
[826df16]	29	const int SCREEN_WIDTH = 800;
	30	const int SCREEN_HEIGHT = 600;
	31
[47bff4c]	32	const int MAX_FRAMES_IN_FLIGHT = 2;
	33
[90a424f]	34	/* START OF REFACTORED CODE */
[826df16]	35	#ifdef NDEBUG
	36	const bool enableValidationLayers = false;
	37	#else
	38	const bool enableValidationLayers = true;
	39	#endif
	40
[bfd620e]	41	const vector<const char*> validationLayers = {
	42	"VK_LAYER_KHRONOS_validation"
	43	};
	44
	45	const vector<const char*> deviceExtensions = {
	46	VK_KHR_SWAPCHAIN_EXTENSION_NAME
	47	};
	48
[909b51a]	49	struct QueueFamilyIndices {
	50	optional<uint32_t> graphicsFamily;
[b3671b5]	51	optional<uint32_t> presentFamily;
[909b51a]	52
	53	bool isComplete() {
[b3671b5]	54	return graphicsFamily.has_value() && presentFamily.has_value();
[909b51a]	55	}
	56	};
	57
[bfd620e]	58	struct SwapChainSupportDetails {
	59	VkSurfaceCapabilitiesKHR capabilities;
	60	vector<VkSurfaceFormatKHR> formats;
	61	vector<VkPresentModeKHR> presentModes;
	62	};
	63
[80edd70]	64	struct Vertex {
[adcd252]	65	glm::vec3 pos;
[80edd70]	66	glm::vec3 color;
[fba08f2]	67	glm::vec2 texCoord;
[f00ee54]	68	};
[80edd70]	69
[f00ee54]	70	struct OverlayVertex {
	71	glm::vec3 pos;
	72	glm::vec2 texCoord;
[80edd70]	73	};
[5b02676]	74	/* END OF REFACTORED CODE */
[80edd70]	75
[de32fda]	76	struct UniformBufferObject {
[f00ee54]	77	alignas(16) mat4 model;
	78	alignas(16) mat4 view;
	79	alignas(16) mat4 proj;
[de32fda]	80	};
	81
[b794178]	82	/* START OF REFACTORED CODE */
[721e8be]	83	struct DescriptorInfo {
	84	VkDescriptorType type;
	85	VkShaderStageFlags stageFlags;
	86
	87	vector<VkDescriptorBufferInfo>* bufferDataList;
	88	VkDescriptorImageInfo* imageData;
	89	};
[b794178]	90	/* END OF REFACTORED CODE */
[721e8be]	91
[b8b32bd]	92	struct GraphicsPipelineInfo {
[b794178]	93	/* START OF REFACTORED CODE */
[d22ae72]	94	VkPipelineLayout pipelineLayout;
[b8b32bd]	95	VkPipeline pipeline;
	96
[f00ee54]	97	VkVertexInputBindingDescription bindingDescription;
	98	vector<VkVertexInputAttributeDescription> attributeDescriptions;
	99
[721e8be]	100	vector<DescriptorInfo> descriptorInfoList;
	101
[d22ae72]	102	VkDescriptorPool descriptorPool;
	103	VkDescriptorSetLayout descriptorSetLayout;
	104	vector<VkDescriptorSet> descriptorSets;
[b794178]	105	/* END OF REFACTORED CODE */
[d22ae72]	106
[f00ee54]	107	size_t numVertices; // Currently unused
[7563b8a]	108	size_t vertexCapacity;
[c8b0357]	109	VkBuffer vertexBuffer;
	110	VkDeviceMemory vertexBufferMemory;
	111
[f00ee54]	112	size_t numIndices;
[7563b8a]	113	size_t indexCapacity;
[c8b0357]	114	VkBuffer indexBuffer;
	115	VkDeviceMemory indexBufferMemory;
[80edd70]	116	};
	117
[cabdd5c]	118	/* START OF REFACTORED CODE */
[b6127d2]	119	VkResult CreateDebugUtilsMessengerEXT(VkInstance instance,
	120	const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
	121	const VkAllocationCallbacks* pAllocator,
	122	VkDebugUtilsMessengerEXT* pDebugMessenger) {
[621664a]	123	auto func = (PFN_vkCreateDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
[b6127d2]	124
	125	if (func != nullptr) {
	126	return func(instance, pCreateInfo, pAllocator, pDebugMessenger);
	127	} else {
	128	return VK_ERROR_EXTENSION_NOT_PRESENT;
	129	}
	130	}
	131
[80de39d]	132	void DestroyDebugUtilsMessengerEXT(VkInstance instance,
	133	VkDebugUtilsMessengerEXT debugMessenger,
	134	const VkAllocationCallbacks* pAllocator) {
[621664a]	135	auto func = (PFN_vkDestroyDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
[80de39d]	136
	137	if (func != nullptr) {
	138	func(instance, debugMessenger, pAllocator);
	139	}
	140	}
	141
[826df16]	142	class VulkanGame {
	143	public:
	144	void run() {
	145	if (initWindow() == RTWO_ERROR) {
	146	return;
	147	}
	148	initVulkan();
	149	mainLoop();
	150	cleanup();
	151	}
[621664a]	152
[826df16]	153	private:
[98f3232]	154	GameGui* gui = new GameGui_SDL();
[cabdd5c]	155
[c8c6da8]	156	SDL_version sdlVersion;
[80de39d]	157	SDL_Window* window = nullptr;
[5f3dba8]	158	SDL_Renderer* gRenderer = nullptr;
	159	SDL_Texture* uiOverlay = nullptr;
[b794178]	160	/* END OF REFACTORED CODE */
[5f3dba8]	161
	162	TTF_Font* gFont = nullptr;
	163	SDL_Texture* uiText = nullptr;
	164	SDL_Texture* uiImage = nullptr;
	165
[cabdd5c]	166	/* START OF REFACTORED CODE */
[826df16]	167	VkInstance instance;
[b6127d2]	168	VkDebugUtilsMessengerEXT debugMessenger;
[b3671b5]	169	VkSurfaceKHR surface;
[5f3dba8]	170
[909b51a]	171	VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
	172	VkDevice device;
[b3671b5]	173
[909b51a]	174	VkQueue graphicsQueue;
[b3671b5]	175	VkQueue presentQueue;
[826df16]	176
[bfd620e]	177	VkSwapchainKHR swapChain;
	178	vector<VkImage> swapChainImages;
	179	VkFormat swapChainImageFormat;
[5b02676]	180	/* END OF REFACTORED CODE */
[771b33a]	181	// (This was taken out of vulkan-game for now and replaced with Viewport)
[b794178]	182	// It will definitely be needed when creating command buffers and I could use it in a few other places
	183	// TODO: Check above ^
[771b33a]	184	VkExtent2D swapChainExtent;
[5b02676]	185	/* START OF REFACTORED CODE */
[bfd620e]	186	vector<VkImageView> swapChainImageViews;
[f94eea9]	187	/* END OF REFACTORED CODE */
[621664a]	188	vector<VkFramebuffer> swapChainFramebuffers;
	189
[6fc24c7]	190	/* START OF REFACTORED CODE */
[be34c9a]	191	VkRenderPass renderPass;
[1187ef5]	192
[f5d5686]	193	VkCommandPool commandPool;
[fa9fa1c]	194	/* END OF REFACTORED CODE */
[1187ef5]	195	vector<VkCommandBuffer> commandBuffers;
	196
[b794178]	197	/* START OF REFACTORED CODE */
[1187ef5]	198	// The images and the sampler are used to store data for specific attributes. I probably
	199	// want to keep them separate from the GraphicsPipelineInfo objects and start passing
	200	// references to them once I start defining uniform and varying attributes in GraphicsPipelineInfo objects
[f5d5686]	201
[adcd252]	202	VkImage depthImage;
	203	VkDeviceMemory depthImageMemory;
	204	VkImageView depthImageView;
[b794178]	205	/* END OF REFACTORED CODE */
[adcd252]	206
[f5d5686]	207	VkImage textureImage;
	208	VkDeviceMemory textureImageMemory;
[fba08f2]	209	VkImageView textureImageView;
[69dccfe]	210
[e1a7f5a]	211	VkImage sdlOverlayImage;
	212	VkDeviceMemory sdlOverlayImageMemory;
	213	VkImageView sdlOverlayImageView;
	214
[b794178]	215	/* START OF REFACTORED CODE */
[fba08f2]	216	VkSampler textureSampler;
[f5d5686]	217
[1187ef5]	218	// These are currently to store the MVP matrix
	219	// I should figure out if it makes sense to use them for other uniforms in the future
[b794178]	220	// If not, I should rename them to better indicate their purpose.
[1187ef5]	221	// I should also decide if I can use these for all shaders, or if I need a separapte set of buffers for each one
[de32fda]	222	vector<VkBuffer> uniformBuffers;
	223	vector<VkDeviceMemory> uniformBuffersMemory;
[b794178]	224	/* END OF REFACTORED CODE */
[de32fda]	225
[721e8be]	226	VkDescriptorImageInfo sceneImageInfo;
	227	VkDescriptorImageInfo overlayImageInfo;
	228
[b794178]	229	/* START OF REFACTORED CODE */
[721e8be]	230	vector<VkDescriptorBufferInfo> uniformBufferInfoList;
[b794178]	231	/* END OF REFACTORED CODE */
[721e8be]	232
[1187ef5]	233	GraphicsPipelineInfo scenePipeline;
	234	GraphicsPipelineInfo overlayPipeline;
[47bff4c]	235
	236	vector<VkSemaphore> imageAvailableSemaphores;
	237	vector<VkSemaphore> renderFinishedSemaphores;
	238	vector<VkFence> inFlightFences;
	239
	240	size_t currentFrame = 0;
[ebeb3aa]	241
[7563b8a]	242	size_t numPlanes = 0; // temp
	243
[0e09340]	244	/* START OF REFACTORED CODE */
[75108ef]	245	bool framebufferResized = false;
	246
[826df16]	247	bool initWindow() {
[7fc5e27]	248	if (gui->init() == RTWO_ERROR) {
[826df16]	249	cout << "UI library could not be initialized!" << endl;
[5f3dba8]	250	cout << SDL_GetError() << endl;
[826df16]	251	return RTWO_ERROR;
[5f3dba8]	252	}
	253	cout << "GUI init succeeded" << endl;
[826df16]	254
[91c89f7]	255	window = (SDL_Window*) gui->createWindow("Vulkan Game", SCREEN_WIDTH, SCREEN_HEIGHT, true);
[5f3dba8]	256	if (window == nullptr) {
	257	cout << "Window could not be created!" << endl;
	258	return RTWO_ERROR;
	259	}
	260
	261	gRenderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED \| SDL_RENDERER_PRESENTVSYNC);
	262	if (gRenderer == nullptr) {
	263	cout << "Renderer could not be created! SDL Error: " << SDL_GetError() << endl;
	264	return RTWO_ERROR;
	265	}
	266
[c8c6da8]	267	SDL_VERSION(&sdlVersion);
	268
	269	// In SDL 2.0.10 (currently, the latest), SDL_TEXTUREACCESS_TARGET is required to get a transparent overlay working
	270	// However, the latest SDL version available through homebrew on Mac is 2.0.9, which requires SDL_TEXTUREACCESS_STREAMING
	271	// I tried building sdl 2.0.10 (and sdl_image and sdl_ttf) from source on Mac, but had some issues, so this is easier
	272	// until the homebrew recipe is updated
	273	if (sdlVersion.major == 2 && sdlVersion.minor == 0 && sdlVersion.patch == 9) {
	274	uiOverlay = SDL_CreateTexture(gRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STREAMING, SCREEN_WIDTH, SCREEN_HEIGHT);
	275	} else {
	276	uiOverlay = SDL_CreateTexture(gRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, SCREEN_WIDTH, SCREEN_HEIGHT);
	277	}
	278
[5f3dba8]	279	if (uiOverlay == nullptr) {
	280	cout << "Unable to create blank texture! SDL Error: " << SDL_GetError() << endl;
	281	}
	282	if (SDL_SetTextureBlendMode(uiOverlay, SDL_BLENDMODE_BLEND) != 0) {
	283	cout << "Unable to set texture blend mode! SDL Error: " << SDL_GetError() << endl;
	284	}
[b794178]	285	/* END OF REFACTORED CODE */
[5f3dba8]	286
	287	gFont = TTF_OpenFont("fonts/lazy.ttf", 28);
	288	if (gFont == nullptr) {
	289	cout << "Failed to load lazy font! SDL_ttf Error: " << TTF_GetError() << endl;
	290	return RTWO_ERROR;
	291	}
	292
	293	SDL_Color textColor = { 0, 0, 0 };
	294
	295	SDL_Surface* textSurface = TTF_RenderText_Solid(gFont, "Great sucess!", textColor);
	296	if (textSurface == nullptr) {
	297	cout << "Unable to render text surface! SDL_ttf Error: " << TTF_GetError() << endl;
	298	return RTWO_ERROR;
	299	}
	300
	301	uiText = SDL_CreateTextureFromSurface(gRenderer, textSurface);
	302	if (uiText == nullptr) {
	303	cout << "Unable to create texture from rendered text! SDL Error: " << SDL_GetError() << endl;
	304	SDL_FreeSurface(textSurface);
	305	return RTWO_ERROR;
	306	}
	307
	308	SDL_FreeSurface(textSurface);
	309
	310	// TODO: Load a PNG instead
	311	SDL_Surface* uiImageSurface = SDL_LoadBMP("assets/images/spaceship.bmp");
	312	if (uiImageSurface == nullptr) {
	313	cout << "Unable to load image " << "spaceship.bmp" << "! SDL Error: " << SDL_GetError() << endl;
	314	return RTWO_ERROR;
[826df16]	315	}
[5f3dba8]	316
	317	uiImage = SDL_CreateTextureFromSurface(gRenderer, uiImageSurface);
	318	if (uiImage == nullptr) {
	319	cout << "Unable to create texture from BMP surface! SDL Error: " << SDL_GetError() << endl;
	320	SDL_FreeSurface(uiImageSurface);
	321	return RTWO_ERROR;
	322	}
	323
	324	SDL_FreeSurface(uiImageSurface);
	325
	326	return RTWO_SUCCESS;
[826df16]	327	}
	328
[cabdd5c]	329	/* START OF REFACTORED CODE */
[826df16]	330	void initVulkan() {
	331	createInstance();
[7dcd925]	332	setupDebugMessenger();
[b3671b5]	333	createSurface();
[909b51a]	334	pickPhysicalDevice();
	335	createLogicalDevice();
[bfd620e]	336	createSwapChain();
	337	createImageViews();
[be34c9a]	338	createRenderPass();
[d22ae72]	339
[47bff4c]	340	createCommandPool();
[fa9fa1c]	341	/* END OF REFACTORED CODE */
[1187ef5]	342
[69dccfe]	343	createImageResources("textures/texture.jpg", textureImage, textureImageMemory, textureImageView);
[b794178]	344	/* START OF REFACTORED CODE */
[e1a7f5a]	345	createImageResourcesFromSDLTexture(uiOverlay, sdlOverlayImage, sdlOverlayImageMemory, sdlOverlayImageView);
[fba08f2]	346	createTextureSampler();
[c8b0357]	347
[721e8be]	348	sceneImageInfo = {};
	349	sceneImageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
	350	sceneImageInfo.imageView = textureImageView;
	351	sceneImageInfo.sampler = textureSampler;
	352
	353	overlayImageInfo = {};
	354	overlayImageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
	355	overlayImageInfo.imageView = sdlOverlayImageView;
	356	overlayImageInfo.sampler = textureSampler;
[b794178]	357	/* END OF REFACTORED CODE */
[721e8be]	358
[a0da009]	359	// SHADER-SPECIFIC STUFF STARTS HERE
	360
[f00ee54]	361	vector<Vertex> sceneVertices = {
[c8b0357]	362	{{-0.5f, -0.5f, -0.5f}, {1.0f, 0.0f, 0.0f}, {0.0f, 1.0f}},
	363	{{ 0.5f, -0.5f, -0.5f}, {0.0f, 1.0f, 0.0f}, {1.0f, 1.0f}},
	364	{{ 0.5f, 0.5f, -0.5f}, {0.0f, 0.0f, 1.0f}, {1.0f, 0.0f}},
	365	{{-0.5f, 0.5f, -0.5f}, {1.0f, 1.0f, 1.0f}, {0.0f, 0.0f}},
	366
	367	{{-0.5f, -0.5f, 0.0f}, {1.0f, 0.0f, 0.0f}, {0.0f, 1.0f}},
	368	{{ 0.5f, -0.5f, 0.0f}, {0.0f, 1.0f, 0.0f}, {1.0f, 1.0f}},
	369	{{ 0.5f, 0.5f, 0.0f}, {0.0f, 0.0f, 1.0f}, {1.0f, 0.0f}},
	370	{{-0.5f, 0.5f, 0.0f}, {1.0f, 1.0f, 1.0f}, {0.0f, 0.0f}}
[f00ee54]	371	};
	372	vector<uint16_t> sceneIndices = {
[e5d4aca]	373	0, 1, 2, 2, 3, 0,
	374	4, 5, 6, 6, 7, 4
[f00ee54]	375	};
	376
	377	initGraphicsPipelineInfo(scenePipeline,
	378	sceneVertices.data(), sizeof(Vertex), sceneVertices.size(),
	379	sceneIndices.data(), sizeof(uint16_t), sceneIndices.size());
	380
[5b02676]	381	/* START OF REFACTORED CODE */
[f00ee54]	382	addAttributeDescription(scenePipeline, VK_FORMAT_R32G32B32_SFLOAT, offset_of(&Vertex::pos));
	383	addAttributeDescription(scenePipeline, VK_FORMAT_R32G32B32_SFLOAT, offset_of(&Vertex::color));
	384	addAttributeDescription(scenePipeline, VK_FORMAT_R32G32_SFLOAT, offset_of(&Vertex::texCoord));
	385
[721e8be]	386	addDescriptorInfo(scenePipeline, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT, &uniformBufferInfoList, nullptr);
	387	addDescriptorInfo(scenePipeline, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr, &sceneImageInfo);
	388
	389	createDescriptorSetLayout(scenePipeline);
[b794178]	390	/* END OF REFACTORED CODE */
[c8b0357]	391
[7563b8a]	392	numPlanes = 2;
[f00ee54]	393
	394	vector<OverlayVertex> overlayVertices = {
	395	{{-1.0f, 1.0f, 0.0f}, {0.0f, 1.0f}},
	396	{{ 1.0f, 1.0f, 0.0f}, {1.0f, 1.0f}},
	397	{{ 1.0f, -1.0f, 0.0f}, {1.0f, 0.0f}},
	398	{{-1.0f, -1.0f, 0.0f}, {0.0f, 0.0f}}
	399	};
	400	vector<uint16_t> overlayIndices = {
	401	0, 1, 2, 2, 3, 0
	402	};
	403
	404	initGraphicsPipelineInfo(overlayPipeline,
	405	overlayVertices.data(), sizeof(OverlayVertex), overlayVertices.size(),
	406	overlayIndices.data(), sizeof(uint16_t), overlayIndices.size());
	407
[5b02676]	408	/* START OF REFACTORED CODE */
[f00ee54]	409	addAttributeDescription(overlayPipeline, VK_FORMAT_R32G32B32_SFLOAT, offset_of(&OverlayVertex::pos));
	410	addAttributeDescription(overlayPipeline, VK_FORMAT_R32G32_SFLOAT, offset_of(&OverlayVertex::texCoord));
	411
[721e8be]	412	addDescriptorInfo(overlayPipeline, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr, &overlayImageInfo);
	413
	414	createDescriptorSetLayout(overlayPipeline);
[b794178]	415	/* END OF REFACTORED CODE */
[c8b0357]	416
[e5d4aca]	417	createBufferResources();
[d22ae72]	418
[47bff4c]	419	createSyncObjects();
[826df16]	420	}
	421
	422	void createInstance() {
[b6127d2]	423	if (enableValidationLayers && !checkValidationLayerSupport()) {
	424	throw runtime_error("validation layers requested, but not available!");
	425	}
	426
[826df16]	427	VkApplicationInfo appInfo = {};
	428	appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
	429	appInfo.pApplicationName = "Vulkan Game";
	430	appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
	431	appInfo.pEngineName = "No Engine";
	432	appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
	433	appInfo.apiVersion = VK_API_VERSION_1_0;
	434
	435	VkInstanceCreateInfo createInfo = {};
	436	createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
	437	createInfo.pApplicationInfo = &appInfo;
	438
[a8f0577]	439	vector<const char*> extensions = getRequiredExtensions();
[b6127d2]	440	createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
	441	createInfo.ppEnabledExtensionNames = extensions.data();
[826df16]	442
[8667f76]	443	cout << endl << "Extensions:" << endl;
[b3671b5]	444	for (const char* extensionName : extensions) {
	445	cout << extensionName << endl;
	446	}
	447	cout << endl;
	448
[80de39d]	449	VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo;
[b6127d2]	450	if (enableValidationLayers) {
	451	createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
	452	createInfo.ppEnabledLayerNames = validationLayers.data();
[80de39d]	453
	454	populateDebugMessengerCreateInfo(debugCreateInfo);
	455	createInfo.pNext = &debugCreateInfo;
[b6127d2]	456	} else {
	457	createInfo.enabledLayerCount = 0;
[80de39d]	458
	459	createInfo.pNext = nullptr;
[b6127d2]	460	}
[826df16]	461
	462	if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) {
	463	throw runtime_error("failed to create instance!");
	464	}
	465	}
	466
[621664a]	467	bool checkValidationLayerSupport() {
	468	uint32_t layerCount;
	469	vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
	470
	471	vector<VkLayerProperties> availableLayers(layerCount);
	472	vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
	473
	474	for (const char* layerName : validationLayers) {
	475	bool layerFound = false;
	476
	477	for (const auto& layerProperties : availableLayers) {
	478	if (strcmp(layerName, layerProperties.layerName) == 0) {
	479	layerFound = true;
	480	break;
	481	}
	482	}
	483
	484	if (!layerFound) {
	485	return false;
	486	}
	487	}
	488
	489	return true;
	490	}
	491
[cabdd5c]	492	/* START OF REFACTORED CODE */
[621664a]	493	vector<const char*> getRequiredExtensions() {
[7fc5e27]	494	vector<const char*> extensions = gui->getRequiredExtensions();
[621664a]	495
	496	if (enableValidationLayers) {
	497	extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
	498	}
	499
	500	return extensions;
	501	}
	502
[80de39d]	503	void setupDebugMessenger() {
	504	if (!enableValidationLayers) return;
	505
	506	VkDebugUtilsMessengerCreateInfoEXT createInfo;
	507	populateDebugMessengerCreateInfo(createInfo);
[b6127d2]	508
	509	if (CreateDebugUtilsMessengerEXT(instance, &createInfo, nullptr, &debugMessenger) != VK_SUCCESS) {
[621664a]	510	throw runtime_error("failed to set up debug messenger!");
[b6127d2]	511	}
	512	}
	513
[621664a]	514	void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo) {
	515	createInfo = {};
	516	createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
	517	createInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT \| VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT \| VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
	518	createInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT \| VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT \| VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
	519	createInfo.pfnUserCallback = debugCallback;
	520	}
	521
[b3671b5]	522	void createSurface() {
[7fc5e27]	523	if (gui->createVulkanSurface(instance, &surface) == RTWO_ERROR) {
[b3671b5]	524	throw runtime_error("failed to create window surface!");
	525	}
	526	}
	527
[909b51a]	528	void pickPhysicalDevice() {
	529	uint32_t deviceCount = 0;
	530	vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
	531
	532	if (deviceCount == 0) {
	533	throw runtime_error("failed to find GPUs with Vulkan support!");
	534	}
	535
	536	vector<VkPhysicalDevice> devices(deviceCount);
	537	vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());
	538
	539	cout << endl << "Graphics cards:" << endl;
	540	for (const VkPhysicalDevice& device : devices) {
	541	if (isDeviceSuitable(device)) {
	542	physicalDevice = device;
	543	break;
	544	}
	545	}
	546	cout << endl;
	547
	548	if (physicalDevice == VK_NULL_HANDLE) {
	549	throw runtime_error("failed to find a suitable GPU!");
	550	}
	551	}
	552
	553	bool isDeviceSuitable(VkPhysicalDevice device) {
	554	VkPhysicalDeviceProperties deviceProperties;
	555	vkGetPhysicalDeviceProperties(device, &deviceProperties);
	556
	557	cout << "Device: " << deviceProperties.deviceName << endl;
	558
	559	QueueFamilyIndices indices = findQueueFamilies(device);
[bfd620e]	560	bool extensionsSupported = checkDeviceExtensionSupport(device);
	561	bool swapChainAdequate = false;
	562
	563	if (extensionsSupported) {
	564	SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device);
	565	swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();
	566	}
	567
[fba08f2]	568	VkPhysicalDeviceFeatures supportedFeatures;
	569	vkGetPhysicalDeviceFeatures(device, &supportedFeatures);
	570
	571	return indices.isComplete() && extensionsSupported && swapChainAdequate && supportedFeatures.samplerAnisotropy;
[bfd620e]	572	}
	573
	574	bool checkDeviceExtensionSupport(VkPhysicalDevice device) {
	575	uint32_t extensionCount;
	576	vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);
	577
	578	vector<VkExtensionProperties> availableExtensions(extensionCount);
	579	vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, availableExtensions.data());
	580
	581	set<string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());
	582
	583	for (const auto& extension : availableExtensions) {
	584	requiredExtensions.erase(extension.extensionName);
	585	}
	586
	587	return requiredExtensions.empty();
[909b51a]	588	}
	589
	590	void createLogicalDevice() {
	591	QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
	592
[b3671b5]	593	vector<VkDeviceQueueCreateInfo> queueCreateInfos;
	594	set<uint32_t> uniqueQueueFamilies = {indices.graphicsFamily.value(), indices.presentFamily.value()};
[909b51a]	595
	596	float queuePriority = 1.0f;
[b3671b5]	597	for (uint32_t queueFamily : uniqueQueueFamilies) {
	598	VkDeviceQueueCreateInfo queueCreateInfo = {};
	599	queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
	600	queueCreateInfo.queueFamilyIndex = queueFamily;
	601	queueCreateInfo.queueCount = 1;
	602	queueCreateInfo.pQueuePriorities = &queuePriority;
	603
	604	queueCreateInfos.push_back(queueCreateInfo);
	605	}
[909b51a]	606
	607	VkPhysicalDeviceFeatures deviceFeatures = {};
[fba08f2]	608	deviceFeatures.samplerAnisotropy = VK_TRUE;
[909b51a]	609
	610	VkDeviceCreateInfo createInfo = {};
	611	createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
[621664a]	612	createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
[b3671b5]	613	createInfo.pQueueCreateInfos = queueCreateInfos.data();
[909b51a]	614
	615	createInfo.pEnabledFeatures = &deviceFeatures;
	616
[bfd620e]	617	createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
	618	createInfo.ppEnabledExtensionNames = deviceExtensions.data();
[909b51a]	619
	620	// These fields are ignored by up-to-date Vulkan implementations,
	621	// but it's a good idea to set them for backwards compatibility
	622	if (enableValidationLayers) {
	623	createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
	624	createInfo.ppEnabledLayerNames = validationLayers.data();
	625	} else {
	626	createInfo.enabledLayerCount = 0;
	627	}
	628
	629	if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS) {
	630	throw runtime_error("failed to create logical device!");
	631	}
	632
	633	vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
[b3671b5]	634	vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
[909b51a]	635	}
	636
[621664a]	637	void createSwapChain() {
	638	SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice);
[a8f0577]	639
[621664a]	640	VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
	641	VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
	642	VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities);
[a8f0577]	643
[621664a]	644	uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
	645	if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount) {
	646	imageCount = swapChainSupport.capabilities.maxImageCount;
[a8f0577]	647	}
	648
[621664a]	649	VkSwapchainCreateInfoKHR createInfo = {};
	650	createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
	651	createInfo.surface = surface;
	652	createInfo.minImageCount = imageCount;
	653	createInfo.imageFormat = surfaceFormat.format;
	654	createInfo.imageColorSpace = surfaceFormat.colorSpace;
	655	createInfo.imageExtent = extent;
	656	createInfo.imageArrayLayers = 1;
	657	createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
[909b51a]	658
[621664a]	659	QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
	660	uint32_t queueFamilyIndices[] = {indices.graphicsFamily.value(), indices.presentFamily.value()};
[b3671b5]	661
[621664a]	662	if (indices.graphicsFamily != indices.presentFamily) {
	663	createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
	664	createInfo.queueFamilyIndexCount = 2;
	665	createInfo.pQueueFamilyIndices = queueFamilyIndices;
	666	} else {
	667	createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
	668	createInfo.queueFamilyIndexCount = 0;
	669	createInfo.pQueueFamilyIndices = nullptr;
	670	}
[b3671b5]	671
[621664a]	672	createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
	673	createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
	674	createInfo.presentMode = presentMode;
	675	createInfo.clipped = VK_TRUE;
	676	createInfo.oldSwapchain = VK_NULL_HANDLE;
[909b51a]	677
[621664a]	678	if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapChain) != VK_SUCCESS) {
	679	throw runtime_error("failed to create swap chain!");
[909b51a]	680	}
	681
[621664a]	682	vkGetSwapchainImagesKHR(device, swapChain, &imageCount, nullptr);
	683	swapChainImages.resize(imageCount);
	684	vkGetSwapchainImagesKHR(device, swapChain, &imageCount, swapChainImages.data());
	685
	686	swapChainImageFormat = surfaceFormat.format;
	687	swapChainExtent = extent;
[909b51a]	688	}
	689
[bfd620e]	690	SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device) {
	691	SwapChainSupportDetails details;
	692
	693	vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
	694
	695	uint32_t formatCount;
	696	vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
	697
	698	if (formatCount != 0) {
	699	details.formats.resize(formatCount);
	700	vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
	701	}
	702
	703	uint32_t presentModeCount;
	704	vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
	705
	706	if (presentModeCount != 0) {
	707	details.presentModes.resize(presentModeCount);
	708	vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
	709	}
	710
	711	return details;
	712	}
	713
	714	VkSurfaceFormatKHR chooseSwapSurfaceFormat(const vector<VkSurfaceFormatKHR>& availableFormats) {
	715	for (const auto& availableFormat : availableFormats) {
	716	if (availableFormat.format == VK_FORMAT_B8G8R8A8_UNORM && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
	717	return availableFormat;
	718	}
	719	}
	720
	721	return availableFormats[0];
	722	}
	723
	724	VkPresentModeKHR chooseSwapPresentMode(const vector<VkPresentModeKHR>& availablePresentModes) {
	725	VkPresentModeKHR bestMode = VK_PRESENT_MODE_FIFO_KHR;
	726
	727	for (const auto& availablePresentMode : availablePresentModes) {
	728	if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR) {
	729	return availablePresentMode;
[621664a]	730	}
	731	else if (availablePresentMode == VK_PRESENT_MODE_IMMEDIATE_KHR) {
[bfd620e]	732	bestMode = availablePresentMode;
	733	}
	734	}
	735
	736	return bestMode;
	737	}
	738
	739	VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities) {
	740	if (capabilities.currentExtent.width != numeric_limits<uint32_t>::max()) {
	741	return capabilities.currentExtent;
[cabdd5c]	742	} else {
[75108ef]	743	VkExtent2D actualExtent = {
[cabdd5c]	744	static_cast<uint32_t>(gui->getWindowWidth()),
	745	static_cast<uint32_t>(gui->getWindowHeight())
[75108ef]	746	};
[bfd620e]	747
[f00ee54]	748	actualExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, actualExtent.width));
	749	actualExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, actualExtent.height));
[bfd620e]	750
	751	return actualExtent;
	752	}
	753	}
	754
	755	void createImageViews() {
	756	swapChainImageViews.resize(swapChainImages.size());
	757
[621664a]	758	for (size_t i = 0; i < swapChainImages.size(); i++) {
[adcd252]	759	swapChainImageViews[i] = createImageView(swapChainImages[i], swapChainImageFormat, VK_IMAGE_ASPECT_COLOR_BIT);
[bfd620e]	760	}
	761	}
	762
[be34c9a]	763	void createRenderPass() {
	764	VkAttachmentDescription colorAttachment = {};
	765	colorAttachment.format = swapChainImageFormat;
	766	colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
	767	colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
	768	colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
	769	colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
	770	colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
	771	colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
	772	colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
	773
	774	VkAttachmentReference colorAttachmentRef = {};
	775	colorAttachmentRef.attachment = 0;
	776	colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
	777
[adcd252]	778	VkAttachmentDescription depthAttachment = {};
	779	depthAttachment.format = findDepthFormat();
	780	depthAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
	781	depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
	782	depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
	783	depthAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
	784	depthAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
	785	depthAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
	786	depthAttachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
	787
	788	VkAttachmentReference depthAttachmentRef = {};
	789	depthAttachmentRef.attachment = 1;
	790	depthAttachmentRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
	791
[be34c9a]	792	VkSubpassDescription subpass = {};
	793	subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
	794	subpass.colorAttachmentCount = 1;
	795	subpass.pColorAttachments = &colorAttachmentRef;
[adcd252]	796	subpass.pDepthStencilAttachment = &depthAttachmentRef;
[be34c9a]	797
[621664a]	798	VkSubpassDependency dependency = {};
[47bff4c]	799	dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
	800	dependency.dstSubpass = 0;
	801	dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
	802	dependency.srcAccessMask = 0;
	803	dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
	804	dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT \| VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
	805
[adcd252]	806	array<VkAttachmentDescription, 2> attachments = { colorAttachment, depthAttachment };
[be34c9a]	807	VkRenderPassCreateInfo renderPassInfo = {};
	808	renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
[adcd252]	809	renderPassInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
	810	renderPassInfo.pAttachments = attachments.data();
[be34c9a]	811	renderPassInfo.subpassCount = 1;
	812	renderPassInfo.pSubpasses = &subpass;
[47bff4c]	813	renderPassInfo.dependencyCount = 1;
	814	renderPassInfo.pDependencies = &dependency;
[be34c9a]	815
	816	if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS) {
	817	throw runtime_error("failed to create render pass!");
	818	}
	819	}
[6fc24c7]	820	/* END OF REFACTORED CODE */
[be34c9a]	821
[f00ee54]	822	void initGraphicsPipelineInfo(GraphicsPipelineInfo& info,
	823	const void* vertexData, int vertexSize, size_t numVertices,
	824	const void* indexData, int indexSize, size_t numIndices) {
[5b02676]	825	/* START OF REFACTORED CODE */
[f00ee54]	826	// Since there is only one array of vertex data, we use binding = 0
	827	// I'll probably do that for the foreseeable future
	828	// I can calculate the stride myself given info about all the varying attributes
	829
	830	info.bindingDescription.binding = 0;
	831	info.bindingDescription.stride = vertexSize;
	832	info.bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
[5b02676]	833	/* END OF REFACTORED CODE */
[f00ee54]	834
	835	info.numVertices = numVertices;
[7563b8a]	836	info.vertexCapacity = numVertices * 2;
	837	createVertexBuffer(info, vertexData, vertexSize);
[f00ee54]	838
	839	info.numIndices = numIndices;
[7563b8a]	840	info.indexCapacity = numIndices * 2;
	841	createIndexBuffer(info, indexData, indexSize);
[f00ee54]	842	}
	843
	844	void addAttributeDescription(GraphicsPipelineInfo& info, VkFormat format, size_t offset) {
	845	VkVertexInputAttributeDescription attributeDesc = {};
	846
	847	attributeDesc.binding = 0;
	848	attributeDesc.location = info.attributeDescriptions.size();
	849	attributeDesc.format = format;
	850	attributeDesc.offset = offset;
	851
	852	info.attributeDescriptions.push_back(attributeDesc);
	853	}
	854
[b794178]	855	/* START OF REFACTORED CODE */
[721e8be]	856	void addDescriptorInfo(GraphicsPipelineInfo& info, VkDescriptorType type, VkShaderStageFlags stageFlags, vector<VkDescriptorBufferInfo>* bufferData, VkDescriptorImageInfo* imageData) {
	857	info.descriptorInfoList.push_back({ type, stageFlags, bufferData, imageData });
	858	}
	859
	860	void createDescriptorSetLayout(GraphicsPipelineInfo& info) {
	861	vector<VkDescriptorSetLayoutBinding> bindings(info.descriptorInfoList.size());
	862
	863	for (size_t i = 0; i < bindings.size(); i++) {
	864	bindings[i].binding = i;
	865	bindings[i].descriptorCount = 1;
	866	bindings[i].descriptorType = info.descriptorInfoList[i].type;
	867	bindings[i].stageFlags = info.descriptorInfoList[i].stageFlags;
	868	bindings[i].pImmutableSamplers = nullptr;
	869	}
	870
	871	VkDescriptorSetLayoutCreateInfo layoutInfo = {};
	872	layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
	873	layoutInfo.bindingCount = static_cast<uint32_t>(bindings.size());
	874	layoutInfo.pBindings = bindings.data();
	875
	876	if (vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &info.descriptorSetLayout) != VK_SUCCESS) {
	877	throw runtime_error("failed to create descriptor set layout!");
	878	}
	879	}
	880
[d22ae72]	881	void createGraphicsPipeline(string vertShaderFile, string fragShaderFile, GraphicsPipelineInfo& info) {
[7d2b0b9]	882	vector<char> vertShaderCode = readFile(vertShaderFile);
	883	vector<char> fragShaderCode = readFile(fragShaderFile);
[e09ad38]	884
	885	VkShaderModule vertShaderModule = createShaderModule(vertShaderCode);
	886	VkShaderModule fragShaderModule = createShaderModule(fragShaderCode);
	887
	888	VkPipelineShaderStageCreateInfo vertShaderStageInfo = {};
	889	vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
	890	vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
	891	vertShaderStageInfo.module = vertShaderModule;
	892	vertShaderStageInfo.pName = "main";
	893
	894	VkPipelineShaderStageCreateInfo fragShaderStageInfo = {};
	895	fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
	896	fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
	897	fragShaderStageInfo.module = fragShaderModule;
	898	fragShaderStageInfo.pName = "main";
	899
	900	VkPipelineShaderStageCreateInfo shaderStages[] = { vertShaderStageInfo, fragShaderStageInfo };
	901
[84216c7]	902	VkPipelineVertexInputStateCreateInfo vertexInputInfo = {};
	903	vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
[80edd70]	904
	905	vertexInputInfo.vertexBindingDescriptionCount = 1;
[f00ee54]	906	vertexInputInfo.vertexAttributeDescriptionCount = static_cast<uint32_t>(info.attributeDescriptions.size());
	907	vertexInputInfo.pVertexBindingDescriptions = &info.bindingDescription;
	908	vertexInputInfo.pVertexAttributeDescriptions = info.attributeDescriptions.data();
[84216c7]	909
	910	VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};
	911	inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
	912	inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
	913	inputAssembly.primitiveRestartEnable = VK_FALSE;
	914
	915	VkViewport viewport = {};
	916	viewport.x = 0.0f;
	917	viewport.y = 0.0f;
	918	viewport.width = (float) swapChainExtent.width;
	919	viewport.height = (float) swapChainExtent.height;
	920	viewport.minDepth = 0.0f;
	921	viewport.maxDepth = 1.0f;
	922
	923	VkRect2D scissor = {};
	924	scissor.offset = { 0, 0 };
	925	scissor.extent = swapChainExtent;
	926
	927	VkPipelineViewportStateCreateInfo viewportState = {};
	928	viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
	929	viewportState.viewportCount = 1;
	930	viewportState.pViewports = &viewport;
	931	viewportState.scissorCount = 1;
	932	viewportState.pScissors = &scissor;
	933
	934	VkPipelineRasterizationStateCreateInfo rasterizer = {};
	935	rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
	936	rasterizer.depthClampEnable = VK_FALSE;
	937	rasterizer.rasterizerDiscardEnable = VK_FALSE;
	938	rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
	939	rasterizer.lineWidth = 1.0f;
	940	rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
[c7fb883]	941	rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
[621664a]	942	rasterizer.depthBiasEnable = VK_FALSE;
[84216c7]	943
	944	VkPipelineMultisampleStateCreateInfo multisampling = {};
	945	multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
	946	multisampling.sampleShadingEnable = VK_FALSE;
	947	multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
	948
	949	VkPipelineColorBlendAttachmentState colorBlendAttachment = {};
	950	colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT \| VK_COLOR_COMPONENT_G_BIT \| VK_COLOR_COMPONENT_B_BIT \| VK_COLOR_COMPONENT_A_BIT;
[69dccfe]	951	colorBlendAttachment.blendEnable = VK_TRUE;
	952	colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
	953	colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
	954	colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
	955	colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
	956	colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
	957	colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
[84216c7]	958
	959	VkPipelineColorBlendStateCreateInfo colorBlending = {};
	960	colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
	961	colorBlending.logicOpEnable = VK_FALSE;
	962	colorBlending.logicOp = VK_LOGIC_OP_COPY;
	963	colorBlending.attachmentCount = 1;
	964	colorBlending.pAttachments = &colorBlendAttachment;
	965	colorBlending.blendConstants[0] = 0.0f;
	966	colorBlending.blendConstants[1] = 0.0f;
	967	colorBlending.blendConstants[2] = 0.0f;
	968	colorBlending.blendConstants[3] = 0.0f;
	969
[adcd252]	970	VkPipelineDepthStencilStateCreateInfo depthStencil = {};
	971	depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
	972	depthStencil.depthTestEnable = VK_TRUE;
	973	depthStencil.depthWriteEnable = VK_TRUE;
	974	depthStencil.depthCompareOp = VK_COMPARE_OP_LESS;
	975	depthStencil.depthBoundsTestEnable = VK_FALSE;
	976	depthStencil.minDepthBounds = 0.0f;
	977	depthStencil.maxDepthBounds = 1.0f;
	978	depthStencil.stencilTestEnable = VK_FALSE;
	979	depthStencil.front = {};
	980	depthStencil.back = {};
	981
[84216c7]	982	VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
	983	pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
[de32fda]	984	pipelineLayoutInfo.setLayoutCount = 1;
[d22ae72]	985	pipelineLayoutInfo.pSetLayouts = &info.descriptorSetLayout;
[84216c7]	986	pipelineLayoutInfo.pushConstantRangeCount = 0;
	987
[d22ae72]	988	if (vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &info.pipelineLayout) != VK_SUCCESS) {
[84216c7]	989	throw runtime_error("failed to create pipeline layout!");
	990	}
	991
[fd70015]	992	VkGraphicsPipelineCreateInfo pipelineInfo = {};
	993	pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
	994	pipelineInfo.stageCount = 2;
	995	pipelineInfo.pStages = shaderStages;
	996	pipelineInfo.pVertexInputState = &vertexInputInfo;
	997	pipelineInfo.pInputAssemblyState = &inputAssembly;
	998	pipelineInfo.pViewportState = &viewportState;
	999	pipelineInfo.pRasterizationState = &rasterizer;
	1000	pipelineInfo.pMultisampleState = &multisampling;
[adcd252]	1001	pipelineInfo.pDepthStencilState = &depthStencil;
[fd70015]	1002	pipelineInfo.pColorBlendState = &colorBlending;
	1003	pipelineInfo.pDynamicState = nullptr;
[d22ae72]	1004	pipelineInfo.layout = info.pipelineLayout;
[fd70015]	1005	pipelineInfo.renderPass = renderPass;
	1006	pipelineInfo.subpass = 0;
	1007	pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
	1008	pipelineInfo.basePipelineIndex = -1;
	1009
[d22ae72]	1010	if (vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &info.pipeline) != VK_SUCCESS) {
[fd70015]	1011	throw runtime_error("failed to create graphics pipeline!");
	1012	}
	1013
[e09ad38]	1014	vkDestroyShaderModule(device, vertShaderModule, nullptr);
	1015	vkDestroyShaderModule(device, fragShaderModule, nullptr);
	1016	}
[b794178]	1017	/* END OF REFACTORED CODE */
[e09ad38]	1018
	1019	VkShaderModule createShaderModule(const vector<char>& code) {
	1020	VkShaderModuleCreateInfo createInfo = {};
	1021	createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
	1022	createInfo.codeSize = code.size();
	1023	createInfo.pCode = reinterpret_cast<const uint32_t*>(code.data());
	1024
	1025	VkShaderModule shaderModule;
	1026	if (vkCreateShaderModule(device, &createInfo, nullptr, &shaderModule) != VK_SUCCESS) {
	1027	throw runtime_error("failed to create shader module!");
	1028	}
	1029
	1030	return shaderModule;
[4befb76]	1031	}
	1032
[ebeb3aa]	1033	void createFramebuffers() {
	1034	swapChainFramebuffers.resize(swapChainImageViews.size());
	1035
	1036	for (size_t i = 0; i < swapChainImageViews.size(); i++) {
[adcd252]	1037	array <VkImageView, 2> attachments = {
	1038	swapChainImageViews[i],
	1039	depthImageView
[ebeb3aa]	1040	};
	1041
	1042	VkFramebufferCreateInfo framebufferInfo = {};
	1043	framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
	1044	framebufferInfo.renderPass = renderPass;
[adcd252]	1045	framebufferInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
	1046	framebufferInfo.pAttachments = attachments.data();
[ebeb3aa]	1047	framebufferInfo.width = swapChainExtent.width;
	1048	framebufferInfo.height = swapChainExtent.height;
	1049	framebufferInfo.layers = 1;
	1050
	1051	if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &swapChainFramebuffers[i]) != VK_SUCCESS) {
	1052	throw runtime_error("failed to create framebuffer!");
	1053	}
	1054	}
	1055	}
	1056
[fa9fa1c]	1057	/* START OF REFACTORED CODE */
[47bff4c]	1058	void createCommandPool() {
	1059	QueueFamilyIndices queueFamilyIndices = findQueueFamilies(physicalDevice);
	1060
	1061	VkCommandPoolCreateInfo poolInfo = {};
	1062	poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
	1063	poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
	1064	poolInfo.flags = 0;
	1065
	1066	if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS) {
[621664a]	1067	throw runtime_error("failed to create graphics command pool!");
[47bff4c]	1068	}
	1069	}
	1070
[621664a]	1071	QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device) {
	1072	QueueFamilyIndices indices;
	1073
	1074	uint32_t queueFamilyCount = 0;
	1075	vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);
	1076
	1077	vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
	1078	vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());
	1079
	1080	int i = 0;
	1081	for (const auto& queueFamily : queueFamilies) {
	1082	if (queueFamily.queueCount > 0 && queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) {
	1083	indices.graphicsFamily = i;
	1084	}
	1085
	1086	VkBool32 presentSupport = false;
	1087	vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
	1088
	1089	if (queueFamily.queueCount > 0 && presentSupport) {
	1090	indices.presentFamily = i;
	1091	}
	1092
	1093	if (indices.isComplete()) {
	1094	break;
	1095	}
	1096
	1097	i++;
	1098	}
	1099
	1100	return indices;
	1101	}
[90a424f]	1102	/* END OF REFACTORED CODE */
[621664a]	1103
[adcd252]	1104	void createDepthResources() {
	1105	VkFormat depthFormat = findDepthFormat();
	1106
	1107	createImage(swapChainExtent.width, swapChainExtent.height, depthFormat, VK_IMAGE_TILING_OPTIMAL,
	1108	VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, depthImage, depthImageMemory);
	1109	depthImageView = createImageView(depthImage, depthFormat, VK_IMAGE_ASPECT_DEPTH_BIT);
	1110
	1111	transitionImageLayout(depthImage, depthFormat, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
	1112	}
	1113
[6fc24c7]	1114	/* START OF REFACTORED CODE */
[adcd252]	1115	VkFormat findDepthFormat() {
	1116	return findSupportedFormat(
	1117	{ VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT },
	1118	VK_IMAGE_TILING_OPTIMAL,
	1119	VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
	1120	);
	1121	}
	1122
	1123	VkFormat findSupportedFormat(const vector<VkFormat>& candidates, VkImageTiling tiling,
	1124	VkFormatFeatureFlags features) {
	1125	for (VkFormat format : candidates) {
	1126	VkFormatProperties props;
	1127	vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &props);
	1128
	1129	if (tiling == VK_IMAGE_TILING_LINEAR &&
	1130	(props.linearTilingFeatures & features) == features) {
	1131	return format;
	1132	} else if (tiling == VK_IMAGE_TILING_OPTIMAL &&
	1133	(props.optimalTilingFeatures & features) == features) {
	1134	return format;
	1135	}
	1136	}
	1137
	1138	throw runtime_error("failed to find supported format!");
	1139	}
	1140
	1141	bool hasStencilComponent(VkFormat format) {
	1142	return format == VK_FORMAT_D32_SFLOAT_S8_UINT \|\| format == VK_FORMAT_D24_UNORM_S8_UINT;
	1143	}
	1144
[69dccfe]	1145	void createImageResources(string filename, VkImage& image, VkDeviceMemory& imageMemory, VkImageView& view) {
[eea05dd]	1146	int texWidth, texHeight, texChannels;
	1147
[69dccfe]	1148	stbi_uc* pixels = stbi_load(filename.c_str(), &texWidth, &texHeight, &texChannels, STBI_rgb_alpha);
[eea05dd]	1149	VkDeviceSize imageSize = texWidth * texHeight * 4;
	1150
	1151	if (!pixels) {
	1152	throw runtime_error("failed to load texture image!");
	1153	}
	1154
	1155	VkBuffer stagingBuffer;
	1156	VkDeviceMemory stagingBufferMemory;
	1157
	1158	createBuffer(imageSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
	1159	VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT \| VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
	1160	stagingBuffer, stagingBufferMemory);
	1161
	1162	void* data;
	1163
	1164	vkMapMemory(device, stagingBufferMemory, 0, imageSize, 0, &data);
	1165	memcpy(data, pixels, static_cast<size_t>(imageSize));
	1166	vkUnmapMemory(device, stagingBufferMemory);
	1167
	1168	stbi_image_free(pixels);
	1169
	1170	createImage(texWidth, texHeight, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TILING_OPTIMAL,
	1171	VK_IMAGE_USAGE_TRANSFER_DST_BIT \| VK_IMAGE_USAGE_SAMPLED_BIT,
[69dccfe]	1172	VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, image, imageMemory);
[eea05dd]	1173
[69dccfe]	1174	transitionImageLayout(image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
	1175	copyBufferToImage(stagingBuffer, image, static_cast<uint32_t>(texWidth), static_cast<uint32_t>(texHeight));
	1176	transitionImageLayout(image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
[eea05dd]	1177
	1178	vkDestroyBuffer(device, stagingBuffer, nullptr);
[f5d5686]	1179	vkFreeMemory(device, stagingBufferMemory, nullptr);
[69dccfe]	1180
	1181	view = createImageView(image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_ASPECT_COLOR_BIT);
[eea05dd]	1182	}
	1183
[e1a7f5a]	1184	void createImageResourcesFromSDLTexture(SDL_Texture* texture, VkImage& image, VkDeviceMemory& imageMemory, VkImageView& view) {
	1185	int a, w, h;
	1186
	1187	// I only need this here for the width and height, which are constants, so just use those instead
	1188	SDL_QueryTexture(texture, nullptr, &a, &w, &h);
	1189
	1190	createImage(w, h, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TILING_OPTIMAL,
	1191	VK_IMAGE_USAGE_TRANSFER_DST_BIT \| VK_IMAGE_USAGE_SAMPLED_BIT,
	1192	VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, image, imageMemory);
	1193
	1194	view = createImageView(image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_ASPECT_COLOR_BIT);
	1195	}
[b794178]	1196	/* END OF REFACTORED CODE */
[e1a7f5a]	1197
	1198	void populateImageFromSDLTexture(SDL_Texture* texture, VkImage& image) {
[f00ee54]	1199	int a, w, h;
[e1a7f5a]	1200
	1201	SDL_QueryTexture(texture, nullptr, &a, &w, &h);
	1202
	1203	VkDeviceSize imageSize = w * h * 4;
	1204	unsigned char* pixels = new unsigned char[imageSize];
	1205
	1206	SDL_RenderReadPixels(gRenderer, nullptr, SDL_PIXELFORMAT_ABGR8888, pixels, w * 4);
	1207
	1208	VkBuffer stagingBuffer;
	1209	VkDeviceMemory stagingBufferMemory;
	1210
	1211	createBuffer(imageSize,
	1212	VK_BUFFER_USAGE_TRANSFER_DST_BIT \| VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
	1213	VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
	1214	stagingBuffer, stagingBufferMemory);
	1215
	1216	void* data;
	1217
	1218	vkMapMemory(device, stagingBufferMemory, 0, VK_WHOLE_SIZE, 0, &data);
	1219	memcpy(data, pixels, static_cast<size_t>(imageSize));
	1220
	1221	VkMappedMemoryRange mappedMemoryRange = {};
	1222	mappedMemoryRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
	1223	mappedMemoryRange.memory = stagingBufferMemory;
	1224	mappedMemoryRange.offset = 0;
	1225	mappedMemoryRange.size = VK_WHOLE_SIZE;
	1226
	1227	// TODO: Should probably check that the function succeeded
	1228	vkFlushMappedMemoryRanges(device, 1, &mappedMemoryRange);
	1229	vkUnmapMemory(device, stagingBufferMemory);
	1230
[8a40f4b]	1231	delete[] pixels;
	1232
[e1a7f5a]	1233	transitionImageLayout(image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
	1234	copyBufferToImage(stagingBuffer, image, static_cast<uint32_t>(w), static_cast<uint32_t>(h));
	1235	transitionImageLayout(image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
	1236
	1237	vkDestroyBuffer(device, stagingBuffer, nullptr);
	1238	vkFreeMemory(device, stagingBufferMemory, nullptr);
	1239	}
	1240
[621664a]	1241	void createImage(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage,
	1242	VkMemoryPropertyFlags properties, VkImage& image, VkDeviceMemory& imageMemory) {
[eea05dd]	1243	VkImageCreateInfo imageInfo = {};
	1244	imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
	1245	imageInfo.imageType = VK_IMAGE_TYPE_2D;
	1246	imageInfo.extent.width = width;
	1247	imageInfo.extent.height = height;
	1248	imageInfo.extent.depth = 1;
	1249	imageInfo.mipLevels = 1;
	1250	imageInfo.arrayLayers = 1;
	1251	imageInfo.format = format;
	1252	imageInfo.tiling = tiling;
	1253	imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
	1254	imageInfo.usage = usage;
	1255	imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
	1256	imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
	1257
	1258	if (vkCreateImage(device, &imageInfo, nullptr, &image) != VK_SUCCESS) {
	1259	throw runtime_error("failed to create image!");
	1260	}
	1261
	1262	VkMemoryRequirements memRequirements;
	1263	vkGetImageMemoryRequirements(device, image, &memRequirements);
	1264
[621664a]	1265	VkMemoryAllocateInfo allocInfo = {};
[eea05dd]	1266	allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
	1267	allocInfo.allocationSize = memRequirements.size;
	1268	allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties);
	1269
	1270	if (vkAllocateMemory(device, &allocInfo, nullptr, &imageMemory) != VK_SUCCESS) {
	1271	throw runtime_error("failed to allocate image memory!");
	1272	}
	1273
	1274	vkBindImageMemory(device, image, imageMemory, 0);
	1275	}
	1276
[621664a]	1277	void transitionImageLayout(VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout) {
[eea05dd]	1278	VkCommandBuffer commandBuffer = beginSingleTimeCommands();
	1279
	1280	VkImageMemoryBarrier barrier = {};
	1281	barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
	1282	barrier.oldLayout = oldLayout;
	1283	barrier.newLayout = newLayout;
	1284	barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
	1285	barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
	1286	barrier.image = image;
[adcd252]	1287
	1288	if (newLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) {
	1289	barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
	1290
	1291	if (hasStencilComponent(format)) {
	1292	barrier.subresourceRange.aspectMask \|= VK_IMAGE_ASPECT_STENCIL_BIT;
	1293	}
	1294	} else {
	1295	barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
	1296	}
	1297
[eea05dd]	1298	barrier.subresourceRange.baseMipLevel = 0;
	1299	barrier.subresourceRange.levelCount = 1;
	1300	barrier.subresourceRange.baseArrayLayer = 0;
	1301	barrier.subresourceRange.layerCount = 1;
[f5d5686]	1302
	1303	VkPipelineStageFlags sourceStage;
	1304	VkPipelineStageFlags destinationStage;
[eea05dd]	1305
	1306	if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
	1307	barrier.srcAccessMask = 0;
	1308	barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
	1309
	1310	sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
	1311	destinationStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
	1312	} else if (oldLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL && newLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
	1313	barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
	1314	barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
	1315
	1316	sourceStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
	1317	destinationStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
[adcd252]	1318	} else if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && newLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) {
	1319	barrier.srcAccessMask = 0;
	1320	barrier.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT \| VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
	1321
	1322	sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
	1323	destinationStage = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
[eea05dd]	1324	} else {
	1325	throw invalid_argument("unsupported layout transition!");
	1326	}
	1327
	1328	vkCmdPipelineBarrier(
	1329	commandBuffer,
[f5d5686]	1330	sourceStage, destinationStage,
[eea05dd]	1331	0,
	1332	0, nullptr,
	1333	0, nullptr,
	1334	1, &barrier
	1335	);
	1336
	1337	endSingleTimeCommands(commandBuffer);
	1338	}
	1339
	1340	void copyBufferToImage(VkBuffer buffer, VkImage image, uint32_t width, uint32_t height) {
	1341	VkCommandBuffer commandBuffer = beginSingleTimeCommands();
	1342
	1343	VkBufferImageCopy region = {};
	1344	region.bufferOffset = 0;
	1345	region.bufferRowLength = 0;
	1346	region.bufferImageHeight = 0;
	1347	region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
	1348	region.imageSubresource.mipLevel = 0;
	1349	region.imageSubresource.baseArrayLayer = 0;
	1350	region.imageSubresource.layerCount = 1;
	1351	region.imageOffset = { 0, 0, 0 };
	1352	region.imageExtent = { width, height, 1 };
	1353
	1354	vkCmdCopyBufferToImage(
	1355	commandBuffer,
	1356	buffer,
	1357	image,
	1358	VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
	1359	1,
	1360	&region
	1361	);
	1362
	1363	endSingleTimeCommands(commandBuffer);
	1364	}
	1365
[f94eea9]	1366	/* START OF REFACTORED CODE */
[adcd252]	1367	VkImageView createImageView(VkImage image, VkFormat format, VkImageAspectFlags aspectFlags) {
[fba08f2]	1368	VkImageViewCreateInfo viewInfo = {};
	1369	viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
	1370	viewInfo.image = image;
	1371	viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
	1372	viewInfo.format = format;
	1373
	1374	viewInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
	1375	viewInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
	1376	viewInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
	1377	viewInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
	1378
[adcd252]	1379	viewInfo.subresourceRange.aspectMask = aspectFlags;
[fba08f2]	1380	viewInfo.subresourceRange.baseMipLevel = 0;
	1381	viewInfo.subresourceRange.levelCount = 1;
	1382	viewInfo.subresourceRange.baseArrayLayer = 0;
	1383	viewInfo.subresourceRange.layerCount = 1;
	1384
	1385	VkImageView imageView;
	1386	if (vkCreateImageView(device, &viewInfo, nullptr, &imageView) != VK_SUCCESS) {
	1387	throw runtime_error("failed to create texture image view!");
	1388	}
	1389
	1390	return imageView;
	1391	}
	1392
	1393	void createTextureSampler() {
	1394	VkSamplerCreateInfo samplerInfo = {};
	1395	samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
	1396	samplerInfo.magFilter = VK_FILTER_LINEAR;
	1397	samplerInfo.minFilter = VK_FILTER_LINEAR;
	1398
	1399	samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
	1400	samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
	1401	samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
	1402
	1403	samplerInfo.anisotropyEnable = VK_TRUE;
	1404	samplerInfo.maxAnisotropy = 16;
	1405	samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
	1406	samplerInfo.unnormalizedCoordinates = VK_FALSE;
	1407	samplerInfo.compareEnable = VK_FALSE;
	1408	samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS;
	1409	samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
	1410	samplerInfo.mipLodBias = 0.0f;
	1411	samplerInfo.minLod = 0.0f;
	1412	samplerInfo.maxLod = 0.0f;
	1413
	1414	if (vkCreateSampler(device, &samplerInfo, nullptr, &textureSampler) != VK_SUCCESS) {
	1415	throw runtime_error("failed to create texture sampler!");
	1416	}
	1417	}
[b794178]	1418	/* END OF REFACTORED CODE */
[fba08f2]	1419
[7563b8a]	1420	void createVertexBuffer(GraphicsPipelineInfo& info, const void* vertexData, int vertexSize) {
	1421	VkDeviceSize bufferSize = info.numVertices * vertexSize;
	1422	VkDeviceSize bufferCapacity = info.vertexCapacity * vertexSize;
	1423
[d9ef6ab]	1424	VkBuffer stagingBuffer;
	1425	VkDeviceMemory stagingBufferMemory;
[621664a]	1426	createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
[d9ef6ab]	1427	VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT \| VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
	1428	stagingBuffer, stagingBufferMemory);
	1429
	1430	void* data;
	1431	vkMapMemory(device, stagingBufferMemory, 0, bufferSize, 0, &data);
[f00ee54]	1432	memcpy(data, vertexData, (size_t) bufferSize);
[d9ef6ab]	1433	vkUnmapMemory(device, stagingBufferMemory);
	1434
[7563b8a]	1435	createBuffer(bufferCapacity, VK_BUFFER_USAGE_TRANSFER_DST_BIT \| VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
[f00ee54]	1436	VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, info.vertexBuffer, info.vertexBufferMemory);
[d9ef6ab]	1437
[7563b8a]	1438	copyBuffer(stagingBuffer, info.vertexBuffer, 0, 0, bufferSize);
[d9ef6ab]	1439
	1440	vkDestroyBuffer(device, stagingBuffer, nullptr);
	1441	vkFreeMemory(device, stagingBufferMemory, nullptr);
	1442	}
	1443
[7563b8a]	1444	void createIndexBuffer(GraphicsPipelineInfo& info, const void* indexData, int indexSize) {
	1445	VkDeviceSize bufferSize = info.numIndices * indexSize;
	1446	VkDeviceSize bufferCapacity = info.indexCapacity * indexSize;
	1447
[cae7a2c]	1448	VkBuffer stagingBuffer;
	1449	VkDeviceMemory stagingBufferMemory;
	1450	createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
	1451	VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT \| VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
	1452	stagingBuffer, stagingBufferMemory);
	1453
	1454	void* data;
	1455	vkMapMemory(device, stagingBufferMemory, 0, bufferSize, 0, &data);
[f00ee54]	1456	memcpy(data, indexData, (size_t) bufferSize);
[cae7a2c]	1457	vkUnmapMemory(device, stagingBufferMemory);
	1458
[7563b8a]	1459	createBuffer(bufferCapacity, VK_BUFFER_USAGE_TRANSFER_DST_BIT \| VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
[f00ee54]	1460	VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, info.indexBuffer, info.indexBufferMemory);
[cae7a2c]	1461
[7563b8a]	1462	copyBuffer(stagingBuffer, info.indexBuffer, 0, 0, bufferSize);
[cae7a2c]	1463
	1464	vkDestroyBuffer(device, stagingBuffer, nullptr);
	1465	vkFreeMemory(device, stagingBufferMemory, nullptr);
	1466	}
	1467
[b794178]	1468	/* START OF REFACTORED CODE */
[621664a]	1469	void createUniformBuffers() {
	1470	VkDeviceSize bufferSize = sizeof(UniformBufferObject);
	1471
	1472	uniformBuffers.resize(swapChainImages.size());
	1473	uniformBuffersMemory.resize(swapChainImages.size());
[721e8be]	1474	uniformBufferInfoList.resize(swapChainImages.size());
[621664a]	1475
	1476	for (size_t i = 0; i < swapChainImages.size(); i++) {
	1477	createBuffer(bufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
	1478	VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT \| VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
	1479	uniformBuffers[i], uniformBuffersMemory[i]);
[721e8be]	1480
	1481	uniformBufferInfoList[i].buffer = uniformBuffers[i];
	1482	uniformBufferInfoList[i].offset = 0;
	1483	uniformBufferInfoList[i].range = sizeof(UniformBufferObject);
[621664a]	1484	}
	1485	}
	1486
	1487	void createBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer, VkDeviceMemory& bufferMemory) {
[80edd70]	1488	VkBufferCreateInfo bufferInfo = {};
	1489	bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
[d9ef6ab]	1490	bufferInfo.size = size;
	1491	bufferInfo.usage = usage;
[80edd70]	1492	bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
	1493
[d9ef6ab]	1494	if (vkCreateBuffer(device, &bufferInfo, nullptr, &buffer) != VK_SUCCESS) {
	1495	throw runtime_error("failed to create buffer!");
[80edd70]	1496	}
	1497
[d9ef6ab]	1498	VkMemoryRequirements memRequirements;
	1499	vkGetBufferMemoryRequirements(device, buffer, &memRequirements);
[80edd70]	1500
	1501	VkMemoryAllocateInfo allocInfo = {};
	1502	allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
[d9ef6ab]	1503	allocInfo.allocationSize = memRequirements.size;
	1504	allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties);
[621664a]	1505
[d9ef6ab]	1506	if (vkAllocateMemory(device, &allocInfo, nullptr, &bufferMemory) != VK_SUCCESS) {
	1507	throw runtime_error("failed to allocate buffer memory!");
[80edd70]	1508	}
	1509
[d9ef6ab]	1510	vkBindBufferMemory(device, buffer, bufferMemory, 0);
	1511	}
[b794178]	1512	/* END OF REFACTORED CODE */
[80edd70]	1513
[7563b8a]	1514	void copyDataToBuffer(const void* srcData, VkBuffer dst, VkDeviceSize dstOffset, VkDeviceSize dataSize) {
	1515	VkBuffer stagingBuffer;
	1516	VkDeviceMemory stagingBufferMemory;
	1517	createBuffer(dataSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
	1518	VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT \| VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
	1519	stagingBuffer, stagingBufferMemory);
	1520
	1521	void* data;
	1522	vkMapMemory(device, stagingBufferMemory, 0, dataSize, 0, &data);
	1523	memcpy(data, srcData, (size_t) dataSize);
	1524	vkUnmapMemory(device, stagingBufferMemory);
	1525
	1526	copyBuffer(stagingBuffer, dst, 0, dstOffset, dataSize);
	1527
	1528	vkDestroyBuffer(device, stagingBuffer, nullptr);
	1529	vkFreeMemory(device, stagingBufferMemory, nullptr);
	1530	}
	1531
	1532	void copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize srcOffset, VkDeviceSize dstOffset,
	1533	VkDeviceSize size) {
[eea05dd]	1534	VkCommandBuffer commandBuffer = beginSingleTimeCommands();
	1535
[7563b8a]	1536	VkBufferCopy copyRegion = { srcOffset, dstOffset, size };
[eea05dd]	1537	vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, &copyRegion);
	1538
	1539	endSingleTimeCommands(commandBuffer);
	1540	}
	1541
	1542	VkCommandBuffer beginSingleTimeCommands() {
[d9ef6ab]	1543	VkCommandBufferAllocateInfo allocInfo = {};
	1544	allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
	1545	allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
	1546	allocInfo.commandPool = commandPool;
	1547	allocInfo.commandBufferCount = 1;
	1548
	1549	VkCommandBuffer commandBuffer;
	1550	vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer);
	1551
	1552	VkCommandBufferBeginInfo beginInfo = {};
	1553	beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
	1554	beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
	1555
	1556	vkBeginCommandBuffer(commandBuffer, &beginInfo);
	1557
[eea05dd]	1558	return commandBuffer;
	1559	}
[d9ef6ab]	1560
[eea05dd]	1561	void endSingleTimeCommands(VkCommandBuffer commandBuffer) {
[d9ef6ab]	1562	vkEndCommandBuffer(commandBuffer);
	1563
	1564	VkSubmitInfo submitInfo = {};
	1565	submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
	1566	submitInfo.commandBufferCount = 1;
	1567	submitInfo.pCommandBuffers = &commandBuffer;
	1568
	1569	vkQueueSubmit(graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE);
	1570	vkQueueWaitIdle(graphicsQueue);
	1571
	1572	vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer);
[80edd70]	1573	}
	1574
[b794178]	1575	/* START OF REFACTORED CODE */
[80edd70]	1576	uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) {
	1577	VkPhysicalDeviceMemoryProperties memProperties;
	1578	vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProperties);
	1579
	1580	for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) {
	1581	if ((typeFilter & (1 << i)) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties) {
	1582	return i;
	1583	}
	1584	}
	1585
	1586	throw runtime_error("failed to find suitable memory type!");
	1587	}
	1588
[721e8be]	1589	void createDescriptorPool(GraphicsPipelineInfo& info) {
	1590	vector<VkDescriptorPoolSize> poolSizes(info.descriptorInfoList.size());
[c7fb883]	1591
[721e8be]	1592	for (size_t i = 0; i < poolSizes.size(); i++) {
	1593	poolSizes[i].type = info.descriptorInfoList[i].type;
	1594	poolSizes[i].descriptorCount = static_cast<uint32_t>(swapChainImages.size());
[c7fb883]	1595	}
[e5d4aca]	1596
	1597	VkDescriptorPoolCreateInfo poolInfo = {};
	1598	poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
	1599	poolInfo.poolSizeCount = static_cast<uint32_t>(poolSizes.size());
	1600	poolInfo.pPoolSizes = poolSizes.data();
	1601	poolInfo.maxSets = static_cast<uint32_t>(swapChainImages.size());
	1602
	1603	if (vkCreateDescriptorPool(device, &poolInfo, nullptr, &info.descriptorPool) != VK_SUCCESS) {
	1604	throw runtime_error("failed to create descriptor pool!");
	1605	}
	1606	}
	1607
[721e8be]	1608	void createDescriptorSets(GraphicsPipelineInfo& info) {
[e5d4aca]	1609	vector<VkDescriptorSetLayout> layouts(swapChainImages.size(), info.descriptorSetLayout);
	1610
	1611	VkDescriptorSetAllocateInfo allocInfo = {};
	1612	allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
	1613	allocInfo.descriptorPool = info.descriptorPool;
	1614	allocInfo.descriptorSetCount = static_cast<uint32_t>(swapChainImages.size());
	1615	allocInfo.pSetLayouts = layouts.data();
	1616
	1617	info.descriptorSets.resize(swapChainImages.size());
	1618	if (vkAllocateDescriptorSets(device, &allocInfo, info.descriptorSets.data()) != VK_SUCCESS) {
	1619	throw runtime_error("failed to allocate descriptor sets!");
	1620	}
	1621
	1622	for (size_t i = 0; i < swapChainImages.size(); i++) {
[721e8be]	1623	vector<VkWriteDescriptorSet> descriptorWrites(info.descriptorInfoList.size());
	1624
	1625	for (size_t j = 0; j < descriptorWrites.size(); j++) {
	1626	descriptorWrites[j].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
	1627	descriptorWrites[j].dstSet = info.descriptorSets[i];
	1628	descriptorWrites[j].dstBinding = j;
	1629	descriptorWrites[j].dstArrayElement = 0;
	1630	descriptorWrites[j].descriptorType = info.descriptorInfoList[j].type;
	1631	descriptorWrites[j].descriptorCount = 1;
	1632	descriptorWrites[j].pBufferInfo = nullptr;
	1633	descriptorWrites[j].pImageInfo = nullptr;
	1634	descriptorWrites[j].pTexelBufferView = nullptr;
	1635
	1636	switch (descriptorWrites[j].descriptorType) {
	1637	case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
	1638	descriptorWrites[j].pBufferInfo = &(*info.descriptorInfoList[j].bufferDataList)[i];
	1639	break;
	1640	case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
	1641	descriptorWrites[j].pImageInfo = info.descriptorInfoList[j].imageData;
	1642	break;
	1643	default:
	1644	cout << "Unknown descriptor type: " << descriptorWrites[j].descriptorType << endl;
	1645	}
	1646	}
[e5d4aca]	1647
	1648	vkUpdateDescriptorSets(device, static_cast<uint32_t>(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
	1649	}
	1650	}
[b794178]	1651	/* END OF REFACTORED CODE */
[e5d4aca]	1652
[47bff4c]	1653	void createCommandBuffers() {
	1654	commandBuffers.resize(swapChainFramebuffers.size());
	1655
	1656	VkCommandBufferAllocateInfo allocInfo = {};
	1657	allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
	1658	allocInfo.commandPool = commandPool;
	1659	allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
[621664a]	1660	allocInfo.commandBufferCount = (uint32_t) commandBuffers.size();
[47bff4c]	1661
	1662	if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS) {
[621664a]	1663	throw runtime_error("failed to allocate command buffers!");
[47bff4c]	1664	}
	1665
	1666	for (size_t i = 0; i < commandBuffers.size(); i++) {
	1667	VkCommandBufferBeginInfo beginInfo = {};
	1668	beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
	1669	beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
	1670	beginInfo.pInheritanceInfo = nullptr;
	1671
	1672	if (vkBeginCommandBuffer(commandBuffers[i], &beginInfo) != VK_SUCCESS) {
	1673	throw runtime_error("failed to begin recording command buffer!");
	1674	}
	1675
	1676	VkRenderPassBeginInfo renderPassInfo = {};
	1677	renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
	1678	renderPassInfo.renderPass = renderPass;
	1679	renderPassInfo.framebuffer = swapChainFramebuffers[i];
	1680	renderPassInfo.renderArea.offset = { 0, 0 };
	1681	renderPassInfo.renderArea.extent = swapChainExtent;
	1682
[adcd252]	1683	array<VkClearValue, 2> clearValues = {};
[f00ee54]	1684	clearValues[0].color = {{ 0.0f, 0.0f, 0.0f, 1.0f }};
[adcd252]	1685	clearValues[1].depthStencil = { 1.0f, 0 };
	1686
	1687	renderPassInfo.clearValueCount = static_cast<uint32_t>(clearValues.size());
	1688	renderPassInfo.pClearValues = clearValues.data();
[47bff4c]	1689
	1690	vkCmdBeginRenderPass(commandBuffers[i], &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
[621664a]	1691
[d22ae72]	1692	createGraphicsPipelineCommands(scenePipeline, i);
	1693	createGraphicsPipelineCommands(overlayPipeline, i);
[621664a]	1694
[47bff4c]	1695	vkCmdEndRenderPass(commandBuffers[i]);
	1696
	1697	if (vkEndCommandBuffer(commandBuffers[i]) != VK_SUCCESS) {
	1698	throw runtime_error("failed to record command buffer!");
	1699	}
	1700	}
	1701	}
	1702
[1187ef5]	1703	void createGraphicsPipelineCommands(GraphicsPipelineInfo& info, uint32_t currentImage) {
	1704	vkCmdBindPipeline(commandBuffers[currentImage], VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);
	1705	vkCmdBindDescriptorSets(commandBuffers[currentImage], VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipelineLayout, 0, 1,
	1706	&info.descriptorSets[currentImage], 0, nullptr);
[d22ae72]	1707
	1708	VkBuffer vertexBuffers[] = { info.vertexBuffer };
	1709	VkDeviceSize offsets[] = { 0 };
[1187ef5]	1710	vkCmdBindVertexBuffers(commandBuffers[currentImage], 0, 1, vertexBuffers, offsets);
[d22ae72]	1711
[1187ef5]	1712	vkCmdBindIndexBuffer(commandBuffers[currentImage], info.indexBuffer, 0, VK_INDEX_TYPE_UINT16);
[d22ae72]	1713
[1187ef5]	1714	vkCmdDrawIndexed(commandBuffers[currentImage], static_cast<uint32_t>(info.numIndices), 1, 0, 0, 0);
[d22ae72]	1715	}
	1716
[47bff4c]	1717	void createSyncObjects() {
	1718	imageAvailableSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
	1719	renderFinishedSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
	1720	inFlightFences.resize(MAX_FRAMES_IN_FLIGHT);
	1721
	1722	VkSemaphoreCreateInfo semaphoreInfo = {};
	1723	semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
	1724
	1725	VkFenceCreateInfo fenceInfo = {};
	1726	fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
	1727	fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
	1728
	1729	for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
	1730	if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) != VK_SUCCESS \|\|
[1187ef5]	1731	vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) != VK_SUCCESS \|\|
	1732	vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS) {
[47bff4c]	1733	throw runtime_error("failed to create synchronization objects for a frame!");
	1734	}
	1735	}
	1736	}
	1737
[7563b8a]	1738	bool addObjectToScene(GraphicsPipelineInfo& info,
	1739	const void* vertexData, int vertexSize, size_t numVertices,
	1740	vector<uint16_t>& indices, size_t numIndices) {
	1741	int indexSize = sizeof(uint16_t);
	1742
	1743	for (uint16_t& idx : indices) {
	1744	idx += info.numVertices;
	1745	}
	1746
	1747	if (info.numVertices + numVertices > info.vertexCapacity) {
	1748	cout << "ERROR: Need to resize vertex buffers" << endl;
	1749	} else if (info.numIndices + numIndices > info.indexCapacity) {
	1750	cout << "ERROR: Need to resize index buffers" << endl;
	1751	} else {
	1752	cout << "Added object to scene" << endl;
	1753
	1754	copyDataToBuffer(vertexData, info.vertexBuffer, info.numVertices * vertexSize, numVertices * vertexSize);
	1755	info.numVertices += numVertices;
	1756
	1757	copyDataToBuffer(indices.data(), info.indexBuffer, info.numIndices * indexSize, numIndices * indexSize);
	1758	info.numIndices += numIndices;
	1759
	1760	vkFreeCommandBuffers(device, commandPool, static_cast<uint32_t>(commandBuffers.size()), commandBuffers.data());
	1761	createCommandBuffers();
	1762
	1763	return true;
	1764	}
	1765
	1766	return false;
	1767	}
	1768
[c1c2021]	1769	/* START OF REFACTORED CODE */
[826df16]	1770	void mainLoop() {
	1771	// TODO: Create some generic event-handling functions in game-gui-*
	1772	SDL_Event e;
	1773	bool quit = false;
	1774
[7dcd925]	1775	while (!quit) {
[826df16]	1776	while (SDL_PollEvent(&e)) {
	1777	if (e.type == SDL_QUIT) {
	1778	quit = true;
	1779	}
	1780	if (e.type == SDL_KEYDOWN) {
[7563b8a]	1781	if (e.key.keysym.sym == SDLK_SPACE) {
	1782	float zOffset = -0.5f + (0.5f * numPlanes);
	1783	vector<Vertex> vertices = {
	1784	{{-0.5f, -0.5f, zOffset}, {1.0f, 0.0f, 0.0f}, {0.0f, 1.0f}},
	1785	{{ 0.5f, -0.5f, zOffset}, {0.0f, 1.0f, 0.0f}, {1.0f, 1.0f}},
	1786	{{ 0.5f, 0.5f, zOffset}, {0.0f, 0.0f, 1.0f}, {1.0f, 0.0f}},
	1787	{{-0.5f, 0.5f, zOffset}, {1.0f, 1.0f, 1.0f}, {0.0f, 0.0f}}
	1788	};
	1789	vector<uint16_t> indices = {
	1790	0, 1, 2, 2, 3, 0
	1791	};
	1792
	1793	if (addObjectToScene(scenePipeline,
	1794	vertices.data(), sizeof(Vertex), vertices.size(),
	1795	indices, indices.size())) {
	1796	numPlanes++;
	1797	}
	1798	} else if (e.key.keysym.sym == SDLK_ESCAPE) {
[91c89f7]	1799	quit = true;
	1800	}
[826df16]	1801	}
	1802	if (e.type == SDL_MOUSEBUTTONDOWN) {
	1803	quit = true;
	1804	}
[75108ef]	1805	if (e.type == SDL_WINDOWEVENT) {
[1187ef5]	1806	if (e.window.event == SDL_WINDOWEVENT_SIZE_CHANGED \|\|
	1807	e.window.event == SDL_WINDOWEVENT_MINIMIZED) {
[75108ef]	1808	framebufferResized = true;
	1809	}
	1810	}
[47bff4c]	1811	}
[321272c]	1812
[5f3dba8]	1813	drawUI();
[e1a7f5a]	1814
	1815	drawFrame();
[47bff4c]	1816	}
	1817
	1818	vkDeviceWaitIdle(device);
	1819	}
	1820
	1821	void drawFrame() {
[f94eea9]	1822	/* END OF REFACTORED CODE */
[47bff4c]	1823	vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, numeric_limits<uint64_t>::max());
	1824
	1825	uint32_t imageIndex;
	1826
[621664a]	1827	VkResult result = vkAcquireNextImageKHR(device, swapChain, numeric_limits<uint64_t>::max(),
	1828	imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
[75108ef]	1829
	1830	if (result == VK_ERROR_OUT_OF_DATE_KHR) {
	1831	recreateSwapChain();
	1832	return;
	1833	} else if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) {
	1834	throw runtime_error("failed to acquire swap chain image!");
	1835	}
[47bff4c]	1836
[de32fda]	1837	updateUniformBuffer(imageIndex);
	1838
[47bff4c]	1839	VkSubmitInfo submitInfo = {};
	1840	submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
	1841
	1842	VkSemaphore waitSemaphores[] = { imageAvailableSemaphores[currentFrame] };
	1843	VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
	1844
	1845	submitInfo.waitSemaphoreCount = 1;
	1846	submitInfo.pWaitSemaphores = waitSemaphores;
	1847	submitInfo.pWaitDstStageMask = waitStages;
	1848	submitInfo.commandBufferCount = 1;
	1849	submitInfo.pCommandBuffers = &commandBuffers[imageIndex];
	1850
	1851	VkSemaphore signalSemaphores[] = { renderFinishedSemaphores[currentFrame] };
	1852
	1853	submitInfo.signalSemaphoreCount = 1;
	1854	submitInfo.pSignalSemaphores = signalSemaphores;
	1855
[75108ef]	1856	vkResetFences(device, 1, &inFlightFences[currentFrame]);
	1857
[47bff4c]	1858	if (vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]) != VK_SUCCESS) {
	1859	throw runtime_error("failed to submit draw command buffer!");
[bfd620e]	1860	}
[47bff4c]	1861
	1862	VkPresentInfoKHR presentInfo = {};
	1863	presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
	1864	presentInfo.waitSemaphoreCount = 1;
	1865	presentInfo.pWaitSemaphores = signalSemaphores;
	1866
	1867	VkSwapchainKHR swapChains[] = { swapChain };
	1868	presentInfo.swapchainCount = 1;
	1869	presentInfo.pSwapchains = swapChains;
	1870	presentInfo.pImageIndices = &imageIndex;
	1871	presentInfo.pResults = nullptr;
	1872
[75108ef]	1873	result = vkQueuePresentKHR(presentQueue, &presentInfo);
	1874
	1875	if (result == VK_ERROR_OUT_OF_DATE_KHR \|\| result == VK_SUBOPTIMAL_KHR \|\| framebufferResized) {
	1876	framebufferResized = false;
	1877	recreateSwapChain();
	1878	} else if (result != VK_SUCCESS) {
	1879	throw runtime_error("failed to present swap chain image!");
	1880	}
[47bff4c]	1881
	1882	currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
[fba08f2]	1883	currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
[f94eea9]	1884	/* START OF REFACTORED CODE */
[826df16]	1885	}
	1886
[5f3dba8]	1887	void drawUI() {
[f94eea9]	1888	/* END OF REFACTORED CODE */
[e1a7f5a]	1889	// TODO: Since I currently don't use any other render targets,
	1890	// I may as well set this once before the render loop
[5f3dba8]	1891	SDL_SetRenderTarget(gRenderer, uiOverlay);
	1892
[5936c58]	1893	SDL_SetRenderDrawColor(gRenderer, 0x00, 0x00, 0x00, 0x00);
[5f3dba8]	1894	SDL_RenderClear(gRenderer);
	1895
	1896	SDL_Rect rect;
	1897
	1898	rect = {280, 220, 100, 100};
[5936c58]	1899	SDL_SetRenderDrawColor(gRenderer, 0x00, 0xFF, 0x00, 0xFF);
[5f3dba8]	1900	SDL_RenderFillRect(gRenderer, &rect);
	1901	SDL_SetRenderDrawColor(gRenderer, 0x00, 0x9F, 0x9F, 0xFF);
	1902
	1903	rect = {10, 10, 0, 0};
	1904	SDL_QueryTexture(uiText, nullptr, nullptr, &(rect.w), &(rect.h));
	1905	SDL_RenderCopy(gRenderer, uiText, nullptr, &rect);
	1906
	1907	rect = {10, 80, 0, 0};
	1908	SDL_QueryTexture(uiImage, nullptr, nullptr, &(rect.w), &(rect.h));
	1909	SDL_RenderCopy(gRenderer, uiImage, nullptr, &rect);
	1910
[5936c58]	1911	SDL_SetRenderDrawColor(gRenderer, 0x00, 0x00, 0xFF, 0xFF);
[5f3dba8]	1912	SDL_RenderDrawLine(gRenderer, 50, 5, 150, 500);
	1913
[e1a7f5a]	1914	populateImageFromSDLTexture(uiOverlay, sdlOverlayImage);
[f94eea9]	1915	/* START OF REFACTORED CODE */
[5f3dba8]	1916	}
[f94eea9]	1917	/* END OF REFACTORED CODE */
[5f3dba8]	1918
[de32fda]	1919	void updateUniformBuffer(uint32_t currentImage) {
	1920	static auto startTime = chrono::high_resolution_clock::now();
	1921
	1922	auto currentTime = chrono::high_resolution_clock::now();
	1923	float time = chrono::duration<float, chrono::seconds::period>(currentTime - startTime).count();
	1924
	1925	UniformBufferObject ubo = {};
[f00ee54]	1926	ubo.model = rotate(glm::mat4(1.0f), time * glm::radians(90.0f), glm::vec3(0.0f, 0.0f, 1.0f));
	1927	ubo.view = lookAt(glm::vec3(0.0f, 2.0f, 2.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
	1928	ubo.proj = perspective(radians(45.0f), swapChainExtent.width / (float)swapChainExtent.height, 0.1f, 10.0f);
[4f63fa8]	1929	ubo.proj[1][1] *= -1; // flip the y-axis so that +y is up
[fba08f2]	1930
[de32fda]	1931	void* data;
	1932	vkMapMemory(device, uniformBuffersMemory[currentImage], 0, sizeof(ubo), 0, &data);
	1933	memcpy(data, &ubo, sizeof(ubo));
	1934	vkUnmapMemory(device, uniformBuffersMemory[currentImage]);
	1935	}
	1936
[621664a]	1937	void recreateSwapChain() {
[cabdd5c]	1938	gui->refreshWindowSize();
[621664a]	1939
[cabdd5c]	1940	while (gui->getWindowWidth() == 0 \|\| gui->getWindowHeight() == 0 \|\|
[621664a]	1941	(SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED) != 0) {
	1942	SDL_WaitEvent(nullptr);
[cabdd5c]	1943	gui->refreshWindowSize();
[621664a]	1944	}
	1945
	1946	vkDeviceWaitIdle(device);
	1947
	1948	cleanupSwapChain();
	1949
	1950	createSwapChain();
	1951	createImageViews();
	1952	createRenderPass();
[d22ae72]	1953
[e5d4aca]	1954	createBufferResources();
	1955	}
[d22ae72]	1956
[e5d4aca]	1957	void createBufferResources() {
[b794178]	1958	// TODO: The three functions below will be called in vulkan-game following the
	1959	// pipeline creation (createDescriptorSets()), and before createCommandBuffers()
[adcd252]	1960	createDepthResources();
[621664a]	1961	createFramebuffers();
	1962	createUniformBuffers();
[d22ae72]	1963
[b794178]	1964	/* START OF REFACTORED CODE */
[e5d4aca]	1965	createGraphicsPipeline("shaders/scene-vert.spv", "shaders/scene-frag.spv", scenePipeline);
[721e8be]	1966	createDescriptorPool(scenePipeline);
[b794178]	1967	/* END OF REFACTORED CODE */
[721e8be]	1968	createDescriptorSets(scenePipeline);
[d22ae72]	1969
[b794178]	1970	/* START OF REFACTORED CODE */
[e5d4aca]	1971	createGraphicsPipeline("shaders/overlay-vert.spv", "shaders/overlay-frag.spv", overlayPipeline);
[721e8be]	1972	createDescriptorPool(overlayPipeline);
[b794178]	1973	/* END OF REFACTORED CODE */
[721e8be]	1974	createDescriptorSets(overlayPipeline);
[d22ae72]	1975
[621664a]	1976	createCommandBuffers();
	1977	}
	1978
[826df16]	1979	void cleanup() {
[b794178]	1980	/* START OF REFACTORED CODE */
[75108ef]	1981	cleanupSwapChain();
[c1c2021]	1982	/* END OF REFACTORED CODE */
[75108ef]	1983
[fba08f2]	1984	vkDestroySampler(device, textureSampler, nullptr);
[69dccfe]	1985
[fba08f2]	1986	vkDestroyImageView(device, textureImageView, nullptr);
[eea05dd]	1987	vkDestroyImage(device, textureImage, nullptr);
[f5d5686]	1988	vkFreeMemory(device, textureImageMemory, nullptr);
[eea05dd]	1989
[e1a7f5a]	1990	vkDestroyImageView(device, sdlOverlayImageView, nullptr);
	1991	vkDestroyImage(device, sdlOverlayImage, nullptr);
	1992	vkFreeMemory(device, sdlOverlayImageMemory, nullptr);
	1993
[b794178]	1994	/* START OF REFACTORED CODE */
[d22ae72]	1995	cleanupPipelineBuffers(scenePipeline);
	1996	cleanupPipelineBuffers(overlayPipeline);
[b794178]	1997	/* END OF REFACTORED CODE */
[80edd70]	1998
[47bff4c]	1999	for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
	2000	vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr);
[621664a]	2001	vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr);
[47bff4c]	2002	vkDestroyFence(device, inFlightFences[i], nullptr);
	2003	}
	2004
[c1c2021]	2005	/* START OF REFACTORED CODE */
[fa9fa1c]	2006	vkDestroyCommandPool(device, commandPool, nullptr);
[909b51a]	2007	vkDestroyDevice(device, nullptr);
[cabdd5c]	2008	vkDestroySurfaceKHR(instance, surface, nullptr);
[909b51a]	2009
[80de39d]	2010	if (enableValidationLayers) {
	2011	DestroyDebugUtilsMessengerEXT(instance, debugMessenger, nullptr);
	2012	}
	2013
[826df16]	2014	vkDestroyInstance(instance, nullptr);
	2015
[5f3dba8]	2016	// TODO: Check if any of these functions accept null parameters
	2017	// If they do, I don't need to check for that
	2018
	2019	if (uiOverlay != nullptr) {
	2020	SDL_DestroyTexture(uiOverlay);
	2021	uiOverlay = nullptr;
	2022	}
[b794178]	2023	/* END OF REFACTORED CODE */
[5f3dba8]	2024
	2025	TTF_CloseFont(gFont);
	2026	gFont = nullptr;
	2027
	2028	if (uiText != nullptr) {
	2029	SDL_DestroyTexture(uiText);
	2030	uiText = nullptr;
	2031	}
	2032
	2033	if (uiImage != nullptr) {
	2034	SDL_DestroyTexture(uiImage);
	2035	uiImage = nullptr;
	2036	}
	2037
[cabdd5c]	2038	/* START OF REFACTORED CODE */
[5f3dba8]	2039	SDL_DestroyRenderer(gRenderer);
	2040	gRenderer = nullptr;
	2041
[7fc5e27]	2042	gui->destroyWindow();
	2043	gui->shutdown();
[98f3232]	2044	delete gui;
[826df16]	2045	}
[e09ad38]	2046
[621664a]	2047	void cleanupSwapChain() {
[c1c2021]	2048	/* END OF REFACTORED CODE */
[adcd252]	2049	vkDestroyImageView(device, depthImageView, nullptr);
	2050	vkDestroyImage(device, depthImage, nullptr);
	2051	vkFreeMemory(device, depthImageMemory, nullptr);
	2052
[621664a]	2053	for (auto framebuffer : swapChainFramebuffers) {
	2054	vkDestroyFramebuffer(device, framebuffer, nullptr);
	2055	}
	2056
	2057	vkFreeCommandBuffers(device, commandPool, static_cast<uint32_t>(commandBuffers.size()), commandBuffers.data());
	2058
[b794178]	2059	/* START OF REFACTORED CODE */
[d22ae72]	2060	cleanupPipeline(scenePipeline);
	2061	cleanupPipeline(overlayPipeline);
[b8b32bd]	2062
[621664a]	2063	vkDestroyRenderPass(device, renderPass, nullptr);
	2064
	2065	for (auto imageView : swapChainImageViews) {
	2066	vkDestroyImageView(device, imageView, nullptr);
	2067	}
	2068
	2069	vkDestroySwapchainKHR(device, swapChain, nullptr);
[502bd0b]	2070	/* END OF REFACTORED CODE */
[621664a]	2071
	2072	for (size_t i = 0; i < swapChainImages.size(); i++) {
	2073	vkDestroyBuffer(device, uniformBuffers[i], nullptr);
	2074	vkFreeMemory(device, uniformBuffersMemory[i], nullptr);
	2075	}
[d22ae72]	2076	}
	2077
[b794178]	2078	/* START OF REFACTORED CODE */
[d22ae72]	2079	void cleanupPipeline(GraphicsPipelineInfo& pipeline) {
	2080	vkDestroyPipeline(device, pipeline.pipeline, nullptr);
	2081	vkDestroyDescriptorPool(device, pipeline.descriptorPool, nullptr);
	2082	vkDestroyPipelineLayout(device, pipeline.pipelineLayout, nullptr);
	2083	}
[b794178]	2084	/* END OF REFACTORED CODE */
[d22ae72]	2085
	2086	void cleanupPipelineBuffers(GraphicsPipelineInfo& pipeline) {
[b794178]	2087	/* START OF REFACTORED CODE */
[d22ae72]	2088	vkDestroyDescriptorSetLayout(device, pipeline.descriptorSetLayout, nullptr);
[b794178]	2089	/* END OF REFACTORED CODE */
[621664a]	2090
[d22ae72]	2091	vkDestroyBuffer(device, pipeline.vertexBuffer, nullptr);
	2092	vkFreeMemory(device, pipeline.vertexBufferMemory, nullptr);
	2093	vkDestroyBuffer(device, pipeline.indexBuffer, nullptr);
	2094	vkFreeMemory(device, pipeline.indexBufferMemory, nullptr);
[621664a]	2095	}
	2096
[e09ad38]	2097	static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(
[621664a]	2098	VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
	2099	VkDebugUtilsMessageTypeFlagsEXT messageType,
	2100	const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
	2101	void* pUserData) {
[e09ad38]	2102	cerr << "validation layer: " << pCallbackData->pMessage << endl;
	2103
	2104	return VK_FALSE;
[0e6ecf3]	2105	}
[e09ad38]	2106
	2107	static vector<char> readFile(const string& filename) {
	2108	ifstream file(filename, ios::ate \| ios::binary);
	2109
	2110	if (!file.is_open()) {
	2111	throw runtime_error("failed to open file!");
	2112	}
	2113
[621664a]	2114	size_t fileSize = (size_t) file.tellg();
[e09ad38]	2115	vector<char> buffer(fileSize);
	2116
	2117	file.seekg(0);
	2118	file.read(buffer.data(), fileSize);
	2119
	2120	file.close();
	2121
	2122	return buffer;
	2123	}
[826df16]	2124	};
	2125
[cabdd5c]	2126	/* START OF REFACTORED CODE */
[1c6cd5e]	2127	int main(int argc, char* argv[]) {
[826df16]	2128
[b6127d2]	2129	#ifdef NDEBUG
	2130	cout << "DEBUGGING IS OFF" << endl;
	2131	#else
	2132	cout << "DEBUGGING IS ON" << endl;
	2133	#endif
[a8f0577]	2134
[826df16]	2135	cout << "Starting Vulkan game..." << endl;
	2136
	2137	VulkanGame game;
	2138
	2139	try {
	2140	game.run();
	2141	} catch (const exception& e) {
	2142	cerr << e.what() << endl;
	2143	return EXIT_FAILURE;
	2144	}
[03f4c64]	2145
[826df16]	2146	cout << "Finished running the game" << endl;
[03f4c64]	2147
[826df16]	2148	return EXIT_SUCCESS;
[03f4c64]	2149	}
[cabdd5c]	2150	/* END OF REFACTORED CODE */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: