graphite/engine/renderer/include/renderer.hpp

#pragma once

#include <vector>
#include <functional>
#include <map>
#include <memory>

#include <renderer.hpp>
#include <vk.hpp>
#include <module.hpp>

#include "drawlist.hpp"

struct VulkanMesh
{
    VkBuffer vertexBuffer;
    VkDeviceMemory vertexBufferMemory;

    VkBuffer indexBuffer;
    VkDeviceMemory indexBufferMemory;
};

struct VulkanTexture
{
    VkImage image;
    VkDeviceMemory memory;
    VkImageView view;
    VkSampler sampler;
};

struct VulkanCubemap
{

};

namespace ResourceLimits
{
    constexpr size_t maxLights = 35;
    constexpr size_t maxDynamicGeometry = 100;
};

struct RequestedFeatures
{
    bool debugPass = false;
    bool imgui = false;
    bool autoload = false;
};

struct RuntimeOptions
{
    bool vsync = false;
};

class Pipeline;
class ImGuiWrapper;
class Mesh;
class Texture;
class Cubemap;
class Engine;

class Renderer
{
public:
    Renderer(Engine* engine, RequestedFeatures features);
    ~Renderer();

    void NewFrame();
    void Draw();

    void Resized();
    void ChangeOptions(RuntimeOptions);

    DrawList& GetDrawList()
    {
        return m_drawList;
    }

    //renderer resource operations
    void SynthesizeMesh(Mesh* mesh);
    void ReleaseMesh(Mesh* mesh);

    VulkanMesh GetMesh(Mesh* mesh);

    void SynthesizeTexture(Texture* texture);
    void ReleaseTexture(Texture* texture);

    VulkanTexture GetTexture(Texture* texture);

    void SynthesizeCubemap(Cubemap* cubemap) {}
    void ReleaseCubemap(Cubemap* cubemap) {}

    VulkanCubemap GetTexture(Cubemap* cubemap) {}

    void PrepareFrame();
    void SubmitFrame();

    vk::Instance instance;
    VkSurfaceKHR surface;

    vk::Device device;

    VkSwapchainKHR swapchain;
    VkExtent2D swapchainExtent;
    VkFormat swapchainImageFormat;
    std::vector<VkImage> swapchainImages;
    std::vector<VkImageView> swapchainImageViews;

    Pipeline* pipeline;

    std::vector<VkCommandBuffer> commandBuffers;

    VkSemaphore imageAvailableSemaphore;

    VkFence submitFence;

    std::function<void()> onRender;
    std::function<void(VkCommandBuffer)> onRenderPassEnd;

    uint32_t imageIndex;

private:
    void CreateSwapchain();
    void AllocateCommandBuffers();

    DrawList m_drawList;
    Engine* m_engine;

    ImGuiWrapper* m_imWrapper;

    std::map<Mesh*, VulkanMesh> m_vulkanMeshes;
    std::map<Texture*, VulkanTexture> m_vulkanTextures;
};