RehtiGraphics.hpp

Go to the documentation of this file.

#pragma once
#include <vulkan/vulkan.h>
 
#include "AABB.hpp"
#include "Camera.hpp"
#include "GraphicsObjectManager.hpp"
#include "Mesh.hpp"
#include "TimerCallbackSystem.hpp"
 
#include <algorithm>
#include <chrono>
#include <iostream>
#include <map>
#include <memory>
#include <set>
#include <string>
 
// Forward declarations
class RehtiGui;
 
enum EngineFlags
{
    NO_FLAGS = 0,
    FRAME_BUFFER_RESIZED = 1 << 0,
    UNKNOWN = 1 << 7
};
 
// Useful structs
struct QueueFamilyIndices
{
    std::optional<uint32_t> graphicsFamily;
    std::optional<uint32_t> presentFamily;
    std::optional<uint32_t> transferFamily;
 
    bool isComplete()
    {
        return graphicsFamily.has_value() && presentFamily.has_value();
    }
    bool hasTransferOnlyQueue()
    {
        return transferFamily.has_value();
    }
};
 
struct SwapChainSupportDetails
{
    VkSurfaceCapabilitiesKHR capabilities;
    std::vector<VkSurfaceFormatKHR> formats;
    std::vector<VkPresentModeKHR> presentModes;
};
 
struct EngineStatistics
{
    uint64_t frameTime; // In microseconds
    double ftPerSec;    // time per second
};
 
// The actual application class
class RehtiGraphics
{
public:
    void startMainLoop();
 
    RehtiGraphics(uint32_t width = 1200, uint32_t height = 900, glm::vec3 cameraLocation = glm::vec3(0.f));
 
    ~RehtiGraphics();
 
    bool addCharacterObject(int characterID, std::vector<CharacterVertex> vertices, std::vector<uint32_t> indices, ImageData texture, std::array<Animation, ANIMATION_TYPE_COUNT> animations, std::vector<BoneNode> bones, std::vector<glm::mat4> transformations, glm::vec3 location = glm::vec3(0.f), float rotation = 0.f, bool isPlayer = false);
 
    bool removeCharacterObject(int characterID);
 
    bool addGameObject(int objectID, std::vector<Vertex> vertices, std::vector<uint32_t> indices, ImageData texture, glm::vec3 location = glm::vec3(0.f), float rotation = 0.f);
 
    bool removeGameObject(int objectID);
 
    bool doesGameObjectExist(int objectID);
 
    bool doesCharacterExist(int characterID);
 
    void moveGameObject(int objectID, glm::vec3 location, float timeInSeconds);
 
    void rotateGameObject(int objectID, float radians, float timeInSeconds);
 
    void forceGameObjectMove(int objectID, glm::vec3 location);
 
    void forceGameObjectRotate(int objectID, float radians);
 
    void movePlayer(int playerID, glm::vec3 location, float timeInSeconds);
 
    void playAnimation(int characterID, AnimationConfig cfg);
 
    void forcePlayerMove(int playerID, glm::vec3 location);
 
    void moveCharacter(int characterID, glm::vec3 location, float timeInSeconds);
 
    void forceCharacterMove(int characterID, glm::vec3 location);
 
    bool addArea(std::vector<Vertex> vertices, std::vector<uint32_t> indices, std::array<ImageData, 6> textures);
 
    void transformTestObject(int id, glm::mat4 transformation);
 
    void addMapBoundingBox(const MapAABBData& mapAABBData);
 
    Hit traceClick();
 
    void setEngineFlags(EngineFlags flags);
 
    void addMouseClickCallback(std::function<void(const Hit&)> callback);
 
    std::shared_ptr<RehtiGui> getGui();
 
private:
    // Functions
 
    void initWindow();
 
    void initVulkan();
 
    void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo);
 
    void setupDebugMessenger();
 
    void pickPhysicalDevice();
 
    void createLogicalDevice();
 
    void createObjectManager();
 
    void createSwapChain();
 
    void recreateSwapChain();
 
    void cleanupSwapChain();
 
    void createImageViews();
 
    void createRenderPass();
 
    void createGraphicsPipeline();
 
    void createFramebuffers();
 
    void createCommandPool();
 
    void createCommandBuffers();
 
    void recordCommandBuffer(VkCommandBuffer cmdBuffer, uint32_t imageIndex);
 
    void createSynchronization();
 
    void drawFrame();
 
    void mainLoop();
 
    void cleanup();
 
    // Helper functions
 
    void createInstance();
 
    void createSurface();
 
    void createTextureSampler();
 
    void createDepthResources();
 
    void createGui();
 
    bool checkDeviceExtensionSupport(VkPhysicalDevice device);
 
    bool checkValidationLayerSupport();
 
    bool isDeviceSuitable(VkPhysicalDevice device);
 
    bool bbHit(const glm::vec3 min, const glm::vec3 max, const glm::vec3 rayOrig, const glm::vec3 dirInv, float& t);
 
    bool trace(const glm::vec3 orig, const glm::vec3 dirInv, const AABB* pBoxNode, AABB& boxHit, float& t);
 
    int rateDevice(VkPhysicalDevice device);
 
    QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device);
 
    SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device);
 
    std::vector<const char*> getRequiredExtensions();
 
    VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR> availableFormats);
 
    VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR> availableModes);
 
    VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities);
 
    VkPushConstantRange getCameraRange();
 
    VkFormat findSupportedFormat(const std::vector<VkFormat>& candidates, VkImageTiling tiling, VkFormatFeatureFlags features);
 
    size_t getNextFrame();
 
    void moveBoundingBox(int objectID, ObjectType objType, glm::vec3 location);
 
    void debugMatrix(glm::mat4 matrix);
 
    void debugAABB(const AABB& aabb, int level);
 
    void fillAABB(std::vector<Vertex> vertices, AABB& box);
 
    // Private members:
    GLFWwindow* pWindowM;
    VkInstance instanceM;
    VkDebugUtilsMessengerEXT debugMessengerM;
    VkSurfaceKHR surfaceM;
 
    // Camera
    Camera cameraM;
 
    // Gpu
    VkPhysicalDevice gpuM;
 
    // Logicaldevice
    VkDevice logDeviceM;
 
    // Auxiliary classes
    std::shared_ptr<GraphicsObjectManager> pObjectManagerM;
    std::shared_ptr<RehtiGui> pGuiM;
 
    // Queues
    std::shared_mutex graphicsQueueMutexM;
    VkQueue graphicsQueueM;
    VkQueue presentQueueM;
 
    // Swapchain
    VkSwapchainKHR swapChainM;
    std::vector<VkImage> swapChainImagesM;
    VkFormat swapChainImageFormatM;
    VkExtent2D swapChainExtentM;
    std::vector<VkImageView> swapChainImageViewsM;
 
    // Framebuffer
    std::vector<VkFramebuffer> swapChainFramebuffersM;
    // Depth image
    AllocatedImage depthImageM;
    VkImageView depthImageViewM;
    VkFormat depthFormatM;
    // Sampler
    VkSampler textureSamplerM;
 
    // Pipeline
    VkRenderPass renderPassM;
    std::array<VkPipelineLayout, OBJECT_TYPE_COUNT> pipelineLayoutsM;
    std::array<VkPipeline, OBJECT_TYPE_COUNT> pipelinesM;
 
    // Commands
    VkCommandPool commandPoolM;
    std::vector<VkCommandBuffer> commandBuffersM;
 
    // Semaphores
    std::vector<VkSemaphore> imagesReadyM;
    std::vector<VkSemaphore> rendersFinishedM;
    std::vector<VkFence> frameFencesM;
 
    // Callbacks
    std::function<void(const Hit&)> mouseClickCallbackM;
 
    // Other variables
    uint32_t widthM;
    uint32_t heightM;
    float anisotropyM;
    EngineFlags engineFlagsM = EngineFlags::NO_FLAGS;
    EngineStatistics statsM;
 
    std::shared_mutex dataMutexM; 
    // Bounding box lists in an array. Each index corresponds to an object type.
    std::array<std::map<int, AABB>, OBJECT_TYPE_COUNT> boundingBoxesM;
    // Location and animation storage
    std::map<int, GfxOrientation> gameObjectOrientationsM;
    std::map<int, CharacterData> characterOrientationsM;
 
    DirectionalLight sunM;
 
    // timer callback system
    TimerCallbackSystem timersM;
 
    const int kConcurrentFramesM = 2;
    size_t currentFrameM = 0;
 
    bool validationLayersEnabledM = false;
 
    const std::vector<const char*> kValidationlayersM = {
        "VK_LAYER_KHRONOS_validation"};
 
    const std::vector<const char*> kDeviceExtensionsM = {
        VK_KHR_SWAPCHAIN_EXTENSION_NAME};
 
    // Debugging functions
    static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(
        VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
        VkDebugUtilsMessageTypeFlagsEXT messageType,
        const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
        void* pUserData);
 
    static VkResult CreateDebugUtilsMessengerEXT(
        VkInstance instance,
        const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
        const VkAllocationCallbacks* pAllocator,
        VkDebugUtilsMessengerEXT* pDebugMessenger);
 
    static void DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator);
 
    static void frameBufferResizeCallback(GLFWwindow* window, int width, int height);
 
#ifdef NDEBUG
    const bool enableValidationLayers = false;
#else
    const bool enableValidationLayers = true;
#endif
};