Rework API graphique Vulkan - EnTT pour ECS + Chargement modèle 3D assimp + SDL3 pour events input et fenetre + mesh texture camera transform ok + attention tous les assets nouveaus ne sont pas commités et il y a du code test en dur dans scene addentity + restructuration globale

src/Engine/Core/Component/Camera/CAbstractCamera.hpp

@@ -1,10 +0,0 @@
-#ifndef CABSTRACTCAMERA_HPP
-#define CABSTRACTCAMERA_HPP
-#include "../CAbstractComponent.hpp"
-namespace CosmicCore {
-    class CAbstractCamera: CAbstractComponent
-    {
-
-    };
-}
-#endif

src/Engine/Core/Component/Camera/CCamera.hpp

@@ -0,0 +1,153 @@
+#ifndef CCAMERA_HPP
+#define CCAMERA_HPP
+
+#include "../CAbstractComponent.hpp"
+//pour vulkan depth 0-1 (opengl [-1,1])
+#define GLM_FORCE_DEPTH_ZERO_TO_ONE
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include "../../Graphics/API/VulkanImpl.hpp"
+#include "../Geometry/CTransform.hpp"
+namespace CosmicCore {
+
+class CCamera : public CAbstractComponent {
+private:
+    // paramètres de la caméra
+    float m_fov    = 45.0f;
+    float m_near   = 0.1f;
+    float m_far    = 1000.0f;
+    float m_aspect = 16.0f / 9.0f;
+
+    // matrices calculées
+    glm::mat4 m_view       = glm::mat4(1.0f);
+    glm::mat4 m_projection = glm::mat4(1.0f);
+
+    // GPU
+    struct CameraUBOData {
+        glm::mat4 view;
+        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() {
+        m_projection = glm::perspective(glm::radians(m_fov), m_aspect, m_near, m_far);
+        // Vulkan a l'axe Y inversé par rapport à OpenGL
+        m_projection[1][1] *= -1;
+    }
+
+public:
+    CCamera(CEntity& entity) : CAbstractComponent(entity) {
+        recalcProjection();
+    }
+
+    ~CCamera(){
+        destroy();
+    }
+
+    void setFov(float fov) {
+        m_fov = fov;
+        recalcProjection();
+    }
+
+    void setAspect(float aspect) {
+        m_aspect = aspect;
+        recalcProjection();
+    }
+
+    void setNearFar(float near, float far) {
+        m_near = near;
+        m_far  = far;
+        recalcProjection();
+    }
+
+    // getters
+    glm::mat4 getView(const CTransform& transform) const { 
+        glm::quat q        = transform.getOrientation();
+        glm::vec3 position = transform.getCenter();
+    
+        // rotation inverse (conjugué du quaternion) + translation inverse
+        glm::mat4 rotInverse    = glm::toMat4(glm::conjugate(q));
+        glm::mat4 transInverse  = glm::translate(glm::mat4(1.0f), -position);
+    
+        return rotInverse * transInverse;
+    }
+    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(CameraUBOData);
+            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->getCameraLayout()
+            );
+
+            vk::DescriptorBufferInfo descriptorBufferInfo{
+                vk::Buffer(m_uniformBuffers[i].buffer),
+                0,
+                sizeof(CameraUBOData)
+            };
+            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 CTransform& transform) {
+        CameraUBOData data{ getView(transform), 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(){};
+};
+
+} // namespace CosmicCore
+#endif