Major - ECS - V12.0.0

enginecustom/enginecustom.vcxproj

@@ -119,6 +119,15 @@
     <ClInclude Include="src\inc\system\camera_class.h" />
     <ClInclude Include="src\inc\system\d_3d_class.h" />
     <ClInclude Include="src\inc\system\display_plane_class.h" />
+    <ClInclude Include="src\inc\system\ecs\component.h" />
+    <ClInclude Include="src\inc\system\ecs\components\identity_component.h" />
+    <ClInclude Include="src\inc\system\ecs\components\physics_component.h" />
+    <ClInclude Include="src\inc\system\ecs\components\render_component.h" />
+    <ClInclude Include="src\inc\system\ecs\components\shader_component.h" />
+    <ClInclude Include="src\inc\system\ecs\components\transform_component.h" />
+    <ClInclude Include="src\inc\system\ecs\entity.h" />
+    <ClInclude Include="src\inc\system\ecs\entity_manager.h" />
+    <ClInclude Include="src\inc\system\ecs\systems\render_system.h" />
     <ClInclude Include="src\inc\system\font_class.h" />
     <ClInclude Include="src\inc\system\fps_class.h" />
     <ClInclude Include="src\inc\system\fps_limiter.h" />

enginecustom/imgui.ini

@@ -10,7 +10,7 @@ Collapsed=0
 
 [Window][Khaotic Engine]
 Pos=1267,19
-Size=317,441
+Size=317,842
 Collapsed=0
 DockId=0x00000005,0
 
@@ -28,7 +28,7 @@ DockId=0x0000000B,0
 
 [Window][Terrain]
 Pos=0,19
-Size=266,609
+Size=266,842
 Collapsed=0
 DockId=0x00000007,0
 

enginecustom/src/inc/system/application_class.h

@@ -32,6 +32,12 @@
 #include "shadow_map.h"
 #include "stats.h"
 
+#include "ecs/components/identity_component.h"
+#include "ecs/components/render_component.h"
+#include "ecs/components/transform_component.h"
+#include "ecs/components/physics_component.h"
+#include "ecs/components/shader_component.h"
+#include "ecs/systems/render_system.h"
 
 #include <fstream>
 #include <WICTextureLoader.h>
@@ -46,6 +52,8 @@
 #include <vector>
 #include <filesystem>
 
+#include "ecs/entity_manager.h"
+
 
 /////////////
 // GLOBALS //
@@ -234,6 +242,8 @@ private :
 	// ------------- OBJECTS -------------- //
 	// ------------------------------------ //
 
+	std::unique_ptr<ecs::EntityManager> entity_manager_;
+	
 	object* selected_object_;
 	std::vector<object*> cubes_;
 	std::vector<object*> terrain_chunk_;

enginecustom/src/inc/system/ecs/component.h

@@ -0,0 +1,40 @@
+#pragma once
+#include <memory>
+#include <typeindex>
+#include <typeinfo>
+
+namespace ecs {
+
+// Classe de base pour tous les composants
+class Component {
+public:
+    Component() = default;
+    virtual ~Component() = default;
+
+    // Empêcher la copie
+    Component(const Component&) = delete;
+    Component& operator=(const Component&) = delete;
+
+    // Permettre le déplacement
+    Component(Component&&) = default;
+    Component& operator=(Component&&) = default;
+
+    // Fonction virtuelle pour initialiser le composant
+    virtual void Initialize() {}
+    
+    // Fonction virtuelle pour la mise à jour du composant
+    virtual void Update(float deltaTime) {}
+};
+
+// Alias utiles
+using ComponentPtr = std::shared_ptr<Component>;
+using ComponentTypeID = std::type_index;
+
+// Fonction pour obtenir l'ID de type d'un composant
+template<typename T>
+ComponentTypeID GetComponentTypeID() {
+    static_assert(std::is_base_of<Component, T>::value, "T must derive from Component");
+    return std::type_index(typeid(T));
+}
+
+}  // namespace ecs

enginecustom/src/inc/system/ecs/components/identity_component.h

@@ -0,0 +1,58 @@
+#pragma once
+#include "../component.h"
+#include <string>
+
+namespace ecs {
+
+enum class ObjectType
+{
+    Sphere,
+    Cube,
+    Terrain,
+    Unknown
+};
+
+class IdentityComponent : public Component {
+public:
+    IdentityComponent() : m_id(0), m_type(ObjectType::Unknown) {}
+    explicit IdentityComponent(int id) : m_id(id), m_type(ObjectType::Unknown) {}
+    IdentityComponent(int id, const std::string& name) : m_id(id), m_name(name), m_type(ObjectType::Unknown) {}
+    ~IdentityComponent() = default;
+
+    void Initialize() override {}
+    void Update(float deltaTime) override {}
+
+    // Getters et setters
+    int GetId() const { return m_id; }
+    void SetId(int id) { m_id = id; }
+
+    const std::string& GetName() const { return m_name; }
+    void SetName(const std::string& name) { m_name = name; }
+
+    ObjectType GetType() const { return m_type; }
+    void SetType(ObjectType type) { m_type = type; }
+
+    // Conversions utiles
+    static std::string ObjectTypeToString(ObjectType type) {
+        switch (type) {
+            case ObjectType::Cube: return "Cube";
+            case ObjectType::Sphere: return "Sphere";
+            case ObjectType::Terrain: return "Terrain";
+            default: return "Unknown";
+        }
+    }
+
+    static ObjectType StringToObjectType(const std::string& str) {
+        if (str == "Cube") return ObjectType::Cube;
+        if (str == "Sphere") return ObjectType::Sphere;
+        if (str == "Terrain") return ObjectType::Terrain;
+        return ObjectType::Unknown;
+    }
+
+private:
+    int m_id;
+    std::string m_name;
+    ObjectType m_type;
+};
+
+}  // namespace ecs

enginecustom/src/inc/system/ecs/components/physics_component.h

@@ -0,0 +1,110 @@
+#pragma once
+#include "../component.h"
+#include <DirectXMath.h>
+
+using namespace DirectX;
+
+namespace ecs {
+
+class PhysicsComponent : public Component {
+public:
+    PhysicsComponent() {
+        m_Velocity = XMVectorZero();
+        m_Acceleration = XMVectorZero();
+        m_PreviousPosition = XMVectorZero();
+        m_Mass = 1.0f;
+        m_BoundingRadius = 1.0f;
+        m_IsGrounded = false;
+        m_IsPhysicsEnabled = false;
+        m_GravityEnabled = true;
+    }
+
+    ~PhysicsComponent() = default;
+
+    void Initialize() override {
+        // Initialisation du composant physique
+    }
+
+    void Update(float deltaTime) override {
+        if (!m_IsPhysicsEnabled) return;
+
+        // Mise à jour de la vélocité basée sur l'accélération
+        m_Velocity = m_Velocity + m_Acceleration * deltaTime;
+        
+        // Si la physique est activée et qu'une fonction de mise à jour de position est définie
+        if (m_UpdatePositionCallback) {
+            m_UpdatePositionCallback(m_Velocity * deltaTime);
+        }
+    }
+
+    // Lancement d'un objet
+    void LaunchObject(float alpha, float initialStretch, float springConstant) {
+        // Constants
+        const float gravity = -9.81f;
+    
+        // Convert alpha from degrees to radians if needed
+        float alphaRadians = alpha * (XM_PI / 180.0f);
+    
+        // Scale factors to make the physics simulation more visible
+        float scaleFactor = 200.0f;  // Adjust this based on your world scale
+    
+        // Calculate initial velocity magnitude
+        float velocityMagnitude = initialStretch * sqrtf(springConstant / m_Mass) * 
+                                  sqrtf(1.0f - powf((m_Mass * gravity * sinf(alphaRadians) / 
+                                  (springConstant * initialStretch)), 2.0f));
+    
+        // Apply scale factor
+        velocityMagnitude *= scaleFactor;
+    
+        // Calculate velocity components
+        XMVECTOR velocity = XMVectorSet(
+            velocityMagnitude * cosf(alphaRadians),  // vx = v0 * cos(alpha)
+            velocityMagnitude * sinf(alphaRadians),  // vy = v0 * sin(alpha)
+            0.0f,                                   // z-component (0 for 2D trajectory)
+            0.0f
+        );
+    
+        // Apply velocity
+        SetVelocity(velocity);
+        
+        // Enable physics and reset grounded state
+        SetPhysicsEnabled(true);
+        SetGrounded(false);
+    }
+
+    // Setters
+    void SetVelocity(XMVECTOR velocity) { m_Velocity = velocity; }
+    void SetAcceleration(XMVECTOR acceleration) { m_Acceleration = acceleration; }
+    void SetMass(float mass) { m_Mass = mass; }
+    void SetGrounded(bool isGrounded) { m_IsGrounded = isGrounded; }
+    void SetPhysicsEnabled(bool enabled) { m_IsPhysicsEnabled = enabled; }
+    void SetBoundingRadius(float radius) { m_BoundingRadius = radius; }
+    void SetPreviousPosition(XMVECTOR position) { m_PreviousPosition = position; }
+    void SetGravityEnabled(bool enabled) { m_GravityEnabled = enabled; }
+    void SetUpdatePositionCallback(std::function<void(XMVECTOR)> callback) { m_UpdatePositionCallback = callback; }
+
+    // Getters
+    XMVECTOR GetVelocity() const { return m_Velocity; }
+    XMVECTOR GetAcceleration() const { return m_Acceleration; }
+    float GetMass() const { return m_Mass; }
+    bool IsGrounded() const { return m_IsGrounded; }
+    bool IsPhysicsEnabled() const { return m_IsPhysicsEnabled; }
+    float GetBoundingRadius() const { return m_BoundingRadius; }
+    XMVECTOR GetPreviousPosition() const { return m_PreviousPosition; }
+    bool IsGravityEnabled() const { return m_GravityEnabled; }
+
+private:
+    XMVECTOR m_Velocity;
+    XMVECTOR m_Acceleration;
+    XMVECTOR m_PreviousPosition;
+    float m_Mass;
+    float m_BoundingRadius;
+    bool m_IsGrounded;
+    bool m_IsPhysicsEnabled;
+    bool m_GravityEnabled;
+    
+    // Callback pour mettre à jour la position (sera connecté au TransformComponent)
+    std::function<void(XMVECTOR)> m_UpdatePositionCallback;
+};
+
+}  // namespace ecs

enginecustom/src/inc/system/ecs/components/render_component.h

@@ -0,0 +1,124 @@
+#pragma once
+#include "../component.h"
+#include "model_class.h"
+#include <memory>
+#include <string>
+#include <map>
+#include <WICTextureLoader.h>
+
+// Déclaration externe de la variable globale définie dans application_class.h
+extern std::map<std::string, std::shared_ptr<model_class>> g_model_cache;
+
+namespace ecs {
+
+enum class TextureType
+{
+    Diffuse,
+    Normal,
+    Specular,
+    Alpha,
+    Reflection
+};
+
+class RenderComponent : public Component {
+public:
+    RenderComponent() : m_model(nullptr), m_isVisible(true) {}
+    ~RenderComponent() = default;
+
+    void Initialize() override {}
+    void Update(float deltaTime) override {}
+
+    // Initialisation avec un modèle existant
+    bool InitializeWithModel(std::shared_ptr<model_class> model) {
+        if (!model) return false;
+        m_model = model;
+        return true;
+    }
+
+    // Initialisation avec un chemin de fichier
+    bool InitializeFromFile(ID3D11Device* device, ID3D11DeviceContext* deviceContext, 
+                           const char* modelFilename, TextureContainer& textureContainer) {
+        // Vérifier si le modèle existe déjà dans le cache
+        std::string filename(modelFilename);
+        auto it = g_model_cache.find(filename);
+        if (it != g_model_cache.end()) {
+            m_model = it->second;
+        } else {
+            // Créer un nouveau modèle
+            auto new_model = std::make_shared<model_class>();
+            if (!new_model->Initialize(device, deviceContext, const_cast<char*>(modelFilename), textureContainer)) {
+                return false;
+            }
+            g_model_cache[filename] = new_model;
+            m_model = new_model;
+        }
+
+        m_modelFilePath = modelFilename;
+        return true;
+    }
+
+    // Charger des textures depuis un chemin
+    bool LoadTexturesFromPath(std::vector<std::wstring>& texturePaths, TextureContainer& texturesContainer,
+                             ID3D11Device* device, ID3D11DeviceContext* deviceContext) {
+        HRESULT result;
+        
+        int i = 0;
+        for (const auto& texturePath : texturePaths) {
+            ID3D11ShaderResourceView* texture = nullptr;
+            result = DirectX::CreateWICTextureFromFile(device, deviceContext, texturePath.c_str(), nullptr, &texture);
+            if (FAILED(result)) {
+                return false;
+            }
+            texturesContainer.AssignTexture(texturesContainer, texture, texturePath, i);
+            i++;
+        }
+
+        return true;
+    }
+
+    // Getters et setters
+    std::shared_ptr<model_class> GetModel() const { return m_model; }
+    void SetModel(std::shared_ptr<model_class> model) { m_model = model; }
+
+    const std::string& GetModelFilePath() const { return m_modelFilePath; }
+    void SetModelFilePath(const std::string& path) { m_modelFilePath = path; }
+
+    bool IsVisible() const { return m_isVisible; }
+    void SetVisible(bool visible) { m_isVisible = visible; }
+
+    // Accès aux textures
+    ID3D11ShaderResourceView* GetTexture(TextureType type, int index = 0) {
+        if (!m_model) return nullptr;
+        
+        switch (type) {
+            case TextureType::Diffuse: 
+                return m_model->GetTexture(::TextureType::Diffuse, index);
+            case TextureType::Normal: 
+                return m_model->GetTexture(::TextureType::Normal, index);
+            case TextureType::Specular: 
+                return m_model->GetTexture(::TextureType::Specular, index);
+            case TextureType::Alpha: 
+                return m_model->GetTexture(::TextureType::Alpha, index);
+            default: 
+                return nullptr;
+        }
+    }
+
+    // Pour le rendu
+    int GetIndexCount() const {
+        return m_model ? m_model->GetIndexCount() : 0;
+    }
+
+    void Render(ID3D11DeviceContext* deviceContext) {
+        if (m_model && m_isVisible) {
+            m_model->Render(deviceContext);
+        }
+    }
+
+private:
+    std::shared_ptr<model_class> m_model;
+    std::string m_modelFilePath;
+    bool m_isVisible;
+};
+
+}  // namespace ecs

enginecustom/src/inc/system/ecs/components/shader_component.h

@@ -0,0 +1,67 @@
+#pragma once
+#include "../component.h"
+
+namespace ecs {
+
+enum class ShaderType
+{
+    CEL_SHADING,
+    LIGHTING,
+    NORMAL_MAPPING,
+    SPECULAR_MAPPING,
+    REFLECTION,
+    REFRACTION,
+    TEXTURE,
+    SKYBOX,
+    SUNLIGHT,
+    ALPHA_MAPPING
+};
+
+class ShaderComponent : public Component {
+public:
+    ShaderComponent() : m_activeShader(ShaderType::LIGHTING) {}
+    ~ShaderComponent() = default;
+
+    void Initialize() override {}
+    void Update(float deltaTime) override {}
+
+    // Getters et setters
+    ShaderType GetActiveShader() const { return m_activeShader; }
+    void SetActiveShader(ShaderType shader) { m_activeShader = shader; }
+
+    // Conversions utiles
+    static ShaderType StringToShaderType(const std::string& str) {
+        if (str == "ALPHA_MAPPING") return ShaderType::ALPHA_MAPPING;
+        if (str == "CEL_SHADING") return ShaderType::CEL_SHADING;
+        if (str == "NORMAL_MAPPING") return ShaderType::NORMAL_MAPPING;
+        if (str == "SPECULAR_MAPPING") return ShaderType::SPECULAR_MAPPING;
+        if (str == "TEXTURE") return ShaderType::TEXTURE;
+        if (str == "LIGHTING") return ShaderType::LIGHTING;
+        if (str == "SUNLIGHT") return ShaderType::SUNLIGHT;
+        if (str == "SKYBOX") return ShaderType::SKYBOX;
+        if (str == "REFLECTION") return ShaderType::REFLECTION;
+        if (str == "REFRACTION") return ShaderType::REFRACTION;
+        return ShaderType::TEXTURE;
+    }
+
+    static std::string ShaderTypeToString(ShaderType type) {
+        switch (type) {
+            case ShaderType::ALPHA_MAPPING: return "ALPHA_MAPPING";
+            case ShaderType::CEL_SHADING: return "CEL_SHADING";
+            case ShaderType::NORMAL_MAPPING: return "NORMAL_MAPPING";
+            case ShaderType::SPECULAR_MAPPING: return "SPECULAR_MAPPING";
+            case ShaderType::TEXTURE: return "TEXTURE";
+            case ShaderType::LIGHTING: return "LIGHTING";
+            case ShaderType::SUNLIGHT: return "SUNLIGHT";
+            case ShaderType::SKYBOX: return "SKYBOX";
+            case ShaderType::REFLECTION: return "REFLECTION";
+            case ShaderType::REFRACTION: return "REFRACTION";
+            default: return "TEXTURE";
+        }
+    }
+
+private:
+    ShaderType m_activeShader;
+};
+
+}  // namespace ecs

enginecustom/src/inc/system/ecs/components/transform_component.h

@@ -0,0 +1,101 @@
+#pragma once
+#include "../component.h"
+#include <DirectXMath.h>
+
+using namespace DirectX;
+
+namespace ecs {
+
+class TransformComponent : public Component {
+public:
+    TransformComponent() {
+        m_ScaleMatrix = XMMatrixIdentity();
+        m_RotateMatrix = XMMatrixIdentity();
+        m_TranslateMatrix = XMMatrixIdentity();
+        m_WorldMatrix = XMMatrixIdentity();
+    }
+
+    ~TransformComponent() = default;
+
+    // Méthodes pour les matrices
+    void SetPosition(XMVECTOR position) {
+        XMFLOAT4X4 matrix;
+        XMStoreFloat4x4(&matrix, m_TranslateMatrix);
+        matrix._41 = XMVectorGetX(position);
+        matrix._42 = XMVectorGetY(position);
+        matrix._43 = XMVectorGetZ(position);
+        m_TranslateMatrix = XMLoadFloat4x4(&matrix);
+        UpdateWorldMatrix();
+    }
+
+    void SetRotation(XMVECTOR rotation) {
+        m_RotateMatrix = XMMatrixRotationRollPitchYawFromVector(rotation);
+        UpdateWorldMatrix();
+    }
+
+    void SetScale(XMVECTOR scale) {
+        XMFLOAT4X4 matrix;
+        XMStoreFloat4x4(&matrix, m_ScaleMatrix);
+        matrix._11 = XMVectorGetX(scale);
+        matrix._22 = XMVectorGetY(scale);
+        matrix._33 = XMVectorGetZ(scale);
+        m_ScaleMatrix = XMLoadFloat4x4(&matrix);
+        UpdateWorldMatrix();
+    }
+
+    XMVECTOR GetPosition() const {
+        XMFLOAT4X4 matrix;
+        XMStoreFloat4x4(&matrix, m_TranslateMatrix);
+        return XMVectorSet(matrix._41, matrix._42, matrix._43, 0.0f);
+    }
+
+    XMVECTOR GetRotation() const {
+        XMFLOAT4X4 matrix;
+        XMStoreFloat4x4(&matrix, m_RotateMatrix);
+        float rotationX = atan2f(matrix._32, matrix._33);
+        float rotationY = atan2f(-matrix._31, sqrtf(matrix._32 * matrix._32 + matrix._33 * matrix._33));
+        float rotationZ = atan2f(matrix._21, matrix._11);
+        return XMVectorSet(rotationX, rotationY, rotationZ, 0.0f);
+    }
+
+    XMVECTOR GetScale() const {
+        XMFLOAT4X4 matrix;
+        XMStoreFloat4x4(&matrix, m_ScaleMatrix);
+
+        XMVECTOR row1 = XMLoadFloat3(reinterpret_cast<XMFLOAT3*>(&matrix._11));
+        XMVECTOR row2 = XMLoadFloat3(reinterpret_cast<XMFLOAT3*>(&matrix._21));
+        XMVECTOR row3 = XMLoadFloat3(reinterpret_cast<XMFLOAT3*>(&matrix._31));
+
+        XMVECTOR scale = XMVectorSet(
+            XMVectorGetX(XMVector3Length(row1)),
+            XMVectorGetX(XMVector3Length(row2)),
+            XMVectorGetX(XMVector3Length(row3)),
+            0.0f
+        );
+
+        return scale;
+    }
+
+    void UpdateWorldMatrix() {
+        m_WorldMatrix = m_ScaleMatrix * m_RotateMatrix * m_TranslateMatrix;
+    }
+
+    // Getters pour les matrices
+    XMMATRIX GetScaleMatrix() const { return m_ScaleMatrix; }
+    XMMATRIX GetRotateMatrix() const { return m_RotateMatrix; }
+    XMMATRIX GetTranslateMatrix() const { return m_TranslateMatrix; }
+    XMMATRIX GetWorldMatrix() const { return m_WorldMatrix; }
+
+    // Setters pour les matrices
+    void SetScaleMatrix(XMMATRIX matrix) { m_ScaleMatrix = matrix; UpdateWorldMatrix(); }
+    void SetRotateMatrix(XMMATRIX matrix) { m_RotateMatrix = matrix; UpdateWorldMatrix(); }
+    void SetTranslateMatrix(XMMATRIX matrix) { m_TranslateMatrix = matrix; UpdateWorldMatrix(); }
+
+private:
+    XMMATRIX m_ScaleMatrix;
+    XMMATRIX m_RotateMatrix;
+    XMMATRIX m_TranslateMatrix;
+    XMMATRIX m_WorldMatrix;
+};
+
+}  // namespace ecs

enginecustom/src/inc/system/ecs/entity.h

@@ -0,0 +1,101 @@
+#pragma once
+#include "component.h"
+#include <unordered_map>
+#include <vector>
+#include <memory>
+#include <algorithm>
+#include <cassert>
+
+namespace ecs {
+
+// Identifiant unique pour les entités
+using EntityID = uint32_t;
+
+class Entity {
+public:
+    explicit Entity(EntityID id) : m_ID(id) {}
+    ~Entity() = default;
+
+    // Empêcher la copie
+    Entity(const Entity&) = delete;
+    Entity& operator=(const Entity&) = delete;
+
+    // Permettre le déplacement
+    Entity(Entity&&) = default;
+    Entity& operator=(Entity&&) = default;
+
+    // Getter pour l'ID
+    EntityID GetID() const { return m_ID; }
+
+    // Ajouter un composant
+    template<typename T, typename... Args>
+    std::shared_ptr<T> AddComponent(Args&&... args) {
+        static_assert(std::is_base_of<Component, T>::value, "T must derive from Component");
+        
+        ComponentTypeID typeID = GetComponentTypeID<T>();
+        
+        // Vérifier si le composant existe déjà
+        if (m_Components.find(typeID) != m_Components.end()) {
+            return std::static_pointer_cast<T>(m_Components[typeID]);
+        }
+        
+        // Créer et ajouter le composant
+        auto component = std::make_shared<T>(std::forward<Args>(args)...);
+        m_Components[typeID] = component;
+        
+        // Initialiser le composant
+        component->Initialize();
+        
+        return component;
+    }
+
+    // Récupérer un composant
+    template<typename T>
+    std::shared_ptr<T> GetComponent() {
+        static_assert(std::is_base_of<Component, T>::value, "T must derive from Component");
+        
+        ComponentTypeID typeID = GetComponentTypeID<T>();
+        
+        auto it = m_Components.find(typeID);
+        if (it != m_Components.end()) {
+            return std::static_pointer_cast<T>(it->second);
+        }
+        
+        return nullptr;
+    }
+
+    // Vérifier si l'entité possède un composant
+    template<typename T>
+    bool HasComponent() const {
+        static_assert(std::is_base_of<Component, T>::value, "T must derive from Component");
+        
+        ComponentTypeID typeID = GetComponentTypeID<T>();
+        return m_Components.find(typeID) != m_Components.end();
+    }
+
+    // Supprimer un composant
+    template<typename T>
+    void RemoveComponent() {
+        static_assert(std::is_base_of<Component, T>::value, "T must derive from Component");
+        
+        ComponentTypeID typeID = GetComponentTypeID<T>();
+        auto it = m_Components.find(typeID);
+        
+        if (it != m_Components.end()) {
+            m_Components.erase(it);
+        }
+    }
+
+    // Mettre à jour tous les composants
+    void UpdateComponents(float deltaTime) {
+        for (auto& [typeID, component] : m_Components) {
+            component->Update(deltaTime);
+        }
+    }
+
+private:
+    EntityID m_ID;
+    std::unordered_map<ComponentTypeID, ComponentPtr> m_Components;
+};
+
+}  // namespace ecs

enginecustom/src/inc/system/ecs/entity_manager.h

@@ -0,0 +1,95 @@
+#pragma once
+#include "entity.h"
+#include <vector>
+#include <unordered_map>
+#include <queue>
+
+namespace ecs {
+
+class EntityManager {
+public:
+    EntityManager() : m_NextEntityID(0) {}
+    ~EntityManager() = default;
+
+    // Créer une nouvelle entité
+    std::shared_ptr<Entity> CreateEntity() {
+        EntityID id;
+        
+        // Réutiliser les IDs des entités supprimées si possible
+        if (!m_FreeIDs.empty()) {
+            id = m_FreeIDs.front();
+            m_FreeIDs.pop();
+        } else {
+            id = m_NextEntityID++;
+        }
+        
+        auto entity = std::make_shared<Entity>(id);
+        m_Entities[id] = entity;
+        
+        return entity;
+    }
+
+    // Supprimer une entité
+    void DestroyEntity(EntityID id) {
+        auto it = m_Entities.find(id);
+        if (it != m_Entities.end()) {
+            m_Entities.erase(it);
+            m_FreeIDs.push(id); // Recycler l'ID
+        }
+    }
+
+    // Obtenir une entité par son ID
+    std::shared_ptr<Entity> GetEntity(EntityID id) {
+        auto it = m_Entities.find(id);
+        if (it != m_Entities.end()) {
+            return it->second;
+        }
+        return nullptr;
+    }
+
+    // Mettre à jour toutes les entités
+    void UpdateEntities(float deltaTime) {
+        for (auto& [id, entity] : m_Entities) {
+            entity->UpdateComponents(deltaTime);
+        }
+    }
+
+    // Obtenir toutes les entités qui ont un composant spécifique
+    template<typename T>
+    std::vector<std::shared_ptr<Entity>> GetEntitiesWithComponent() {
+        static_assert(std::is_base_of<Component, T>::value, "T must derive from Component");
+        
+        std::vector<std::shared_ptr<Entity>> result;
+        
+        for (auto& [id, entity] : m_Entities) {
+            if (entity->HasComponent<T>()) {
+                result.push_back(entity);
+            }
+        }
+        
+        return result;
+    }
+
+    // Obtenir le nombre d'entités
+    size_t GetEntityCount() const {
+        return m_Entities.size();
+    }
+
+    // Vider toutes les entités
+    void Clear() {
+        m_Entities.clear();
+        
+        // Vider la file des IDs libres
+        std::queue<EntityID> empty;
+        std::swap(m_FreeIDs, empty);
+        
+        m_NextEntityID = 0;
+    }
+
+private:
+    EntityID m_NextEntityID;
+    std::unordered_map<EntityID, std::shared_ptr<Entity>> m_Entities;
+    std::queue<EntityID> m_FreeIDs; // IDs à réutiliser
+};
+
+}  // namespace ecs

enginecustom/src/inc/system/ecs/systems/render_system.h

@@ -0,0 +1,222 @@
+#pragma once
+#include "../entity_manager.h"
+#include "../components/render_component.h"
+#include "../components/transform_component.h"
+#include "../components/shader_component.h"
+#include "shader_manager_class.h"
+#include <DirectXMath.h>
+
+namespace ecs {
+
+class RenderSystem {
+public:
+    RenderSystem(ID3D11DeviceContext* deviceContext, shader_manager_class* shaderManager) 
+        : m_deviceContext(deviceContext), m_shaderManager(shaderManager) {}
+    
+    // Rendu d'une entité spécifique
+    bool RenderEntity(std::shared_ptr<Entity> entity, 
+                      const DirectX::XMMATRIX& viewMatrix, 
+                      const DirectX::XMMATRIX& projectionMatrix,
+                      const DirectX::XMFLOAT4* diffuseColors,
+                      const DirectX::XMFLOAT4* lightPositions,
+                      const DirectX::XMFLOAT4* ambientColors,
+                      const DirectX::XMFLOAT3& cameraPosition,
+                      const DirectX::XMFLOAT4& sunlightDiffuse,
+                      const DirectX::XMFLOAT4& sunlightAmbient,
+                      const DirectX::XMFLOAT3& sunlightDirection,
+                      float sunlightIntensity) {
+        
+        // Vérifier si l'entité a tous les composants nécessaires
+        auto transform = entity->GetComponent<TransformComponent>();
+        auto render = entity->GetComponent<RenderComponent>();
+        auto shader = entity->GetComponent<ShaderComponent>();
+
+        if (!transform || !render || !shader || !render->GetModel())
+            return false;
+
+        // Calculer la matrice monde
+        XMMATRIX scaleMatrix = transform->GetScaleMatrix();
+        XMMATRIX rotateMatrix = transform->GetRotateMatrix();
+        XMMATRIX translateMatrix = transform->GetTranslateMatrix();
+
+        XMMATRIX worldMatrix = XMMatrixMultiply(
+            XMMatrixMultiply(scaleMatrix, rotateMatrix),
+            translateMatrix
+        );
+
+        // Rendre le modèle
+        render->Render(m_deviceContext);
+
+        // Sélectionner le shader approprié
+        switch (shader->GetActiveShader()) {
+            case ShaderType::ALPHA_MAPPING:
+                return m_shaderManager->render_alpha_map_shader(
+                    m_deviceContext,
+                    render->GetIndexCount(),
+                    worldMatrix,
+                    viewMatrix,
+                    projectionMatrix,
+                    render->GetTexture(TextureType::Diffuse, 0),
+                    render->GetTexture(TextureType::Diffuse, 1),
+                    render->GetTexture(TextureType::Alpha, 0)
+                );
+
+            case ShaderType::CEL_SHADING:
+                return m_shaderManager->render_cel_shading_shader(
+                    m_deviceContext,
+                    render->GetIndexCount(),
+                    worldMatrix,
+                    viewMatrix,
+                    projectionMatrix,
+                    render->GetTexture(TextureType::Diffuse, 0),
+                    sunlightDiffuse,
+                    sunlightAmbient,
+                    sunlightDirection,
+                    sunlightIntensity
+                );
+
+            case ShaderType::NORMAL_MAPPING:
+                return m_shaderManager->render_normal_map_shader(
+                    m_deviceContext,
+                    render->GetIndexCount(),
+                    worldMatrix,
+                    viewMatrix,
+                    projectionMatrix,
+                    render->GetTexture(TextureType::Diffuse, 0),
+                    render->GetTexture(TextureType::Normal, 0),
+                    sunlightDirection,
+                    sunlightDiffuse
+                );
+
+            case ShaderType::SPECULAR_MAPPING:
+
+                return m_shaderManager->render_spec_map_shader(
+                    m_deviceContext,
+                    render->GetIndexCount(),
+                    worldMatrix,
+                    viewMatrix,
+                    projectionMatrix,
+                    render->GetTexture(TextureType::Diffuse, 0),
+                    render->GetTexture(TextureType::Normal, 0),
+                    render->GetTexture(TextureType::Specular, 0),
+                    sunlightDirection,
+                    sunlightDiffuse,
+                    cameraPosition,
+                    sunlightDiffuse,        // Couleur speculaire (à ajuster)
+                    16.0f                   // Puissance speculaire (à ajuster)
+                );
+
+            case ShaderType::LIGHTING:
+                {
+                    // Créer des copies locales non constantes des tableaux
+                    DirectX::XMFLOAT4 localDiffuseColors[4];
+                    DirectX::XMFLOAT4 localLightPositions[4];
+                    DirectX::XMFLOAT4 localAmbientColors[4];
+                    
+                    // Copier les données
+                    for (int i = 0; i < 4; i++) {
+                        localDiffuseColors[i] = diffuseColors[i];
+                        localLightPositions[i] = lightPositions[i];
+                        localAmbientColors[i] = ambientColors[i];
+                    }
+                    
+                    return m_shaderManager->renderlight_shader(
+                        m_deviceContext,
+                        render->GetIndexCount(),
+                        worldMatrix,
+                        viewMatrix,
+                        projectionMatrix,
+                        render->GetTexture(TextureType::Diffuse, 0),
+                        localDiffuseColors,
+                        localLightPositions,
+                        localAmbientColors
+                    );
+                }
+
+            case ShaderType::SUNLIGHT:
+                return m_shaderManager->render_sunlight_shader(
+                    m_deviceContext,
+                    render->GetIndexCount(),
+                    worldMatrix,
+                    viewMatrix,
+                    projectionMatrix,
+                    render->GetTexture(TextureType::Diffuse, 0),
+                    sunlightDiffuse,
+                    sunlightAmbient,
+                    sunlightDirection,
+                    sunlightIntensity
+                );
+
+            case ShaderType::SKYBOX:
+                return m_shaderManager->render_skybox_shader(
+                    m_deviceContext,
+                    render->GetIndexCount(),
+                    worldMatrix,
+                    viewMatrix,
+                    projectionMatrix,
+                    render->GetTexture(TextureType::Diffuse, 0),
+                    sunlightDiffuse,
+                    sunlightAmbient,
+                    sunlightDirection,
+                    sunlightIntensity
+                );
+
+            case ShaderType::TEXTURE:
+            default:
+                return m_shaderManager->render_texture_shader(
+                    m_deviceContext,
+                    render->GetIndexCount(),
+                    worldMatrix,
+                    viewMatrix,
+                    projectionMatrix,
+                    render->GetTexture(TextureType::Diffuse, 0)
+                );
+        }
+    }
+
+    // Rendu de toutes les entités avec les composants nécessaires
+    int RenderAllEntities(EntityManager* entityManager,
+                         const DirectX::XMMATRIX& viewMatrix,
+                         const DirectX::XMMATRIX& projectionMatrix,
+                         const DirectX::XMFLOAT4* diffuseColors,
+                         const DirectX::XMFLOAT4* lightPositions,
+                         const DirectX::XMFLOAT4* ambientColors,
+                         const DirectX::XMFLOAT3& cameraPos,
+                         const DirectX::XMFLOAT4& sunlightDiffuse,
+                         const DirectX::XMFLOAT4& sunlightAmbient,
+                         const DirectX::XMFLOAT3& sunlightDirection,
+                         float sunlightIntensity) {
+        
+        int renderCount = 0;
+
+        // Récupérer toutes les entités qui ont les composants RenderComponent et TransformComponent
+        auto entities = entityManager->GetEntitiesWithComponent<RenderComponent>();
+        
+        for (auto& entity : entities) {
+            auto render = entity->GetComponent<RenderComponent>();
+            
+            // Vérifier si l'entité a un TransformComponent
+            auto transform = entity->GetComponent<TransformComponent>();
+            if (!transform) continue;
+
+            // Vérifier si le modèle est visible
+            if (!render->IsVisible()) continue;
+
+            // Effectuer le rendu
+            if (RenderEntity(entity, viewMatrix, projectionMatrix, 
+                            diffuseColors, lightPositions, ambientColors,cameraPos,
+                            sunlightDiffuse, sunlightAmbient, sunlightDirection,
+                            sunlightIntensity)) {
+                renderCount++;
+            }
+        }
+
+        return renderCount;
+    }
+
+private:
+    ID3D11DeviceContext* m_deviceContext;
+    shader_manager_class* m_shaderManager;
+};
+
+} // namespace ecs

enginecustom/src/src/system/application_class.cpp

@@ -91,6 +91,9 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
 		render_queues_.push_back(std::ref(cubes_));
 		render_queues_.push_back(std::ref(terrain_chunk_));
 
+		// create entity manager
+		entity_manager_ = std::make_unique<ecs::EntityManager>();
+
 		screen_width_ = screenWidth;
 		screen_height_ = screenHeight;
 
@@ -1725,271 +1728,100 @@ void application_class::culling_thread_function()
 bool application_class::render_pass(const std::vector<std::reference_wrapper<std::vector<object*>>>& RenderQueues, XMFLOAT4* diffuse, XMFLOAT4* position, XMFLOAT4* ambient, XMMATRIX view, XMMATRIX projection)
 {
 	std::lock_guard<std::mutex> lock(objects_mutex_);
-	XMMATRIX scaleMatrix, rotateMatrix, translateMatrix ;
+	XMMATRIX scaleMatrix, rotateMatrix, translateMatrix;
 	bool result;
 
 	int renderCount = 0;
 	int i;
 
-	if (RenderQueues.empty())
+	// render skybox
+	for (auto& skyboxObject : skybox_)
 	{
-		Logger::Get().Log("RenderQueues is empty", __FILE__, __LINE__, Logger::LogLevel::Error);
+		if (skyboxObject == nullptr)
-		return false;
+		{
+			Logger::Get().Log("skyboxObject is null", __FILE__, __LINE__, Logger::LogLevel::Error);
+			return false;
+		}
+
+		if (!skyboxObject->IsVisible())
+		{
+			continue;
+		}
+
+		direct_3d_->turn_z_buffer_off();
+
+		scaleMatrix = skyboxObject->GetScaleMatrix();
+		rotateMatrix = skyboxObject->GetRotateMatrix();
+		translateMatrix = skyboxObject->GetTranslateMatrix();
+
+		XMMATRIX worldMatrix = XMMatrixMultiply(
+			XMMatrixMultiply(scaleMatrix, rotateMatrix),
+			translateMatrix
+		);
+
+		renderCount++;
+
+		skyboxObject->get_model()->Render(direct_3d_->get_device_context());
+
+		result = shader_manager_->render_skybox_shader(
+					direct_3d_->get_device_context(),
+					skyboxObject->get_model()->GetIndexCount(),
+					worldMatrix,
+					view,
+					projection,
+					skyboxObject->get_model()->GetTexture(TextureType::Diffuse,0),
+					sun_light_->GetDiffuseColor(),
+					sun_light_->GetAmbientColor(),
+					sun_light_->GetDirection(),
+					sun_light_->GetIntensity()
+					);
+		if (!result)
+		{
+			Logger::Get().Log("Could not render the object model using the skybox shader", __FILE__, __LINE__, Logger::LogLevel::Error);
+			return false;
+		}
+		direct_3d_->turn_z_buffer_on(); // Réactiver le Z-buffer après le rendu de la skybox
+		
+		break;
+		
 	}
 
+	// Rendu des entités du système ECS s'il est disponible
+	if (entity_manager_) {
+		// Créer le système de rendu pour les entités
+		ecs::RenderSystem renderSystem(direct_3d_->get_device_context(), shader_manager_);
+		
+		// Données pour le système de rendu
+		XMFLOAT4 sunlightDiffuse = sun_light_->GetDiffuseColor();
+		XMFLOAT4 sunlightAmbient = sun_light_->GetAmbientColor();
+		XMFLOAT3 sunlightDirection = sun_light_->GetDirection();
+		float sunlightIntensity = sun_light_->GetIntensity();
+		
+		// Effectuer le rendu de toutes les entités
+		int entitiesRendered = renderSystem.RenderAllEntities(
+			entity_manager_.get(),
+			view, 
+			projection, 
+			diffuse, 
+			position, 
+			ambient,
+			camera_->get_position(),
+			sunlightDiffuse,
+			sunlightAmbient, 
+			sunlightDirection,
+			sunlightIntensity
+		);
+		
+		renderCount += entitiesRendered;
+	}
+
+	// Rendu des objets traditionnels comme avant
 	// if (active_camera_ == sun_camera_)
 	// {
 	// 	shadow_map_->set_render_target(direct_3d_->get_device_context());
 	// 	shadow_map_->clear_render_target(direct_3d_->get_device_context());
 	// }
 
-	for (const auto& RenderQueue : RenderQueues)
-	{
-		// Désactiver le Z-buffer si la RenderQueue est skybox_
-		bool isSkybox = (&RenderQueue.get() == &skybox_);
-		if (isSkybox)
-		{
-			direct_3d_->turn_z_buffer_off();
-		}
-
-		for (auto& object : RenderQueue.get())
-		{
-			if (object == nullptr)
-			{
-				Logger::Get().Log("object is null", __FILE__, __LINE__, Logger::LogLevel::Error);
-				return false;
-			}
-
-			// Check if the object has physics enabled
-			if (object->IsPhysicsEnabled())
-			{
-				object->UpdatePosition(timer_->GetTime());
-			}
-			
-			if (!object->IsVisible())
-			{
-				continue;
-			}
-			
-			renderCount++;
-
-			scaleMatrix = object->GetScaleMatrix();
-			rotateMatrix = object->GetRotateMatrix();
-			translateMatrix = object->GetTranslateMatrix();
-
-			XMMATRIX worldMatrix = XMMatrixMultiply(
-				XMMatrixMultiply(scaleMatrix, rotateMatrix),
-				translateMatrix
-			);
-
-			object->get_model()->Render(direct_3d_->get_device_context());
-
-			if (active_camera_ == sun_camera_)
-			{
-				result = shader_manager_->render_depth_shader(
-					direct_3d_->get_device_context(),
-					object->get_model()->GetIndexCount(),
-					worldMatrix,
-					view,
-					projection,
-					object->get_model()->GetTexture(TextureType::Diffuse,0)
-				);
-			}
-
-			// Utiliser l'enum ShaderType pour déterminer quel shader utiliser
-			switch (object->GetActiveShader())
-			{
-
-			case ShaderType::ALPHA_MAPPING:
-
-				// Enable alpha blending for transparency.
-				direct_3d_->enable_alpha_blending();
-				
-				result = shader_manager_->render_alpha_map_shader(
-					direct_3d_->get_device_context(),
-					object->get_model()->GetIndexCount(),
-					worldMatrix,
-					view,
-					projection,
-					object->get_model()->GetTexture(TextureType::Diffuse,0),
-					object->get_model()->GetTexture(TextureType::Diffuse,1),
-					object->get_model()->GetTexture(TextureType::Alpha,0)
-					);
-				if (!result)
-				{
-					Logger::Get().Log("Could not render the model using the alpha map shader", __FILE__, __LINE__, Logger::LogLevel::Error);
-					direct_3d_->disable_alpha_blending();
-					return false;
-				}
-				direct_3d_->disable_alpha_blending();
-				break;
-			
-			case ShaderType::CEL_SHADING:
-				result = shader_manager_->render_cel_shading_shader(
-					direct_3d_->get_device_context(),
-					object->get_model()->GetIndexCount(),
-					worldMatrix,
-					view,
-					projection,
-					object->get_model()->GetTexture(TextureType::Diffuse,0),
-					sun_light_->GetDiffuseColor(),
-					sun_light_->GetAmbientColor(),
-					sun_light_->GetDirection(),
-					sun_light_->GetIntensity()
-					);
-				if (!result)
-				{
-					Logger::Get().Log("Could not render the model using the cel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
-					return false;
-				}
-				break;
-
-			case ShaderType::NORMAL_MAPPING:
-				result = shader_manager_->render_normal_map_shader(
-					direct_3d_->get_device_context(),
-					object->get_model()->GetIndexCount(),
-					worldMatrix,
-					view,
-					projection,
-					object->get_model()->GetTexture(TextureType::Diffuse,0),
-					object->get_model()->GetTexture(TextureType::Normal,0),
-					lights_[0]->GetDirection(),
-					lights_[0]->GetDiffuseColor()
-					);
-				if (!result)
-				{
-					Logger::Get().Log("Could not render the model using the normal map shader", __FILE__, __LINE__, Logger::LogLevel::Error);
-					return false;
-				}
-				break;
-
-			case ShaderType::SPECULAR_MAPPING:
-				result = shader_manager_->render_spec_map_shader(
-					direct_3d_->get_device_context(),
-					object->get_model()->GetIndexCount(),
-					worldMatrix,
-					view,
-					projection,
-					object->get_model()->GetTexture(TextureType::Diffuse,0),
-					object->get_model()->GetTexture(TextureType::Normal,0),
-					object->get_model()->GetTexture(TextureType::Specular,0),
-					lights_[0]->GetDirection(),
-					lights_[0]->GetDiffuseColor(),
-					camera_->get_position(),
-					lights_[0]->GetSpecularColor(),
-					lights_[0]->GetSpecularPower()
-					);
-				if (!result)
-				{
-					Logger::Get().Log("Could not render the model using the specular map shader", __FILE__, __LINE__, Logger::LogLevel::Error);
-					return false;
-				}
-				break;
-				
-			case ShaderType::TEXTURE:
-				result = shader_manager_->render_texture_shader(
-					direct_3d_->get_device_context(),
-					object->get_model()->GetIndexCount(),
-					worldMatrix,
-					view,
-					projection,
-					object->get_model()->GetTexture(TextureType::Diffuse,0)
-					);
-				if (!result)
-				{
-					Logger::Get().Log("Could not render the model using the texture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
-					return false;
-				}
-				break;
-
-			case ShaderType::LIGHTING:
-				result = shader_manager_->renderlight_shader(
-					direct_3d_->get_device_context(),
-					object->get_model()->GetIndexCount(),
-					worldMatrix,
-					view,
-					projection,
-					object->get_model()->GetTexture(TextureType::Diffuse,0),
-					diffuse,
-					position,
-					ambient
-					);
-				if (!result)
-				{
-					Logger::Get().Log("Could not render the object model using the light shader", __FILE__, __LINE__, Logger::LogLevel::Error);
-					return false;
-				}
-				break;
-
-			case ShaderType::SKYBOX:
-				result = shader_manager_->render_skybox_shader(
-					direct_3d_->get_device_context(),
-					object->get_model()->GetIndexCount(),
-					worldMatrix,
-					view,
-					projection,
-					object->get_model()->GetTexture(TextureType::Diffuse,0),
-					sun_light_->GetDiffuseColor(),
-					sun_light_->GetAmbientColor(),
-					sun_light_->GetDirection(),
-					sun_light_->GetIntensity()
-					);
-				if (!result)
-				{
-					Logger::Get().Log("Could not render the object model using the skybox shader", __FILE__, __LINE__, Logger::LogLevel::Error);
-					return false;
-				}
-				break;
-
-			case ShaderType::SUNLIGHT:
-				result = shader_manager_->render_sunlight_shader(
-					direct_3d_->get_device_context(),
-					object->get_model()->GetIndexCount(),
-					worldMatrix,
-					view,
-					projection,
-					object->get_model()->GetTexture(TextureType::Diffuse,0),
-					sun_light_->GetDiffuseColor(),
-					sun_light_->GetAmbientColor(),
-					sun_light_->GetDirection(),
-					sun_light_->GetIntensity()
-					//shadow_map_srv_
-					);
-				if (!result)
-				{
-					Logger::Get().Log("Could not render the object model using the sunlight shader", __FILE__, __LINE__, Logger::LogLevel::Error);
-					return false;
-				}
-				break;
-			default:
-				result = shader_manager_->renderlight_shader(
-					direct_3d_->get_device_context(),
-					object->get_model()->GetIndexCount(),
-					worldMatrix,
-					view,
-					projection,
-					object->get_model()->GetTexture(TextureType::Diffuse,0),
-					diffuse,
-					position,
-					ambient
-					);
-				if (!result)
-				{
-					Logger::Get().Log("Could not render the object model using the light shader", __FILE__, __LINE__, Logger::LogLevel::Error);
-					return false;
-				}
-				break;
-			}
-
-			stats_->increment_draw_call_count();
-		}
-
-		if (isSkybox)
-		{
-			direct_3d_->turn_z_buffer_on();
-		}
-	}
-
 	// if (active_camera_ == sun_camera_)
 	// {
 	// 	direct_3d_->set_back_buffer_render_target();
@@ -2161,28 +1993,56 @@ bool application_class::create_big_cube(int side_count)
         sharedModel = newModel;
     }
 
-    // Créer temporairement les cubes dans un vecteur local
+    // Version ECS - Créer les entités pour le cube
-    std::vector<object*> tempCubes;
+    if (entity_manager_) {
-    tempCubes.reserve(side_count * side_count * side_count);
+        for (int x = 0; x < side_count; x++) {
+            for (int y = 0; y < side_count; y++) {
+                for (int z = 0; z < side_count; z++) {
+                    // Créer une entité
+                    auto entity = entity_manager_->CreateEntity();
                     
-    // Générer side_count³ cubes
+                    // Ajouter un composant d'identité
-    for (int x = 0; x < side_count; x++)
+                    auto identity = entity->AddComponent<ecs::IdentityComponent>(object_id_++);
-    {
+                    identity->SetName("CubePart_" + std::to_string(x) + "_" + std::to_string(y) + "_" + std::to_string(z));
-        for (int y = 0; y < side_count; y++)
+                    identity->SetType(ecs::ObjectType::Cube);
-        {
+                    
-            for (int z = 0; z < side_count; z++)
+                    // Ajouter un composant de transformation
-            {
+                    auto transform = entity->AddComponent<ecs::TransformComponent>();
-                object* cubePart = new object(*this);
+                    transform->SetPosition(XMVectorSet(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), 0.0f));
-                cubePart->SetModel(sharedModel);
+                    transform->SetScale(XMVectorSet(1.0f, 1.0f, 1.0f, 0.0f));
-                cubePart->SetTranslateMatrix(XMMatrixTranslation(static_cast<float>(x),static_cast<float>(y),static_cast<float>(z)));
+                    transform->UpdateWorldMatrix();
-                tempCubes.push_back(cubePart);
+                    
+                    // Ajouter un composant de rendu
+                    auto render = entity->AddComponent<ecs::RenderComponent>();
+                    render->InitializeWithModel(sharedModel);
+                    
+                    // Ajouter un composant de shader
+                    auto shader = entity->AddComponent<ecs::ShaderComponent>();
+                    shader->SetActiveShader(ecs::ShaderType::LIGHTING);
+                }
             }
         }
-    }
+    } else {
-    // Transférer les cubes du vecteur temporaire au vecteur membre
+        // Ancien système - Créer temporairement les cubes dans un vecteur local
-    cubes_ = std::move(tempCubes);
+        std::vector<object*> tempCubes;
+        tempCubes.reserve(side_count * side_count * side_count);
 
-	update_stats_after_modification();
+        // Générer side_count³ cubes
+        for (int x = 0; x < side_count; x++) {
+            for (int y = 0; y < side_count; y++) {
+                for (int z = 0; z < side_count; z++) {
+                    object* cubePart = new object(*this);
+                    cubePart->SetModel(sharedModel);
+                    cubePart->SetTranslateMatrix(XMMatrixTranslation(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z)));
+                    tempCubes.push_back(cubePart);
+                }
+            }
+        }
+        // Transférer les cubes du vecteur temporaire au vecteur membre
+        cubes_ = std::move(tempCubes);
+    }
+
+    update_stats_after_modification();
     
     return true;
 }