Index: sdl-game.cpp
===================================================================
--- sdl-game.cpp	(revision 3b7d4970dceeff33d77df2de5074fb85023aa4e6)
+++ sdl-game.cpp	(revision 3b7d4970dceeff33d77df2de5074fb85023aa4e6)
@@ -0,0 +1,684 @@
+#include "sdl-game.hpp"
+
+#include <iostream>
+#include <set>
+#include <stdexcept>
+
+// dear imgui: standalone example application for SDL2 + Vulkan
+// If you are new to dear imgui, see examples/README.txt and documentation at the top of imgui.cpp.
+
+// Important note to the reader who wish to integrate imgui_impl_vulkan.cpp/.h in their own engine/app.
+// - Common ImGui_ImplVulkan_XXX functions and structures are used to interface with imgui_impl_vulkan.cpp/.h.
+//   You will use those if you want to use this rendering back-end in your engine/app.
+// - Helper ImGui_ImplVulkanH_XXX functions and structures are only used by this example (main.cpp) and by
+//   the back-end itself (imgui_impl_vulkan.cpp), but should PROBABLY NOT be used by your own engine/app code.
+// Read comments in imgui_impl_vulkan.h.
+
+#include "IMGUI/imgui.h"
+#include "IMGUI/imgui_impl_sdl.h"
+#include "IMGUI/imgui_impl_vulkan.h"
+#include <stdio.h>          // printf, fprintf
+#include <stdlib.h>         // abort
+
+#include <SDL2/SDL_vulkan.h>
+
+#include "logger.hpp"
+
+#include "vulkan-utils.hpp"
+
+using namespace std;
+
+//#define IMGUI_UNLIMITED_FRAME_RATE
+
+static VkAllocationCallbacks* g_Allocator = NULL;
+static VkInstance               g_Instance = VK_NULL_HANDLE;
+static VkPhysicalDevice         g_PhysicalDevice = VK_NULL_HANDLE;
+static VkDevice                 g_Device = VK_NULL_HANDLE;
+static uint32_t                 g_QueueFamily = (uint32_t)-1;
+static VkQueue                  g_Queue = VK_NULL_HANDLE;
+static VkPipelineCache          g_PipelineCache = VK_NULL_HANDLE;
+static VkDescriptorPool         g_DescriptorPool = VK_NULL_HANDLE;
+
+static ImGui_ImplVulkanH_Window g_MainWindowData;
+static uint32_t                 g_MinImageCount = 2;
+static bool                     g_SwapChainRebuild = false;
+
+static void check_vk_result(VkResult err)
+{
+   if (err == 0)
+      return;
+   fprintf(stderr, "[vulkan] Error: VkResult = %d\n", err);
+   if (err < 0)
+      abort();
+}
+
+// All the ImGui_ImplVulkanH_XXX structures/functions are optional helpers used by the demo.
+// Your real engine/app may not use them.
+static void SetupVulkanWindow(ImGui_ImplVulkanH_Window* wd, VkSurfaceKHR surface, int width, int height)
+{
+   wd->Surface = surface;
+
+   // Check for WSI support
+   VkBool32 res;
+   vkGetPhysicalDeviceSurfaceSupportKHR(g_PhysicalDevice, g_QueueFamily, wd->Surface, &res);
+   if (res != VK_TRUE)
+   {
+      fprintf(stderr, "Error no WSI support on physical device 0\n");
+      exit(-1);
+   }
+
+   // Select Surface Format
+   const VkFormat requestSurfaceImageFormat[] = { VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_B8G8R8_UNORM, VK_FORMAT_R8G8B8_UNORM };
+   const VkColorSpaceKHR requestSurfaceColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
+   wd->SurfaceFormat = ImGui_ImplVulkanH_SelectSurfaceFormat(g_PhysicalDevice, wd->Surface, requestSurfaceImageFormat, (size_t)IM_ARRAYSIZE(requestSurfaceImageFormat), requestSurfaceColorSpace);
+
+   // Select Present Mode
+#ifdef IMGUI_UNLIMITED_FRAME_RATE
+   VkPresentModeKHR present_modes[] = { VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR };
+#else
+   VkPresentModeKHR present_modes[] = { VK_PRESENT_MODE_FIFO_KHR };
+#endif
+   wd->PresentMode = ImGui_ImplVulkanH_SelectPresentMode(g_PhysicalDevice, wd->Surface, &present_modes[0], IM_ARRAYSIZE(present_modes));
+   //printf("[vulkan] Selected PresentMode = %d\n", wd->PresentMode);
+
+   // Create SwapChain, RenderPass, Framebuffer, etc.
+   IM_ASSERT(g_MinImageCount >= 2);
+   ImGui_ImplVulkanH_CreateOrResizeWindow(g_Instance, g_PhysicalDevice, g_Device, wd, g_QueueFamily, g_Allocator, width, height, g_MinImageCount);
+}
+
+static void CleanupVulkanWindow()
+{
+   ImGui_ImplVulkanH_DestroyWindow(g_Instance, g_Device, &g_MainWindowData, g_Allocator);
+}
+
+static void FrameRender(ImGui_ImplVulkanH_Window* wd, ImDrawData* draw_data)
+{
+   VkResult err;
+
+   VkSemaphore image_acquired_semaphore = wd->FrameSemaphores[wd->SemaphoreIndex].ImageAcquiredSemaphore;
+   VkSemaphore render_complete_semaphore = wd->FrameSemaphores[wd->SemaphoreIndex].RenderCompleteSemaphore;
+   err = vkAcquireNextImageKHR(g_Device, wd->Swapchain, UINT64_MAX, image_acquired_semaphore, VK_NULL_HANDLE, &wd->FrameIndex);
+   if (err == VK_ERROR_OUT_OF_DATE_KHR)
+   {
+      g_SwapChainRebuild = true;
+      return;
+   }
+   check_vk_result(err);
+
+   ImGui_ImplVulkanH_Frame* fd = &wd->Frames[wd->FrameIndex];
+   {
+      err = vkWaitForFences(g_Device, 1, &fd->Fence, VK_TRUE, UINT64_MAX);    // wait indefinitely instead of periodically checking
+      check_vk_result(err);
+
+      err = vkResetFences(g_Device, 1, &fd->Fence);
+      check_vk_result(err);
+   }
+   {
+      err = vkResetCommandPool(g_Device, fd->CommandPool, 0);
+      check_vk_result(err);
+      VkCommandBufferBeginInfo info = {};
+      info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+      info.flags |= VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+      err = vkBeginCommandBuffer(fd->CommandBuffer, &info);
+      check_vk_result(err);
+   }
+   {
+      VkRenderPassBeginInfo info = {};
+      info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+      info.renderPass = wd->RenderPass;
+      info.framebuffer = fd->Framebuffer;
+      info.renderArea.extent.width = wd->Width;
+      info.renderArea.extent.height = wd->Height;
+      info.clearValueCount = 1;
+      info.pClearValues = &wd->ClearValue;
+      vkCmdBeginRenderPass(fd->CommandBuffer, &info, VK_SUBPASS_CONTENTS_INLINE);
+   }
+
+   // Record dear imgui primitives into command buffer
+   ImGui_ImplVulkan_RenderDrawData(draw_data, fd->CommandBuffer);
+
+   // Submit command buffer
+   vkCmdEndRenderPass(fd->CommandBuffer);
+   {
+      VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+      VkSubmitInfo info = {};
+      info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+      info.waitSemaphoreCount = 1;
+      info.pWaitSemaphores = &image_acquired_semaphore;
+      info.pWaitDstStageMask = &wait_stage;
+      info.commandBufferCount = 1;
+      info.pCommandBuffers = &fd->CommandBuffer;
+      info.signalSemaphoreCount = 1;
+      info.pSignalSemaphores = &render_complete_semaphore;
+
+      err = vkEndCommandBuffer(fd->CommandBuffer);
+      check_vk_result(err);
+      err = vkQueueSubmit(g_Queue, 1, &info, fd->Fence);
+      check_vk_result(err);
+   }
+}
+
+static void FramePresent(ImGui_ImplVulkanH_Window* wd)
+{
+   if (g_SwapChainRebuild)
+      return;
+   VkSemaphore render_complete_semaphore = wd->FrameSemaphores[wd->SemaphoreIndex].RenderCompleteSemaphore;
+   VkPresentInfoKHR info = {};
+   info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+   info.waitSemaphoreCount = 1;
+   info.pWaitSemaphores = &render_complete_semaphore;
+   info.swapchainCount = 1;
+   info.pSwapchains = &wd->Swapchain;
+   info.pImageIndices = &wd->FrameIndex;
+   VkResult err = vkQueuePresentKHR(g_Queue, &info);
+   if (err == VK_ERROR_OUT_OF_DATE_KHR)
+   {
+      g_SwapChainRebuild = true;
+      return;
+   }
+   check_vk_result(err);
+   wd->SemaphoreIndex = (wd->SemaphoreIndex + 1) % wd->ImageCount; // Now we can use the next set of semaphores
+}
+
+/********************************************* START OF NEW CODE *********************************************/
+
+VKAPI_ATTR VkBool32 VKAPI_CALL VulkanGame::debugCallback(
+   VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+   VkDebugUtilsMessageTypeFlagsEXT messageType,
+   const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
+   void* pUserData) {
+   cerr << "validation layer: " << pCallbackData->pMessage << endl;
+
+   return VK_FALSE;
+}
+
+VulkanGame::VulkanGame(int maxFramesInFlight) : MAX_FRAMES_IN_FLIGHT(maxFramesInFlight) {
+   this->gui = nullptr;
+   this->window = nullptr;
+}
+
+VulkanGame::~VulkanGame() {
+}
+
+void VulkanGame::run(int width, int height, unsigned char guiFlags) {
+   cout << "DEBUGGING IS " << (ENABLE_VALIDATION_LAYERS ? "ON" : "OFF") << endl;
+
+   cout << "Vulkan Game" << endl;
+
+   if (initUI(width, height, guiFlags) == RTWO_ERROR) {
+      return;
+   }
+
+   initVulkan();
+
+   // Create Framebuffers
+   int w, h;
+   SDL_GetWindowSize(window, &w, &h);
+   ImGui_ImplVulkanH_Window* wd = &g_MainWindowData;
+   // TODO: SetupVulkanWIndow calls vkGetPhysicalDeviceSurfaceSupportKHR to get the present queue. In vulkan-game, I do this in findQueueFamilies.
+   SetupVulkanWindow(wd, surface, w, h);
+
+   // TODO: Start from here. I've already reviewed everything before this
+
+   // Setup Dear ImGui context
+   IMGUI_CHECKVERSION();
+   ImGui::CreateContext();
+   ImGuiIO& io = ImGui::GetIO(); (void)io;
+   //io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
+   //io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
+
+   // Setup Dear ImGui style
+   ImGui::StyleColorsDark();
+   //ImGui::StyleColorsClassic();
+
+   // Setup Platform/Renderer bindings
+   ImGui_ImplSDL2_InitForVulkan(window);
+   ImGui_ImplVulkan_InitInfo init_info = {};
+   init_info.Instance = g_Instance;
+   init_info.PhysicalDevice = g_PhysicalDevice;
+   init_info.Device = g_Device;
+   init_info.QueueFamily = g_QueueFamily;
+   init_info.Queue = g_Queue;
+   init_info.PipelineCache = g_PipelineCache;
+   init_info.DescriptorPool = g_DescriptorPool;
+   init_info.Allocator = g_Allocator;
+   init_info.MinImageCount = g_MinImageCount;
+   init_info.ImageCount = wd->ImageCount;
+   init_info.CheckVkResultFn = check_vk_result;
+   ImGui_ImplVulkan_Init(&init_info, wd->RenderPass);
+
+   // Load Fonts
+   // - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use ImGui::PushFont()/PopFont() to select them.
+   // - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple.
+   // - If the file cannot be loaded, the function will return NULL. Please handle those errors in your application (e.g. use an assertion, or display an error and quit).
+   // - The fonts will be rasterized at a given size (w/ oversampling) and stored into a texture when calling ImFontAtlas::Build()/GetTexDataAsXXXX(), which ImGui_ImplXXXX_NewFrame below will call.
+   // - Read 'docs/FONTS.md' for more instructions and details.
+   // - Remember that in C/C++ if you want to include a backslash \ in a string literal you need to write a double backslash \\ !
+   //io.Fonts->AddFontDefault();
+   //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Roboto-Medium.ttf", 16.0f);
+   //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Cousine-Regular.ttf", 15.0f);
+   //io.Fonts->AddFontFromFileTTF("../../misc/fonts/DroidSans.ttf", 16.0f);
+   //io.Fonts->AddFontFromFileTTF("../../misc/fonts/ProggyTiny.ttf", 10.0f);
+   //ImFont* font = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesJapanese());
+   //IM_ASSERT(font != NULL);
+
+   VkResult err;
+
+   // Upload Fonts
+   {
+      // Use any command queue
+      VkCommandPool command_pool = wd->Frames[wd->FrameIndex].CommandPool;
+      VkCommandBuffer command_buffer = wd->Frames[wd->FrameIndex].CommandBuffer;
+
+      err = vkResetCommandPool(g_Device, command_pool, 0);
+      check_vk_result(err);
+      VkCommandBufferBeginInfo begin_info = {};
+      begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+      begin_info.flags |= VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+      err = vkBeginCommandBuffer(command_buffer, &begin_info);
+      check_vk_result(err);
+
+      ImGui_ImplVulkan_CreateFontsTexture(command_buffer);
+
+      VkSubmitInfo end_info = {};
+      end_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+      end_info.commandBufferCount = 1;
+      end_info.pCommandBuffers = &command_buffer;
+      err = vkEndCommandBuffer(command_buffer);
+      check_vk_result(err);
+      err = vkQueueSubmit(g_Queue, 1, &end_info, VK_NULL_HANDLE);
+      check_vk_result(err);
+
+      err = vkDeviceWaitIdle(g_Device);
+      check_vk_result(err);
+      ImGui_ImplVulkan_DestroyFontUploadObjects();
+   }
+
+   // Our state
+   bool show_demo_window = true;
+   bool show_another_window = false;
+   ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
+
+   // Main loop
+   bool done = false;
+   while (!done) {
+      // Poll and handle events (inputs, window resize, etc.)
+      // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
+      // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application.
+      // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application.
+      // Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
+      SDL_Event event;
+      while (SDL_PollEvent(&event)) {
+         ImGui_ImplSDL2_ProcessEvent(&event);
+         if (event.type == SDL_QUIT)
+            done = true;
+         if (event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_CLOSE && event.window.windowID == SDL_GetWindowID(window))
+            done = true;
+      }
+
+      // Resize swap chain?
+      if (g_SwapChainRebuild) {
+         int width, height;
+         SDL_GetWindowSize(window, &width, &height);
+         if (width > 0 && height > 0)
+         {
+            ImGui_ImplVulkan_SetMinImageCount(g_MinImageCount);
+            ImGui_ImplVulkanH_CreateOrResizeWindow(g_Instance, g_PhysicalDevice, g_Device, &g_MainWindowData, g_QueueFamily, g_Allocator, width, height, g_MinImageCount);
+            g_MainWindowData.FrameIndex = 0;
+            g_SwapChainRebuild = false;
+         }
+      }
+
+      // Start the Dear ImGui frame
+      ImGui_ImplVulkan_NewFrame();
+      ImGui_ImplSDL2_NewFrame(window);
+      ImGui::NewFrame();
+
+      // 1. Show the big demo window (Most of the sample code is in ImGui::ShowDemoWindow()! You can browse its code to learn more about Dear ImGui!).
+      if (show_demo_window)
+         ImGui::ShowDemoWindow(&show_demo_window);
+
+      // 2. Show a simple window that we create ourselves. We use a Begin/End pair to created a named window.
+      {
+         static float f = 0.0f;
+         static int counter = 0;
+
+         ImGui::Begin("Hello, world!");                          // Create a window called "Hello, world!" and append into it.
+
+         ImGui::Text("This is some useful text.");               // Display some text (you can use a format strings too)
+         ImGui::Checkbox("Demo Window", &show_demo_window);      // Edit bools storing our window open/close state
+         ImGui::Checkbox("Another Window", &show_another_window);
+
+         ImGui::SliderFloat("float", &f, 0.0f, 1.0f);            // Edit 1 float using a slider from 0.0f to 1.0f
+         ImGui::ColorEdit3("clear color", (float*)&clear_color); // Edit 3 floats representing a color
+
+         if (ImGui::Button("Button"))                            // Buttons return true when clicked (most widgets return true when edited/activated)
+            counter++;
+         ImGui::SameLine();
+         ImGui::Text("counter = %d", counter);
+
+         ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
+         ImGui::End();
+      }
+
+      // 3. Show another simple window.
+      if (show_another_window)
+      {
+         ImGui::Begin("Another Window", &show_another_window);   // Pass a pointer to our bool variable (the window will have a closing button that will clear the bool when clicked)
+         ImGui::Text("Hello from another window!");
+         if (ImGui::Button("Close Me"))
+            show_another_window = false;
+         ImGui::End();
+      }
+
+      // Rendering
+      ImGui::Render();
+      ImDrawData* draw_data = ImGui::GetDrawData();
+      const bool is_minimized = (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f);
+      if (!is_minimized)
+      {
+         memcpy(&wd->ClearValue.color.float32[0], &clear_color, 4 * sizeof(float));
+         FrameRender(wd, draw_data);
+         FramePresent(wd);
+      }
+   }
+
+   // Cleanup
+   err = vkDeviceWaitIdle(g_Device);
+   check_vk_result(err);
+   ImGui_ImplVulkan_Shutdown();
+   ImGui_ImplSDL2_Shutdown();
+   ImGui::DestroyContext();
+
+   CleanupVulkanWindow();
+   cleanup();
+
+   close_log();
+}
+
+bool VulkanGame::initUI(int width, int height, unsigned char guiFlags) {
+   // TODO: Create a game-gui function to get the gui version and retrieve it that way
+
+   SDL_VERSION(&sdlVersion); // This gets the compile-time version
+   SDL_GetVersion(&sdlVersion); // This gets the runtime version
+
+   cout << "SDL " <<
+      to_string(sdlVersion.major) << "." <<
+      to_string(sdlVersion.minor) << "." <<
+      to_string(sdlVersion.patch) << endl;
+
+   // TODO: Refactor the logger api to be more flexible,
+   // esp. since gl_log() and gl_log_err() have issues printing anything besides strings
+   restart_gl_log();
+   gl_log("starting SDL\n%s.%s.%s",
+      to_string(sdlVersion.major).c_str(),
+      to_string(sdlVersion.minor).c_str(),
+      to_string(sdlVersion.patch).c_str());
+
+   // TODO: Use open_Log() and related functions instead of gl_log ones
+   // TODO: In addition, delete the gl_log functions
+   open_log();
+   get_log() << "starting SDL" << endl;
+   get_log() <<
+      (int)sdlVersion.major << "." <<
+      (int)sdlVersion.minor << "." <<
+      (int)sdlVersion.patch << endl;
+
+   // TODO: Put all fonts, textures, and images in the assets folder
+   gui = new GameGui_SDL();
+
+   if (gui->init() == RTWO_ERROR) {
+      // TODO: Also print these sorts of errors to the log
+      cout << "UI library could not be initialized!" << endl;
+      cout << gui->getError() << endl;
+      return RTWO_ERROR;
+   }
+
+   window = (SDL_Window*)gui->createWindow("Vulkan Game", width, height, guiFlags & GUI_FLAGS_WINDOW_FULLSCREEN);
+   if (window == nullptr) {
+      cout << "Window could not be created!" << endl;
+      cout << gui->getError() << endl;
+      return RTWO_ERROR;
+   }
+
+   cout << "Target window size: (" << width << ", " << height << ")" << endl;
+   cout << "Actual window size: (" << gui->getWindowWidth() << ", " << gui->getWindowHeight() << ")" << endl;
+
+   return RTWO_SUCCESS;
+}
+
+void VulkanGame::initVulkan() {
+   const vector<const char*> validationLayers = {
+      "VK_LAYER_KHRONOS_validation"
+   };
+   const vector<const char*> deviceExtensions = {
+      VK_KHR_SWAPCHAIN_EXTENSION_NAME
+   };
+
+   createVulkanInstance(validationLayers);
+   setupDebugMessenger();
+   createVulkanSurface();
+   pickPhysicalDevice(deviceExtensions);
+   createLogicalDevice(validationLayers, deviceExtensions);
+
+   VkResult err;
+
+   // Create Descriptor Pool
+   {
+      VkDescriptorPoolSize pool_sizes[] =
+      {
+          { VK_DESCRIPTOR_TYPE_SAMPLER, 1000 },
+          { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1000 },
+          { VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1000 },
+          { VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1000 },
+          { VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1000 },
+          { VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1000 },
+          { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1000 },
+          { VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1000 },
+          { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1000 },
+          { VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 1000 },
+          { VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1000 }
+      };
+      VkDescriptorPoolCreateInfo pool_info = {};
+      pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+      pool_info.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
+      pool_info.maxSets = 1000 * IM_ARRAYSIZE(pool_sizes);
+      pool_info.poolSizeCount = (uint32_t)IM_ARRAYSIZE(pool_sizes);
+      pool_info.pPoolSizes = pool_sizes;
+      err = vkCreateDescriptorPool(g_Device, &pool_info, g_Allocator, &g_DescriptorPool);
+      check_vk_result(err);
+   }
+}
+
+void VulkanGame::cleanup() {
+   vkDestroyDescriptorPool(g_Device, g_DescriptorPool, g_Allocator);
+
+   if (ENABLE_VALIDATION_LAYERS) {
+      VulkanUtils::destroyDebugUtilsMessengerEXT(g_Instance, debugMessenger, nullptr);
+   }
+
+   vkDestroyDevice(g_Device, g_Allocator);
+   vkDestroyInstance(g_Instance, g_Allocator);
+
+   gui->destroyWindow();
+   gui->shutdown();
+   delete gui;
+}
+
+void VulkanGame::createVulkanInstance(const vector<const char*>& validationLayers) {
+   if (ENABLE_VALIDATION_LAYERS && !VulkanUtils::checkValidationLayerSupport(validationLayers)) {
+      throw runtime_error("validation layers requested, but not available!");
+   }
+
+   VkApplicationInfo appInfo = {};
+   appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+   appInfo.pApplicationName = "Vulkan Game";
+   appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
+   appInfo.pEngineName = "No Engine";
+   appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
+   appInfo.apiVersion = VK_API_VERSION_1_0;
+
+   VkInstanceCreateInfo createInfo = {};
+   createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+   createInfo.pApplicationInfo = &appInfo;
+
+   vector<const char*> extensions = gui->getRequiredExtensions();
+   if (ENABLE_VALIDATION_LAYERS) {
+      extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
+   }
+
+   createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
+   createInfo.ppEnabledExtensionNames = extensions.data();
+
+   cout << endl << "Extensions:" << endl;
+   for (const char* extensionName : extensions) {
+      cout << extensionName << endl;
+   }
+   cout << endl;
+
+   VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo;
+   if (ENABLE_VALIDATION_LAYERS) {
+      createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
+      createInfo.ppEnabledLayerNames = validationLayers.data();
+
+      populateDebugMessengerCreateInfo(debugCreateInfo);
+      createInfo.pNext = &debugCreateInfo;
+   } else {
+      createInfo.enabledLayerCount = 0;
+
+      createInfo.pNext = nullptr;
+   }
+
+   if (vkCreateInstance(&createInfo, nullptr, &g_Instance) != VK_SUCCESS) {
+      throw runtime_error("failed to create instance!");
+   }
+}
+
+void VulkanGame::setupDebugMessenger() {
+   if (!ENABLE_VALIDATION_LAYERS) {
+      return;
+   }
+
+   VkDebugUtilsMessengerCreateInfoEXT createInfo;
+   populateDebugMessengerCreateInfo(createInfo);
+
+   if (VulkanUtils::createDebugUtilsMessengerEXT(g_Instance, &createInfo, nullptr, &debugMessenger) != VK_SUCCESS) {
+      throw runtime_error("failed to set up debug messenger!");
+   }
+}
+
+void VulkanGame::populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo) {
+   createInfo = {};
+   createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
+   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;
+   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;
+   createInfo.pfnUserCallback = debugCallback;
+}
+
+void VulkanGame::createVulkanSurface() {
+   if (gui->createVulkanSurface(g_Instance, &surface) == RTWO_ERROR) {
+      throw runtime_error("failed to create window surface!");
+   }
+}
+
+void VulkanGame::pickPhysicalDevice(const vector<const char*>& deviceExtensions) {
+   uint32_t deviceCount = 0;
+   // TODO: Check VkResult
+   vkEnumeratePhysicalDevices(g_Instance, &deviceCount, nullptr);
+
+   if (deviceCount == 0) {
+      throw runtime_error("failed to find GPUs with Vulkan support!");
+   }
+
+   vector<VkPhysicalDevice> devices(deviceCount);
+   // TODO: Check VkResult
+   vkEnumeratePhysicalDevices(g_Instance, &deviceCount, devices.data());
+
+   cout << endl << "Graphics cards:" << endl;
+   for (const VkPhysicalDevice& device : devices) {
+      if (isDeviceSuitable(device, deviceExtensions)) {
+         g_PhysicalDevice = device;
+         break;
+      }
+   }
+   cout << endl;
+
+   if (g_PhysicalDevice == VK_NULL_HANDLE) {
+      throw runtime_error("failed to find a suitable GPU!");
+   }
+}
+
+bool VulkanGame::isDeviceSuitable(VkPhysicalDevice physicalDevice, const vector<const char*>& deviceExtensions) {
+   VkPhysicalDeviceProperties deviceProperties;
+   vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties);
+
+   cout << "Device: " << deviceProperties.deviceName << endl;
+
+   QueueFamilyIndices indices = VulkanUtils::findQueueFamilies(physicalDevice, surface);
+   bool extensionsSupported = VulkanUtils::checkDeviceExtensionSupport(physicalDevice, deviceExtensions);
+   bool swapChainAdequate = false;
+
+   if (extensionsSupported) {
+      SwapChainSupportDetails swapChainSupport = VulkanUtils::querySwapChainSupport(physicalDevice, surface);
+      swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();
+   }
+
+   VkPhysicalDeviceFeatures supportedFeatures;
+   vkGetPhysicalDeviceFeatures(physicalDevice, &supportedFeatures);
+
+   return indices.isComplete() && extensionsSupported && swapChainAdequate && supportedFeatures.samplerAnisotropy;
+}
+
+void VulkanGame::createLogicalDevice(const vector<const char*>& validationLayers,
+      const vector<const char*>& deviceExtensions) {
+   QueueFamilyIndices indices = VulkanUtils::findQueueFamilies(g_PhysicalDevice, surface);
+   g_QueueFamily = indices.graphicsFamily.value();
+
+   vector<VkDeviceQueueCreateInfo> queueCreateInfoList;
+   set<uint32_t> uniqueQueueFamilies = { indices.graphicsFamily.value() };
+
+   float queuePriority = 1.0f;
+   for (uint32_t queueFamily : uniqueQueueFamilies) {
+      VkDeviceQueueCreateInfo queueCreateInfo = {};
+      queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+      queueCreateInfo.queueCount = 1;
+      queueCreateInfo.queueFamilyIndex = queueFamily;
+      queueCreateInfo.pQueuePriorities = &queuePriority;
+
+      queueCreateInfoList.push_back(queueCreateInfo);
+   }
+
+   VkPhysicalDeviceFeatures deviceFeatures = {};
+   deviceFeatures.samplerAnisotropy = VK_TRUE;
+
+   VkDeviceCreateInfo createInfo = {};
+   createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+
+   createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfoList.size());
+   createInfo.pQueueCreateInfos = queueCreateInfoList.data();
+
+   createInfo.pEnabledFeatures = &deviceFeatures;
+
+   createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
+   createInfo.ppEnabledExtensionNames = deviceExtensions.data();
+
+   // These fields are ignored  by up-to-date Vulkan implementations,
+   // but it's a good idea to set them for backwards compatibility
+   if (ENABLE_VALIDATION_LAYERS) {
+      createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
+      createInfo.ppEnabledLayerNames = validationLayers.data();
+   }
+   else {
+      createInfo.enabledLayerCount = 0;
+   }
+
+   if (vkCreateDevice(g_PhysicalDevice, &createInfo, nullptr, &g_Device) != VK_SUCCESS) {
+      throw runtime_error("failed to create logical device!");
+   }
+
+   vkGetDeviceQueue(g_Device, g_QueueFamily, 0, &g_Queue);
+   //vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
+   //vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
+}
+
+/********************************************** END OF NEW CODE **********************************************/
