VulkanManager.h

// Copyright (c) 2024 Michael Carlie. All Rights Reserved.
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
 
#ifndef INCLUDE_VULKANENGINE_VULKANMANAGER_H_
#define INCLUDE_VULKANENGINE_VULKANMANAGER_H_
 
#include <VulkanEngine/Camera.h>
#include <VulkanEngine/Device.h>
#include <VulkanEngine/IndexAttribute.h>
#include <VulkanEngine/MeshBase.h>
#include <VulkanEngine/Shader.h>
#include <VulkanEngine/UniformBuffer.h>
#include <VulkanEngine/VertexAttribute.h>
#include <VulkanEngine/Window.h>
 
// Support latest vk_mem_alloc with older Vulkan SDK headers.
#ifndef VK_API_VERSION_MAJOR
#define VK_API_VERSION_MAJOR(version) VK_VERSION_MAJOR(version)
#endif
 
#ifndef VK_API_VERSION_MINOR
#define VK_API_VERSION_MINOR(version) VK_VERSION_MINOR(version)
#endif
 
#ifndef VK_API_VERSION_PATCH
#define VK_API_VERSION_PATCH(version) VK_VERSION_PATCH(version)
#endif
#include <vk_mem_alloc.h>
 
#include <Eigen/Eigen>
#include <iostream>
#include <memory>
 
namespace VulkanEngine {
 
// Forward decleration
template <vk::Format format, vk::ImageType image_type, vk::ImageTiling tiling,
          vk::SampleCountFlagBits  // NOLINT(whitespace/indent_namespace)
              sample_count_flags>  // NOLINT(whitespace/indent_namespace)
class Image;
class RenderPass;
class Framebuffer;
class Swapchain;
 
class VulkanManager {
 private:
  VulkanManager();
 
  static std::shared_ptr<VulkanManager>& getInstanceInternal();
 
 public:
  ~VulkanManager();
 
  VulkanManager(const VulkanManager&) = delete;
 
  void operator=(const VulkanManager&) = delete;
 
  static VulkanManager& getInstance();
 
  static void resetInstance();
 
  static void destroyInstance();
 
  bool initialize(const std::shared_ptr<Window> _window);
 
  vk::CommandBuffer getCurrentCommandBuffer();
 
  void waitForFence();
 
  vk::Framebuffer getCurrentSwapchainFramebuffer();
 
  void drawImage();
 
  std::shared_ptr<Device> getDevice() { return device; }
 
  vk::Instance getVkInstance() const { return vk_instance; }
 
  const std::shared_ptr<RenderPass> getDefaultRenderPass() const {
    return default_render_pass;
  }
 
  const size_t getCurrentFrame() const { return current_frame; }
 
  const size_t getFramesInFlight() const { return frames_in_flight; }
 
 private:
  void cleanup();
 
  vk::Instance vk_instance;
 
  std::shared_ptr<Window> window;
 
  std::shared_ptr<Device> device;
  std::shared_ptr<Swapchain> swapchain;
  std::shared_ptr<RenderPass> default_render_pass;
 
  size_t frames_in_flight;
  size_t current_frame;
 
  bool initialized;
};
 
}  // namespace VulkanEngine
 
#endif  // INCLUDE_VULKANENGINE_VULKANMANAGER_H_