Major - ECS - V12.0.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<6D>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 <20> 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 <20> jour de la v<>locit<69> bas<61>e sur l'acc<63>l<EFBFBD>ration
+        m_Velocity = m_Velocity + m_Acceleration * deltaTime;
+        
+        // Si la physique est activ<69>e et qu'une fonction de mise <20> 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 <20> jour la position (sera connect<63> 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<6F>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<6F>le existe d<>j<EFBFBD> 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<43>er un nouveau mod<6F>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<63>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<69>s
+using EntityID = uint32_t;
+
+class Entity {
+public:
+    explicit Entity(EntityID id) : m_ID(id) {}
+    ~Entity() = default;
+
+    // Emp<6D>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<EFBFBD>
+        if (m_Components.find(typeID) != m_Components.end()) {
+            return std::static_pointer_cast<T>(m_Components[typeID]);
+        }
+        
+        // Cr<43>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<75>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<69> poss<73>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 <20> 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<43>er une nouvelle entit<69>
+    std::shared_ptr<Entity> CreateEntity() {
+        EntityID id;
+        
+        // R<>utiliser les IDs des entit<69>s supprim<69>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<69>
+    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<69> 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 <20> jour toutes les entit<69>s
+    void UpdateEntities(float deltaTime) {
+        for (auto& [id, entity] : m_Entities) {
+            entity->UpdateComponents(deltaTime);
+        }
+    }
+
+    // Obtenir toutes les entit<69>s qui ont un composant sp<73>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<69>s
+    size_t GetEntityCount() const {
+        return m_Entities.size();
+    }
+
+    // Vider toutes les entit<69>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 <20> 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<69> sp<73>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<69> 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<6F>le
+        render->Render(m_deviceContext);
+
+        // S<>lectionner le shader appropri<72>
+        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 (<28> ajuster)
+                    16.0f                   // Puissance speculaire (<28> ajuster)
+                );
+
+            case ShaderType::LIGHTING:
+                {
+                    // Cr<43>er des copies locales non constantes des tableaux
+                    DirectX::XMFLOAT4 localDiffuseColors[4];
+                    DirectX::XMFLOAT4 localLightPositions[4];
+                    DirectX::XMFLOAT4 localAmbientColors[4];
+                    
+                    // Copier les donn<6E>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<69>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<75>rer toutes les entit<69>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<69> a un TransformComponent
+            auto transform = entity->GetComponent<TransformComponent>();
+            if (!transform) continue;
+
+            // V<>rifier si le mod<6F>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