Context Navigation

source: opengl-game/vulkan-game.cpp@ d53ef6a

feature/imgui-sdl points-test

Last change on this file since d53ef6a was cbe946d, checked in by Dmitry Portnoy <dmp1488@…>, 5 years ago
Add separate shaders for the scene and overlay to the Vulkan project and add some notes about future work
Property mode set to `100644`
File size: 84.2 KB

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

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

Download in other formats: