Patch - TODO : Serialized / Deserialized Component DATA - V12.7.1

Minor - ECS use when loading scene - V12.7.0
Minor - ECS use in save - V12.6.0
2025-06-26 21:44:28 +02:00 · 2025-06-24 18:58:53 +02:00 · 2025-06-24 18:41:13 +02:00 · 2025-06-24 17:15:58 +02:00 · 2025-06-24 17:01:05 +02:00 · 2025-06-24 16:44:29 +02:00
16 changed files with 996 additions and 774 deletions
--- a/.idea/.idea.KhaoticEngineReborn/.idea/workspace.xml
+++ b/.idea/.idea.KhaoticEngineReborn/.idea/workspace.xml
@ -7,12 +7,9 @@
    <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/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/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/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/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" />
+      <change beforePath="$PROJECT_DIR$/enginecustom/src/inc/system/ecs/component.h" beforeDir="false" afterPath="$PROJECT_DIR$/enginecustom/src/inc/system/ecs/component.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/enginecustom/src/inc/system/ecs/components/identity_component.h" beforeDir="false" afterPath="$PROJECT_DIR$/enginecustom/src/inc/system/ecs/components/identity_component.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/enginecustom/src/src/system/scene_manager.cpp" beforeDir="false" afterPath="$PROJECT_DIR$/enginecustom/src/src/system/scene_manager.cpp" afterDir="false" />
    </list>
    <option name="SHOW_DIALOG" value="false" />
    <option name="HIGHLIGHT_CONFLICTS" value="true" />
@ -26,52 +23,21 @@
    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
  </component>
  <component name="HighlightingSettingsPerFile">
-    <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="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="cidr-memory-view://10" root0="FORCE_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" />
    <setting file="file://$PROJECT_DIR$/enginecustom/include/Inc/VertexTypes.h" root0="SKIP_HIGHLIGHTING" />
    <setting file="file://$PROJECT_DIR$/enginecustom/include/Vulkan/Include/vulkan/vulkan_core.h" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$PROJECT_DIR$/enginecustom/src/inc/system/ecs/component.h" root0="FORCE_HIGHLIGHTING" />
+    <setting file="file://$PROJECT_DIR$/enginecustom/src/inc/system/ecs/components/identity_component.h" root0="FORCE_HIGHLIGHTING" />
+    <setting file="file://$PROJECT_DIR$/enginecustom/src/inc/system/ecs/components/model_path_component.h" root0="FORCE_HIGHLIGHTING" />
+    <setting file="file://$PROJECT_DIR$/enginecustom/src/inc/system/ecs/components/physics_component.h" root0="FORCE_HIGHLIGHTING" />
+    <setting file="file://$PROJECT_DIR$/enginecustom/src/inc/system/ecs/components/render_component.h" root0="FORCE_HIGHLIGHTING" />
+    <setting file="file://$PROJECT_DIR$/enginecustom/src/inc/system/ecs/components/shader_component.h" root0="FORCE_HIGHLIGHTING" />
+    <setting file="file://$PROJECT_DIR$/enginecustom/src/inc/system/ecs/components/transform_component.h" root0="FORCE_HIGHLIGHTING" />
+    <setting file="file://$PROJECT_DIR$/enginecustom/src/inc/system/ecs/entity.h" root0="FORCE_HIGHLIGHTING" />
+    <setting file="file://$PROJECT_DIR$/enginecustom/src/inc/system/ecs/entity_manager.h" root0="FORCE_HIGHLIGHTING" />
+    <setting file="file://$PROJECT_DIR$/enginecustom/src/inc/system/ecs/systems/render_system.h" root0="FORCE_HIGHLIGHTING" />
    <setting file="file://$PROJECT_DIR$/../../IDE_VS/VC/Tools/MSVC/14.38.33130/include/type_traits" root0="SKIP_HIGHLIGHTING" />
  </component>
  <component name="KubernetesApiPersistence">{}</component>
@ -93,26 +59,26 @@
    <option name="hideEmptyMiddlePackages" value="true" />
    <option name="showLibraryContents" value="true" />
  </component>
-  <component name="PropertiesComponent"><![CDATA[{
-  "keyToString": {
-    "ASKED_SHARE_PROJECT_CONFIGURATION_FILES": "true",
-    "C++ Project.enginecustom.executor": "Run",
-    "C/C++ Project.KhaoticDemo.executor": "Run",
-    "C/C++ Project.enginecustom.executor": "Run",
-    "RunOnceActivity.ShowReadmeOnStart": "true",
-    "RunOnceActivity.git.unshallow": "true",
-    "SHARE_PROJECT_CONFIGURATION_FILES": "true",
-    "git-widget-placeholder": "main",
-    "ignore.virus.scanning.warn.message": "true",
-    "node.js.detected.package.eslint": "true",
-    "node.js.detected.package.tslint": "true",
-    "node.js.selected.package.eslint": "(autodetect)",
-    "node.js.selected.package.tslint": "(autodetect)",
-    "nodejs_package_manager_path": "npm",
-    "settings.editor.selected.configurable": "preferences.environmentSetup",
-    "vue.rearranger.settings.migration": "true"
+  <component name="PropertiesComponent">{
+  &quot;keyToString&quot;: {
+    &quot;ASKED_SHARE_PROJECT_CONFIGURATION_FILES&quot;: &quot;true&quot;,
+    &quot;C++ Project.enginecustom.executor&quot;: &quot;Run&quot;,
+    &quot;C/C++ Project.KhaoticDemo.executor&quot;: &quot;Run&quot;,
+    &quot;C/C++ Project.enginecustom.executor&quot;: &quot;Run&quot;,
+    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.git.unshallow&quot;: &quot;true&quot;,
+    &quot;SHARE_PROJECT_CONFIGURATION_FILES&quot;: &quot;true&quot;,
+    &quot;git-widget-placeholder&quot;: &quot;main&quot;,
+    &quot;ignore.virus.scanning.warn.message&quot;: &quot;true&quot;,
+    &quot;node.js.detected.package.eslint&quot;: &quot;true&quot;,
+    &quot;node.js.detected.package.tslint&quot;: &quot;true&quot;,
+    &quot;node.js.selected.package.eslint&quot;: &quot;(autodetect)&quot;,
+    &quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;,
+    &quot;nodejs_package_manager_path&quot;: &quot;npm&quot;,
+    &quot;settings.editor.selected.configurable&quot;: &quot;preferences.environmentSetup&quot;,
+    &quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
  }
-}]]></component>
+}</component>
  <component name="RunManager" selected="C/C++ Project.enginecustom">
    <configuration name="KhaoticDemo" type="CppProject" factoryName="C++ Project">
      <configuration_1 setup="1">
@ -263,6 +229,10 @@
      <workItem from="1750420267631" duration="148000" />
      <workItem from="1750592598277" duration="332000" />
      <workItem from="1750699146323" duration="10385000" />
+      <workItem from="1750763086646" duration="4874000" />
+      <workItem from="1750770680795" duration="13425000" />
+      <workItem from="1750964683511" duration="27000" />
+      <workItem from="1750964770914" duration="2126000" />
    </task>
    <task id="LOCAL-00001" summary="Minor update - viewport window tweak">
      <option name="closed" value="true" />
--- a/enginecustom/DemoScene_V10.1.2.ker
+++ b/enginecustom/DemoScene_V10.1.2.ker
@ -1 +0,0 @@
-1 isosphere 0 10 0 0 -0 0 1 1 1 Content/Assets/Kobject/isosphere.obj ALPHA_MAPPING 1 Unknown 1 0 2 assets/Texture/Bricks2K.png F:\Github_Repo\khaotic-engine-Reborn\enginecustom\assets\Texture\moss01.png 1 assets/Texture/BricksNRM2K.png 1 assets/Texture/BricksGLOSS2K.png 1 F:\Github_Repo\khaotic-engine-Reborn\enginecustom\assets\Texture\alpha01.png
--- a/enginecustom/DemoScene_V10.8.1.ker
+++ b/enginecustom/DemoScene_V10.8.1.ker
@ -1 +0,0 @@
-0 vaisseautri 0 50 0 0 -0 0 1 1 1 Content/Assets/Kobject/vaisseautri.obj CEL_SHADING 1 Unknown 1 0 1 F:\Github_Repo\khaotic-engine-Reborn\enginecustom\assets\Texture\marble01.png 1 assets/Texture/BricksNRM2K.png 1 assets/Texture/BricksGLOSS2K.png 0
--- a/enginecustom/DemoScene_V12.6.0.ker
+++ b/enginecustom/DemoScene_V12.6.0.ker
@ -0,0 +1 @@
+1 CubePart_0_0_0 0 0 0 0 -0 0 1 1 1  LIGHTING 0 Terrain 0 0 1 assets/Texture/Bricks2K.png 1 assets/Texture/BricksNRM2K.png 1 assets/Texture/BricksGLOSS2K.png 0
--- a/enginecustom/enginecustom.vcxproj
+++ b/enginecustom/enginecustom.vcxproj
@ -121,6 +121,7 @@
    <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\model_path_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" />
@ -143,7 +144,6 @@
    <ClInclude Include="src\inc\system\physics.h" />
    <ClInclude Include="src\inc\system\position_class.h" />
    <ClInclude Include="src\inc\system\render_texture_class.h" />
-    <ClInclude Include="src\inc\system\sceneManager.h" />
    <ClInclude Include="src\inc\system\scene_manager.h" />
    <ClInclude Include="src\inc\system\shadow_map.h" />
    <ClInclude Include="src\inc\system\Skybox.h" />
--- a/enginecustom/imgui.ini
+++ b/enginecustom/imgui.ini
@ -16,25 +16,25 @@ DockId=0x00000005,0

 [Window][render Stats]
 Pos=0,630
-Size=1584,231
+Size=792,231
 Collapsed=0
 DockId=0x00000009,0

 [Window][Objects]
 Pos=0,19
-Size=234,842
+Size=234,609
 Collapsed=0
 DockId=0x0000000B,0

 [Window][Terrain]
-Pos=0,19
-Size=266,842
+Pos=236,19
+Size=266,609
 Collapsed=0
 DockId=0x00000007,0

 [Window][Log Window]
-Pos=0,630
-Size=1584,231
+Pos=794,630
+Size=790,231
 Collapsed=0
 DockId=0x0000000A,0

@ -42,7 +42,7 @@ DockId=0x0000000A,0
 Pos=0,19
 Size=234,609
 Collapsed=0
-DockId=0x0000000B,0
+DockId=0x0000000B,1

 [Window][Engine Settings]
 Pos=1267,462
--- a/enginecustom/src/inc/system/application_class.h
+++ b/enginecustom/src/inc/system/application_class.h
@ -7,7 +7,6 @@
 ///////////////////////
 #include "d_3d_class.h"
 #include "camera_class.h"
-#include "object.h"
 #include "light_class.h"

 #include "bitmap_class.h"
@ -38,6 +37,7 @@
 #include "ecs/components/physics_component.h"
 #include "ecs/components/shader_component.h"
 #include "ecs/systems/render_system.h"
+#include "ecs/components/model_path_component.h"

 #include <fstream>
 #include <WICTextureLoader.h>
@ -105,17 +105,12 @@ public:
 	void set_speed(const float speed) { this->speed_ = speed; };
 	
 	void add_cube();
-	void delete_kobject(int index);
-	size_t get_cube_count() const { return cubes_.size(); };
-	size_t get_terrain_cube_count() const { return terrain_chunk_.size(); };
-	std::vector<object*> get_cubes() const { return cubes_; };
-	std::vector<object*> get_terrain_cubes() const { return terrain_chunk_; };
-	std::vector<object*> get_kobjects() const { return object_; };
-	void set_kobjects(std::vector<object*> kobjects) { object_ = kobjects; };
+	void delete_entity_by_id(int entity_id);
 	void add_kobject(std::wstring& filepath);
 	void set_path(WCHAR* path) { path_ = path; };
 	void set_w_folder(const std::filesystem::path& w_folder) { w_folder_ = w_folder; };
 	std::filesystem::path get_w_folder() const { return w_folder_; };
+	int get_terrain_entity_count();

 	int get_object_id() const { return object_id_; };
 	void set_object_id(int object_id) { object_id_ = object_id; };
@ -178,20 +173,23 @@ public:
 	stats* get_stats() const { return stats_; };
 	fps_class* get_fps() const { return fps_; };
 	
+	ecs::EntityManager* get_entity_manager() const { return entity_manager_.get(); };
+	void update_stats_after_modification();
+	std::map<std::string, std::shared_ptr<model_class>>& get_model_cache() { return g_model_cache; }
+	
 private:
 	bool render(float, float, float, float, float);
-	bool render_physics(bool key_left, bool key_right, bool key_up, bool key_down, float delta_time);
+	bool render_physics(float delta_time);
 	bool update_mouse_strings(int, int, bool);
 	bool update_fps();
 	bool update_render_count_string(int);
 	bool render_scene_to_texture(float);
 	bool render_refraction_to_texture();
 	bool render_reflection_to_texture();
-	bool render_pass(const std::vector<std::reference_wrapper<std::vector<object*>>>& RenderQueues, XMFLOAT4* diffuse, XMFLOAT4* position, XMFLOAT4* ambient, XMMATRIX view, XMMATRIX projection);
+	bool render_pass(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;
@ -245,14 +243,10 @@ private :
 	std::unique_ptr<ecs::EntityManager> entity_manager_;
 	
 	object* selected_object_;
-	std::vector<object*> cubes_;
-	std::vector<object*> terrain_chunk_;
-	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_;
 	std::vector<object*> skybox_;

 	// ----------------------------------- //
--- a/enginecustom/src/inc/system/ecs/component.h
+++ b/enginecustom/src/inc/system/ecs/component.h
@ -24,6 +24,9 @@ public:
    
    // Fonction virtuelle pour la mise à jour du composant
    virtual void Update(float deltaTime) {}
+
+    // virtual std::string Serialize() {}
+    // virtual void Deserialize(const std::string& data) {}
 };

 // Alias utiles
--- a/enginecustom/src/inc/system/ecs/components/identity_component.h
+++ b/enginecustom/src/inc/system/ecs/components/identity_component.h
@ -20,7 +20,7 @@ public:
    ~IdentityComponent() = default;

    void Initialize() override {}
-    void Update(float deltaTime) override {}
+    //void Update(float deltaTime) override {}

    // Getters et setters
    int GetId() const { return m_id; }
--- a/enginecustom/src/inc/system/ecs/components/model_path_component.h
+++ b/enginecustom/src/inc/system/ecs/components/model_path_component.h
@ -0,0 +1,24 @@
+#pragma once
+#include "../component.h"
+#include <string>
+
+namespace ecs {
+
+class ModelPathComponent : public Component {
+public:
+    ModelPathComponent() = default;
+    explicit ModelPathComponent(const std::wstring& path) : m_path(path) {}
+    ~ModelPathComponent() = default;
+
+    void Initialize() override {}
+    void Update(float deltaTime) override {}
+
+    // Getters et setters
+    const std::wstring& GetPath() const { return m_path; }
+    void SetPath(const std::wstring& path) { m_path = path; }
+
+private:
+    std::wstring m_path;
+};
+
+} // namespace ecs
--- a/enginecustom/src/inc/system/ecs/entity_manager.h
+++ b/enginecustom/src/inc/system/ecs/entity_manager.h
@ -54,6 +54,18 @@ public:
        }
    }

+    // Obtenir toutes les entités
+    std::vector<std::shared_ptr<Entity>> GetAllEntities() {
+        std::vector<std::shared_ptr<Entity>> result;
+        result.reserve(m_Entities.size());
+        
+        for (const auto& [id, entity] : m_Entities) {
+            result.push_back(entity);
+        }
+        
+        return result;
+    }
+
    // Obtenir toutes les entités qui ont un composant spécifique
    template<typename T>
    std::vector<std::shared_ptr<Entity>> GetEntitiesWithComponent() {
--- a/enginecustom/src/inc/system/scene_manager.h
+++ b/enginecustom/src/inc/system/scene_manager.h
@ -3,6 +3,8 @@
 #include <string>
 #include <vector>

+#include "ecs/entity.h"
+
 class d_3d_class;
 class object;
 class application_class;
@ -26,6 +28,8 @@ public:

 private:

+    std::vector<std::shared_ptr<ecs::Entity>> entity_;
+    
    application_class* app_;
    std::string scene_path_;
    std::vector<object*> object_vec_;
--- a/enginecustom/src/src/system/application_class.cpp
+++ b/enginecustom/src/src/system/application_class.cpp
@ -28,10 +28,6 @@ application_class::application_class() : should_quit_(false)
 	reflection_texture_ = nullptr;
 	scene_texture_ = nullptr;
 	physics_ = nullptr;
-	cubes_.clear();
-	terrain_chunk_.clear();
-	object_.clear();
-	render_queues_.clear();
 	skybox_.clear();
 	lights_.clear();
 	sun_light_ = nullptr;
@ -86,11 +82,6 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
 		bool result;
 		HRESULT Hresult;

-		render_queues_.push_back(std::ref(skybox_)); // Skybox doit être rendu en premier pour être derrière touts les autres objets
-		render_queues_.push_back(std::ref(object_));
-		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>();

@ -1138,7 +1129,7 @@ bool application_class::render(float rotation, float x, float y, float z, float
 	// active_camera_->render();
 	// // Render the objects in the render queues. with depth only pass.
 	// active_camera_->get_view_matrix(viewMatrix);
-	result = render_pass(render_queues_, diffuseColor, lightPosition, ambientColor, viewMatrix, projectionMatrix);
+	result = render_pass(diffuseColor, lightPosition, ambientColor, viewMatrix, projectionMatrix);
 	if (!result)
 	{
 		Logger::Get().Log("Could not render the model using any shader", __FILE__, __LINE__, Logger::LogLevel::Error);
@ -1301,9 +1292,10 @@ int application_class::get_screen_height() const

 void application_class::generate_terrain()
 {
-    Logger::Get().Log("Génération du terrain avec instanciation", __FILE__, __LINE__, Logger::LogLevel::Info);
+    Logger::Get().Log("Génération du terrain avec ECS", __FILE__, __LINE__, Logger::LogLevel::Info);

-    terrain_chunk_.clear();
+	// delete previous terrain if it exists
+	delete_terrain();
 	
    // Dimensions du terrain
    float scaleX = 10.0f;
@ -1312,56 +1304,75 @@ void application_class::generate_terrain()
    int gridSizeX = 20;
    int gridSizeZ = 20;

-    // Créer un conteneur de textures_ partagé
-    TextureContainer textureContainer;
-    textureContainer.diffusePaths.push_back(L"assets/Texture/Bricks2K.png");
-    textureContainer.normalPaths.push_back(L"assets/Texture/BricksNRM2K.png");
-    textureContainer.specularPaths.push_back(L"assets/Texture/BricksGLOSS2K.png");
+    // Vérifier si le modèle existe déjà dans le cache
+    std::string modelName = "assets/Model/OBJ/plane.obj";
+    std::shared_ptr<model_class> sharedModel;

-    // Précharger les textures_ une seule fois
-    model_class* sharedModel = new model_class();
-    sharedModel->PreloadTextures(direct_3d_->get_device(), direct_3d_->get_device_context(), textureContainer);
+    auto it = g_model_cache.find(modelName);
+    if (it != g_model_cache.end()) {
+        // Utiliser le modèle existant du cache
+        Logger::Get().Log("Using cached model for terrain: " + modelName, __FILE__, __LINE__);
+        sharedModel = it->second;
+    }
+    else {
+        // Créer un conteneur de textures partagé
+        TextureContainer textureContainer;
+        textureContainer.diffusePaths.push_back(L"assets/Texture/Bricks2K.png");
+        textureContainer.normalPaths.push_back(L"assets/Texture/BricksNRM2K.png");
+        textureContainer.specularPaths.push_back(L"assets/Texture/BricksGLOSS2K.png");

-    char modelFilename[128];
-    strcpy_s(modelFilename, "assets/Model/OBJ/plane.obj");
+        // Créer et initialiser le modèle si non trouvé
+        char modelFilename[128];
+        strcpy_s(modelFilename, modelName.c_str());

-    // Générer les tuiles de terrain
-    for (int i = 0; i < gridSizeX; i++)
-    {
-        for (int j = 0; j < gridSizeZ; j++)
-        {
-            // Créer un nouvel objet de terrain
-            object* terrain = new object(*this);
+        auto newModel = std::make_shared<model_class>();
+        newModel->PreloadTextures(direct_3d_->get_device(), direct_3d_->get_device_context(), textureContainer);

-            // Initialiser avec le modèle et les textures_ préchargées
-            if (!terrain->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), modelFilename, textureContainer))
-            {
-                Logger::Get().Log("Échec de l'initialisation d'une tuile de terrain", __FILE__, __LINE__, Logger::LogLevel::Error);
-                delete terrain;
-                continue;
+        if (!newModel->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), modelFilename, textureContainer)) {
+            Logger::Get().Log("Impossible d'initialiser le modèle du terrain", __FILE__, __LINE__, Logger::LogLevel::Error);
+            return;
+        }
+
+        // Ajouter le modèle au cache
+        g_model_cache[modelName] = newModel;
+        sharedModel = newModel;
+        Logger::Get().Log("Added terrain model to cache: " + modelName, __FILE__, __LINE__);
+    }
+
+    // Vérifier si l'entity manager est disponible
+    if (entity_manager_) {
+        // Générer les tuiles de terrain avec le système ECS
+        for (int i = 0; i < gridSizeX; i++) {
+            for (int j = 0; j < gridSizeZ; j++) {
+                // Créer une entité
+                auto entity = entity_manager_->CreateEntity();
+
+                // Ajouter un composant d'identité
+                auto identity = entity->AddComponent<ecs::IdentityComponent>(object_id_++);
+                identity->SetName("TerrainTile_" + std::to_string(i) + "_" + std::to_string(j));
+                identity->SetType(ecs::ObjectType::Terrain);
+
+                // Ajouter un composant de transformation
+                auto transform = entity->AddComponent<ecs::TransformComponent>();
+                transform->SetPosition(XMVectorSet(i * scaleX, -12.0f, j * scaleZ, 0.0f));
+                transform->SetScale(XMVectorSet(scaleX, scaleY, scaleZ, 0.0f));
+                transform->UpdateWorldMatrix();
+
+                // 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::SUNLIGHT);
            }
-
-            // Définir la position dans la grille
-            XMFLOAT3 position(i * scaleX, -12.0f, j * scaleZ);
-            XMFLOAT3 scale(scaleX, scaleY, scaleZ);
-
-            terrain->SetPosition(XMLoadFloat3(&position));
-            terrain->SetScale(XMLoadFloat3(&scale));
-
-            // Configurer les propriétés
-            terrain->SetName("TerrainTile_" + std::to_string(i) + "_" + std::to_string(j));
-            terrain->SetType(ObjectType::Cube);
-            terrain->SetActiveShader(ShaderType::SUNLIGHT);
-            terrain->SetId(object_id_++);
-
-            // Ajouter à la liste des chunks de terrain
-            terrain_chunk_.push_back(terrain);
-
-        	update_stats_after_modification();
        }
    }

-    Logger::Get().Log("Terrain généré avec " + std::to_string(terrain_chunk_.size()) + " tuiles", __FILE__, __LINE__, Logger::LogLevel::Info);
+    update_stats_after_modification();
+
+    int totalTiles = gridSizeX * gridSizeZ;
+    Logger::Get().Log("Terrain généré avec " + std::to_string(totalTiles) + " tuiles", __FILE__, __LINE__, Logger::LogLevel::Info);
 }

 void application_class::add_kobject(std::wstring& filepath)
@ -1370,7 +1381,6 @@ void application_class::add_kobject(std::wstring& filepath)
 	Logger::Get().Log("Adding object", __FILE__, __LINE__);

 	char modelFilename[128];
-	vector<string> Filename;
 	TextureContainer KobjectsTextures;
 	filesystem::path p(filepath);
 	string filename = p.stem().string();
@ -1387,26 +1397,68 @@ void application_class::add_kobject(std::wstring& filepath)
 		L"assets/Texture/BricksGLOSS2K.png"
 	};

-	object* newObject = new object(*this);
-	newObject->LoadTexturesFromPath(kobjTexture,KobjectsTextures, direct_3d_); // Load textures_ from the path
-	newObject->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), modelFilename, KobjectsTextures);
-	newObject->SetMass(1.0f);
-	newObject->SetTranslateMatrix(XMMatrixTranslation(0.0f, 50.0f, 0.0f));
-	newObject->SetName(filename);
-	newObject->SetId(object_id_);
-	newObject->SetModelPath(filepath); // Store the path as std::wstring
+	// Configurer les chemins des textures dans le conteneur
+	KobjectsTextures.diffusePaths.push_back(kobjTexture[0]);
+	if (kobjTexture.size() > 1) KobjectsTextures.normalPaths.push_back(kobjTexture[1]);
+	if (kobjTexture.size() > 2) KobjectsTextures.specularPaths.push_back(kobjTexture[2]);

-	object_id_++;
+	// Vérifier si le modèle existe déjà dans le cache
+	std::string modelKey = std::string(modelFilename);
+	std::shared_ptr<model_class> sharedModel;

-	object_.push_back(newObject);
+	auto it = g_model_cache.find(modelKey);
+	if (it != g_model_cache.end()) {
+		// Utiliser le modèle existant du cache
+		Logger::Get().Log("Using cached model for " + modelKey, __FILE__, __LINE__);
+		sharedModel = it->second;
+	}
+	else {
+		// Créer un nouveau modèle
+		sharedModel = std::make_shared<model_class>();
+
+		// Précharger les textures
+		sharedModel->PreloadTextures(direct_3d_->get_device(), direct_3d_->get_device_context(), KobjectsTextures);
+
+		// Initialiser le modèle
+		if (!sharedModel->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), modelFilename, KobjectsTextures)) {
+			Logger::Get().Log("Failed to initialize model for object: " + modelKey, __FILE__, __LINE__, Logger::LogLevel::Error);
+			return;
+		}
+
+		// Ajouter le modèle au cache
+		g_model_cache[modelKey] = sharedModel;
+		Logger::Get().Log("Added model to cache: " + modelKey, __FILE__, __LINE__);
+	}
+
+	// Créer une nouvelle entité
+	auto entity = entity_manager_->CreateEntity();
+
+	// Ajouter un composant d'identité
+	auto identity = entity->AddComponent<ecs::IdentityComponent>(object_id_++);
+	identity->SetName(filename);
+	identity->SetType(ecs::ObjectType::Unknown);
+
+	// Ajouter un composant de transformation
+	auto transform = entity->AddComponent<ecs::TransformComponent>();
+	transform->SetPosition(XMVectorSet(0.0f, 50.0f, 0.0f, 0.0f));
+	transform->SetScale(XMVectorSet(1.0f, 1.0f, 1.0f, 0.0f));
+	transform->UpdateWorldMatrix();
+
+	// Ajouter un composant de rendu avec le modèle partagé
+	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);
+
+	// Stocker le chemin du modèle
+	auto modelPath = entity->AddComponent<ecs::ModelPathComponent>();
+	modelPath->SetPath(filepath);
+
+	Logger::Get().Log("ECS entity created with ID: " + std::to_string(identity->GetId()), __FILE__, __LINE__);

 	update_stats_after_modification();
-
-	// Vérifiez que l'objet a bien reçu les textures_
-	if (newObject->get_model()->GetTexture(TextureType::Diffuse,0) == nullptr)
-	{
-		Logger::Get().Log("object texture is null after initialization", __FILE__, __LINE__, Logger::LogLevel::Error);
-	}
 }

 void application_class::add_cube()
@ -1414,37 +1466,80 @@ void application_class::add_cube()
 	std::lock_guard<std::mutex> lock(objects_mutex_);
 	Logger::Get().Log("Adding cube", __FILE__, __LINE__);

-	char modelFilename[128];
-	TextureContainer CubeTexture;
-	// Set the file name of the model.
-	strcpy_s(modelFilename, "assets/Model/TXT/cube.txt");
+	std::string model_name = "assets/Model/TXT/cube.txt";
+	std::shared_ptr<model_class> sharedModel;

-	// Liste des fichiers de texture
-	std::vector<std::wstring> cubeTexture = {
-		L"assets/Texture/Bricks2K.png"
-	};
+	auto it = g_model_cache.find(model_name);
+	if (it != g_model_cache.end())
+	{
+		Logger::Get().Log("Using cached model: " + model_name, __FILE__, __LINE__);
+		sharedModel = it->second;
+	}
+	else
+	{
+		TextureContainer cube_textures;
+		cube_textures.diffusePaths.push_back(L"assets/Texture/Bricks2K.png");
+		cube_textures.normalPaths.push_back(L"assets/Texture/BricksNRM2K.png");
+		cube_textures.specularPaths.push_back(L"assets/Texture/BricksGLOSS2K.png");

-	static int cubeCount = 0;
-	float position = cubeCount * 2.0f;
-	object* newCube = new object(*this);
-	newCube->LoadTexturesFromPath(cubeTexture, CubeTexture, direct_3d_); // Load textures_ from the path
-	newCube->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), modelFilename, CubeTexture);
-	newCube->SetTranslateMatrix(XMMatrixTranslation(position, 0.0f, 0.0f));
+		char model_filename[128];
+		strcpy_s(model_filename, model_name.c_str());

-	cubes_.push_back(newCube);
+		auto newModel = std::make_shared<model_class>();
+		newModel->PreloadTextures(direct_3d_->get_device(), direct_3d_->get_device_context(), cube_textures);
+		if (!newModel->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), model_filename, cube_textures)) {
+			Logger::Get().Log("Failed to initialize cube model", __FILE__, __LINE__, Logger::LogLevel::Error);
+			return;
+		}
+
+		g_model_cache[model_name] = newModel;
+		sharedModel = newModel;
+		Logger::Get().Log("Added cube model to cache: " + model_name, __FILE__, __LINE__);
+
+
+		if (entity_manager_)
+		{
+			auto entity = entity_manager_->CreateEntity();
+
+			auto identity = entity->AddComponent<ecs::IdentityComponent>(object_id_++);
+			identity->SetName("Cube");
+			identity->SetType(ecs::ObjectType::Cube);
+
+			auto transform = entity->AddComponent<ecs::TransformComponent>();
+			transform->SetPosition(XMVectorSet(0.0f, 10.0f, 0.0f, 0.0f));
+			transform->SetScale(XMVectorSet(1.0f, 1.0f, 1.0f, 0.0f));
+			transform->UpdateWorldMatrix();
+
+			auto render = entity->AddComponent<ecs::RenderComponent>();
+			render->InitializeWithModel(sharedModel);
+			
+			auto shader = entity->AddComponent<ecs::ShaderComponent>();
+			shader->SetActiveShader(ecs::ShaderType::TEXTURE);
+		}
+	}

 	update_stats_after_modification();
+	Logger::Get().Log("Cube added successfully", __FILE__, __LINE__, Logger::LogLevel::Info);

 }

-void application_class::delete_kobject(int index)
+void application_class::delete_entity_by_id(int entity_id)
 {
 	std::lock_guard<std::mutex> lock(objects_mutex_);
-	Logger::Get().Log("Deleting object", __FILE__, __LINE__);
+	Logger::Get().Log("Deleting entity with ID: " + std::to_string(entity_id), __FILE__, __LINE__, Logger::LogLevel::Info);

-	if (index < object_.size())
-	{
-		object_.erase(object_.begin() + index);
+	if (entity_manager_) {
+		// Rechercher l'entité avec l'ID spécifié via le composant IdentityComponent
+		auto entities_with_identity = entity_manager_->GetEntitiesWithComponent<ecs::IdentityComponent>();
+		for (auto& entity : entities_with_identity) {
+			auto identity = entity->GetComponent<ecs::IdentityComponent>();
+			if (identity && identity->GetId() == entity_id) {
+				// Supprimer l'entité
+				entity_manager_->DestroyEntity(entity->GetID());
+				Logger::Get().Log("Entity with ID " + std::to_string(entity_id) + " successfully deleted", __FILE__, __LINE__, Logger::LogLevel::Info);
+				break;
+			}
+		}
 	}

 	update_stats_after_modification();
@ -1453,8 +1548,19 @@ void application_class::delete_kobject(int index)
 void application_class::delete_terrain()
 {
 	std::lock_guard<std::mutex> lock(objects_mutex_);
-	Logger::Get().Log("Deleting terrain", __FILE__, __LINE__);
-	terrain_chunk_.clear();
+	Logger::Get().Log("Deleting terrain", __FILE__, __LINE__, Logger::LogLevel::Info);
+
+	// Get all entities with the Terrain type
+	auto entities_with_terrain = entity_manager_->GetEntitiesWithComponent<ecs::IdentityComponent>();
+	for (auto& entity : entities_with_terrain) {
+		auto identity = entity->GetComponent<ecs::IdentityComponent>();
+		if (identity && identity->GetType() == ecs::ObjectType::Terrain) {
+			// Destroy the entity
+			entity_manager_->DestroyEntity(entity->GetID());
+			Logger::Get().Log("Terrain entity with ID " + std::to_string(identity->GetId()) + " successfully deleted", __FILE__, __LINE__, Logger::LogLevel::Info);
+		}
+	}
+	
 	update_stats_after_modification();
 }

@ -1685,36 +1791,34 @@ void application_class::culling_thread_function()
        }

        // Traitement des files d'objets normaux (sans la skybox)
-        std::vector<std::reference_wrapper<std::vector<object*>>> queues = {
-            std::ref(object_), std::ref(cubes_), std::ref(terrain_chunk_)
-        };
+        auto all_entity = entity_manager_->GetAllEntities();

-        for (auto& queueRef : queues)
-        {
-            std::vector<object*>& queue = queueRef.get();
+    	for (auto& entity : all_entity)
+		{
+    		std::lock_guard<std::mutex> lock(objects_mutex_);
+    		auto renderComponent = entity->GetComponent<ecs::RenderComponent>();
+    		if (renderComponent && renderComponent->GetModel())
+			{
+				// Extraction des données de position via le composant TransformComponent
+    			auto transformComponent = entity->GetComponent<ecs::TransformComponent>();
+    			if (transformComponent)
+    			{
+    				XMVECTOR transformPosition = transformComponent->GetPosition();
+    				float x = XMVectorGetX(transformPosition);
+    				float y = XMVectorGetY(transformPosition);
+    				float z = XMVectorGetZ(transformPosition);

-            std::lock_guard<std::mutex> lock(objects_mutex_);
+    				// Calcul du rayon approximatif
+    				XMVECTOR scale = transformComponent->GetScale();
+    				float radius = max(max(XMVectorGetX(scale), XMVectorGetY(scale)), XMVectorGetZ(scale));

-            for (auto* object : queue)
-            {
-                if (!object) continue;
+    				// verification du frustum
+    				bool visible = frustum_culling_.CheckCube(x, y, z, radius, get_frustum_tolerance());
+    				renderComponent->SetVisible(visible);
+    			}
    								
-                // Extraction des données de position
-                XMVECTOR position = object->GetPosition();
-                float x = XMVectorGetX(position);
-                float y = XMVectorGetY(position);
-                float z = XMVectorGetZ(position);
-
-                // Calcul du rayon approximatif
-                XMVECTOR scale = object->GetScale();
-                float radius = max(max(XMVectorGetX(scale), XMVectorGetY(scale)), XMVectorGetZ(scale));
-
-                // Vérification du frustum
-                bool visible = frustum_culling_.CheckCube(x, y, z, radius, get_frustum_tolerance());
-                object->SetVisible(visible);
-            	
-            }
-        }
+			}
+		}

        // Pause pour éviter de surcharger le CPU
        std::this_thread::sleep_for(std::chrono::milliseconds(16)); // ~60 Hz
@ -1725,7 +1829,7 @@ 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)
+bool application_class::render_pass(XMFLOAT4* diffuse, XMFLOAT4* position, XMFLOAT4* ambient, XMMATRIX view, XMMATRIX projection)
 {
 	std::lock_guard<std::mutex> lock(objects_mutex_);
 	XMMATRIX scaleMatrix, rotateMatrix, translateMatrix;
@ -1856,83 +1960,16 @@ void application_class::update_skybox_position()

 }

-bool application_class::render_physics(bool key_left, bool key_right, bool key_up, bool key_down, float delta_time) {
-	const float maxSpeed = 50.0f; // Limite de vitesse maximale
+bool application_class::render_physics(float delta_time) {

-	for (auto& object : object_) {
-		if (object == nullptr) {
-			Logger::Get().Log("object is null", __FILE__, __LINE__, Logger::LogLevel::Error);
-			return false;
+	// update the physical entity if they have the physics component
+	auto entities_with_physics = entity_manager_->GetEntitiesWithComponent<ecs::PhysicsComponent>();
+	for (auto& entity : entities_with_physics) {
+		auto physicsComponent = entity->GetComponent<ecs::PhysicsComponent>();
+		if (physicsComponent) {
+			// Update the physics component with the input keys and delta time
+			physicsComponent->Update(delta_time);
 		}
-
-		if (!object->IsPhysicsEnabled()) {
-			continue;
-		}
-
-		// Reset acceleration for the new frame
-		object->SetAcceleration(XMVectorZero());
-		object->SetGrounded(false);
-
-		for (auto& chunk : terrain_chunk_) {
-			if (!physics_->IsColliding(object, chunk)) {
-				continue;
-			}
-
-			object->SetVelocity(XMVectorSetY(object->GetVelocity(), 0.0f));
-			object->SetAcceleration(XMVectorSetY(object->GetAcceleration(), 0.0f));
-			object->SetGrounded(true);
-		}
-
-		for (auto& object2 : object_) {
-			if (object->GetId() == object2->GetId()) {
-				continue;
-			}
-
-			if (!physics_->IsColliding(object, object2)) {
-				continue;
-			}
-
-			object->SetVelocity(XMVectorZero());
-			object->SetAcceleration(XMVectorZero());
-		}
-
-		float forceX = 0, forceY = 0, forceZ = 0, forceW = 0;
-
-		if (key_left) {
-			forceX = -40.0f;
-		}
-		if (key_right) {
-			forceX = 40.0f;
-		}
-		if (key_up) {
-			forceY = 40.0f;
-		}
-		if (key_down && !object->IsGrounded()) {
-			forceY = -40.0f;
-		}
-
-		XMVECTOR force = XMVectorSet(forceX, forceY, forceZ, forceW);
-		physics_->AddForce(object, force);
-
-		object->AddVelocity(delta_time);
-
-		XMVECTOR velocity = object->GetVelocity();
-		float speed = XMVectorGetX(XMVector3Length(velocity));
-		if (speed > maxSpeed) {
-			velocity = XMVectorScale(velocity, maxSpeed / speed);
-			object->SetVelocity(velocity);
-		}
-
-		if (object->m_gravityEnabled) {
-			physics_->ApplyGravity(object, delta_time);
-		}
-
-		if (XMVectorGetY(object->GetPosition()) < -30.0f) {
-			XMVECTOR currentPosition = object->GetPosition();
-			object->SetPosition(XMVectorSetY(currentPosition, 50.0f));
-		}
-
-		object->m_previousPosition = object->GetPosition();
 	}

 	return true;
@ -1951,7 +1988,7 @@ void application_class::physics_thread_function()
 			lastTime = now;

 			float deltaTime = 1.0f / static_cast<float>(physics_tick_rate_);
-			bool result = render_physics(inputs_.key_left, inputs_.key_right, inputs_.key_up, inputs_.key_down, deltaTime);
+			bool result = render_physics(deltaTime);
 			if (!result)
 			{
 				Logger::Get().Log("Could not render the physics scene", __FILE__, __LINE__, Logger::LogLevel::Error);
@ -1993,54 +2030,33 @@ bool application_class::create_big_cube(int side_count)
        sharedModel = newModel;
    }

-    // Version ECS - Créer les entités pour le cube
-    if (entity_manager_) {
-        for (int x = 0; x < side_count; x++) {
-            for (int y = 0; y < side_count; y++) {
-                for (int z = 0; z < side_count; z++) {
-                    // Créer une entité
-                    auto entity = entity_manager_->CreateEntity();
+	for (int x = 0; x < side_count; x++) {
+		for (int y = 0; y < side_count; y++) {
+			for (int z = 0; z < side_count; z++) {
+				// Créer une entité
+				auto entity = entity_manager_->CreateEntity();

-                    // Ajouter un composant d'identité
-                    auto identity = entity->AddComponent<ecs::IdentityComponent>(object_id_++);
-                    identity->SetName("CubePart_" + std::to_string(x) + "_" + std::to_string(y) + "_" + std::to_string(z));
-                    identity->SetType(ecs::ObjectType::Cube);
+				// Ajouter un composant d'identité
+				auto identity = entity->AddComponent<ecs::IdentityComponent>(object_id_++);
+				identity->SetName("CubePart_" + std::to_string(x) + "_" + std::to_string(y) + "_" + std::to_string(z));
+				identity->SetType(ecs::ObjectType::Terrain);

-                    // Ajouter un composant de transformation
-                    auto transform = entity->AddComponent<ecs::TransformComponent>();
-                    transform->SetPosition(XMVectorSet(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), 0.0f));
-                    transform->SetScale(XMVectorSet(1.0f, 1.0f, 1.0f, 0.0f));
-                    transform->UpdateWorldMatrix();
+				// Ajouter un composant de transformation
+				auto transform = entity->AddComponent<ecs::TransformComponent>();
+				transform->SetPosition(XMVectorSet(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), 0.0f));
+				transform->SetScale(XMVectorSet(1.0f, 1.0f, 1.0f, 0.0f));
+				transform->UpdateWorldMatrix();

-                    // Ajouter un composant de rendu
-                    auto render = entity->AddComponent<ecs::RenderComponent>();
-                    render->InitializeWithModel(sharedModel);
+				// 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ème - Créer temporairement les cubes dans un vecteur local
-        std::vector<object*> tempCubes;
-        tempCubes.reserve(side_count * side_count * side_count);
-
-        // Générer side_count³ cubes
-        for (int x = 0; x < side_count; x++) {
-            for (int y = 0; y < side_count; y++) {
-                for (int z = 0; z < side_count; z++) {
-                    object* cubePart = new object(*this);
-                    cubePart->SetModel(sharedModel);
-                    cubePart->SetTranslateMatrix(XMMatrixTranslation(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z)));
-                    tempCubes.push_back(cubePart);
-                }
-            }
-        }
-        // Transférer les cubes du vecteur temporaire au vecteur membre
-        cubes_ = std::move(tempCubes);
-    }
+				// Ajouter un composant de shader
+				auto shader = entity->AddComponent<ecs::ShaderComponent>();
+				shader->SetActiveShader(ecs::ShaderType::LIGHTING);
+			}
+		}
+	}

    update_stats_after_modification();

@ -2054,3 +2070,20 @@ void application_class::update_stats_after_modification()
 		stats_ -> update_geometric_stats();
 	}
 }
+
+int application_class::get_terrain_entity_count()
+{
+	std::lock_guard<std::mutex> lock(objects_mutex_);
+	int terrainCount = 0;
+
+	// Get all entities with the Terrain type
+	auto entities_with_terrain = entity_manager_->GetEntitiesWithComponent<ecs::IdentityComponent>();
+	for (auto& entity : entities_with_terrain) {
+		auto identity = entity->GetComponent<ecs::IdentityComponent>();
+		if (identity && identity->GetType() == ecs::ObjectType::Terrain) {
+			terrainCount++;
+		}
+	}
+
+	return terrainCount;
+}
--- a/enginecustom/src/src/system/imguiManager.cpp
+++ b/enginecustom/src/src/system/imguiManager.cpp
@ -386,290 +386,313 @@ void imguiManager::WidgetAddObject()

 		}
 		ImGui::SameLine();
-		ImGui::Text("Number of cubes: %d", app_->get_cube_count());
+		ImGui::Text("Number of cubes: %d", app_->get_entity_manager()->GetEntityCount());
 	}
 }

 void imguiManager::WidgetObjectWindow()
 {
 	ImGui::Begin("Objects", &showObjectWindow);
+
+	// Obtenir toutes les entités avec un composant d'identité et de transformation
+	auto entities = app_->get_entity_manager()->GetEntitiesWithComponent<ecs::IdentityComponent>();
+	
 	int index = 0;
-	for (auto& object : app_->get_kobjects())
+	for (auto& entity : entities)
 	{
-		std::string headerName = object->GetName() + " " + std::to_string(index);
-		if (ImGui::CollapsingHeader(headerName.c_str()))
+		auto identity = entity->GetComponent<ecs::IdentityComponent>();
+		auto transform = entity->GetComponent<ecs::TransformComponent>();
+		auto render = entity->GetComponent<ecs::RenderComponent>();
+		auto shader = entity->GetComponent<ecs::ShaderComponent>();
+		auto physics = entity->GetComponent<ecs::PhysicsComponent>();
+		
+		if (identity && transform)
 		{
-
-			XMVECTOR position = object->GetPosition();
-			XMVECTOR rotation = object->GetRotation();
-			XMVECTOR scale = object->GetScale();
-
-			float pos[3] = { XMVectorGetX(position), XMVectorGetY(position), XMVectorGetZ(position) };
-			std::string posLabel = "Position##" + std::to_string(index);
-			if (ImGui::DragFloat3(posLabel.c_str(), pos))
+			std::string headerName = identity->GetName() + " " + std::to_string(identity->GetId());
+			if (ImGui::CollapsingHeader(headerName.c_str()))
 			{
-				object->SetPosition(XMVectorSet(pos[0], pos[1], pos[2], 0.0f));
-			}
+				// Position, Rotation, Scale
+				XMVECTOR position = transform->GetPosition();
+				XMVECTOR rotation = transform->GetRotation();
+				XMVECTOR scale = transform->GetScale();

-			float rot[3] = { XMVectorGetX(rotation), XMVectorGetY(rotation), XMVectorGetZ(rotation) };
-			std::string rotLabel = "Rotation##" + std::to_string(index);
-			if (ImGui::DragFloat3(rotLabel.c_str(), rot))
-			{
-				object->SetRotation(XMVectorSet(rot[0], rot[1], rot[2], 0.0f));
-			}
-
-			float scl[3] = { XMVectorGetX(scale), XMVectorGetY(scale), XMVectorGetZ(scale) };
-			std::string sclLabel = "Scale##" + std::to_string(index);
-			if (ImGui::DragFloat3(sclLabel.c_str(), scl))
-			{
-				object->SetScale(XMVectorSet(scl[0], scl[1], scl[2], 0.0f));
-			}
-			
-			 ImGui::Separator();
-
-            // Définir les types de textures_
-            std::vector<std::string> textureCategories = {
-                "Diffuse", "Normal", "Specular", "Alpha"
-            };
-
-            std::vector<TextureType> textureTypes = {
-                TextureType::Diffuse, TextureType::Normal, 
-                TextureType::Specular, TextureType::Alpha
-            };
-
-            // Créer un espace pour afficher les textures_ avec défilement
-            ImGui::BeginChild("TextureChild", ImVec2(0, 200), true, ImGuiWindowFlags_HorizontalScrollbar);
-            
-            // Pour chaque type de texture
-            for (int typeIndex = 0; typeIndex < textureCategories.size(); typeIndex++)
-            {
-                TextureType type = textureTypes[typeIndex];
-                std::string typeName = textureCategories[typeIndex];
-                
-                // Afficher le titre de la catégorie
-                ImGui::Text("%s:", typeName.c_str());
-                ImGui::SameLine();
-
-                // Compter combien de textures_ de ce type existent
-                int textureCount = 0;
-                while (object->get_model()->GetTexture(type, textureCount) != nullptr)
-                {
-                    textureCount++;
-                }
-
-                // Afficher toutes les textures_ existantes
-                ImGui::BeginGroup();
-                for (int texIndex = 0; texIndex < textureCount; texIndex++)
-                {
-                    ID3D11ShaderResourceView* texture = object->get_model()->GetTexture(type, texIndex);
-                    if (texture)
-                    {
-                        // ID unique pour chaque bouton de texture
-                        std::string buttonId = "tex##" + std::to_string(index) + "_" + 
-                                               std::to_string(typeIndex) + "_" + 
-                                               std::to_string(texIndex);
-                        
-                        if (ImGui::ImageButton(buttonId.c_str(), (ImTextureID)texture, ImVec2(48, 48)))
-                        {
-                            // Ouvrir une boîte de dialogue pour changer la texture
-                            OPENFILENAME ofn;
-                            WCHAR szFile[260];
-                            ZeroMemory(&ofn, sizeof(ofn));
-                            ofn.lStructSize = sizeof(ofn);
-                            ofn.hwndOwner = NULL;
-                            ofn.lpstrFile = szFile;
-                            szFile[0] = '\0';
-                            ofn.nMaxFile = sizeof(szFile);
-                            ofn.lpstrFilter = L"Texture\0*.png;*.jpg;*.dds\0";
-                            ofn.nFilterIndex = 1;
-                            ofn.lpstrInitialDir = NULL;
-                            ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
-
-                            if (GetOpenFileName(&ofn))
-                            {
-                                // Changer la texture existante
-                                object->get_model()->ChangeTexture(m_device, m_deviceContext, ofn.lpstrFile, type, texIndex);
-                            }
-                        }
-                        
-                        // Afficher l'indice de texture et prévisualisation au survol
-                        if (ImGui::IsItemHovered())
-                        {
-                            ImGui::BeginTooltip();
-                            ImGui::Text("%s %d", typeName.c_str(), texIndex);
-                            ImGui::Image((ImTextureID)texture, ImVec2(192, 192));
-                            ImGui::EndTooltip();
-                        }
-                        
-                        ImGui::SameLine();
-                    }
-                }
-                
-                // Bouton pour ajouter une nouvelle texture
-                std::string addButtonLabel = "+##" + std::to_string(index) + "_" + std::to_string(typeIndex);
-                if (ImGui::Button(addButtonLabel.c_str(), ImVec2(48, 48)))
-                {
-                    // Ouvrir une boîte de dialogue pour ajouter une texture
-                    OPENFILENAME ofn;
-                    WCHAR szFile[260];
-                    ZeroMemory(&ofn, sizeof(ofn));
-                    ofn.lStructSize = sizeof(ofn);
-                    ofn.hwndOwner = NULL;
-                    ofn.lpstrFile = szFile;
-                    szFile[0] = '\0';
-                    ofn.nMaxFile = sizeof(szFile);
-                    ofn.lpstrFilter = L"Texture\0*.png;*.jpg;*.dds\0";
-                    ofn.nFilterIndex = 1;
-                    ofn.lpstrInitialDir = NULL;
-                    ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
-
-                    if (GetOpenFileName(&ofn))
-                    {
-                        // Ajouter une nouvelle texture
-                        object->get_model()->AddTexture(m_device, m_deviceContext, ofn.lpstrFile, type);
-                    }
-                }
-                
-                ImGui::EndGroup();
-                ImGui::Separator();
-            }
-            
-            ImGui::EndChild();
-
-			ImGui::Separator();
-
-			// Delete button
-			std::string deleteLabel = "Delete##" + std::to_string(index);
-			if (ImGui::Button(deleteLabel.c_str()))
-			{
-				app_->delete_kobject(index);
-			}
-
-			ImGui::Separator();
-
-			// Liste des options
-			const char* shaderOptions[] = {
-				"Enable Global Lighting",
-				"Enable Lighting",
-				"Enable Cel Shading",
-				"Enable Normal Mapping",
-				"Enable Specular Mapping",
-				"Enable Alpha Mapping"
-			};
-			
-			ShaderType shaderTypes[] = {
-				ShaderType::SUNLIGHT,
-				ShaderType::LIGHTING,
-				ShaderType::CEL_SHADING,
-				ShaderType::NORMAL_MAPPING,
-				ShaderType::SPECULAR_MAPPING,
-				ShaderType::ALPHA_MAPPING
-			};
-
-			// Variable pour stocker l'option sélectionnée
-			static int currentShader = 0; // Index de l'option actuellement sélectionnée
-
-			// Création du menu déroulant
-			if (ImGui::BeginCombo("Shader Options", shaderOptions[currentShader]))
-			{
-				for (int i = 0; i < IM_ARRAYSIZE(shaderOptions); i++)
+				float pos[3] = { XMVectorGetX(position), XMVectorGetY(position), XMVectorGetZ(position) };
+				std::string posLabel = "Position##" + std::to_string(identity->GetId());
+				if (ImGui::DragFloat3(posLabel.c_str(), pos))
 				{
-					// Crée une option sélectionnable pour chaque shader
-					bool isSelected = (currentShader == i);
-					if (ImGui::Selectable(shaderOptions[i], isSelected))
+					transform->SetPosition(XMVectorSet(pos[0], pos[1], pos[2], 0.0f));
+					transform->UpdateWorldMatrix();
+				}
+
+				float rot[3] = { XMVectorGetX(rotation), XMVectorGetY(rotation), XMVectorGetZ(rotation) };
+				std::string rotLabel = "Rotation##" + std::to_string(identity->GetId());
+				if (ImGui::DragFloat3(rotLabel.c_str(), rot))
+				{
+					transform->SetRotation(XMVectorSet(rot[0], rot[1], rot[2], 0.0f));
+					transform->UpdateWorldMatrix();
+				}
+
+				float scl[3] = { XMVectorGetX(scale), XMVectorGetY(scale), XMVectorGetZ(scale) };
+				std::string sclLabel = "Scale##" + std::to_string(identity->GetId());
+				if (ImGui::DragFloat3(sclLabel.c_str(), scl))
+				{
+					transform->SetScale(XMVectorSet(scl[0], scl[1], scl[2], 0.0f));
+					transform->UpdateWorldMatrix();
+				}
+				
+				ImGui::Separator();
+
+				// Textures - Seulement si le composant de rendu existe
+				if (render && render->GetModel())
+				{
+					// Définir les types de textures_
+					std::vector<std::string> textureCategories = {
+						"Diffuse", "Normal", "Specular", "Alpha"
+					};
+
+					std::vector<TextureType> textureTypes = {
+						TextureType::Diffuse, TextureType::Normal, 
+						TextureType::Specular, TextureType::Alpha
+					};
+
+					// Créer un espace pour afficher les textures_ avec défilement
+					std::string textureChildId = "TextureChild##" + std::to_string(identity->GetId());
+					ImGui::BeginChild(textureChildId.c_str(), ImVec2(0, 200), true, ImGuiWindowFlags_HorizontalScrollbar);
+					
+					// Pour chaque type de texture
+					for (int typeIndex = 0; typeIndex < textureCategories.size(); typeIndex++)
 					{
-						// Met à jour l'option sélectionnée
-						currentShader = i;
-						object->SetActiveShader(shaderTypes[i]);
+						TextureType type = textureTypes[typeIndex];
+						std::string typeName = textureCategories[typeIndex];
+						
+						// Afficher le titre de la catégorie
+						std::string categoryLabel = typeName + "##" + std::to_string(identity->GetId());
+						ImGui::Text("%s:", typeName.c_str());
+						ImGui::SameLine();
+
+						// Compter combien de textures_ de ce type existent
+						int textureCount = 0;
+						while (render->GetModel()->GetTexture(type, textureCount) != nullptr)
+						{
+							textureCount++;
+						}
+
+						// Afficher toutes les textures_ existantes
+						std::string groupId = "TextureGroup_" + std::to_string(identity->GetId()) + "_" + std::to_string(typeIndex);
+						ImGui::BeginGroup();
+						for (int texIndex = 0; texIndex < textureCount; texIndex++)
+						{
+							ID3D11ShaderResourceView* texture = render->GetModel()->GetTexture(type, texIndex);
+							if (texture)
+							{
+								// ID unique pour chaque bouton de texture
+								std::string buttonId = "tex##" + std::to_string(identity->GetId()) + "_" + 
+													std::to_string(typeIndex) + "_" + 
+													std::to_string(texIndex);
+								
+								if (ImGui::ImageButton(buttonId.c_str(), (ImTextureID)texture, ImVec2(48, 48)))
+								{
+									// Ouvrir une boîte de dialogue pour changer la texture
+									OPENFILENAME ofn;
+									WCHAR szFile[260] = {0};
+									ZeroMemory(&ofn, sizeof(ofn));
+									ofn.lStructSize = sizeof(ofn);
+									ofn.hwndOwner = NULL;
+									ofn.lpstrFile = szFile;
+									ofn.nMaxFile = sizeof(szFile);
+									ofn.lpstrFilter = L"Texture\0*.png;*.jpg;*.dds\0";
+									ofn.nFilterIndex = 1;
+									ofn.lpstrInitialDir = NULL;
+									ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
+
+									if (GetOpenFileName(&ofn))
+									{
+										// Changer la texture existante
+										render->GetModel()->ChangeTexture(m_device, m_deviceContext, ofn.lpstrFile, type, texIndex);
+									}
+								}
+								
+								// Afficher l'indice de texture et prévisualisation au survol
+								if (ImGui::IsItemHovered())
+								{
+									ImGui::BeginTooltip();
+									ImGui::Text("%s %d", typeName.c_str(), texIndex);
+									ImGui::Image((ImTextureID)texture, ImVec2(192, 192));
+									ImGui::EndTooltip();
+								}
+								
+								ImGui::SameLine();
+							}
+						}
+						
+						// Bouton pour ajouter une nouvelle texture
+						std::string addButtonLabel = "+##" + std::to_string(identity->GetId()) + "_" + std::to_string(typeIndex);
+						if (ImGui::Button(addButtonLabel.c_str(), ImVec2(48, 48)))
+						{
+							// Ouvrir une boîte de dialogue pour ajouter une texture
+							OPENFILENAME ofn;
+							WCHAR szFile[260] = {0};
+							ZeroMemory(&ofn, sizeof(ofn));
+							ofn.lStructSize = sizeof(ofn);
+							ofn.hwndOwner = NULL;
+							ofn.lpstrFile = szFile;
+							ofn.nMaxFile = sizeof(szFile);
+							ofn.lpstrFilter = L"Texture\0*.png;*.jpg;*.dds\0";
+							ofn.nFilterIndex = 1;
+							ofn.lpstrInitialDir = NULL;
+							ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
+
+							if (GetOpenFileName(&ofn))
+							{
+								// Ajouter une nouvelle texture
+								render->GetModel()->AddTexture(m_device, m_deviceContext, ofn.lpstrFile, type);
+							}
+						}
+						
+						ImGui::EndGroup();
+						ImGui::Separator();
 					}
 					
-					// Si l'option sélectionnée est active, nous mettons en surbrillance
-					if (isSelected)
-						ImGui::SetItemDefaultFocus();
+					ImGui::EndChild();
 				}
-				ImGui::EndCombo();
+
+				ImGui::Separator();
+
+				// Delete button
+				std::string deleteLabel = "Delete##" + std::to_string(identity->GetId());
+				if (ImGui::Button(deleteLabel.c_str()))
+				{
+					app_->delete_entity_by_id(identity->GetId());
+					// Sortir du boucle après suppression pour éviter des accès invalides
+					break;
+				}
+
+				ImGui::Separator();
+
+				// Shader options
+				if (shader)
+				{
+					// Liste des options de shader
+					const char* shaderOptions[] = {
+						"Enable Global Lighting",
+						"Enable Lighting",
+						"Enable Cel Shading",
+						"Enable Normal Mapping",
+						"Enable Specular Mapping",
+						"Enable Alpha Mapping"
+					};
+					
+					std::vector<ecs::ShaderType> shaderTypes = {
+						ecs::ShaderType::SUNLIGHT,
+						ecs::ShaderType::LIGHTING,
+						ecs::ShaderType::CEL_SHADING,
+						ecs::ShaderType::NORMAL_MAPPING,
+						ecs::ShaderType::SPECULAR_MAPPING,
+						ecs::ShaderType::ALPHA_MAPPING
+					};
+
+					// Trouver l'index actuel du shader pour cette entité spécifique
+					int currentShader = 0;
+					ecs::ShaderType activeShader = shader->GetActiveShader();
+					for (size_t i = 0; i < shaderTypes.size(); i++)
+					{
+						if (shaderTypes[i] == activeShader)
+						{
+							currentShader = static_cast<int>(i);
+							break;
+						}
+					}
+
+					// Création du menu déroulant avec un ID unique pour chaque entité
+					std::string shaderComboId = "Shader Options##" + std::to_string(identity->GetId());
+					if (ImGui::BeginCombo(shaderComboId.c_str(), shaderOptions[currentShader]))
+					{
+						for (int i = 0; i < IM_ARRAYSIZE(shaderOptions); i++)
+						{
+							// Crée une option sélectionnable pour chaque shader avec ID unique
+							std::string shaderSelectableId = std::to_string(i) + "##shader_" + std::to_string(identity->GetId());
+							bool isSelected = (currentShader == i);
+							if (ImGui::Selectable(shaderOptions[i], isSelected))
+							{
+								// Met à jour l'option sélectionnée uniquement pour cette entité
+								currentShader = i;
+								shader->SetActiveShader(shaderTypes[i]);
+							}
+
+							// Si l'option sélectionnée est active, nous mettons en surbrillance
+							if (isSelected)
+								ImGui::SetItemDefaultFocus();
+						}
+						ImGui::EndCombo();
+					}
+				}
+				
+				ImGui::Separator();
+
+				// Physics
+				bool isPhysicsEnabled = (physics != nullptr);
+				std::string physicsLabel = "Physics##" + std::to_string(identity->GetId());
+				
+				if (ImGui::Checkbox(physicsLabel.c_str(), &isPhysicsEnabled)) 
+				{
+					if (isPhysicsEnabled && !physics)
+					{
+						// Ajouter un composant de physique
+						physics = entity->AddComponent<ecs::PhysicsComponent>();
+						physics->Initialize();
+					}
+					else if (!isPhysicsEnabled && physics)
+					{
+						// Retirer le composant de physique
+						entity->RemoveComponent<ecs::PhysicsComponent>();
+						physics = nullptr;
+					}
+				}
+
+				if (physics)
+				{
+					// Gravity Enabled checkbox
+					bool gravityEnabled = physics->IsGravityEnabled();
+					std::string gravityLabel = "Gravity##" + std::to_string(identity->GetId());
+					if (ImGui::Checkbox(gravityLabel.c_str(), &gravityEnabled))
+					{
+						physics->SetGravityEnabled(gravityEnabled);
+					}
+
+					// 3 radio buttons pour le type d'objet physique avec IDs uniques
+					std::string typeLabel = "Type##" + std::to_string(identity->GetId());
+					ecs::ObjectType type = identity->GetType();
+
+					if (ImGui::RadioButton(("None##" + std::to_string(identity->GetId())).c_str(), 
+						type == ecs::ObjectType::Unknown))
+					{
+						identity->SetType(ecs::ObjectType::Unknown);
+					}
+					ImGui::SameLine();
+					if (ImGui::RadioButton(("Cube##" + std::to_string(identity->GetId())).c_str(), 
+						type == ecs::ObjectType::Cube))
+					{
+						identity->SetType(ecs::ObjectType::Cube);
+					}
+					ImGui::SameLine();
+					if (ImGui::RadioButton(("Sphere##" + std::to_string(identity->GetId())).c_str(), 
+						type == ecs::ObjectType::Sphere))
+					{
+						identity->SetType(ecs::ObjectType::Sphere);
+					}
+					ImGui::SameLine();
+					if (ImGui::RadioButton(("Terrain##" + std::to_string(identity->GetId())).c_str(), 
+						type == ecs::ObjectType::Terrain))
+					{
+						identity->SetType(ecs::ObjectType::Terrain);
+					}
+
+				}
+
+				ImGui::Separator();
 			}
-
-			
-			ImGui::Separator();
-
-			// physics
-			std::string physicsLabel = "physics##" + std::to_string(index);
-			
-			if (ImGui::Checkbox(physicsLabel.c_str(), &m_isPhyiscsEnabled)) 
-			{
-				object->SetPhysicsEnabled(m_isPhyiscsEnabled);
-			}
-
-			// Gravity Enabled checkbox
-			std::string gravityLabel = "Gravity##" + std::to_string(index);
-			if (ImGui::Checkbox(gravityLabel.c_str(), &object->m_gravityEnabled))
-			{
-				object->SetGravityEnabled(object->m_gravityEnabled);
-			}
-			
-
-			// 3 radio button on the same line to set the ObjectType
-			std::string typeLabel = "Type##" + std::to_string(index);
-			ObjectType type = object->GetType();
-			if (ImGui::RadioButton("None", type == ObjectType::Unknown))
-			{
-				object->SetType(ObjectType::Unknown);
-			}
-			ImGui::SameLine();
-			if (ImGui::RadioButton("Cube", type == ObjectType::Cube))
-			{
-				object->SetType(ObjectType::Cube);
-			}
-			ImGui::SameLine();
-			if (ImGui::RadioButton("Sphere", type == ObjectType::Sphere))
-			{
-				object->SetType(ObjectType::Sphere);
-			}
-
-			// button to launch the object
-			std::string launchLabel = "Launch##" + std::to_string(index);
-
-			// paraeter to set the alpha, initial stretch and spring constant
-			float alpha = object->GetAlpha();
-			float initialStretch = object->GetInitialStretch();
-			float springConstant = object->GetSpringConstant();
-			if (ImGui::DragFloat("Alpha##" , &alpha, 0.01f, 0.0f, 1.0f))
-			{
-				object->SetAlpha(alpha);
-			}
-			if (ImGui::DragFloat("Initial Stretch##", &initialStretch, 0.01f, 0.0f, 1.0f))
-			{
-				object->SetInitialStretch(initialStretch);
-			}
-			if (ImGui::DragFloat("Spring Constant##", &springConstant, 0.01f, 0.0f, 100.0f))
-			{
-				object->SetSpringConstant(springConstant);
-			}
-			
-			if (ImGui::Button(launchLabel.c_str()))
-			{
-				object->LaunchObject();
-			}
-			ImGui::SameLine();
-			// button to stop the object
-			std::string stopLabel = "Stop##" + std::to_string(index);
-			if (ImGui::Button(stopLabel.c_str()))
-			{
-				object->SetVelocity(XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f));
-				object->SetPosition(XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f));
-			}
-			
-
-
-
-			ImGui::Separator();
-
-			// Demo spinning
-			std::string demoLabel = "Demo spinning##" + std::to_string(index);
-			ImGui::Checkbox(demoLabel.c_str(), &object->m_demoSpinning);
+			index++;
 		}
-		index++;
 	}
 	
 	ImGui::End();
@ -679,7 +702,7 @@ void imguiManager::WidgetTerrainWindow()
 {
 	ImGui::Begin("Terrain", &showTerrainWindow);

-	ImGui::Text("Number of terrain cubes: %d", app_->get_terrain_cube_count());
+	ImGui::Text("Number of terrain cubes: %d", app_->get_terrain_entity_count());

 	ImGui::Separator();

@ -1107,3 +1130,4 @@ void imguiManager::WidgetRenderStats()

    ImGui::End();
 }
+
--- a/enginecustom/src/src/system/scene_manager.cpp
+++ b/enginecustom/src/src/system/scene_manager.cpp
@ -52,7 +52,7 @@ bool scene_manager::save_scene_as() {
        
        // Mettre à jour le chemin de scène
        scene_path_ = convert_w_string_to_string(filepath.wstring());
-        object_vec_ = app_->get_kobjects();
+        //object_vec_ = app_->get_kobjects(); // TODO
        
        // Sauvegarder la scène avec le nouveau chemin
        save_scene();
@ -67,29 +67,32 @@ bool scene_manager::save_scene_as() {
 bool scene_manager::load_scene() {
 	Logger::Get().Log("Loading scene from " , __FILE__, __LINE__, Logger::LogLevel::Info);

-    object_vec_ = app_->get_kobjects();
    object_id_ = app_->get_object_id();
    w_folder_ = app_->get_w_folder();
    direct_3d_ = app_->get_direct_3d();
 	std::wstring scenePath = get_scene_path();
    
-    
-	if (!scenePath.empty())
-	{
+	if (!scenePath.empty()) {
 	    scene_path_ = convert_w_string_to_string(scenePath);
 	}
 	
 	std::ifstream inFile(scene_path_);
 	if (!inFile.is_open()) {
-		Logger::Get().Log("Failed to open file for loading scene: ", __FILE__, __LINE__, Logger::LogLevel::Error);
+		Logger::Get().Log("Failed to open file for loading scene: " + scene_path_, __FILE__, __LINE__, Logger::LogLevel::Error);
 		return false;
 	}
    
-    object_vec_.clear();
+    // Réinitialiser l'ID d'objet le plus élevé
    object_id_ = 0;
    
-	// Sauvegarder le répertoire de travail actuel
-	std::wstring currentDirectory = w_folder_;
+    // Récupérer l'EntityManager pour créer de nouvelles entités
+    auto entity_manager = app_->get_entity_manager();
+    
+    // Supprimer toutes les entités existantes
+    entity_manager->Clear();
+
+    // Sauvegarder le répertoire de travail actuel
+    std::wstring currentDirectory = w_folder_;

    std::string line;
    while (std::getline(inFile, line)) {
@ -104,47 +107,61 @@ bool scene_manager::load_scene() {
        float mass;
        bool physicsEnabled;

-        // Lire les données de base de l'objet
+        // Lire les données de base de l'entité
        iss >> id >> name
            >> position.x >> position.y >> position.z
            >> rotation.x >> rotation.y >> rotation.z
-            >> scale.x >> scale.y >> scale.z
-            >> modelPath >> shaderTypeStr
+            >> scale.x >> scale.y >> scale.z;
+        
+        // Lire le chemin du modèle - vérifier s'il est vide
+        iss >> modelPath;
+        
+        // Si le chemin du modèle est vide ou commence par une lettre majuscule (probablement un type de shader),
+        // c'est qu'il a été omis - utilisez une valeur par défaut
+        if (modelPath.empty() || (modelPath[0] >= 'A' && modelPath[0] <= 'Z')) {
+            // Reculer le curseur de lecture pour lire le type de shader à la place
+            iss.seekg(-static_cast<int>(modelPath.length()), std::ios::cur);
+            modelPath = "assets/Model/TXT/cube.txt"; // Valeur par défaut
+        }
+        
+        iss >> shaderTypeStr
            >> boundingRadius >> objectTypeStr
            >> mass >> physicsEnabled;

        if (iss.fail()) {
-            Logger::Get().Log("Failed to parse object data", __FILE__, __LINE__, Logger::LogLevel::Error);
+            Logger::Get().Log("Failed to parse entity data: " + line, __FILE__, __LINE__, Logger::LogLevel::Error);
            continue;
        }

-        // Créer un nouvel objet
-        object* newObject = new object();
+        // Mettre à jour l'ID d'objet le plus élevé si nécessaire
+        if (id >= object_id_) {
+            object_id_ = id + 1;
+        }

        // Convertir le chemin du modèle en wstring
        std::wstring wModelPath(modelPath.begin(), modelPath.end());

-    	// Vérifier si le chemin est relatif (ne commence pas par un disque comme C:)
-    	if (modelPath.length() > 1 && modelPath[1] != ':') {
-    		// C'est un chemin relatif, préfixer avec le répertoire de travail
-    		if (currentDirectory.back() != L'/' && currentDirectory.back() != L'\\') {
-    			// Ajouter un séparateur si nécessaire
-    			wModelPath = currentDirectory + L"\\" + wModelPath;
-    		} else {
-    			wModelPath = currentDirectory + wModelPath;
-    		}
-    	}
+        // Vérifier si le chemin est relatif
+        if (modelPath != "NoModel" && modelPath.length() > 1 && modelPath[1] != ':') {
+            // C'est un chemin relatif, préfixer avec le répertoire de travail
+            if (currentDirectory.back() != L'/' && currentDirectory.back() != L'\\') {
+                // Ajouter un séparateur si nécessaire
+                wModelPath = currentDirectory + L"\\" + wModelPath;
+            } else {
+                wModelPath = currentDirectory + wModelPath;
+            }
+        }

-        // Créer le conteneur de textures_ pour stocker les chemins
+        // Créer le conteneur de textures pour stocker les chemins
        TextureContainer objectTextures;
        
-        // IMPORTANT: Vider les conteneurs de chemins de textures_
+        // Vider les conteneurs de chemins de textures
        objectTextures.diffusePaths.clear();
        objectTextures.normalPaths.clear();
        objectTextures.specularPaths.clear();
        objectTextures.alphaPaths.clear();

-        // Lire les chemins des textures_ diffuses
+        // Lire les chemins des textures diffuses
        int diffuseTextureCount;
        iss >> diffuseTextureCount;
        for (int i = 0; i < diffuseTextureCount; i++) {
@ -154,7 +171,7 @@ bool scene_manager::load_scene() {
            objectTextures.diffusePaths.push_back(wTexturePath);
        }

-        // Lire les chemins des textures_ normales
+        // Lire les chemins des textures normales
        int normalTextureCount;
        iss >> normalTextureCount;
        for (int i = 0; i < normalTextureCount; i++) {
@ -164,7 +181,7 @@ bool scene_manager::load_scene() {
            objectTextures.normalPaths.push_back(wTexturePath);
        }

-        // Lire les chemins des textures_ spéculaires
+        // Lire les chemins des textures spéculaires
        int specularTextureCount;
        iss >> specularTextureCount;
        for (int i = 0; i < specularTextureCount; i++) {
@ -174,7 +191,7 @@ bool scene_manager::load_scene() {
            objectTextures.specularPaths.push_back(wTexturePath);
        }

-        // Lire les chemins des textures_ alpha
+        // Lire les chemins des textures alpha
        int alphaTextureCount;
        iss >> alphaTextureCount;
        for (int i = 0; i < alphaTextureCount; i++) {
@ -184,60 +201,100 @@ bool scene_manager::load_scene() {
            objectTextures.alphaPaths.push_back(wTexturePath);
        }
        
-    	// preload texture
-    	if (!newObject->get_model()->PreloadTextures(direct_3d_->get_device(),  direct_3d_->get_device_context(), objectTextures))
-    	{
-    		// Gérer l'erreur
-    		return false;
-    	}
-
-        // Initialiser l'objet avec le modèle et les chemins de textures_
-        char modelFilename[256];
-        size_t convertedChars = 0;
-        wcstombs_s(&convertedChars, modelFilename, sizeof(modelFilename), wModelPath.c_str(), _TRUNCATE);
-
-        Logger::Get().Log("Loading model: " + std::string(modelFilename), __FILE__, __LINE__, Logger::LogLevel::Info);
-
-        // NE PAS charger les textures_ avant initialize
-        // Laisser la méthode initialize s'en charger à partir des chemins
-        if (!newObject->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), modelFilename, objectTextures)) {
-            Logger::Get().Log("Failed to initialize object: " + name, __FILE__, __LINE__, Logger::LogLevel::Error);
-            delete newObject;
+        // Vérifier si on a un modèle à charger
+        if (modelPath == "NoModel") {
+            Logger::Get().Log("Skipping entity without model: " + name, __FILE__, __LINE__, Logger::LogLevel::Warning);
            continue;
        }

-        // Définir les propriétés de l'objet
-        newObject->SetId(id);
-        newObject->SetName(name);
-        newObject->SetPosition(XMLoadFloat3(&position));
-        newObject->SetRotation(XMLoadFloat3(&rotation));
-        newObject->SetScale(XMLoadFloat3(&scale));
-        newObject->SetModelPath(wModelPath);
-        newObject->SetActiveShader(newObject->StringToShaderType(shaderTypeStr));
-        newObject->SetBoundingRadius(boundingRadius);
-        newObject->SetType(newObject->StringToObjectType(objectTypeStr));
-        newObject->SetMass(mass);
-        newObject->SetPhysicsEnabled(physicsEnabled);
+        // Récupérer le cache de modèles de l'application
+        auto& modelCache = app_->get_model_cache();
+        std::shared_ptr<model_class> sharedModel;

-        // Mettre à jour l'ID global si nécessaire
-        if (id >= object_id_) {
-            object_id_ = id + 1;
-            app_->set_object_id(object_id_);
+        // Vérifier si le modèle existe déjà dans le cache
+        std::string modelKey = modelPath;
+        auto it = modelCache.find(modelKey);
+        if (it != modelCache.end()) {
+            // Utiliser le modèle existant du cache
+            Logger::Get().Log("Using cached model for: " + modelKey, __FILE__, __LINE__, Logger::LogLevel::Info);
+            sharedModel = it->second;
+        } else {
+            // Créer un nouveau modèle
+            char modelFilename[256];
+            size_t convertedChars = 0;
+            wcstombs_s(&convertedChars, modelFilename, sizeof(modelFilename), wModelPath.c_str(), _TRUNCATE);
+
+            Logger::Get().Log("Loading model: " + std::string(modelFilename), __FILE__, __LINE__, Logger::LogLevel::Info);
+
+            // Créer et initialiser le modèle
+            auto newModel = std::make_shared<model_class>();
+            
+            // Précharger les textures
+            if (!newModel->PreloadTextures(direct_3d_->get_device(), direct_3d_->get_device_context(), objectTextures)) {
+                Logger::Get().Log("Failed to preload textures for: " + name, __FILE__, __LINE__, Logger::LogLevel::Error);
+                continue;
+            }
+
+            if (!newModel->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), modelFilename, objectTextures)) {
+                Logger::Get().Log("Failed to initialize model: " + name, __FILE__, __LINE__, Logger::LogLevel::Error);
+                continue;
+            }
+
+            // Ajouter le modèle au cache
+            modelCache[modelKey] = newModel;
+            sharedModel = newModel;
        }
        
-        object_vec_.push_back(newObject);
-        Logger::Get().Log("Loaded object: " + name, __FILE__, __LINE__, Logger::LogLevel::Info);
+        // Créer une nouvelle entité avec l'EntityManager
+        auto entity = entity_manager->CreateEntity();
+
+        // Ajouter un composant d'identité
+        auto identityComponent = entity->AddComponent<ecs::IdentityComponent>(id);
+        identityComponent->SetName(name);
+        identityComponent->SetType(ecs::IdentityComponent::StringToObjectType(objectTypeStr));
+        
+        // Ajouter un composant de transformation
+        auto transformComponent = entity->AddComponent<ecs::TransformComponent>();
+        transformComponent->SetPosition(XMLoadFloat3(&position));
+        transformComponent->SetRotation(XMLoadFloat3(&rotation));
+        transformComponent->SetScale(XMLoadFloat3(&scale));
+        transformComponent->UpdateWorldMatrix();
+        
+        // Ajouter un composant de rendu avec le modèle
+        auto renderComponent = entity->AddComponent<ecs::RenderComponent>();
+        renderComponent->InitializeWithModel(sharedModel);
+        
+        // Ajouter un composant de shader
+        auto shaderComponent = entity->AddComponent<ecs::ShaderComponent>();
+        shaderComponent->SetActiveShader(ecs::ShaderComponent::StringToShaderType(shaderTypeStr));
+        
+        // Ajouter un composant de chemin de modèle
+        auto modelPathComponent = entity->AddComponent<ecs::ModelPathComponent>();
+        modelPathComponent->SetPath(wModelPath);
+        
+        // Ajouter un composant de physique si nécessaire
+        auto physicsComponent = entity->AddComponent<ecs::PhysicsComponent>();
+        physicsComponent->Initialize();
+        physicsComponent->SetMass(mass);
+        physicsComponent->SetBoundingRadius(boundingRadius);
+        physicsComponent->SetPhysicsEnabled(physicsEnabled);
+        
+        Logger::Get().Log("Entity loaded: " + name + " with ID: " + std::to_string(id), __FILE__, __LINE__, Logger::LogLevel::Info);
    }

-    // pass the vec to the application
-    app_->set_kobjects(object_vec_);
+    // Mettre à jour l'ID global dans l'application
+    app_->set_object_id(object_id_);
    
-    Logger::Get().Log("Scene loaded successfully from ", __FILE__, __LINE__, Logger::LogLevel::Info);
+    // Mettre à jour les statistiques après le chargement
+    app_->update_stats_after_modification();
+	
+    Logger::Get().Log("Scene loaded successfully from " + scene_path_, __FILE__, __LINE__, Logger::LogLevel::Info);
    return true;
 }

 bool scene_manager::save_scene() {

+    entity_ = app_->get_entity_manager()->GetAllEntities();
    
    if (scene_path_.empty()) {
        Logger::Get().Log("Scene path is empty. Cannot save scene.", __FILE__, __LINE__, Logger::LogLevel::Error);
@ -250,56 +307,102 @@ bool scene_manager::save_scene() {
        return false;
    }

-    for (const auto& object : object_vec_) {
+    for (const auto& object : entity_) {
        XMFLOAT3 position, scale, rotation;
-        XMStoreFloat3(&position, object->GetPosition());
-        XMStoreFloat3(&scale, object->GetScale());
-        XMStoreFloat3(&rotation, object->GetRotation());
+        int id = 0;
+        int mass = 0;
+        float boundingRadius = 0;
+        std::string name = "NONE";
+        std::string shaderType = "NONE";
+        std::string objectType = "NONE";
+        std::wstring model_path = L"";
+        bool physics_enabled = false;
+
+        auto transform = object->GetComponent<ecs::TransformComponent>();
+        if (transform) {
+            // convert XMVECTOR to XMFLOAT3
+            XMStoreFloat3(&position, transform->GetPosition());
+            XMStoreFloat3(&rotation, transform->GetRotation());
+            XMStoreFloat3(&scale, transform->GetScale());
+        }
+
+        
+        auto identity = object->GetComponent<ecs::IdentityComponent>();
+        if (identity) {
+
+            id = identity->GetId();
+            name = identity->GetName();
+            objectType = identity->ObjectTypeToString(identity->GetType());
+            
+        }
+
+        auto model_path_component = object->GetComponent<ecs::ModelPathComponent>();
+        if (model_path_component) {
+            
+            model_path = model_path_component->GetPath();
+        }
+
+        auto shader = object->GetComponent<ecs::ShaderComponent>();
+        if (shader)
+        {
+            shaderType = shader->ShaderTypeToString(shader->GetActiveShader());
+        }
+
+        auto physics = object->GetComponent<ecs::PhysicsComponent>();
+        if (physics) {
+            physics_enabled = physics->IsPhysicsEnabled();
+            mass = physics->GetMass();
+            boundingRadius = physics->GetBoundingRadius();
+        }
        
        // Écrire les données de base de l'objet
-        outFile << object->GetId() << " "
-                << object->GetName() << " "
+        outFile << id << " "
+                << name << " "
                << position.x << " " << position.y << " " << position.z << " "
                << rotation.x << " " << rotation.y << " " << rotation.z << " "
                << scale.x << " " << scale.y << " " << scale.z << " "
-                << convert_w_string_to_string(object->GetModelPath()) << " "
-                << object->ShaderTypeToString(object->GetActiveShader()) << " "
-                << object->GetBoundingRadius() << " "
-                << object->ObjectTypeToString(object->GetType()) << " "
-                << object->GetMass() << " "
-                << object->IsPhysicsEnabled();
+                << convert_w_string_to_string(model_path) << " "
+                << shaderType << " "
+                << boundingRadius << " "
+                << objectType << " "
+                << mass << " "
+                << physics_enabled;
        
        // Sauvegarder les chemins des textures_
        // Format: nombre de textures_ diffuses, puis les chemins
        // Même chose pour les autres types de textures_

-        // Textures diffuses
-        const auto& diffusePaths = object->get_model()->GetTextureContainer().GetPaths(TextureType::Diffuse);
-        outFile << " " << diffusePaths.size();
-        for (const auto& path : diffusePaths) {
-            outFile << " " << convert_w_string_to_string(path);
+
+        auto render = object->GetComponent<ecs::RenderComponent>();
+        if (render)
+        {
+            const auto& model = render->GetModel();
+
+            const auto& textureContainer = model->GetTextureContainer();
+
+            const auto& diffusePaths = textureContainer.GetPaths(TextureType::Diffuse);
+            outFile << " " << diffusePaths.size();
+            for (const auto& path : diffusePaths) {
+                outFile << " " << convert_w_string_to_string(path);
+            }
+
+            const auto& normalPaths = textureContainer.GetPaths(TextureType::Normal);
+            outFile << " " << normalPaths.size();
+            for (const auto& path : normalPaths) {
+                outFile << " " << convert_w_string_to_string(path);
+            }
+            const auto& specularPaths = textureContainer.GetPaths(TextureType::Specular);
+            outFile << " " << specularPaths.size();
+            for (const auto& path : specularPaths) {
+                outFile << " " << convert_w_string_to_string(path);
+            }
+            const auto& alphaPaths = textureContainer.GetPaths(TextureType::Alpha);
+            outFile << " " << alphaPaths.size();
+            for (const auto& path : alphaPaths) {
+                outFile << " " << convert_w_string_to_string(path);
+            }
        }
        
-        // Textures normales
-        const auto& normalPaths = object->get_model()->GetTextureContainer().GetPaths(TextureType::Normal);
-        outFile << " " << normalPaths.size();
-        for (const auto& path : normalPaths) {
-            outFile << " " << convert_w_string_to_string(path);
-        }
-        
-        // Textures spéculaires
-        const auto& specularPaths = object->get_model()->GetTextureContainer().GetPaths(TextureType::Specular);
-        outFile << " " << specularPaths.size();
-        for (const auto& path : specularPaths) {
-            outFile << " " << convert_w_string_to_string(path);
-        }
-        
-        // Textures alpha
-        const auto& alphaPaths = object->get_model()->GetTextureContainer().GetPaths(TextureType::Alpha);
-        outFile << " " << alphaPaths.size();
-        for (const auto& path : alphaPaths) {
-            outFile << " " << convert_w_string_to_string(path);
-        }
        
        outFile << std::endl;
    }
@ -344,3 +447,4 @@ std::string scene_manager::convert_w_string_to_string(const std::wstring& wstr)
    WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), &str[0], size_needed, NULL, NULL);
    return str;
 }
+
--- a/enginecustom/src/src/system/stats.cpp
+++ b/enginecustom/src/src/system/stats.cpp
@ -36,16 +36,16 @@ bool stats::initialize(application_class* app)

 void stats::update_geometric_stats()
 {
+    // Utiliser le système ECS pour accéder aux entités avec des composants de rendu
+    if (app_ && app_->get_entity_manager())
+    {
+        *total_vertex_count_ = get_total_vertex_count();
+        *total_triangle_count_ = get_total_triangle_count();
        
-    object_vec_ = app_->get_kobjects();
-    cubes_vec_ = app_->get_cubes();
-    terrain_chunk_vec_ = app_->get_terrain_cubes();
+        update_visible_count();

-    
-    *total_vertex_count_ = get_total_vertex_count();
-    *total_triangle_count_ = get_total_triangle_count();
-    
-    update_visible_count();
+        Logger::Get().Log("Statistics updated: " + std::to_string(*total_vertex_count_) + " vertices, " + std::to_string(*total_triangle_count_) + " triangles", __FILE__, __LINE__, Logger::LogLevel::Debug);
+    }
 }

 void stats::update_visible_count()
@ -66,88 +66,143 @@ void stats::update_display_stats()
 int stats::get_total_vertex_count() const
 {
    int totalVertices = 0;
+    
+    // Utiliser le système ECS pour accéder aux entités avec des composants de rendu
+    if (app_ && app_->get_entity_manager())
+    {
+        auto entities = app_->get_entity_manager()->GetEntitiesWithComponent<ecs::RenderComponent>();
+        
+        for (const auto& entity : entities)
+        {
+            auto renderComponent = entity->GetComponent<ecs::RenderComponent>();
+            if (renderComponent && renderComponent->GetModel())
+            {
+                totalVertices += renderComponent->GetModel()->GetVertexCount();
+            }
+        }
+    }
+    
+    // Ajouter également les éventuels objets restants de l'ancien système
    for (const auto& obj : object_vec_)
    {
-        if (obj)
+        if (obj && obj->get_model())
        {
            totalVertices += obj->get_model()->GetVertexCount();
        }
    }
-    // Ajoutez le nombre de sommets pour les cubes
+    
    for (const auto& cube : cubes_vec_)
    {
-        if (cube)
+        if (cube && cube->get_model())
        {
            totalVertices += cube->get_model()->GetVertexCount();
        }
    }
-    // Ajoutez le nombre de sommets pour le terrain
+    
    for (const auto& chunk : terrain_chunk_vec_)
    {
-        if (chunk)
+        if (chunk && chunk->get_model())
        {
            totalVertices += chunk->get_model()->GetVertexCount();
        }
    }
+    
    return totalVertices;
 }

 int stats::get_total_triangle_count() const
 {
    int totalTriangles = 0;
+    
+    // Utiliser le système ECS pour accéder aux entités avec des composants de rendu
+    if (app_ && app_->get_entity_manager())
+    {
+        auto entities = app_->get_entity_manager()->GetEntitiesWithComponent<ecs::RenderComponent>();
+        
+        for (const auto& entity : entities)
+        {
+            auto renderComponent = entity->GetComponent<ecs::RenderComponent>();
+            if (renderComponent && renderComponent->GetModel())
+            {
+                // Dans une topologie de liste de triangles, chaque triangle utilise 3 indices
+                totalTriangles += renderComponent->GetModel()->GetIndexCount() / 3;
+            }
+        }
+    }
+    
+    // Ajouter également les éventuels objets restants de l'ancien système
    for (const auto& obj : object_vec_)
    {
-        if (obj)
+        if (obj && obj->get_model())
        {
-            // Dans une topologie de liste de triangles, chaque triangle utilise 3 indices
            totalTriangles += obj->get_model()->GetIndexCount() / 3;
        }
    }
-    // Ajoutez le nombre de triangles pour les cubes
+    
    for (const auto& cube : cubes_vec_)
    {
-        if (cube)
+        if (cube && cube->get_model())
        {
            totalTriangles += cube->get_model()->GetIndexCount() / 3;
        }
    }
-    // Ajoutez le nombre de triangles pour le terrain
+    
    for (const auto& chunk : terrain_chunk_vec_)
    {
-        if (chunk)
+        if (chunk && chunk->get_model())
        {
            totalTriangles += chunk->get_model()->GetIndexCount() / 3;
        }
    }
+    
    return totalTriangles;
 }

 int stats::get_visible_triangle_count() const
 {
    int visibleTriangles = 0;
+    
+    // Utiliser le système ECS pour accéder aux entités avec des composants de rendu
+    if (app_ && app_->get_entity_manager())
+    {
+        auto entities = app_->get_entity_manager()->GetEntitiesWithComponent<ecs::RenderComponent>();
+        
+        for (const auto& entity : entities)
+        {
+            auto renderComponent = entity->GetComponent<ecs::RenderComponent>();
+            if (renderComponent && renderComponent->GetModel() && renderComponent->IsVisible())
+            {
+                // Dans une topologie de liste de triangles, chaque triangle utilise 3 indices
+                visibleTriangles += renderComponent->GetModel()->GetIndexCount() / 3;
+            }
+        }
+    }
+    
+    // Ajouter également les éventuels objets restants de l'ancien système
    for (const auto& obj : object_vec_)
    {
-        if (obj && obj->IsVisible())
+        if (obj && obj->get_model() && obj->IsVisible())
        {
            visibleTriangles += obj->get_model()->GetIndexCount() / 3;
        }
    }
-    // Ajoutez le nombre de triangles visibles pour les cubes
+    
    for (const auto& cube : cubes_vec_)
    {
-        if (cube && cube->IsVisible())
+        if (cube && cube->get_model() && cube->IsVisible())
        {
            visibleTriangles += cube->get_model()->GetIndexCount() / 3;
        }
    }
-    // Ajoutez le nombre de triangles visibles pour le terrain
+    
    for (const auto& chunk : terrain_chunk_vec_)
    {
-        if (chunk && chunk->IsVisible())
+        if (chunk && chunk->get_model() && chunk->IsVisible())
        {
            visibleTriangles += chunk->get_model()->GetIndexCount() / 3;
        }
    }
+    
    return visibleTriangles;
 }
Author	SHA1	Message	Date
CatChow0	2c005592f0	Patch - TODO : Serialized / Deserialized Component DATA - V12.7.1	2025-06-26 21:44:28 +02:00
CatChow0	763ecff93d	Minor - ECS use when loading scene - V12.7.0	2025-06-24 18:58:53 +02:00
CatChow0	e527e85b9c	Minor - ECS use in save - V12.6.0	2025-06-24 18:41:13 +02:00
CatChow0	9d0d2d1dfd	Minor - ECS use in stats - V12.5.0	2025-06-24 17:15:58 +02:00
CatChow0	7755150ae8	Patch - ADD TODO comment - V12.4.1	2025-06-24 17:01:05 +02:00
CatChow0	ddf5ea30a6	Minor - ImGui Use ECS - V12.4.0	2025-06-24 16:44:29 +02:00
CatChow0	8f0e583c62	Minor - ECS implementation pt.2 - V12.3.0	2025-06-24 16:25:03 +02:00
CatChow0	bf1b5d78e5	Minor - ECS use in other method pt.1 - V12.2.0	2025-06-24 16:13:56 +02:00
CatChow0	3adfddf44f	Minor - ECS use for import object - V12.1.0	2025-06-24 15:36:45 +02:00
				`@ -1 +0,0 @@`
				`1 isosphere 0 10 0 0 -0 0 1 1 1 Content/Assets/Kobject/isosphere.obj ALPHA_MAPPING 1 Unknown 1 0 2 assets/Texture/Bricks2K.png F:\Github_Repo\khaotic-engine-Reborn\enginecustom\assets\Texture\moss01.png 1 assets/Texture/BricksNRM2K.png 1 assets/Texture/BricksGLOSS2K.png 1 F:\Github_Repo\khaotic-engine-Reborn\enginecustom\assets\Texture\alpha01.png`
				`@ -1 +0,0 @@`
				`0 vaisseautri 0 50 0 0 -0 0 1 1 1 Content/Assets/Kobject/vaisseautri.obj CEL_SHADING 1 Unknown 1 0 1 F:\Github_Repo\khaotic-engine-Reborn\enginecustom\assets\Texture\marble01.png 1 assets/Texture/BricksNRM2K.png 1 assets/Texture/BricksGLOSS2K.png 0`
				`@ -0,0 +1 @@`
				`1 CubePart_0_0_0 0 0 0 0 -0 0 1 1 1 LIGHTING 0 Terrain 0 0 1 assets/Texture/Bricks2K.png 1 assets/Texture/BricksNRM2K.png 1 assets/Texture/BricksGLOSS2K.png 0`