CosmicEngine/src/Engine/Core/Component/Camera/CCamera2D.hpp

#ifndef CCAMERA2D_HPP
#define CCAMERA2D_HPP

#include "../CAbstractComponent.hpp"
//pour vulkan depth 0-1 (opengl [-1,1])
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include "../../Systems/Graphics/API/VulkanImplementation/VulkanImpl.hpp"
#include "../Geometry/CTransform2D.hpp"
namespace CosmicCore {

    //TODO LES MAJ REELLES DUN MOUVEMENT TRANSFORM
    //AJOUT DONC DE LA VUE ET AUTRE PARAM
    //Pour le moment ne gère qu'une caméra fixe (UI)
class CCamera2D : public CAbstractComponent {
private:
    glm::mat4 m_projection = glm::mat4(1.0f);

    // GPU
    struct Camera2DUBOData {
        glm::mat4 projection;
    };

    std::array<VMABuffer, MAX_FRAMES_IN_FLIGHT> m_uniformBuffers;
    std::array<void*, MAX_FRAMES_IN_FLIGHT>     m_mappedData{};
    std::array<ManagedDescriptorSet, MAX_FRAMES_IN_FLIGHT> m_descriptorSets;

    void recalcProjection();

public:
    CCamera2D(CEntity& entity) : CAbstractComponent(entity) {
        recalcProjection();
    }

    ~CCamera2D(){
        destroy();
    }

    glm::mat4 getProjection() const { return m_projection; }

    // GPU
    void initUniformBuffer(VmaAllocator allocator) {
        VulkanImpl* api = dynamic_cast<VulkanImpl*>(GraphicsAPI::getAPI().get());

        for (uint32_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
            VkBufferCreateInfo bufferInfo{};
            bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
            bufferInfo.size  = sizeof(Camera2DUBOData);
            bufferInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;

            VmaAllocationCreateInfo allocInfo{};
            allocInfo.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
            allocInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;

            VmaAllocationInfo info{};
            vmaCreateBuffer(allocator, &bufferInfo, &allocInfo,
                            &m_uniformBuffers[i].buffer,
                            &m_uniformBuffers[i].allocation,
                            &info);
            m_mappedData[i] = info.pMappedData;

            m_descriptorSets[i] = api->getDescriptorPoolManager().allocate(
                *api->getProjection2DLayout()
            );

            vk::DescriptorBufferInfo descriptorBufferInfo{
                vk::Buffer(m_uniformBuffers[i].buffer),
                0,
                sizeof(Camera2DUBOData)
            };
            vk::WriteDescriptorSet descriptorWrite{
                *m_descriptorSets[i].set,
                0, 0, 1,
                vk::DescriptorType::eUniformBuffer,
                {}, &descriptorBufferInfo
            };
            static_cast<vk::raii::Device*>(api->getDevice())->updateDescriptorSets(descriptorWrite, {});
        }
    }

    void destroyUniformBuffer(VmaAllocator allocator) {
        VulkanImpl* api = dynamic_cast<VulkanImpl*>(GraphicsAPI::getAPI().get());
        for (uint32_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
            api->getDescriptorPoolManager().free(m_descriptorSets[i]);
            vmaDestroyBuffer(allocator, m_uniformBuffers[i].buffer,
                             m_uniformBuffers[i].allocation);
        }
    }

    void updateUniformBuffer(uint32_t frameIndex, const CTransform2D& transform) {
        
        Camera2DUBOData data{ m_projection};
        memcpy(m_mappedData[frameIndex], &data, sizeof(data));
    }

    vk::raii::DescriptorSet& getDescriptorSet(uint32_t frameIndex) {
        return m_descriptorSets[frameIndex].set;
    }

    void destroy()
    {
        VulkanImpl* api = dynamic_cast<VulkanImpl*>(GraphicsAPI::getAPI().get());
    
		for (uint32_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
			
			api->destroyBuffer(m_uniformBuffers[i], api->getCurrentFrameIndex());
			api->destroyDescriptorSet(m_descriptorSets[i], api->getCurrentFrameIndex());
		}
    }

    nlohmann::json to_json(){
        return nlohmann::json();
    };
};

} // namespace CosmicCore
#endif