graph/include/renderer.h

#pragma once

#include <vulkan/vulkan.h>
#include <string_view>

#include "worldpass.h"
#include "postpass.h"
#include "dofpass.h"
#include "imguipass.h"
#include "skypass.h"
#include "shadowpass.h"
#include "smaapass.h"
#include "debugpass.h"

constexpr int numFrameResources = 3;

struct RenderTarget {
    VkSurfaceKHR surface = nullptr;
    VkSwapchainKHR swapchain = nullptr;

    VkExtent2D extent = {};
    uint32_t numImages = 0, imageIndex = 0, currentResource = 0;

    // swapwchain
    VkImage* swapchainImages = nullptr;
    VkImageView* swapchainImageViews = nullptr;
    VkFramebuffer* swapchainFramebuffers = nullptr;

    // offscreen color
    VkImage* offscreenColorImages = nullptr;
    VkDeviceMemory* offscreenColorMemory = nullptr;
    VkImageView* offscreenColorImageViews = nullptr;

    // offscreen depth
    VkImage* offscreenDepthImages = nullptr;
    VkDeviceMemory* offscreenDepthMemory = nullptr;
    VkImageView* offscreenDepthImageViews = nullptr;

    VkFramebuffer* offscreenFramebuffers = nullptr;

    // sobel
    VkImage* sobelImages = nullptr;
    VkDeviceMemory* sobelMemorys = nullptr;
    VkImageView* sobelImageViews = nullptr;

    VkFramebuffer* sobelFramebuffers = nullptr;

    // near field
    VkImage* nearFieldImages = nullptr;
    VkDeviceMemory* nearFieldMemory = nullptr;
    VkImageView* nearFieldImageViews = nullptr;

    VkFramebuffer* nearFieldFramebuffers = nullptr;

    // far field
    VkImage* farFieldImages = nullptr;
    VkDeviceMemory* farFieldMemory = nullptr;
    VkImageView* farFieldImageViews = nullptr;

    VkFramebuffer* farFieldFramebuffers = nullptr;

    VkCommandBuffer* commandBuffers = nullptr;

    VkSemaphore imageAvailableSemaphore = nullptr;
    VkSemaphore renderFinishedSemaphore = nullptr;
    VkFence* fences = nullptr;

    // smaa
    VkImage* edgeImages = nullptr;
    VkDeviceMemory* edgeMemorys = nullptr;
    VkImageView* edgeImageViews = nullptr;
    VkFramebuffer* edgeFramebuffers = nullptr;
    VkDescriptorSet* edgeDescriptorSets = nullptr;

    VkImage* blendImages = nullptr;
    VkDeviceMemory* blendMemorys = nullptr;
    VkImageView* blendImageViews = nullptr;
    VkFramebuffer* blendFramebuffers = nullptr;
    VkDescriptorSet* blendDescriptorSets = nullptr;

    // imgui
    VkBuffer* imguiVertexBuffers = nullptr;
    VkDeviceMemory* imguiVertexMemorys = nullptr;
    size_t* imguiVertexBufferSizes = nullptr;

    VkBuffer* imguiIndexBuffers = nullptr;
    VkDeviceMemory* imguiIndexMemorys = nullptr;
    size_t* imguiIndexBufferSizes = nullptr;

    VkDescriptorSet* postSets = nullptr;
    VkDescriptorSet* dofSets = nullptr;
};

struct GraphicsConfig {
    int shadowResolution, dofDownscale;
    bool vsync = true, filterPCF;
#ifdef DEBUG
    bool enableImgui = true;
#endif
};

using EntityID = uint64_t;

struct RenderExtraInfo {
    EntityID* selectedEntities = nullptr;
    size_t numSelectedEntities = 0;
};

struct World;
class MeshAsset;
class Camera;
class MaterialAsset;

class Renderer {
public:
    Renderer(GraphicsConfig config);
    ~Renderer();

    void render(World& world, RenderTarget* target, RenderExtraInfo* extraInfo = nullptr);

    RenderTarget* createSurfaceRenderTarget(VkSurfaceKHR surface, RenderTarget* oldTarget = nullptr);
    void destroyRenderTarget(RenderTarget* target);

    void takeScreenshot(const char* path, RenderTarget* target);

    VkShaderModule createShader(const char* path);

    void uploadImageData(VkImage image, int width, int height, VkDeviceSize size, const void* src);

    uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties);

    void fillMeshBuffers(MeshAsset* mesh);
    void destroyMeshBuffers(MeshAsset* mesh);

    void fillMaterialBuffers(MaterialAsset* material);
    void destroyMaterialBuffers(MaterialAsset* material);

    GraphicsConfig getConfig() const {
        return config_;
    }

    VkInstance getInstance() const {
        return instance_;
    }

    VkDevice getDevice() const {
        return device_;
    }

    VkQueue getGraphicsQueue() const {
        return graphicsQueue_;
    }

    VkCommandPool getCommandPool() const {
        return commandPool_;
    }

    VkRenderPass getRenderPass() const {
        return presentationRenderPass_;
    }

    VkDescriptorPool getDescriptorPool() const {
        return descriptorPool_;
    }

    VkDescriptorSetLayout getMaterialSetLayout() const {
        return materialSetLayout_;
    }

    WorldPass& getWorldPass() const {
        return *worldPass_;
    }

    ShadowPass& getShadowPass() const {
        return *shadowPass_;
    }

private:
    void createInstance();
#ifdef DEBUG
    void createDebugMessenger();
#endif
    void createLogicalDevice();
    void createCommandPool();
    void createPresentationRenderPass();
    void createDescriptorPool();
    void createMaterialSetLayout();
    void createEmptyMaterialSet();

    GraphicsConfig config_;

    VkInstance instance_ = nullptr;

#ifdef DEBUG
    bool enableDebug = false;

    PFN_vkCreateDebugUtilsMessengerEXT createMessenger_ = nullptr;
    PFN_vkDestroyDebugUtilsMessengerEXT destroyMessenger_ = nullptr;

    VkDebugUtilsMessengerEXT messenger_ = nullptr;
#endif

    VkPhysicalDevice physicalDevice_ = nullptr;
    VkPhysicalDeviceMemoryProperties deviceMemoryProperties_ = {};

    VkDevice device_ = nullptr;

    struct {
        uint32_t graphics = 0, presentation = 0;
    } queueIndices;

    VkQueue graphicsQueue_ = nullptr;

    VkCommandPool commandPool_ = nullptr;

    VkRenderPass presentationRenderPass_ = nullptr;

    VkDescriptorPool descriptorPool_ = nullptr;

    VkDescriptorSetLayout materialSetLayout_ = nullptr;

    VkImage emptyImage_ = nullptr;
    VkDeviceMemory emptyMemory_ = nullptr;
    VkImageView emptyImageView_ = nullptr;
    VkSampler emptySampler_ = nullptr;

    VkDescriptorSet emptyMaterialSet_ = nullptr;

    WorldPass* worldPass_ = nullptr;
    PostPass* postPass_ = nullptr;
    DoFPass* dofPass_ = nullptr;
#ifdef DEBUG
    ImGuiPass* imguiPass_ = nullptr;
#endif
    SkyPass* skyPass_ = nullptr;
    ShadowPass* shadowPass_ = nullptr;
    SMAAPass* smaaPass_ = nullptr;
    DebugPass* debugPass_ = nullptr;
};

VkResult name_object(VkDevice device, VkObjectType type, uint64_t object, std::string_view name);