Destrum/destrum/include/destrum/Graphics/Renderer.h

#ifndef RENDERER_H
#define RENDERER_H

#include <glm/mat4x4.hpp>
#include <glm/vec3.hpp>

#include <destrum/Graphics/Camera.h>
#include <destrum/Graphics/Pipelines/LineRenderingPass.h>
#include <destrum/Graphics/Pipelines/MeshPipeline.h>
#include <destrum/Graphics/Pipelines/QuadRendererPass.h>
#include <destrum/Graphics/ids.h>
#include <destrum/Graphics/MeshDrawCommand.h>
#include <destrum/Graphics/Resources/NBuffer.h>
#include <destrum/Graphics/RenderResources.h>


#include <memory>

#include <destrum/Graphics/Pipelines/SkinningPipeline.h>

#include "Pipelines/SkyboxPipeline.h"

class GameRenderer {
public:
    struct SceneData {
        const Camera& camera;
        glm::vec3 ambientColor;
        float ambientIntensity;
        glm::vec3 fogColor;
        float fogDensity;
    };

    explicit GameRenderer();

    void init(GfxDevice& gfxDevice, RenderResources& _resources, glm::ivec2 drawImageSize);
    void beginDrawing(GfxDevice& gfxDevice);
    void endDrawing();

    void draw(VkCommandBuffer cmd, GfxDevice& gfxDevice, const Camera& camera, const SceneData& sceneData);
    void cleanup(GfxDevice& gfxDevice);

    void drawMesh(MeshID id, const glm::mat4& transform, MaterialID materialId);
    void drawSkinnedMesh(MeshID id, const glm::mat4& transform, MaterialID materialId, SkinnedMesh* skinnedMesh, std::size_t jointMatricesStartIndex);
    const GPUImage& getDrawImage() const;

    void resize(GfxDevice& gfxDevice, const glm::ivec2& newSize) {
        createDrawImage(gfxDevice, newSize, false);
    }

    Material& getMaterialMutable(MaterialID id);
    void updateMaterialGPU(MaterialID id);

    void setSkyboxTexture(ImageID skyboxImageId);

    void flushMaterialUpdates(GfxDevice& gfxDevice);

    [[nodiscard]] SkinningPipeline& getSkinningPipeline() const {
        return *skinningPipeline;
    }

    void setRenderWireframe(bool wireframe) {
        meshPipeline->setRenderWireframe(wireframe);
    }

    bool getRenderWireframe() {
        return meshPipeline->getRenderWireframe();
    }

    RenderResources* getResources()
    {
        return resources;
    }

    void drawQuads(
        VkCommandBuffer cmd,
        GfxDevice& gfxDevice,
        const glm::mat4& projection);

private:
    void createDrawImage(GfxDevice& gfxDevice, const glm::ivec2& drawImageSize, bool firstCreate);

    RenderResources* resources = nullptr;

    std::vector<MaterialID> pendingMaterialUploads;


    std::vector<MeshDrawCommand> meshDrawCommands;
    std::vector<std::size_t> sortedMeshDrawCommands;

    VkFormat drawImageFormat{VK_FORMAT_R16G16B16A16_SFLOAT};
    VkFormat depthImageFormat{VK_FORMAT_D32_SFLOAT};

    ImageID drawImageId{NULL_IMAGE_ID};
    ImageID depthImageId{NULL_IMAGE_ID};

    VkSampleCountFlagBits samples{VK_SAMPLE_COUNT_1_BIT};


    struct GPUSceneData {
        // camera
        glm::mat4 view;
        glm::mat4 proj;
        glm::mat4 viewProj;
        glm::vec4 cameraPos;

        // ambient
        glm::vec3 ambientColor;
        float ambientIntensity;

        // fog
        glm::vec3 fogColor;
        float fogDensity;

        VkDeviceAddress materialsBuffer;
    };

    NBuffer sceneDataBuffer;


    std::unique_ptr<MeshPipeline> meshPipeline;
    std::unique_ptr<SkyboxPipeline> skyboxPipeline;
    std::unique_ptr<LineRenderingPass> lineRenderingPass;
    std::unique_ptr<QuadRendererPass> quadRendererPass;

    std::unique_ptr<SkinningPipeline> skinningPipeline;
    bool initialized{false};
};

#endif //RENDERER_H