source: opengl-game/vulkan-game.hpp@ b794178

#ifndef _VULKAN_GAME_H
#define _VULKAN_GAME_H

#include <glm/glm.hpp>

#include "game-gui-sdl.hpp"
#include "graphics-pipeline_vulkan.hpp"

#include "vulkan-utils.hpp"

#ifdef NDEBUG
   const bool ENABLE_VALIDATION_LAYERS = false;
#else
   const bool ENABLE_VALIDATION_LAYERS = true;
#endif

// TODO: Figure out if these structs should be defined in the VulkanGame class

struct Vertex {
   glm::vec3 pos;
   glm::vec3 color;
   glm::vec2 texCoord;
};

struct OverlayVertex {
   glm::vec3 pos;
   glm::vec2 texCoord;
};

class VulkanGame {
   public:
      VulkanGame();
      ~VulkanGame();

      void run(int width, int height, unsigned char guiFlags);

   private:
      GameGui* gui;
      Viewport viewport;

      vector<GraphicsPipeline_Vulkan> graphicsPipelines;

      SDL_version sdlVersion;
      SDL_Window* window = nullptr;
      SDL_Renderer* renderer = nullptr;

      SDL_Texture* uiOverlay = nullptr;

      VkInstance instance;
      VkDebugUtilsMessengerEXT debugMessenger;
      VkSurfaceKHR surface; // TODO: Change the variable name to vulkanSurface
      VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
      VkDevice device;

      VkQueue graphicsQueue;
      VkQueue presentQueue;

      VkSwapchainKHR swapChain;
      vector<VkImage> swapChainImages;
      VkFormat swapChainImageFormat;
      vector<VkImageView> swapChainImageViews;

      VkRenderPass renderPass;
      VkCommandPool commandPool;

      // TODO: Create these (and wrap them inside a VulkanImage)
      VkImage depthImage;
      VkDeviceMemory depthImageMemory;
      VkImageView depthImageView;

      VkSampler textureSampler;

      vector<VkDescriptorBufferInfo> uniformBufferInfoList;

      // These are currently to store the MVP matrix
      // I should figure out if it makes sense to use them for other uniforms in the future
      // If not, I should rename them to better indicate their purpose.
      // I should also decide if I can use these for all shaders, or if I need a separapte set of buffers for each one
      vector<VkBuffer> uniformBuffers;
      vector<VkDeviceMemory> uniformBuffersMemory;

      VulkanImage floorTextureImage;
      VkDescriptorImageInfo floorTextureImageDescriptor;

      VulkanImage sdlOverlayImage;
      VkDescriptorImageInfo sdlOverlayImageDescriptor;

      bool framebufferResized = false;

      bool initWindow(int width, int height, unsigned char guiFlags);
      void initVulkan();
      void mainLoop();
      void renderUI();
      void renderScene();
      void cleanup();

      void createVulkanInstance(const vector<const char*> &validationLayers);
      void setupDebugMessenger();
      void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo);
      void createVulkanSurface();
      void pickPhysicalDevice(const vector<const char*>& deviceExtensions);
      bool isDeviceSuitable(VkPhysicalDevice physicalDevice, const vector<const char*>& deviceExtensions);
      void createLogicalDevice(
         const vector<const char*> validationLayers,
         const vector<const char*>& deviceExtensions);
      void createSwapChain();
      void createImageViews();
      void createRenderPass();
      VkFormat findDepthFormat();
      void createCommandPool();
      void createVulkanResources();
      void createTextureSampler();
      void createUniformBuffers();

      void cleanupSwapChain();

      static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(
            VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
            VkDebugUtilsMessageTypeFlagsEXT messageType,
            const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
            void* pUserData);
};

#endif // _VULKAN_GAME_H