removing all singletons

runtime/Includes/Core/Application.h

@@ -4,6 +4,8 @@
 #include <Core/Graphics.h>
 #include <Platform/Inputs.h>
 #include <Core/ImagesRegistry.h>
+#include <Core/SDLManager.h>
+#include <Core/Memory.h>
 #include <Core/Fps.h>
 
 namespace mlx
@@ -47,12 +49,17 @@ namespace mlx
 			~Application();
 
 		private:
+			std::unique_ptr<MemManager> p_mem_manager; // Putting ptr here to initialise them before inputs, even if it f*cks the padding
+			std::unique_ptr<SDLManager> p_sdl_manager;
 			FpsManager m_fps;
 			Inputs m_in;
 			ImageRegistry m_image_registry;
 			std::vector<std::unique_ptr<GraphicsSupport>> m_graphics;
 			std::function<int(Handle)> f_loop_hook;
 			std::unique_ptr<RenderCore> p_render_core;
+			#ifdef PROFILER
+				std::unique_ptr<Profiler> p_profiler;
+			#endif
 			Handle p_param = nullptr;
 	};
 }

runtime/Includes/Core/Memory.h

@@ -3,21 +3,23 @@
 
 namespace mlx
 {
-	class MemManager : public Singleton<MemManager>
+	class MemManager
 	{
-		friend class Singleton<MemManager>;
-
 		public:
+			MemManager();
+
 			static void* Malloc(std::size_t size);
 			static void* Calloc(std::size_t n, std::size_t size);
 			static void* Realloc(void* ptr, std::size_t size);
 			static void Free(void* ptr);
 
-		private:
+			inline static bool IsInit() noexcept { return s_instance != nullptr; }
-			MemManager() = default;
+			inline static MemManager& Get() noexcept { return *s_instance; }
+
 			~MemManager();
 
 		private:
+			static MemManager* s_instance;
 			inline static std::list<void*> s_blocks;
 	};
 }

runtime/Includes/Core/Profiler.h

@@ -1,8 +1,6 @@
 #ifndef __MLX_PROFILER__
 #define __MLX_PROFILER__
 
-#include <Utils/Singleton.h>
-
 namespace mlx
 {
 	using FloatingPointMilliseconds = std::chrono::duration<double, std::milli>;
@@ -14,20 +12,21 @@ namespace mlx
 		std::thread::id thread_id;
 	};
 
-	class Profiler : public Singleton<Profiler>
+	class Profiler
 	{
-		friend class Singleton<Profiler>;
-
 		public:
 			Profiler(const Profiler&) = delete;
 			Profiler(Profiler&&) = delete;
+			Profiler() { BeginRuntimeSession(); s_instance = this; }
 
 			void AppendProfileData(ProfileResult&& result);
 
-		private:
+			inline static bool IsInit() noexcept { return s_instance != nullptr; }
-			Profiler() { BeginRuntimeSession(); }
+			inline static Profiler& Get() noexcept { return *s_instance; }
+
 			~Profiler();
 
+		private:
 			void BeginRuntimeSession();
 			void WriteProfile(const ProfileResult& result);
 			void EndRuntimeSession();
@@ -44,6 +43,8 @@ namespace mlx
 			}
 
 		private:
+			static Profiler* s_instance;
+
 			std::unordered_map<std::string, std::pair<std::size_t, ProfileResult>> m_profile_data;
 			std::ofstream m_output_stream;
 			std::mutex m_mutex;

runtime/Includes/Core/SDLManager.h

@@ -5,13 +5,10 @@
 
 namespace mlx
 {
-	class SDLManager : public Singleton<SDLManager>
+	class SDLManager
 	{
-		friend class Singleton<SDLManager>;
-
 		public:
-			void Init() noexcept;
+			SDLManager();
-			void Shutdown() noexcept;
 
 			Handle CreateWindow(const std::string& title, std::size_t w, std::size_t h, bool hidden);
 			void DestroyWindow(Handle window) noexcept;
@@ -30,18 +27,17 @@ namespace mlx
 			std::int32_t GetXRel() const noexcept;
 			std::int32_t GetYRel() const noexcept;
 
-		private:
+			inline static bool IsInit() noexcept { return s_instance != nullptr; }
-			SDLManager() = default;
+			inline static SDLManager& Get() noexcept { return *s_instance; }
-			~SDLManager() = default;
+
+			~SDLManager();
 
 		private:
+			static SDLManager* s_instance;
+
 			std::unordered_set<Handle> m_windows_registry;
 			func::function<void(mlx_event_type, int, int, void*)> f_callback;
 			void* p_callback_data = nullptr;
-			std::int32_t m_x;
-			std::int32_t m_y;
-			std::int32_t m_rel_x;
-			std::int32_t m_rel_y;
 			bool m_drop_sdl_responsability = false;
 	};
 }

runtime/Includes/PreCompiled.h

@@ -93,6 +93,7 @@
 #include <Core/EventBus.h>
 #include <Core/Profiler.h>
 #include <Utils/NonOwningPtr.h>
+#include <Utils/NonCopyable.h>
 
 using Handle = void*;
 

runtime/Includes/Utils/Singleton.h

@@ -1,20 +0,0 @@
-#ifndef __MLX_SINGLETON__
-#define __MLX_SINGLETON__
-
-#include <Utils/NonCopyable.h>
-
-namespace mlx
-{
-	template <typename T>
-	class Singleton : public NonCopyable
-	{
-		public:
-			inline static T& Get()
-			{
-				static T instance;
-				return instance;
-			}
-	};
-}
-
-#endif // __MLX_SINGLETON__

runtime/Sources/Core/Application.cpp

@@ -8,7 +8,7 @@
 
 namespace mlx
 {
-	Application::Application() : m_fps(), m_in() 
+	Application::Application() : p_mem_manager(std::make_unique<MemManager>()), p_sdl_manager(std::make_unique<SDLManager>()), m_fps(), m_in() 
 	{
 		EventBus::RegisterListener({[](const EventBase& event)
 		{
@@ -16,8 +16,11 @@ namespace mlx
 				std::abort();
 		}, "__MlxApplication" });
 
+		#ifdef PROFILER
+			p_profiler = std::make_unique<Profiler>();
+		#endif
+
 		m_fps.Init();
-		SDLManager::Get().Init();
 		p_render_core = std::make_unique<RenderCore>();
 	}
 
@@ -89,6 +92,10 @@ namespace mlx
 	Application::~Application()
 	{
 		p_render_core.reset();
-		SDLManager::Get().Shutdown();
+		p_sdl_manager.reset();
+		#ifdef PROFILER
+			p_profiler.reset();
+		#endif
+		p_mem_manager.reset();
 	}
 }

runtime/Sources/Core/Memory.cpp

@@ -4,6 +4,13 @@
 
 namespace mlx
 {
+	MemManager* MemManager::s_instance = nullptr;
+
+	MemManager::MemManager()
+	{
+		s_instance = this;
+	}
+
 	void* MemManager::Malloc(std::size_t size)
 	{
 		void* ptr = std::malloc(size);
@@ -49,5 +56,6 @@ namespace mlx
 		{
 			std::free(ptr);
 		});
+		s_instance = nullptr;
 	}
 }

runtime/Sources/Core/Profiler.cpp

@@ -4,6 +4,8 @@
 
 namespace mlx
 {
+	Profiler* Profiler::s_instance = nullptr;
+
 	void Profiler::BeginRuntimeSession()
 	{
 		std::lock_guard lock(m_mutex);
@@ -63,5 +65,6 @@ namespace mlx
 		if(!m_runtime_session_began)
 			return;
 		EndRuntimeSession();
+		s_instance = nullptr;
 	}
 }

runtime/Sources/Core/SDLManager.cpp

@@ -26,9 +26,13 @@ namespace mlx
 		};
 	}
 
-	void SDLManager::Init() noexcept
+	SDLManager* SDLManager::s_instance = nullptr;
+
+	SDLManager::SDLManager()
 	{
 		MLX_PROFILE_FUNCTION();
+		s_instance = this;
+
 		m_drop_sdl_responsability = SDL_WasInit(SDL_INIT_VIDEO);
 		if(m_drop_sdl_responsability) // is case the mlx is running in a sandbox like MacroUnitTester where SDL is already init
 			return;
@@ -224,12 +228,13 @@ namespace mlx
 		return y;
 	}
 
-	void SDLManager::Shutdown() noexcept
+	SDLManager::~SDLManager()
 	{
 		if(m_drop_sdl_responsability)
 			return;
 		SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_EVENTS);
 		SDL_Quit();
+		s_instance = nullptr;
 		DebugLog("SDL Manager uninitialized");
 	}
 }