Major - ECS - V12.0.0

.idea/.idea.KhaoticEngineReborn/.idea/workspace.xml

@@ -7,13 +7,11 @@
     <list default="true" id="e81d6e08-efc7-40a0-909d-ec4943d948e9" name="Changes" comment="">
       <change beforePath="$PROJECT_DIR$/.idea/.idea.KhaoticEngineReborn/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/.idea.KhaoticEngineReborn/.idea/workspace.xml" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/enginecustom/imgui.ini" beforeDir="false" afterPath="$PROJECT_DIR$/enginecustom/imgui.ini" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/enginecustom/src/inc/system/Skybox.h" beforeDir="false" afterPath="$PROJECT_DIR$/enginecustom/src/inc/system/Skybox.h" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/enginecustom/src/inc/system/application_class.h" beforeDir="false" afterPath="$PROJECT_DIR$/enginecustom/src/inc/system/application_class.h" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/enginecustom/src/inc/system/object.h" beforeDir="false" afterPath="$PROJECT_DIR$/enginecustom/src/inc/system/object.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/enginecustom/src/inc/system/imguiManager.h" beforeDir="false" afterPath="$PROJECT_DIR$/enginecustom/src/inc/system/imguiManager.h" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/enginecustom/src/inc/system/stats.h" beforeDir="false" afterPath="$PROJECT_DIR$/enginecustom/src/inc/system/stats.h" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/enginecustom/src/src/system/Skybox.cpp" beforeDir="false" afterPath="$PROJECT_DIR$/enginecustom/src/src/system/Skybox.cpp" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/enginecustom/src/src/system/application_class.cpp" beforeDir="false" afterPath="$PROJECT_DIR$/enginecustom/src/src/system/application_class.cpp" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/enginecustom/src/src/system/object.cpp" beforeDir="false" afterPath="$PROJECT_DIR$/enginecustom/src/src/system/object.cpp" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/enginecustom/src/src/system/imguiManager.cpp" beforeDir="false" afterPath="$PROJECT_DIR$/enginecustom/src/src/system/imguiManager.cpp" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/enginecustom/src/src/system/stats.cpp" beforeDir="false" afterPath="$PROJECT_DIR$/enginecustom/src/src/system/stats.cpp" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
@@ -68,46 +66,7 @@
     <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
     <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
     <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
+    <setting file="cidr-memory-view://10" root0="FORCE_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
     <setting file="file://C:/Program Files (x86)/Windows Kits/10/Include/10.0.26100.0/um/d3d11.h" root0="SKIP_HIGHLIGHTING" />
     <setting file="file://C:/Program Files (x86)/Windows Kits/10/Include/10.0.26100.0/um/dinput.h" root0="SKIP_HIGHLIGHTING" />
     <setting file="file://C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Tools/MSVC/14.44.35207/include/memory" root0="SKIP_HIGHLIGHTING" />
@@ -139,7 +98,7 @@
     "ASKED_SHARE_PROJECT_CONFIGURATION_FILES": "true",
     "C++ Project.enginecustom.executor": "Run",
     "C/C++ Project.KhaoticDemo.executor": "Run",
-    "C/C++ Project.enginecustom.executor": "Debug",
+    "C/C++ Project.enginecustom.executor": "Run",
     "RunOnceActivity.ShowReadmeOnStart": "true",
     "RunOnceActivity.git.unshallow": "true",
     "SHARE_PROJECT_CONFIGURATION_FILES": "true",
@@ -150,7 +109,7 @@
     "node.js.selected.package.eslint": "(autodetect)",
     "node.js.selected.package.tslint": "(autodetect)",
     "nodejs_package_manager_path": "npm",
-    "settings.editor.selected.configurable": "preferences.pluginManager",
+    "settings.editor.selected.configurable": "preferences.environmentSetup",
     "vue.rearranger.settings.migration": "true"
   }
 }]]></component>
@@ -300,6 +259,10 @@
       <workItem from="1750335650897" duration="2051000" />
       <workItem from="1750344288223" duration="1751000" />
       <workItem from="1750351735497" duration="9648000" />
+      <workItem from="1750417484899" duration="2384000" />
+      <workItem from="1750420267631" duration="148000" />
+      <workItem from="1750592598277" duration="332000" />
+      <workItem from="1750699146323" duration="10385000" />
     </task>
     <task id="LOCAL-00001" summary="Minor update - viewport window tweak">
       <option name="closed" value="true" />

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,9 +10,9 @@ Collapsed=0
 
 [Window][Khaotic Engine]
 Pos=1267,19
-Size=317,609
+Size=317,842
 Collapsed=0
-DockId=0x00000002,0
+DockId=0x00000005,0
 
 [Window][render Stats]
 Pos=0,630
@@ -22,38 +22,46 @@ DockId=0x00000009,0
 
 [Window][Objects]
 Pos=0,19
-Size=238,609
+Size=234,842
 Collapsed=0
 DockId=0x0000000B,0
 
 [Window][Terrain]
 Pos=0,19
-Size=266,609
+Size=266,842
 Collapsed=0
 DockId=0x00000007,0
 
 [Window][Log Window]
-Pos=794,630
+Pos=0,630
-Size=790,231
+Size=1584,231
 Collapsed=0
 DockId=0x0000000A,0
 
 [Window][Light]
 Pos=0,19
-Size=238,609
+Size=234,609
 Collapsed=0
-DockId=0x0000000B,1
+DockId=0x0000000B,0
+
+[Window][Engine Settings]
+Pos=1267,462
+Size=317,166
+Collapsed=0
+DockId=0x00000006,0
 
 [Docking][Data]
-DockSpace         ID=0xCCBD8CF7 Window=0x3DA2F1DE Pos=0,19 Size=1584,842 Split=Y
+DockSpace           ID=0xCCBD8CF7 Window=0x3DA2F1DE Pos=0,19 Size=1584,842 Split=Y
-  DockNode        ID=0x00000003 Parent=0xCCBD8CF7 SizeRef=1584,609 Split=X
+  DockNode          ID=0x00000003 Parent=0xCCBD8CF7 SizeRef=1584,609 Split=X
-    DockNode      ID=0x0000000B Parent=0x00000003 SizeRef=238,842 Selected=0x031DC75C
+    DockNode        ID=0x0000000B Parent=0x00000003 SizeRef=234,842 Selected=0x321620B2
-    DockNode      ID=0x0000000C Parent=0x00000003 SizeRef=1344,842 Split=X
+    DockNode        ID=0x0000000C Parent=0x00000003 SizeRef=1348,842 Split=X
-      DockNode    ID=0x00000007 Parent=0x0000000C SizeRef=266,842 Selected=0x393905AB
+      DockNode      ID=0x00000007 Parent=0x0000000C SizeRef=266,842 Selected=0x393905AB
-      DockNode    ID=0x00000008 Parent=0x0000000C SizeRef=1316,842 Split=X
+      DockNode      ID=0x00000008 Parent=0x0000000C SizeRef=1316,842 Split=X
-        DockNode  ID=0x00000001 Parent=0x00000008 SizeRef=1025,842 CentralNode=1
+        DockNode    ID=0x00000001 Parent=0x00000008 SizeRef=1265,842 CentralNode=1
-        DockNode  ID=0x00000002 Parent=0x00000008 SizeRef=317,842 Selected=0x9F035453
+        DockNode    ID=0x00000002 Parent=0x00000008 SizeRef=317,842 Split=Y Selected=0x9F035453
-  DockNode        ID=0x00000004 Parent=0xCCBD8CF7 SizeRef=1584,231 Split=X Selected=0xF5D1BB37
+          DockNode  ID=0x00000005 Parent=0x00000002 SizeRef=317,441 Selected=0x9F035453
-    DockNode      ID=0x00000009 Parent=0x00000004 SizeRef=792,231 Selected=0xF5D1BB37
+          DockNode  ID=0x00000006 Parent=0x00000002 SizeRef=317,166 Selected=0x0B098C4B
-    DockNode      ID=0x0000000A Parent=0x00000004 SizeRef=790,231 Selected=0xAB74BEE9
+  DockNode          ID=0x00000004 Parent=0xCCBD8CF7 SizeRef=1584,231 Split=X Selected=0xF5D1BB37
+    DockNode        ID=0x00000009 Parent=0x00000004 SizeRef=792,231 Selected=0xF5D1BB37
+    DockNode        ID=0x0000000A Parent=0x00000004 SizeRef=790,231 Selected=0xAB74BEE9
 

enginecustom/src/inc/system/application_class.h

@@ -9,8 +9,6 @@
 #include "camera_class.h"
 #include "object.h"
 #include "light_class.h"
-#include <vector>
-#include <filesystem>
 
 #include "bitmap_class.h"
 #include "sprite_class.h"
@@ -31,7 +29,15 @@
 #include "physics.h"
 #include "frustum.h"
 #include "skybox.h"
+#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>
@@ -43,9 +49,10 @@
 #include <DirectXMath.h>
 #include <mutex>
 #include <memory>
+#include <vector>
+#include <filesystem>
 
-#include "shadow_map.h"
+#include "ecs/entity_manager.h"
-#include "stats.h"
 
 
 /////////////
@@ -128,14 +135,20 @@ public:
 
 	void set_cel_shading(const bool enable) { enable_cel_shading_ = enable; };
 
-	void set_vsync(bool vsync);
+	void set_vsync(bool vsync) { 
+		vsync_enabled_ = vsync; 
+		if (direct_3d_) {
+			direct_3d_->set_vsync(vsync); 
+			Logger::Get().Log("Setting Vsync to " + std::to_string(vsync), __FILE__, __LINE__);
+		}
+	};
 	bool get_vsync() const { return vsync_enabled_; };
 
-	HWND get_hwnd() const;
+	HWND get_hwnd() const { return hwnd_; };
-	void set_hwnd(HWND hwnd);
+	void set_hwnd(HWND hwnd) { hwnd_ = hwnd; };
 
-	bool is_windowed() const;
+	bool is_windowed() const { return windowed_; };
-	void set_windowed(bool windowed);
+	void set_windowed(bool windowed) { windowed_ = windowed; };
 
 	void set_window_size(const ImVec2 size) { window_size_ = size; };
 	ImVec2 get_window_size() const { return window_size_; };
@@ -151,6 +164,7 @@ public:
 	void set_frustum(const frustum& frustum) { frustum_culling_ = frustum; };
 
 	void construct_frustum();
+	
 	int get_render_count() const { return render_count_; };
 	void set_render_count(const int render_count) { render_count_ = render_count; };
 	float get_frustum_tolerance() const { return frustum_culling_tolerance_; };
@@ -176,6 +190,8 @@ private:
 	bool render_pass(const std::vector<std::reference_wrapper<std::vector<object*>>>& RenderQueues, XMFLOAT4* diffuse, XMFLOAT4* position, XMFLOAT4* ambient, XMMATRIX view, XMMATRIX projection);
 
 	void update_skybox_position();
+	void culling_thread_function();
+	void update_stats_after_modification();
 	
 public :
 	std::vector<ID3D11ShaderResourceView*> textures;
@@ -186,8 +202,6 @@ private :
 	std::thread culling_thread_;
 	std::atomic<bool> culling_active_;
 	std::mutex objects_mutex_;
-	void culling_thread_function();
-
 	
 	std::mutex terrain_mutex_;
 	std::vector<std::tuple<float, float, float, std::string, int>> terrain_generation_data_;
@@ -228,11 +242,14 @@ private :
 	// ------------- OBJECTS -------------- //
 	// ------------------------------------ //
 
+	std::unique_ptr<ecs::EntityManager> entity_manager_;
+	
 	object* selected_object_;
 	std::vector<object*> cubes_;
 	std::vector<object*> terrain_chunk_;
-	float speed_ = 0.1f; // speed for the demo spinning object
 	std::vector<object*> object_;
+	
+	float speed_ = 0.1f; // speed for the demo spinning object
 	std::vector<object*> imported_object_;
 	int object_id_ = 0;
 	std::vector<std::reference_wrapper<std::vector<object*>>> render_queues_;

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

enginecustom/src/inc/system/imguiManager.h

@@ -106,9 +106,12 @@ private:
 
 	const std::deque<Logger::LogEntry>& logBuffer = Logger::Get().GetLogBuffer();
 
-	int current_fps_, min_fps_, max_fps_, draw_calls_, total_vertex_count_, total_triangle_count_, visible_triangle_count_;
+	int current_fps_, min_fps_, max_fps_, draw_calls_, visible_triangle_count_;
 	float current_frame_time_, min_frame_time_, max_frame_time_ ;
 
+	std::shared_ptr<int> total_vertex_count_;
+	std::shared_ptr<int> total_triangle_count_;
+
 	// gpu information
 	char card_name_[128];
 	int video_memory_ = 0;

enginecustom/src/inc/system/stats.h

@@ -18,6 +18,7 @@ public:
 
     bool initialize(application_class* app);
     void update_geometric_stats();
+    void update_visible_count();
     void update_display_stats();
 
     int get_total_vertex_count() const;
@@ -36,6 +37,10 @@ public:
     std::string get_cpu_name();
     std::string get_gpu_driver_version(ID3D11Device* device);
 
+    std::shared_ptr<int>& get_vertex_count_ptr() { return total_vertex_count_; }
+    std::shared_ptr<int>& get_triangle_count_ptr() { return total_triangle_count_; }
+    
+
 private:
     std::thread update_display_thread_;
     
@@ -47,8 +52,9 @@ private:
     std::vector<object*> cubes_vec_;
     std::vector<object*> terrain_chunk_vec_;
 
-    int total_vertex_count_;
+    std::shared_ptr<int> total_vertex_count_;
-    int total_triangle_count_;
+    std::shared_ptr<int> total_triangle_count_;
+    
     int visible_triangle_count_ = 0;
     int current_fps_ = 0;
     int min_fps_ = 0;

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;
 
@@ -1155,7 +1158,7 @@ bool application_class::render(float rotation, float x, float y, float z, float
 	// 	return false;
 	// }
 
-	stats_->update_geometric_stats();
+	// stats_->update_geometric_stats();
 	
 	// Update the render count text.
 	result = update_render_count_string(get_render_count());
@@ -1353,6 +1356,8 @@ void application_class::generate_terrain()
 
             // Ajouter <20> la liste des chunks de terrain
             terrain_chunk_.push_back(terrain);
+
+        	update_stats_after_modification();
         }
     }
 
@@ -1395,6 +1400,8 @@ void application_class::add_kobject(std::wstring& filepath)
 
 	object_.push_back(newObject);
 
+	update_stats_after_modification();
+
 	// V<>rifiez que l'objet a bien re<72>u les textures_
 	if (newObject->get_model()->GetTexture(TextureType::Diffuse,0) == nullptr)
 	{
@@ -1426,6 +1433,8 @@ void application_class::add_cube()
 
 	cubes_.push_back(newCube);
 
+	update_stats_after_modification();
+
 }
 
 void application_class::delete_kobject(int index)
@@ -1437,6 +1446,8 @@ void application_class::delete_kobject(int index)
 	{
 		object_.erase(object_.begin() + index);
 	}
+
+	update_stats_after_modification();
 }
 
 void application_class::delete_terrain()
@@ -1444,6 +1455,7 @@ void application_class::delete_terrain()
 	std::lock_guard<std::mutex> lock(objects_mutex_);
 	Logger::Get().Log("Deleting terrain", __FILE__, __LINE__);
 	terrain_chunk_.clear();
+	update_stats_after_modification();
 }
 
 bool application_class::update_mouse_strings(int mouseX, int mouseY, bool mouseDown)
@@ -1637,39 +1649,6 @@ void application_class::set_light_position(int index, XMVECTOR position)
 	lights_[index]->SetPosition(lightPosition.x, lightPosition.y, lightPosition.z);
 }
 
-void application_class::set_vsync(bool vsync)
-{
-	vsync_enabled_ = vsync;
-
-	if (direct_3d_)
-	{
-		Logger::Get().Log("Setting Vsync to " + std::to_string(vsync) + " with a screen width : " + std::to_string(get_screen_width()) + "and a screen height : " + std::to_string(get_screen_height()), __FILE__, __LINE__);
-		direct_3d_->set_vsync(vsync);
-	}
-}
-
-HWND application_class::get_hwnd() const
-{
-	return hwnd_;
-}
-
-void application_class::set_hwnd(HWND hwnd)
-{
-	hwnd_ = hwnd;
-}
-
-bool application_class::is_windowed() const
-{
-	return windowed_;
-}
-
-void application_class::set_windowed(bool windowed)
-{
-	// log the new windowed mode
-	Logger::Get().Log("Setting windowed mode to " + std::to_string(windowed), __FILE__, __LINE__);
-	windowed_ = windowed;
-}
-
 void application_class::set_screen_height(int height)
 {
 	// log the new screen height
@@ -1749,270 +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<70>s le rendu de la skybox
+		
+		break;
+		
 	}
 
+	// Rendu des entit<69>s du syst<73>me ECS s'il est disponible
+	if (entity_manager_) {
+		// Cr<43>er le syst<73>me de rendu pour les entit<69>s
+		ecs::RenderSystem renderSystem(direct_3d_->get_device_context(), shader_manager_);
+		
+		// Donn<6E>es pour le syst<73>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<69>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();
@@ -2184,26 +1993,64 @@ bool application_class::create_big_cube(int side_count)
         sharedModel = newModel;
     }
 
-    // Cr<EFBFBD>er temporairement les cubes dans un vecteur local
+    // Version ECS - Cr<43>er les entit<69>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<43>er une entit<69>
+                    auto entity = entity_manager_->CreateEntity();
                     
-    // G<>n<EFBFBD>rer side_count<6E> cubes
+                    // Ajouter un composant d'identit<69>
-    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 {
+        // Ancien syst<73>me - Cr<43>er temporairement les cubes dans un vecteur local
+        std::vector<object*> tempCubes;
+        tempCubes.reserve(side_count * side_count * side_count);
+
+        // G<>n<EFBFBD>rer side_count<6E> 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<73>rer les cubes du vecteur temporaire au vecteur membre
+        cubes_ = std::move(tempCubes);
     }
-    // Transf<73>rer les cubes du vecteur temporaire au vecteur membre
+
-    cubes_ = std::move(tempCubes);
+    update_stats_after_modification();
     
     return true;
 }
+
+void application_class::update_stats_after_modification()
+{
+	if (stats_)
+	{
+		stats_ -> update_geometric_stats();
+	}
+}

enginecustom/src/src/system/imguiManager.cpp

@@ -18,6 +18,14 @@ imguiManager::imguiManager()
 	visible_triangle_count_ = 0;
 	current_frame_time_ = 0;
 
+	showObjectWindow = false;
+	showTerrainWindow = false;
+	showLightWindow = false;
+	showOldSceneWindow = false;
+	showEngineSettingsWindow = false;
+	showLogWindow = false;
+	showStatsWindow = false;
+    
 	// Initialiser l'historique des frametimes <20> z<>ro
 	for (int i = 0; i < FRAME_HISTORY_COUNT; i++)
 	{
@@ -172,6 +180,9 @@ bool imguiManager::Initialize(HWND hwnd, ID3D11Device* device, ID3D11DeviceConte
 
 	stats_ = app_->get_stats();
 
+	total_triangle_count_ = stats_->get_triangle_count_ptr();
+	total_vertex_count_ = stats_->get_vertex_count_ptr();
+    
     Logger::Get().Log("imgui initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
     
     return true;
@@ -989,8 +1000,11 @@ void imguiManager::WidgetRenderStats()
 	min_fps_ = stats_->get_min_fps();
 	max_fps_ = stats_->get_max_fps();
 	draw_calls_ = stats_->get_draw_calls();
-	total_vertex_count_ = stats_->get_total_vertex_count();
+
-	total_triangle_count_ = stats_->get_total_triangle_count();
+	
+	// total_vertex_count_ = stats_->get_total_vertex_count();
+	// total_triangle_count_ = stats_->get_total_triangle_count();
+	
 	visible_triangle_count_ = stats_->get_visible_triangle_count();
 	current_frame_time_ = stats_->get_frame_time();
 	
@@ -1039,9 +1053,9 @@ void imguiManager::WidgetRenderStats()
     ImGui::Separator();
 
     ImGui::Text("Statistiques de rendu:");
-    ImGui::Text("Vertices total: %d", total_vertex_count_);
+    ImGui::Text("Vertices total: %d", *total_vertex_count_);
 
-    ImGui::Text("Triangles total: %d", total_triangle_count_);
+    ImGui::Text("Triangles total: %d", *total_triangle_count_);
     ImGui::SameLine();
     ImGui::Text("Triangles visibles: %d", visible_triangle_count_);
 

enginecustom/src/src/system/stats.cpp

@@ -3,6 +3,8 @@
 
 stats::stats() : fps_(nullptr), drawcalls_(0)
 {
+    total_triangle_count_ = std::make_shared<int>(0);
+    total_vertex_count_ = std::make_shared<int>(0);
 }
 
 stats::~stats()
@@ -35,13 +37,20 @@ bool stats::initialize(application_class* app)
 void stats::update_geometric_stats()
 {
     
-        object_vec_ = app_->get_kobjects();
+    object_vec_ = app_->get_kobjects();
-        cubes_vec_ = app_->get_cubes();
+    cubes_vec_ = app_->get_cubes();
-        terrain_chunk_vec_ = app_->get_terrain_cubes();
+    terrain_chunk_vec_ = app_->get_terrain_cubes();
     
-        total_vertex_count_ = get_total_vertex_count();
+    
-        total_triangle_count_ = get_total_triangle_count();
+    *total_vertex_count_ = get_total_vertex_count();
-        visible_triangle_count_ = get_visible_triangle_count();
+    *total_triangle_count_ = get_total_triangle_count();
+    
+    update_visible_count();
+}
+
+void stats::update_visible_count()
+{
+    visible_triangle_count_ = get_visible_triangle_count();
 }
 
 void stats::update_display_stats()