Style: Rename LT_* Log macros to LOG

Engine/src/Engine/Base/Base.h

@@ -4,40 +4,40 @@
 
 namespace Light {
 
-	// Ref (Ref)
+// Ref (Ref)
-	template<typename T>
+template<typename T>
-	using Ref = std::shared_ptr<T>;
+using Ref = std::shared_ptr<T>;
 
-	template<typename T, typename... Args>
+template<typename T, typename... Args>
-	constexpr Ref<T> CreateRef(Args&&... args)
+constexpr Ref<T> CreateRef(Args&&... args)
-	{
+{
 	return std::make_shared<T>(std::forward<Args>(args)...);
-	}
-
-	template<typename T>
-	constexpr Ref<T> MakeRef(T* rawPointer)
-	{
-		return std::shared_ptr<T>(rawPointer);
-	}
-
-	// Scope (std::unique_ptr)
-	template<typename T>
-	using Scope = std::unique_ptr<T>;
-
-	template<typename T, typename... Args>
-	constexpr std::unique_ptr<T> CreateScope(Args&&... args)
-	{
-		return std::make_unique<T>(std::forward<Args>(args)...);
-	}
-
-	template<typename T>
-	constexpr std::unique_ptr<T> MakeScope(T* rawPointer)
-	{
-		return std::unique_ptr<T>(rawPointer);
-	}
-
 }
 
+template<typename T>
+constexpr Ref<T> MakeRef(T* rawPointer)
+{
+	return std::shared_ptr<T>(rawPointer);
+}
+
+// Scope (std::unique_ptr)
+template<typename T>
+using Scope = std::unique_ptr<T>;
+
+template<typename T, typename... Args>
+constexpr std::unique_ptr<T> CreateScope(Args&&... args)
+{
+	return std::make_unique<T>(std::forward<Args>(args)...);
+}
+
+template<typename T>
+constexpr std::unique_ptr<T> MakeScope(T* rawPointer)
+{
+	return std::unique_ptr<T>(rawPointer);
+}
+
+} // namespace Light
+
 //========== PLATFORM ==========//
 #define LT_WIN(x) // windows
 #define LT_LIN(x) // linux
@@ -56,21 +56,34 @@ namespace Light {
 	#define LT_MAC(x) x
 
 #else
-	// #error "Unsupported platform: Unknown"
+// #error "Unsupported platform: Unknown"
 #endif
 //========== PLATFORM ==========//
 
 //====================================================================== OPERATIONS ======================================================================//
 /* assertions */
-#define LT_ENGINE_ASSERT(x, ...) { if(!(x)) { LT_ENGINE_CRITICAL(__VA_ARGS__); LT_DEBUG_TRAP(); throw ::Light::FailedEngineAssertion(__FILE__, __LINE__); } }
+#define ASSERT(x, ...)                                          \
-#define LT_CLIENT_ASSERT(x, ...) { if(!(x)) { LT_CLIENT_CRITICAL(__VA_ARGS__); LT_DEBUG_TRAP(); throw ::Light::FailedClientAssertion(__FILE__, __LINE__); } }
+	{                                                           \
+		if (!(x))                                               \
+		{                                                       \
+			LOG(critical, __VA_ARGS__);                         \
+			LT_DEBUG_TRAP();                                    \
+			throw ::Light::FailedAssertion(__FILE__, __LINE__); \
+		}                                                       \
+	}
 
 /* bit-wise */
 #define BIT(x) 1 << x
 
 /* token */
-#define LT_PAIR_TOKEN_VALUE_TO_NAME(token) { token, #token }
+#define LT_PAIR_TOKEN_VALUE_TO_NAME(token) \
-#define LT_PAIR_TOKEN_NAME_TO_VALUE(token) { #token, token }
+	{                                      \
+		token, #token                      \
+	}
+#define LT_PAIR_TOKEN_NAME_TO_VALUE(token) \
+	{                                      \
+		#token, token                      \
+	}
 #define LT_TOKEN_NAME(token) #token
 //====================================================================== OPERATIONS ======================================================================//
 

Engine/src/Engine/Base/EntryPoint.h

@@ -2,7 +2,7 @@
 
 #ifdef LIGHT_PLATFORM_WINDOWS
 
-#include <LightEngine.h>
+	#include <LightEngine.h>
 
 // to be defined in client project
 extern Light::Application* Light::CreateApplication(std::string execName, std::vector<std::string> args);
@@ -21,35 +21,29 @@ int main(int argc, char* argv[])
 	try
 	{
 		application = Light::CreateApplication(argv[0], args);
-		LT_ENGINE_ASSERT(application, "main: Light::Application is not intialized");
+		ASSERT(application, "Light::Application is not intialized");
 
 		for (int i = 0; i < argc; i++)
-			LT_ENGINE_INFO("main: argv[{}]: {}", i, argv[i]);
+			LOG(info, "argv[{}]: {}", i, argv[i]);
 
 		application->GameLoop();
 	}
 	// failed engine assertion
-	catch (Light::FailedEngineAssertion)
+	catch (Light::FailedAssertion)
 	{
-		LT_ENGINE_CRITICAL("main: exitting due to unhandled 'FailedEngineAssertion'");
+		LOG(critical, "Terminating due to unhandled 'FailedEngineAssertion'");
 		exitCode = -1;
 	}
-	// failed client assertion
-	catch (Light::FailedClientAssertion)
-	{
-		LT_ENGINE_CRITICAL("main: exitting due to unhandled 'FailedClientAssertion'");
-		exitCode = -2;
-	}
 	// gl exception
-	catch(Light::glException)
+	catch (Light::glException)
 	{
-		LT_ENGINE_CRITICAL("main: exitting due to unhandled 'glException'");
+		LOG(critical, "Terminating due to unhandled 'glException'");
 		exitCode = -3;
 	}
 	// dx exception
 	catch (Light::dxException)
 	{
-		LT_ENGINE_CRITICAL("main: exitting due to unhandled 'dxException'");
+		LOG(critical, "Terminating due to unhandled 'dxException'");
 		exitCode = -4;
 	}
 
@@ -59,7 +53,7 @@ int main(int argc, char* argv[])
 
 #elif defined(LIGHT_PLATFORM_LINUX)
 
-#include <LightEngine.h>
+	#include <LightEngine.h>
 
 // to be defined in client project
 extern Light::Application* Light::CreateApplication();
@@ -73,26 +67,20 @@ int main(int argc, char* argv[])
 	try
 	{
 		application = Light::CreateApplication();
-		LT_ENGINE_ASSERT(application, "main: Light::Application is not intialized");
+		ASSERT(application, "Light::Application is not intialized");
 
 		application->GameLoop();
 	}
 	// failed engine assertion
-	catch (Light::FailedEngineAssertion)
+	catch (Light::FailedAssertion)
 	{
-		LT_ENGINE_CRITICAL("main: exitting due to unhandled 'FailedEngineAssertion'");
+		LOG(critical, "Exitting due to unhandled 'FailedEngineAssertion'");
 		exitCode = -1;
 	}
-	// failed client assertion
-	catch (Light::FailedClientAssertion)
-	{
-		LT_ENGINE_CRITICAL("main: exitting due to unhandled 'FailedClientAssertion'");
-		exitCode = -2;
-	}
 	// gl exception
 	catch (Light::glException)
 	{
-		LT_ENGINE_CRITICAL("main: exitting due to unhandled 'glException'");
+		LOG(critical, "main: exitting due to unhandled 'glException'");
 		exitCode = -3;
 	}
 

Engine/src/Engine/Base/Portables/DebugTrap.h

@@ -1,127 +1,149 @@
 #pragma once
 #ifndef LIGHT_DEBUG_TRAP_H
-#define LIGHT_DEBUG_TRAP_H
+	#define LIGHT_DEBUG_TRAP_H
 
-#include "Base/Base.h"
+	#include "Base/Base.h"
 
 // https://github.com/nemequ/portable-snippets/tree/master/debug-trap
 
-#ifdef LIGHT_DIST
+	#ifdef LIGHT_DIST
-#ifdef _MSC_VER
+		#ifdef _MSC_VER
-#define LT_DEBUG_TRAP()                                                        \
+			#define LT_DEBUG_TRAP()                                                 \
 				LT_FILE_CRITICAL("DEBUG_TRAP REQUESTED AT: {}, FILE: {}, LINE: {}", \
 				                 __FUNCSIG__, __FILE__, __LINE__) // or __FUNCSIG__
 
-#else
+		#else
-#define LT_DEBUG_TRAP()                                                        \
+			#define LT_DEBUG_TRAP() \
 				LT_FILE_CRITICAL("DEBUG_TRAP REQUESTED AT: {}", __PRETTY_FUNCTION__)
 
-#endif
+		#endif
-#endif
+	#endif
 
-#if !defined(LT_DEBUG_TRAP) && defined(__has_builtin) && !defined(__ibmxl__)
+	#if !defined(LT_DEBUG_TRAP) && defined(__has_builtin) && !defined(__ibmxl__)
-#if __has_builtin(__builtin_debugtrap)
+		#if __has_builtin(__builtin_debugtrap)
-#define LT_DEBUG_TRAP() __builtin_debugtrap()
+			#define LT_DEBUG_TRAP() __builtin_debugtrap()
 
-#elif __has_builtin(__debugbreak)
+		#elif __has_builtin(__debugbreak)
-#define LT_DEBUG_TRAP() __debugbreak()
+			#define LT_DEBUG_TRAP() __debugbreak()
 
-#endif
+		#endif
-#endif
+	#endif
 
-#if !defined(LT_DEBUG_TRAP)
+	#if !defined(LT_DEBUG_TRAP)
-#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
+		#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
-#define LT_DEBUG_TRAP() __debugbreak()
+			#define LT_DEBUG_TRAP() __debugbreak()
 
-#elif defined(__ARMCC_VERSION)
+		#elif defined(__ARMCC_VERSION)
-#define LT_DEBUG_TRAP() __breakpoint(42)
+			#define LT_DEBUG_TRAP() __breakpoint(42)
 
-#elif defined(__ibmxl__) || defined(__xlC__)
+		#elif defined(__ibmxl__) || defined(__xlC__)
-#include <builtins.h>
+			#include <builtins.h>
-#define LT_DEBUG_TRAP() __trap(42)
+			#define LT_DEBUG_TRAP() __trap(42)
 
-#elif defined(__DMC__) && defined(_M_IX86)
+		#elif defined(__DMC__) && defined(_M_IX86)
-static inline void LT_DEBUG_TRAP(void) { __asm int 3h; }
+static inline void LT_DEBUG_TRAP(void)
+{
+	__asm int 3h;
+}
 
-#elif defined(__i386__) || defined(__x86_64__)
+		#elif defined(__i386__) || defined(__x86_64__)
-static inline void LT_DEBUG_TRAP(void) { __asm__ __volatile__("int3"); }
+static inline void LT_DEBUG_TRAP(void)
+{
+	__asm__ __volatile__("int3");
+}
 
-#elif defined(__thumb__)
+		#elif defined(__thumb__)
-static inline void LT_DEBUG_TRAP(void) { __asm__ __volatile__(".inst 0xde01"); }
+static inline void LT_DEBUG_TRAP(void)
+{
+	__asm__ __volatile__(".inst 0xde01");
+}
 
-#elif defined(__aarch64__)
+		#elif defined(__aarch64__)
-static inline void LT_DEBUG_TRAP(void) {
+static inline void LT_DEBUG_TRAP(void)
+{
 	__asm__ __volatile__(".inst 0xd4200000");
 }
 
-#elif defined(__arm__)
+		#elif defined(__arm__)
-static inline void LT_DEBUG_TRAP(void) {
+static inline void LT_DEBUG_TRAP(void)
+{
 	__asm__ __volatile__(".inst 0xe7f001f0");
 }
 
-#elif defined(__alpha__) && !defined(__osf__)
+		#elif defined(__alpha__) && !defined(__osf__)
-static inline void LT_DEBUG_TRAP(void) { __asm__ __volatile__("bpt"); }
+static inline void LT_DEBUG_TRAP(void)
+{
+	__asm__ __volatile__("bpt");
+}
 
-#elif defined(_54_)
+		#elif defined(_54_)
-static inline void LT_DEBUG_TRAP(void) { __asm__ __volatile__("ESTOP"); }
+static inline void LT_DEBUG_TRAP(void)
+{
+	__asm__ __volatile__("ESTOP");
+}
 
-#elif defined(_55_)
+		#elif defined(_55_)
-static inline void LT_DEBUG_TRAP(void) {
+static inline void LT_DEBUG_TRAP(void)
+{
 	__asm__ __volatile__(
 	    ";\n .if (.MNEMONIC)\n ESTOP_1\n .else\n ESTOP_1()\n .endif\n NOP");
 }
 
-#elif defined(_64P_)
+		#elif defined(_64P_)
-static inline void LT_DEBUG_TRAP(void) { __asm__ __volatile__("SWBP 0"); }
+static inline void LT_DEBUG_TRAP(void)
+{
+	__asm__ __volatile__("SWBP 0");
+}
 
-#elif defined(_6x_)
+		#elif defined(_6x_)
-static inline void LT_DEBUG_TRAP(void) {
+static inline void LT_DEBUG_TRAP(void)
+{
 	__asm__ __volatile__("NOP\n .word 0x10000000");
 }
 
-#elif defined(__STDC_HOSTED__) && (__STDC_HOSTED__ == 0) && defined(__GNUC__)
+		#elif defined(__STDC_HOSTED__) && (__STDC_HOSTED__ == 0) && defined(__GNUC__)
-#define LT_DEBUG_TRAP() __builtin_trap()
+			#define LT_DEBUG_TRAP() __builtin_trap()
 
-#else
+		#else
-#include <signal.h>
+			#include <signal.h>
 
-#if defined(SIGTRAP)
+			#if defined(SIGTRAP)
-#define LT_DEBUG_TRAP() raise(SIGTRAP)
+				#define LT_DEBUG_TRAP() raise(SIGTRAP)
 
-#else
+			#else
-#define LT_DEBUG_TRAP() raise(SIGABRT)
+				#define LT_DEBUG_TRAP() raise(SIGABRT)
 
-#endif
+			#endif
-#endif
+		#endif
-#endif
+	#endif
 
-#if !defined(LT_DEBUG_TRAP)
+	#if !defined(LT_DEBUG_TRAP)
-#if !defined(LIGHT_IGNORE_UNDEFINED_DEBUG_TRAP)
+		#if !defined(LIGHT_IGNORE_UNDEFINED_DEBUG_TRAP)
-#error                                                                         \
+			#error \
 			    "failed to define LT_BREAK, define LIGHT_IGNORE_UNDEFINED_DEBUG_TRAP in Config.h to disable this error"
 
-#elif defined(LIGHT_DIST)
+		#elif defined(LIGHT_DIST)
-#ifdef _MSC_VER
+			#ifdef _MSC_VER
-#define LT_DEBUG_TRAP()                                                        \
+				#define LT_DEBUG_TRAP()                                              \
-  LT_FILE_CRITICAL("DEBUG_TRAP REQUESTED AT: {}, FILE: {}, LINE: {}",          \
+					LOG(critical, "DEBUG_TRAP REQUESTED AT: {}, FILE: {}, LINE: {}", \
 					    __FUNCSIG__, __FILE__, __LINE__) // or __FUNCSIG__
 
-#else
+			#else
-#define LT_DEBUG_TRAP()                                                        \
+				#define LT_DEBUG_TRAP() \
-  LT_FILE_CRITICAL("DEBUG_TRAP REQUESTED AT: {}", __PRETTY_FUNCTION__)
+					LOG(critical, "DEBUG_TRAP REQUESTED AT: {}", __PRETTY_FUNCTION__)
 
-#endif
+			#endif
-#else /* !defined(LIGHT_DIST) */
+		#else /* !defined(LIGHT_DIST) */
-#ifdef _MSC_VER
+			#ifdef _MSC_VER
-#define LT_DEBUG_TRAP()                                                        \
+				#define LT_DEBUG_TRAP()                                              \
-  LT_ENGINE_CRITICAL("DEBUG_TRAP REQUESTED AT: {}, FILE: {}, LINE: {}",        \
+					LOG(critical, "DEBUG_TRAP REQUESTED AT: {}, FILE: {}, LINE: {}", \
 					    __FUNCSIG__, __FILE__, __LINE__) // or __FUNCSIG__
 
-#else
+			#else
-#define LT_DEBUG_TRAP()                                                        \
+				#define LT_DEBUG_TRAP() \
-  LT_ENGINE_CRITICAL("DEBUG_TRAP REQUESTED AT: {}", __PRETTY_FUNCTION__)
+					LOG(critical, "DEBUG_TRAP REQUESTED AT: {}", __PRETTY_FUNCTION__)
 
-#endif
+			#endif
-#endif
+		#endif
-#endif
+	#endif
 #endif

Engine/src/Engine/Core/Application.cpp

@@ -1,32 +1,23 @@
 #include "Application.h"
 
-#include "Window.h"
-
 #include "Debug/Instrumentor.h"
-
 #include "Events/Event.h"
-
 #include "Graphics/GraphicsContext.h"
-#include "Graphics/Renderer.h"
 #include "Graphics/RenderCommand.h"
-
+#include "Graphics/Renderer.h"
 #include "Layer/Layer.h"
-
 #include "Time/Timer.h"
-
 #include "UserInterface/UserInterface.h"
+#include "Window.h"
 
 namespace Light {
 
-	Application* Application::s_Context = nullptr;
+Application* Application::s_Context = nullptr;
 
-	Application::Application(std::string execName, std::vector<std::string> args)
+Application::Application(std::string execName, std::vector<std::string> args)
-		: m_Instrumentor(nullptr),
+    : m_Instrumentor(nullptr), m_LayerStack(nullptr), m_Input(nullptr), m_Window(nullptr)
-		  m_LayerStack(nullptr),
+{
-		  m_Input(nullptr),
+	ASSERT(!s_Context, "Repeated singleton construction");
-		  m_Window(nullptr)
-	{
-		LT_ENGINE_ASSERT(!s_Context, "Application::Application: repeated singleton construction");
 	s_Context = this;
 
 	m_Logger = Logger::Create();
@@ -41,18 +32,18 @@ namespace Light {
 	m_ResourceManager = ResourceManager::Create();
 
 	m_Window = Window::Create(std::bind(&Application::OnEvent, this, std::placeholders::_1));
-	}
+}
 
-	Application::~Application()
+Application::~Application()
-	{
+{
-		LT_ENGINE_TRACE("Application::~Application()");
+	LOG(trace, "Application::~Application()");
 	m_Instrumentor->EndSession(); // ProfileResults_Termination //
-	}
+}
 
-	void Application::GameLoop()
+void Application::GameLoop()
-	{
+{
 	// check
-		LT_ENGINE_ASSERT(!m_LayerStack->IsEmpty(), "Application::GameLoop(pre): LayerStack is empty");
+	ASSERT(!m_LayerStack->IsEmpty(), "LayerStack is empty");
 
 	// log debug data
 	m_Logger->LogDebugData();
@@ -111,21 +102,21 @@ namespace Light {
 
 	m_Instrumentor->EndSession(); // ProfileResults_GameLoop //
 	m_Instrumentor->BeginSession("Logs/ProfileResults_Termination.json");
-	}
+}
 
-	void Application::Quit() 
+void Application::Quit()
-	{
+{
 	s_Context->m_Window->Close();
-	}
+}
 
-	void Application::OnEvent(const Event& event)
+void Application::OnEvent(const Event& event)
-	{
+{
 	// window
 	if (event.HasCategory(WindowEventCategory))
 	{
 		m_Window->OnEvent(event);
 
-			if(event.GetEventType() == EventType::WindowResized)
+		if (event.GetEventType() == EventType::WindowResized)
 			m_Window->GetGfxContext()->GetRenderer()->OnWindowResize((const WindowResizedEvent&)event);
 	}
 
@@ -134,23 +125,24 @@ namespace Light {
 	{
 		m_Input->OnEvent(event);
 
-			if(!m_Input->IsReceivingGameEvents()) // return if the event is an input event and 'Input' has disabled the game events
+		if (!m_Input->IsReceivingGameEvents()) // return if the event is an input event and 'Input' has disabled the game events
 			return;
 	}
 
 	/* layers */
 	for (auto it = m_LayerStack->rbegin(); it != m_LayerStack->rend(); it++)
-			if ((*it)->OnEvent(event)) return;
+		if ((*it)->OnEvent(event))
-	}
+			return;
-
-	void Application::LogDebugData()
-	{
-		// #todo: log more information
-		LT_ENGINE_INFO("________________________________________");
-		LT_ENGINE_INFO("Platform::");
-		LT_ENGINE_INFO("        OS: {}", LT_BUILD_PLATFORM);
-		LT_ENGINE_INFO("       DIR: {}", std::filesystem::current_path().generic_string());
-		LT_ENGINE_INFO("________________________________________");
-	}
-
 }
+
+void Application::LogDebugData()
+{
+	// #todo: log more information
+	LOG(info, "________________________________________");
+	LOG(info, "Platform::");
+	LOG(info, "        OS: {}", LT_BUILD_PLATFORM);
+	LOG(info, "       DIR: {}", std::filesystem::current_path().generic_string());
+	LOG(info, "________________________________________");
+}
+
+} // namespace Light

Engine/src/Engine/Debug/Exceptions.cpp

@@ -10,37 +10,31 @@
 
 namespace Light {
 
-	FailedEngineAssertion::FailedEngineAssertion(const char* file, int line)
+FailedAssertion::FailedAssertion(const char* file, int line)
-	{
+{
-		LT_ENGINE_CRITICAL("FailedAssertion::FailedAssertion: engine assertion failed in: {} (line {})", file, line);
+	LOG(critical, "Assertion failed in: {} (line {})", file, line);
-	}
+}
 
-	FailedClientAssertion::FailedClientAssertion(const char* file, int line)
+glException::glException(unsigned int source, unsigned int type, unsigned int id, const char* msg)
-	{
+{
-		LT_ENGINE_CRITICAL("FailedClientAssertion::FailedClientAssertion: client assertion failed in: {} (line {})", file, line);
-	}
-
-	glException::glException(unsigned int source, unsigned int type, unsigned int id, const char* msg)
-	{
 	// #todo: improve
-		LT_ENGINE_CRITICAL("________________________________________");
+	LOG(critical, "________________________________________");
-		LT_ENGINE_CRITICAL("glException::glException::");
+	LOG(critical, "glException::glException::");
-		LT_ENGINE_CRITICAL("        Severity: {}", Stringifier::glDebugMsgSeverity(GL_DEBUG_SEVERITY_HIGH));
+	LOG(critical, "        Severity: {}", Stringifier::glDebugMsgSeverity(GL_DEBUG_SEVERITY_HIGH));
-		LT_ENGINE_CRITICAL("        Source  : {}", Stringifier::glDebugMsgSource(source));
+	LOG(critical, "        Source  : {}", Stringifier::glDebugMsgSource(source));
-		LT_ENGINE_CRITICAL("        Type    : {}", Stringifier::glDebugMsgType(type));
+	LOG(critical, "        Type    : {}", Stringifier::glDebugMsgType(type));
-		LT_ENGINE_CRITICAL("        ID      : {}", id);
+	LOG(critical, "        ID      : {}", id);
-		LT_ENGINE_CRITICAL("        Vendor  : {}", glGetString(GL_VENDOR));
+	LOG(critical, "        Vendor  : {}", glGetString(GL_VENDOR));
-		LT_ENGINE_CRITICAL("        Renderer: {}", glGetString(GL_RENDERER));
+	LOG(critical, "        Renderer: {}", glGetString(GL_RENDERER));
-		LT_ENGINE_CRITICAL("        Version : {}", glGetString(GL_VERSION));
+	LOG(critical, "        Version : {}", glGetString(GL_VERSION));
-		LT_ENGINE_CRITICAL("        SVersion: {}", glGetString(GL_SHADING_LANGUAGE_VERSION));
+	LOG(critical, "        critical, SVersion: {}", glGetString(GL_SHADING_LANGUAGE_VERSION));
-		LT_ENGINE_CRITICAL("        {}", msg);
+	LOG(critical, "        {}", msg);
-
+	LOG(critical, "________________________________________");
-		LT_ENGINE_CRITICAL("________________________________________");
+}
-	}
 
 #ifdef LIGHT_PLATFORM_WINDOWS
-	dxException::dxException(long hr, const char* file, int line)
+dxException::dxException(long hr, const char* file, int line)
-	{
+{
 	char* message;
 	FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
 	               nullptr, hr,
@@ -48,14 +42,14 @@ namespace Light {
 	               (LPSTR)(&message), NULL, nullptr);
 
 	// #todo: improve
-		LT_ENGINE_CRITICAL("________________________________________");
+	LOG(critical, "________________________________________");
-		LT_ENGINE_CRITICAL("dxException::dxException::");
+	LOG(critical, "dxException::dxException::");
-		LT_ENGINE_CRITICAL("        File: {}, Line: {}", file, line);
+	LOG(critical, "        File: {}, Line: {}", file, line);
-		LT_ENGINE_CRITICAL("        {}", message);
+	LOG(critical, "        {}", message);
-		LT_ENGINE_CRITICAL("________________________________________");
+	LOG(critical, "________________________________________");
 
 	LocalFree(message);
-	}
+}
 #endif
 
-}
+} // namespace Light

Engine/src/Engine/Debug/Exceptions.h

@@ -1,33 +1,33 @@
 #pragma once
 
 #define DXC(x) DXC_NO_REDIFINITION(x, __LINE__)
+
 #define DXC_NO_REDIFINITION(x, line) DXC_NO_REDIFINITION2(x, line)
-#define DXC_NO_REDIFINITION2(x, line) HRESULT hr##line; if(FAILED(hr##line = x)) throw dxException(hr##line, __FILE__, line)
+
+#define DXC_NO_REDIFINITION2(x, line) \
+	HRESULT hr##line;                 \
+	if (FAILED(hr##line = x))         \
+	throw dxException(hr##line, __FILE__, line)
 
 namespace Light {
 
-	struct FailedEngineAssertion : std::exception
+struct FailedAssertion: std::exception
-	{
+{
-		FailedEngineAssertion(const char* file, int line);
+	FailedAssertion(const char* file, int line);
-	};
+};
 
-	struct FailedClientAssertion : std::exception
+// OpenGL
-	{
+struct glException: std::exception
-		FailedClientAssertion(const char* file, int line);
+{
-	};
-
-	// OpenGL
-	struct glException : std::exception
-	{
 	glException(unsigned int source, unsigned int type, unsigned int id, const char* msg);
-	};
+};
 
 #ifdef LIGHT_PLATFORM_WINDOWS
-	// DirectX
+// DirectX
-	struct dxException : std::exception
+struct dxException: std::exception
-	{
+{
 	dxException(long hr, const char* file, int line);
-	};
+};
 #endif
 
-}
+} // namespace Light

Engine/src/Engine/Debug/Instrumentor.cpp

@@ -2,43 +2,43 @@
 
 namespace Light {
 
-	Instrumentor* Instrumentor::s_Context = nullptr;
+Instrumentor* Instrumentor::s_Context = nullptr;
 
-	Scope<Instrumentor> Instrumentor::Create()
+Scope<Instrumentor> Instrumentor::Create()
-	{
+{
 	return MakeScope<Instrumentor>(new Instrumentor);
-	}
+}
 
-	Instrumentor::Instrumentor()
+Instrumentor::Instrumentor()
     : m_CurrentSessionCount(0u)
-	{
+{
 	// #todo: maintenance
-		LT_ENGINE_ASSERT(!s_Context, "Instrumentor::Instrumentor: an instance of 'Instrumentor' already exists, do not construct this class!");
+	ASSERT(!s_Context, "An instance of 'Instrumentor' already exists, do not construct this class!");
 	s_Context = this;
-	}
+}
 
-	void Instrumentor::BeginSessionImpl(const std::string& outputPath)
+void Instrumentor::BeginSessionImpl(const std::string& outputPath)
-	{
+{
 	std::filesystem::create_directory(outputPath.substr(0, outputPath.find_last_of('/') + 1));
 
 	m_OutputFileStream.open(outputPath);
 	m_OutputFileStream << "{\"traceEvents\":[";
-	}
+}
 
-	void Instrumentor::EndSessionImpl()
+void Instrumentor::EndSessionImpl()
-	{
+{
 	if (m_CurrentSessionCount == 0u)
-			LT_ENGINE_WARN("Instrumentor::EndSessionImpl: 0 profiling for the ended session");
+		LOG(warn, "0 profiling for the ended session");
 
 	m_CurrentSessionCount = 0u;
 
 	m_OutputFileStream << "]}";
 	m_OutputFileStream.flush();
 	m_OutputFileStream.close();
-	}
+}
 
-	void Instrumentor::SubmitScopeProfileImpl(const ScopeProfileResult& profileResult)
+void Instrumentor::SubmitScopeProfileImpl(const ScopeProfileResult& profileResult)
-	{
+{
 	if (m_CurrentSessionCount++ == 0u)
 		m_OutputFileStream << "{";
 	else
@@ -50,23 +50,23 @@ namespace Light {
 	m_OutputFileStream << "\"ts\":" << profileResult.start << ",";
 	m_OutputFileStream << "\"dur\":" << profileResult.duration << ",";
 	m_OutputFileStream << "\"pid\":0,";
-		m_OutputFileStream << "\"tid\":" << profileResult.threadID<< "";
+	m_OutputFileStream << "\"tid\":" << profileResult.threadID << "";
 	m_OutputFileStream << "}";
-	}
+}
 
-	InstrumentorTimer::InstrumentorTimer(const std::string& scopeName)
+InstrumentorTimer::InstrumentorTimer(const std::string& scopeName)
-		: m_Result( { scopeName, 0, 0, 0 } ), m_Start(std::chrono::steady_clock::now())
+    : m_Result({ scopeName, 0, 0, 0 }), m_Start(std::chrono::steady_clock::now())
-	{
+{
-	}
+}
 
-	InstrumentorTimer::~InstrumentorTimer()
+InstrumentorTimer::~InstrumentorTimer()
-	{
+{
 	auto end = std::chrono::steady_clock::now();
 
 	m_Result.start    = std::chrono::time_point_cast<std::chrono::microseconds>(m_Start).time_since_epoch().count();
 	m_Result.duration = std::chrono::time_point_cast<std::chrono::microseconds>(end).time_since_epoch().count() - m_Result.start;
 
 	Instrumentor::SubmitScopeProfile(m_Result);
-	}
-
 }
+
+} // namespace Light

Engine/src/Engine/Debug/Logger.cpp

@@ -1,37 +1,31 @@
 #include "Logger.h"
 
-#include <spdlog/sinks/stdout_color_sinks.h>
 #include <spdlog/sinks/basic_file_sink.h>
+#include <spdlog/sinks/stdout_color_sinks.h>
 
 namespace Light {
 
-	Logger* Logger::s_Context = nullptr;
+Logger* Logger::s_Context = nullptr;
 
-	Scope<Logger> Logger::Create()
+Scope<Logger> Logger::Create()
-	{
+{
 	return MakeScope<Logger>(new Logger());
-	}
+}
 
-	Logger::Logger()
+Logger::Logger()
-		: m_EngineLogger(nullptr),
+    : m_EngineLogger(nullptr), m_FileLogger(nullptr), m_LogFilePath(LT_LOG_FILE_LOCATION)
-		  m_ClientLogger(nullptr),
+{
-		  m_FileLogger(nullptr),
+	ASSERT(!s_Context, "An instance of 'Logger' already exists, do not construct this class!");
-		  m_LogFilePath(LT_LOG_FILE_LOCATION)
-	{
-		LT_ENGINE_ASSERT(!s_Context, "Logger::Logger: an instance of 'Logger' already exists, do not construct this class!");
 	s_Context = this;
 
 	// set spdlog pattern
-#if   defined(LIGHT_PLATFORM_WINDOWS)
-		spdlog::set_pattern("%^[%M:%S:%e] <%n>: %v%$");
-#elif defined(LIGHT_PLATFORM_LINUX)
-		spdlog::set_pattern("%^{%l} - [%M:%S:%e] <%n>: %v%$");
-#endif
 	// create loggers
+	spdlog::set_pattern("%^[%H:%M:%S]%g@%! ==> %v%$");
 #ifndef LIGHT_DIST
+	spdlog::set_pattern("%^[%H:%M:%S]%! ==> %v%$");
 	m_EngineLogger = spdlog::stdout_color_mt("Engine");
-		m_ClientLogger = spdlog::stdout_color_mt("Client");
 #endif
+
 	m_FileLogger = spdlog::basic_logger_mt("File", m_LogFilePath);
 	m_FileLogger->set_pattern("%^[%M:%S:%e] <%l>: %v%$");
 
@@ -39,22 +33,21 @@ namespace Light {
 #if defined(LIGHT_DEBUG)
 	m_EngineLogger->set_level(spdlog::level::trace);
 	m_ClientLogger->set_level(spdlog::level::trace);
-#elif defined (LIGHT_RELEASE)
+#elif defined(LIGHT_RELEASE)
 	s_EngineLogger->set_level(spdlog::level::info);
 	s_ClientLogger->set_level(spdlog::level::info);
 #endif
-	}
-
-	void Logger::LogDebugData()
-	{
-		// #todo: improve
-		LT_ENGINE_INFO("________________________________________");
-		LT_ENGINE_INFO("Logger::");
-		LT_ENGINE_INFO("        ClientLevel : {}", Stringifier::spdlogLevel(m_ClientLogger->level()));
-		LT_ENGINE_INFO("        EngineLevel : {}", Stringifier::spdlogLevel(m_EngineLogger->level()));
-		LT_ENGINE_INFO("        FileLevel   : {}", Stringifier::spdlogLevel(m_FileLogger->level()));
-		LT_ENGINE_INFO("        DefaultLevel: {}", Stringifier::spdlogLevel(spdlog::get_level()));
-		LT_ENGINE_INFO("________________________________________");
-	}
-
 }
+
+void Logger::LogDebugData()
+{
+	// #todo: improve
+	LOG(info, "________________________________________");
+	LOG(info, "Logger::");
+	LOG(info, "        EngineLevel : {}", Stringifier::spdlogLevel(m_EngineLogger->level()));
+	LOG(info, "        FileLevel   : {}", Stringifier::spdlogLevel(m_FileLogger->level()));
+	LOG(info, "        DefaultLevel: {}", Stringifier::spdlogLevel(spdlog::get_level()));
+	LOG(info, "________________________________________");
+}
+
+} // namespace Light

Engine/src/Engine/Debug/Logger.h

@@ -1,73 +1,43 @@
 #pragma once
 #ifndef LIGHT_LOGGER_H
-#define LIGHT_LOGGER_H
+	#define LIGHT_LOGGER_H
 
-#include "Base/Base.h"
+	#include "Base/Base.h"
 
-#include <spdlog/spdlog.h>
+	#include <spdlog/spdlog.h>
 
-// LOGGER MACROS //
+	#define LT_LOG_FILE_LOCATION "Logs/Logger.txt"
 
-#define LT_LOG_FILE_LOCATION "Logs/Logger.txt"
+	#ifndef LIGHT_DIST
-
+		#define LOG(logLevel, ...) SPDLOG_LOGGER_CALL(::Light::Logger::GetEngineLogger(), spdlog::level::logLevel, __VA_ARGS__)
-// File
+	#else
-#define LT_FILE_INFO(...)       ::Light::Logger::GetFileLogger()->log(spdlog::level::info    , __VA_ARGS__)
+		#define LOG(logLevel, ...) SPDLOG_LOGGER_CALL(::Light::Logger::GetFileLogger(), spdlog::level::logLevel, __VA_ARGS__)
-#define LT_FILE_WARN(...)       ::Light::Logger::GetFileLogger()->log(spdlog::level::warn    , __VA_ARGS__)
+	#endif
-#define LT_FILE_ERROR(...)      ::Light::Logger::GetFileLogger()->log(spdlog::level::err     , __VA_ARGS__)
-#define LT_FILE_CRITICAL(...)   ::Light::Logger::GetFileLogger()->log(spdlog::level::critical, __VA_ARGS__)
-
-#ifndef LIGHT_DIST
-	// Engine
-	#define LT_ENGINE_TRACE(...)    ::Light::Logger::GetEngineLogger()->log(spdlog::level::trace   , __VA_ARGS__)
-	#define LT_ENGINE_INFO(...)     ::Light::Logger::GetEngineLogger()->log(spdlog::level::info    , __VA_ARGS__)
-	#define LT_ENGINE_WARN(...)     ::Light::Logger::GetEngineLogger()->log(spdlog::level::warn    , __VA_ARGS__)
-	#define LT_ENGINE_ERROR(...)    ::Light::Logger::GetEngineLogger()->log(spdlog::level::err     , __VA_ARGS__)
-	#define LT_ENGINE_CRITICAL(...) ::Light::Logger::GetEngineLogger()->log(spdlog::level::critical, __VA_ARGS__)
-	
-	// Client
-	#define LT_CLIENT_TRACE(...)    ::Light::Logger::GetClientLogger()->log(spdlog::level::trace   , __VA_ARGS__)
-	#define LT_CLIENT_INFO(...)     ::Light::Logger::GetClientLogger()->log(spdlog::level::info    , __VA_ARGS__)
-	#define LT_CLIENT_WARN(...)     ::Light::Logger::GetClientLogger()->log(spdlog::level::warn    , __VA_ARGS__)
-	#define LT_CLIENT_ERROR(...)    ::Light::Logger::GetClientLogger()->log(spdlog::level::err     , __VA_ARGS__)
-	#define LT_CLIENT_CRITICAL(...) ::Light::Logger::GetClientLogger()->log(spdlog::level::critical, __VA_ARGS__)
-#else
-	#define LT_ENGINE_TRACE(...)
-	#define LT_ENGINE_INFO(...)
-	#define LT_ENGINE_WARN(...)
-	#define LT_ENGINE_ERROR(...)
-	#define LT_ENGINE_CRITICAL(...)
-	#define LT_CLIENT_TRACE(...)
-	#define LT_CLIENT_INFO(...)
-	#define LT_CLIENT_WARN(...)
-	#define LT_CLIENT_ERROR(...)
-	#define LT_CLIENT_CRITICAL(...)
-#endif
 
 namespace Light {
 
-	// #todo: extend
+// #todo: extend
-	class Logger /* singleton */
+class Logger /* singleton */
-	{
+{
-	private:
+private:
 	static Logger* s_Context;
 
-	private:
+private:
-		Ref<spdlog::logger> m_EngineLogger, m_ClientLogger, m_FileLogger;
+	Ref<spdlog::logger> m_EngineLogger, m_FileLogger;
 	std::string m_LogFilePath;
 
-	public:
+public:
 	static Scope<Logger> Create();
 
 	static inline Ref<spdlog::logger> GetEngineLogger() { return s_Context->m_EngineLogger; }
-		static inline Ref<spdlog::logger> GetClientLogger() { return s_Context->m_ClientLogger; }
 	static inline Ref<spdlog::logger> GetFileLogger() { return s_Context->m_FileLogger; }
 
 	void LogDebugData();
 
-	private:
+private:
 	Logger();
-	};
+};
 
-}
+} // namespace Light
 
 #endif

Engine/src/Engine/Graphics/Blender.cpp

@@ -1,4 +1,5 @@
 #include "Blender.h"
+
 #include "OpenGL/glBlender.h"
 
 #ifdef LIGHT_PLATFORM_WINDOWS
@@ -10,8 +11,8 @@
 
 namespace Light {
 
-	Scope<Blender> Blender::Create(Ref<SharedContext> sharedContext)
+Scope<Blender> Blender::Create(Ref<SharedContext> sharedContext)
-	{
+{
 	switch (GraphicsContext::GetGraphicsAPI())
 	{
 	case GraphicsAPI::OpenGL:
@@ -21,8 +22,8 @@ namespace Light {
 		return CreateScope<dxBlender>(std::static_pointer_cast<dxSharedContext>(sharedContext));)
 
 	default:
-			LT_ENGINE_ASSERT(false, "Blender::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
+		ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
 	}
-	}
-
 }
+
+} // namespace Light

Engine/src/Engine/Graphics/Buffers.cpp

@@ -1,6 +1,6 @@
 #include "Buffers.h"
-#include "OpenGL/glBuffers.h"
 
+#include "OpenGL/glBuffers.h"
 #include "SharedContext.h"
 
 #ifdef LIGHT_PLATFORM_WINDOWS
@@ -12,9 +12,9 @@
 
 namespace Light {
 
-	//================================================== CONSTANT_BUFFER ==================================================//
+//================================================== CONSTANT_BUFFER ==================================================//
-	Scope<ConstantBuffer> ConstantBuffer::Create(ConstantBufferIndex index, unsigned int size, Ref<SharedContext> sharedContext)
+Scope<ConstantBuffer> ConstantBuffer::Create(ConstantBufferIndex index, unsigned int size, Ref<SharedContext> sharedContext)
-	{
+{
 	switch (GraphicsContext::GetGraphicsAPI())
 	{
 	case GraphicsAPI::OpenGL:
@@ -24,15 +24,15 @@ namespace Light {
 		return CreateScope<dxConstantBuffer>(index, size, std::static_pointer_cast<dxSharedContext>(sharedContext));)
 
 	default:
-			LT_ENGINE_ASSERT(false, "ConstantBuffer::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
+		ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
 		return nullptr;
 	}
-	}
+}
-	//================================================== CONSTANT_BUFFER ==================================================//
+//================================================== CONSTANT_BUFFER ==================================================//
 
-	//================================================== VERTEX_BUFFER ==================================================//
+//================================================== VERTEX_BUFFER ==================================================//
-	Ref<VertexBuffer> VertexBuffer::Create(float* vertices, unsigned int stride, unsigned int count, Ref<SharedContext> sharedContext)
+Ref<VertexBuffer> VertexBuffer::Create(float* vertices, unsigned int stride, unsigned int count, Ref<SharedContext> sharedContext)
-	{
+{
 	switch (GraphicsContext::GetGraphicsAPI())
 	{
 	case GraphicsAPI::OpenGL:
@@ -42,15 +42,15 @@ namespace Light {
 		return CreateRef<dxVertexBuffer>(vertices, stride, count, std::static_pointer_cast<dxSharedContext>(sharedContext));)
 
 	default:
-			LT_ENGINE_ASSERT(false, "VertexBuffer::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
+		ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
 		return nullptr;
 	}
-	}
+}
-	//================================================== VERTEX_BUFFER ==================================================//
+//================================================== VERTEX_BUFFER ==================================================//
 
-	//======================================== INDEX_BUFFER ========================================//
+//======================================== INDEX_BUFFER ========================================//
-	Ref<IndexBuffer> IndexBuffer::Create(unsigned int* indices, unsigned int count, Ref<SharedContext> sharedContext)
+Ref<IndexBuffer> IndexBuffer::Create(unsigned int* indices, unsigned int count, Ref<SharedContext> sharedContext)
-	{
+{
 	switch (GraphicsContext::GetGraphicsAPI())
 	{
 	case GraphicsAPI::OpenGL:
@@ -60,10 +60,10 @@ namespace Light {
 		return CreateRef<dxIndexBuffer>(indices, count, std::dynamic_pointer_cast<dxSharedContext>(sharedContext));)
 
 	default:
-			LT_ENGINE_ASSERT(false, "IndexBuffer::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
+		ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
 		return nullptr;
 	}
-	}
-	//======================================== INDEX_BUFFER ========================================//
-
 }
+//======================================== INDEX_BUFFER ========================================//
+
+} // namespace Light

Engine/src/Engine/Graphics/Framebuffer.cpp

@@ -1,4 +1,5 @@
 #include "Framebuffer.h"
+
 #include "OpenGL/glFramebuffer.h"
 
 #ifdef LIGHT_PLATFORM_WINDOWS
@@ -10,8 +11,8 @@
 
 namespace Light {
 
-	Ref<Framebuffer> Framebuffer::Create(const FramebufferSpecification& specification, Ref<SharedContext> sharedContext)
+Ref<Framebuffer> Framebuffer::Create(const FramebufferSpecification& specification, Ref<SharedContext> sharedContext)
-	{
+{
 	switch (GraphicsContext::GetGraphicsAPI())
 	{
 	case GraphicsAPI::OpenGL:
@@ -21,9 +22,9 @@ namespace Light {
 		return CreateRef<dxFramebuffer>(specification, std::static_pointer_cast<dxSharedContext>(sharedContext));)
 
 	default:
-			LT_ENGINE_ASSERT(false, "Shader::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
+		ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
 		return nullptr;
 	}
-	}
-
 }
+
+} // namespace Light

Engine/src/Engine/Graphics/GraphicsContext.cpp

@@ -1,4 +1,5 @@
 #include "GraphicsContext.h"
+
 #include "OpenGL/glGraphicsContext.h"
 
 #ifdef LIGHT_PLATFORM_WINDOWS
@@ -8,23 +9,21 @@
 
 #include "Blender.h"                     // required for forward declaration
 #include "Buffers.h"                     // required for forward declaration
-#include "Renderer.h" // required for forward declaration
 #include "RenderCommand.h"               // required for forward declaration
-
+#include "Renderer.h"                    // required for forward declaration
 #include "UserInterface/UserInterface.h" // required for forward declaration
-
 #include "Utility/ResourceManager.h"     // required for forward declaration
 
 namespace Light {
 
-	GraphicsContext* GraphicsContext::s_Context = nullptr;
+GraphicsContext* GraphicsContext::s_Context = nullptr;
 
-	GraphicsContext::~GraphicsContext() 
+GraphicsContext::~GraphicsContext()
-	{
+{
-	}
+}
 
-	Scope<GraphicsContext> GraphicsContext::Create(GraphicsAPI api, GLFWwindow* windowHandle)
+Scope<GraphicsContext> GraphicsContext::Create(GraphicsAPI api, GLFWwindow* windowHandle)
-	{
+{
 	// terminate 'GraphicsContext' dependent classes
 	if (s_Context)
 	{
@@ -62,7 +61,7 @@ namespace Light {
 		break;)
 
 	default:
-			LT_ENGINE_ASSERT(false, "GraphicsContext::Create: invalid/unsupported 'GraphicsAPI' {}", Stringifier::GraphicsAPIToString(api));
+		ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", Stringifier::GraphicsAPIToString(api));
 		return nullptr;
 	}
 
@@ -71,10 +70,10 @@ namespace Light {
 	s_Context->m_Renderer      = Renderer::Create(windowHandle, s_Context->m_SharedContext);
 
 	// check
-		LT_ENGINE_ASSERT(s_Context->m_UserInterface, "GraphicsContext::Create: failed to create UserInterface");
+	ASSERT(s_Context->m_UserInterface, "Failed to create UserInterface");
-		LT_ENGINE_ASSERT(s_Context->m_Renderer, "GraphicsContext::Create: failed to create Renderer");
+	ASSERT(s_Context->m_Renderer, "Failed to create Renderer");
 
 	return std::move(scopeGfx);
-	}
-
 }
+
+} // namespace Light

Engine/src/Engine/Graphics/RenderCommand.cpp

@@ -1,4 +1,5 @@
 #include "RenderCommand.h"
+
 #include "OpenGL/glRenderCommand.h"
 
 #ifdef LIGHT_PLATFORM_WINDOWS
@@ -10,8 +11,8 @@
 
 namespace Light {
 
-	Scope<RenderCommand> RenderCommand::Create(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
+Scope<RenderCommand> RenderCommand::Create(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
-	{
+{
 	switch (GraphicsContext::GetGraphicsAPI())
 	{
 	case GraphicsAPI::OpenGL:
@@ -21,9 +22,9 @@ namespace Light {
 		return CreateScope<dxRenderCommand>((std::static_pointer_cast<dxSharedContext>)(sharedContext));)
 
 	default:
-			LT_ENGINE_ASSERT(false, "RenderCommand::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
+		ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
 		return nullptr;
 	}
-	}
-
 }
+
+} // namespace Light

Engine/src/Engine/Graphics/Renderer.cpp

@@ -19,7 +19,7 @@ Renderer* Renderer::s_Context = nullptr;
 Renderer::Renderer(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
     : m_QuadRenderer(LT_MAX_QUAD_RENDERER_VERTICES, sharedContext), m_TextureRenderer(LT_MAX_TEXTURE_RENDERER_VERTICES, sharedContext), m_TintedTextureRenderer(LT_MAX_TINTED_TEXTURE_RENDERER_VERTICES, sharedContext), m_ViewProjectionBuffer(nullptr), m_RenderCommand(nullptr), m_Blender(nullptr), m_DefaultFramebufferCamera(nullptr), m_TargetFramebuffer(nullptr), m_ShouldClearBackbuffer(false)
 {
-	LT_ENGINE_ASSERT(!s_Context, "Renderer::Renderer: an instance of 'Renderer' already exists, do not construct this class!");
+	ASSERT(!s_Context, "An instance of 'Renderer' already exists, do not construct this class!");
 	s_Context = this;
 
 	m_ViewProjectionBuffer = ConstantBuffer::Create(ConstantBufferIndex::ViewProjection, sizeof(glm::mat4), sharedContext);
@@ -87,7 +87,7 @@ void Renderer::DrawQuadImpl(const glm::mat4& transform, const glm::vec4& tint)
 	// advance
 	if (!m_QuadRenderer.Advance())
 	{
-		LT_ENGINE_WARN("Renderer::DrawQuadImpl: exceeded LT_MAX_QUAD_RENDERER_VERTICES: {}", LT_MAX_QUAD_RENDERER_VERTICES);
+		LOG(warn, "Exceeded LT_MAX_QUAD_RENDERER_VERTICES: {}", LT_MAX_QUAD_RENDERER_VERTICES);
 		FlushScene();
 	}
 }
@@ -97,7 +97,7 @@ void Renderer::DrawQuadImpl(const glm::mat4& transform, const glm::vec4& tint)
 void Renderer::DrawQuadImpl(const glm::mat4& transform, Ref<Texture> texture)
 {
 	// #todo: implement a proper binding
-	LT_ENGINE_ASSERT(texture, "Invalid texture passed to Renderer::DrawQuadImpl");
+	ASSERT(texture, "Texture passed to Renderer::DrawQuadImpl");
 	texture->Bind();
 
 	// locals
@@ -122,7 +122,7 @@ void Renderer::DrawQuadImpl(const glm::mat4& transform, Ref<Texture> texture)
 	// advance
 	if (!m_TextureRenderer.Advance())
 	{
-		LT_ENGINE_WARN("Renderer::DrawQuadImpl: exceeded LT_MAX_TEXTURE_RENDERER_VERTICES: {}", LT_MAX_TEXTURE_RENDERER_VERTICES);
+		LOG(warn, "Exceeded LT_MAX_TEXTURE_RENDERER_VERTICES: {}", LT_MAX_TEXTURE_RENDERER_VERTICES);
 		FlushScene();
 	}
 }
@@ -130,7 +130,7 @@ void Renderer::DrawQuadImpl(const glm::mat4& transform, Ref<Texture> texture)
 void Renderer::DrawQuadImpl(const glm::mat4& transform, const glm::vec4& tint, Ref<Texture> texture)
 {
 	// #todo: implement a proper binding
-	LT_ENGINE_ASSERT(texture, "Invalid texture passed to Renderer::DrawQuadImpl");
+	ASSERT(texture, "Texture passed to Renderer::DrawQuadImpl");
 	texture->Bind();
 
 	// locals
@@ -159,7 +159,7 @@ void Renderer::DrawQuadImpl(const glm::mat4& transform, const glm::vec4& tint, R
 	// advance
 	if (!m_TintedTextureRenderer.Advance())
 	{
-		LT_ENGINE_WARN("Renderer::DrawQuadImpl: exceeded LT_MAX_TEXTURE_RENDERER_VERTICES: {}", LT_MAX_TEXTURE_RENDERER_VERTICES);
+		LOG(warn, "Exceeded LT_MAX_TEXTURE_RENDERER_VERTICES: {}", LT_MAX_TEXTURE_RENDERER_VERTICES);
 		FlushScene();
 	}
 }

Engine/src/Engine/Graphics/RendererPrograms/QuadRendererProgram.cpp

@@ -1,67 +1,58 @@
 #include "QuadRendererProgram.h"
 
 #include "Camera/Camera.h"
-
-#include "Graphics/Shader.h"
 #include "Graphics/Buffers.h"
+#include "Graphics/Shader.h"
 #include "Graphics/VertexLayout.h"
-
 #include "Utility/ResourceManager.h"
 
 namespace Light {
 
-	QuadRendererProgram::QuadRendererProgram(unsigned int maxVertices, Ref<SharedContext> sharedContext)
+QuadRendererProgram::QuadRendererProgram(unsigned int maxVertices, Ref<SharedContext> sharedContext)
-		: m_Shader(nullptr),
+    : m_Shader(nullptr), m_IndexBuffer(nullptr), m_VertexLayout(nullptr), m_MapCurrent(nullptr), m_MapEnd(nullptr), m_QuadCount(0u), m_MaxVertices(maxVertices)
-		  m_IndexBuffer(nullptr),
+{
-		  m_VertexLayout(nullptr),
-		  m_MapCurrent(nullptr),
-		  m_MapEnd(nullptr),
-		  m_QuadCount(0u),
-		  m_MaxVertices(maxVertices)
-	{
 	// #todo: don't use relative path
 	ResourceManager::LoadShader("LT_ENGINE_RESOURCES_QUAD_SHADER", "Assets/Shaders/Quad/Quad_VS.glsl", "Assets/Shaders/Quad/Quad_PS.glsl");
 
 	m_Shader       = ResourceManager::GetShader("LT_ENGINE_RESOURCES_QUAD_SHADER");
 	m_VertexBuffer = Ref<VertexBuffer>(VertexBuffer::Create(nullptr, sizeof(QuadVertexData), maxVertices, sharedContext));
 	m_IndexBuffer  = Ref<IndexBuffer>(IndexBuffer::Create(nullptr, (maxVertices / 4) * 6, sharedContext));
-		m_VertexLayout = Ref<VertexLayout>(VertexLayout::Create(m_VertexBuffer, m_Shader, { { "POSITION", VertexElementType::Float4 },
+	m_VertexLayout = Ref<VertexLayout>(VertexLayout::Create(m_VertexBuffer, m_Shader, { { "POSITION", VertexElementType::Float4 }, { "COLOR", VertexElementType::Float4 } }, sharedContext));
-		                                                                                    { "COLOR"   , VertexElementType::Float4 }}, sharedContext));
+}
-	}
 
-	bool QuadRendererProgram::Advance()
+bool QuadRendererProgram::Advance()
-	{
+{
 	m_MapCurrent += 4;
 
 	if (m_MapCurrent >= m_MapEnd)
 	{
-			LT_ENGINE_WARN("QuadRendererProgram::Advance: 'VertexBuffer' map went beyond 'MaxVertices': {}", m_MaxVertices);
+		LOG(warn, "'VertexBuffer' map went beyond 'MaxVertices': {}", m_MaxVertices);
 		return false;
 	}
 
 	m_QuadCount++;
 	return true;
-	}
+}
 
-	void QuadRendererProgram::Map()
+void QuadRendererProgram::Map()
-	{
+{
 	m_QuadCount = 0u;
 
 	m_MapCurrent = (QuadRendererProgram::QuadVertexData*)m_VertexBuffer->Map();
 	m_MapEnd     = m_MapCurrent + m_MaxVertices;
-	}
+}
 
-	void QuadRendererProgram::UnMap()
+void QuadRendererProgram::UnMap()
-	{
+{
 	m_VertexBuffer->UnMap();
-	}
+}
 
-	void QuadRendererProgram::Bind()
+void QuadRendererProgram::Bind()
-	{
+{
 	m_Shader->Bind();
 	m_VertexLayout->Bind();
 	m_VertexBuffer->Bind();
 	m_IndexBuffer->Bind();
-	}
-
 }
+
+} // namespace Light

Engine/src/Engine/Graphics/RendererPrograms/TextureRendererProgram.cpp

@@ -1,66 +1,57 @@
 #include "TextureRendererProgram.h"
 
 #include "Camera/Camera.h"
-
-#include "Graphics/Shader.h"
 #include "Graphics/Buffers.h"
+#include "Graphics/Shader.h"
 #include "Graphics/VertexLayout.h"
-
 #include "Utility/ResourceManager.h"
 
 namespace Light {
 
-	TextureRendererProgram::TextureRendererProgram(unsigned int maxVertices, Ref<SharedContext> sharedContext)
+TextureRendererProgram::TextureRendererProgram(unsigned int maxVertices, Ref<SharedContext> sharedContext)
-		: m_Shader(nullptr),
+    : m_Shader(nullptr), m_IndexBuffer(nullptr), m_VertexLayout(nullptr), m_MapCurrent(nullptr), m_MapEnd(nullptr), m_QuadCount(0u), m_MaxVertices(maxVertices)
-		  m_IndexBuffer(nullptr),
+{
-		  m_VertexLayout(nullptr),
-		  m_MapCurrent(nullptr),
-		  m_MapEnd(nullptr),
-		  m_QuadCount(0u),
-		  m_MaxVertices(maxVertices)
-	{
 	// #todo: don't use relative path
 	ResourceManager::LoadShader("LT_ENGINE_RESOURCES_TEXTURE_SHADER", "Assets/Shaders/Texture/Texture_VS.glsl", "Assets/Shaders/Texture/Texture_PS.glsl");
 
 	m_Shader       = ResourceManager::GetShader("LT_ENGINE_RESOURCES_TEXTURE_SHADER");
 	m_VertexBuffer = Ref<VertexBuffer>(VertexBuffer::Create(nullptr, sizeof(TextureVertexData), maxVertices, sharedContext));
 	m_IndexBuffer  = Ref<IndexBuffer>(IndexBuffer::Create(nullptr, (maxVertices / 4) * 6, sharedContext));
-		m_VertexLayout = Ref<VertexLayout>(VertexLayout::Create(m_VertexBuffer, m_Shader, { { "POSITION", VertexElementType::Float4 },
+	m_VertexLayout = Ref<VertexLayout>(VertexLayout::Create(m_VertexBuffer, m_Shader, { { "POSITION", VertexElementType::Float4 }, { "TEXCOORD", VertexElementType::Float2 } }, sharedContext));
-		                                                                                    { "TEXCOORD", VertexElementType::Float2 }}, sharedContext));
+}
-	}
 
-	bool TextureRendererProgram::Advance()
+bool TextureRendererProgram::Advance()
-	{
+{
 	if (m_MapCurrent + 4 >= m_MapEnd)
 	{
-			LT_ENGINE_WARN("TextureRendererProgram::Advance: 'VertexBuffer' map went beyond 'MaxVertices': {}", m_MaxVertices);
+		LOG(warn, "'VertexBuffer' map went beyond 'MaxVertices': {}", m_MaxVertices);
 		return false;
 	}
 
 	m_MapCurrent += 4;
 	m_QuadCount++;
 	return true;
-	}
+}
 
-	void TextureRendererProgram::Map()
+void TextureRendererProgram::Map()
-	{
+{
 	m_QuadCount = 0u;
 
 	m_MapCurrent = (TextureRendererProgram::TextureVertexData*)m_VertexBuffer->Map();
 	m_MapEnd     = m_MapCurrent + m_MaxVertices;
-	}
+}
 
-	void TextureRendererProgram::UnMap()
+void TextureRendererProgram::UnMap()
-	{
+{
 	m_VertexBuffer->UnMap();
-	}
+}
 
-	void TextureRendererProgram::Bind()
+void TextureRendererProgram::Bind()
-	{
+{
 	m_Shader->Bind();
 	m_VertexLayout->Bind();
 	m_VertexBuffer->Bind();
 	m_IndexBuffer->Bind();
-	}
-
 }
+
+} // namespace Light

Engine/src/Engine/Graphics/RendererPrograms/TintedTextureRendererProgram.cpp

@@ -1,68 +1,58 @@
 #include "TintedTextureRendererProgram.h"
 
 #include "Camera/Camera.h"
-
-#include "Graphics/Shader.h"
 #include "Graphics/Buffers.h"
+#include "Graphics/Shader.h"
 #include "Graphics/VertexLayout.h"
-
 #include "Utility/ResourceManager.h"
 
 namespace Light {
 
-	TintedTextureRendererProgram::TintedTextureRendererProgram(unsigned int maxVertices, Ref<SharedContext> sharedContext)
+TintedTextureRendererProgram::TintedTextureRendererProgram(unsigned int maxVertices, Ref<SharedContext> sharedContext)
-		: m_Shader(nullptr),
+    : m_Shader(nullptr), m_IndexBuffer(nullptr), m_VertexLayout(nullptr), m_MapCurrent(nullptr), m_MapEnd(nullptr), m_QuadCount(0u), m_MaxVertices(maxVertices)
-		  m_IndexBuffer(nullptr),
+{
-		  m_VertexLayout(nullptr),
-		  m_MapCurrent(nullptr),
-		  m_MapEnd(nullptr),
-		  m_QuadCount(0u),
-		  m_MaxVertices(maxVertices)
-	{
 	// #todo: don't use relative path
 	ResourceManager::LoadShader("LT_ENGINE_RESOURCES_TINTED_TEXTURE_SHADER", "Assets/Shaders/TintedTexture/TintedTexture_VS.glsl", "Assets/Shaders/TintedTexture/TintedTexture_PS.glsl");
 
 	m_Shader       = ResourceManager::GetShader("LT_ENGINE_RESOURCES_TINTED_TEXTURE_SHADER");
 	m_VertexBuffer = Ref<VertexBuffer>(VertexBuffer::Create(nullptr, sizeof(TintedTextureVertexData), maxVertices, sharedContext));
 	m_IndexBuffer  = Ref<IndexBuffer>(IndexBuffer::Create(nullptr, (maxVertices / 4) * 6, sharedContext));
-		m_VertexLayout = Ref<VertexLayout>(VertexLayout::Create(m_VertexBuffer, m_Shader, { { "POSITION", VertexElementType::Float4 },
+	m_VertexLayout = Ref<VertexLayout>(VertexLayout::Create(m_VertexBuffer, m_Shader, { { "POSITION", VertexElementType::Float4 }, { "TINT", VertexElementType::Float4 }, { "TEXCOORD", VertexElementType::Float2 } }, sharedContext));
-		                                                                                    { "TINT"    , VertexElementType::Float4 },
+}
-		                                                                                    { "TEXCOORD", VertexElementType::Float2 }}, sharedContext));
-	}
 
-	bool TintedTextureRendererProgram::Advance()
+bool TintedTextureRendererProgram::Advance()
-	{
+{
 	m_MapCurrent += 4;
 
 	if (m_MapCurrent >= m_MapEnd)
 	{
-			LT_ENGINE_WARN("TintedTextureRendererProgram::Advance: 'VertexBuffer' map went beyond 'MaxVertices': {}", m_MaxVertices);
+		LOG(warn, "'VertexBuffer' map went beyond 'MaxVertices': {}", m_MaxVertices);
 		return false;
 	}
 
 	m_QuadCount++;
 	return true;
-	}
+}
 
-	void TintedTextureRendererProgram::Map()
+void TintedTextureRendererProgram::Map()
-	{
+{
 	m_QuadCount = 0u;
 
 	m_MapCurrent = (TintedTextureRendererProgram::TintedTextureVertexData*)m_VertexBuffer->Map();
 	m_MapEnd     = m_MapCurrent + m_MaxVertices;
-	}
+}
 
-	void TintedTextureRendererProgram::UnMap()
+void TintedTextureRendererProgram::UnMap()
-	{
+{
 	m_VertexBuffer->UnMap();
-	}
+}
 
-	void TintedTextureRendererProgram::Bind()
+void TintedTextureRendererProgram::Bind()
-	{
+{
 	m_Shader->Bind();
 	m_VertexLayout->Bind();
 	m_VertexBuffer->Bind();
 	m_IndexBuffer->Bind();
-	}
-
 }
+
+} // namespace Light

Engine/src/Engine/Graphics/Shader.cpp

@@ -1,4 +1,5 @@
 #include "Shader.h"
+
 #include "OpenGL/glShader.h"
 
 #ifdef LIGHT_PLATFORM_WINDOWS
@@ -10,8 +11,8 @@
 
 namespace Light {
 
-	Ref<Shader> Shader::Create(BasicFileHandle vertexFile, BasicFileHandle pixelFile, Ref<SharedContext> sharedContext)
+Ref<Shader> Shader::Create(BasicFileHandle vertexFile, BasicFileHandle pixelFile, Ref<SharedContext> sharedContext)
-	{
+{
 	// load shader source
 	switch (GraphicsContext::GetGraphicsAPI())
 	{
@@ -22,9 +23,9 @@ namespace Light {
 		return CreateRef<dxShader>(vertexFile, pixelFile, std::static_pointer_cast<dxSharedContext>(sharedContext));)
 
 	default:
-			LT_ENGINE_ASSERT(false, "Shader::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
+		ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
 		return nullptr;
 	}
-	}
-
 }
+
+} // namespace Light

Engine/src/Engine/Graphics/Texture.cpp

@@ -1,4 +1,5 @@
 #include "Texture.h"
+
 #include "OpenGL/glTexture.h"
 
 #ifdef LIGHT_PLATFORM_WINDOWS
@@ -10,8 +11,8 @@
 
 namespace Light {
 
-	Ref<Texture>Texture::Create(unsigned int width, unsigned int height, unsigned int components, unsigned char* pixels, Ref<SharedContext> sharedContext, const std::string& filePath)
+Ref<Texture> Texture::Create(unsigned int width, unsigned int height, unsigned int components, unsigned char* pixels, Ref<SharedContext> sharedContext, const std::string& filePath)
-	{
+{
 	switch (GraphicsContext::GetGraphicsAPI())
 	{
 	case GraphicsAPI::OpenGL:
@@ -21,14 +22,14 @@ namespace Light {
 		return CreateRef<dxTexture>(width, height, components, pixels, std::static_pointer_cast<dxSharedContext>(sharedContext), filePath);)
 
 	default:
-			LT_ENGINE_ASSERT(false, "Texture::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
+		ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
 		return nullptr;
 	}
-	}
-
-	Texture::Texture(const std::string& filePath):
-		m_FilePath(filePath)
-	{
-	}
-
 }
+
+Texture::Texture(const std::string& filePath)
+    : m_FilePath(filePath)
+{
+}
+
+} // namespace Light

Engine/src/Engine/Graphics/VertexLayout.cpp

@@ -1,4 +1,5 @@
 #include "VertexLayout.h"
+
 #include "OpenGL/glVertexLayout.h"
 
 #ifdef LIGHT_PLATFORM_WINDOWS
@@ -10,8 +11,8 @@
 
 namespace Light {
 
-	Ref<VertexLayout> VertexLayout::Create(Ref<VertexBuffer> vertexBuffer, Ref<Shader> shader, const std::vector<std::pair<std::string, VertexElementType>>& elements, Ref<SharedContext> sharedContext)
+Ref<VertexLayout> VertexLayout::Create(Ref<VertexBuffer> vertexBuffer, Ref<Shader> shader, const std::vector<std::pair<std::string, VertexElementType>>& elements, Ref<SharedContext> sharedContext)
-	{
+{
 	switch (GraphicsContext::GetGraphicsAPI())
 	{
 	case GraphicsAPI::OpenGL:
@@ -21,9 +22,9 @@ namespace Light {
 		return CreateRef<dxVertexLayout>(shader, elements, std::static_pointer_cast<dxSharedContext>(sharedContext));)
 
 	default:
-			LT_ENGINE_ASSERT(false, "VertexLayout::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
+		ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
 		return nullptr;
 	}
-	}
-
 }
+
+} // namespace Light

Engine/src/Engine/Input/Input.cpp

@@ -1,65 +1,58 @@
-#include "ltpch.h"
 #include "Input.h"
 
-#include "Events/Event.h"
 #include "Events/CharEvent.h"
-#include "Events/MouseEvents.h"
+#include "Events/Event.h"
 #include "Events/KeyboardEvents.h"
+#include "Events/MouseEvents.h"
+#include "Input/KeyCodes.h"
+#include "ltpch.h"
 
 #include <imgui.h>
 
-#include "Input/KeyCodes.h"
-
 namespace Light {
 
-	Input* Input::s_Context = nullptr;
+Input* Input::s_Context = nullptr;
 
-	Scope<Input> Input::Create()
+Scope<Input> Input::Create()
-	{
+{
 	return MakeScope(new Input);
-	}
+}
 
-	Input::Input()
+Input::Input()
-		: m_KeyboadKeys{},
+    : m_KeyboadKeys {}, m_MouseButtons {}, m_MousePosition {}, m_MouseDelta {}, m_MouseWheelDelta {}, m_UserInterfaceEvents(true), m_GameEvents(true)
-		  m_MouseButtons{},
+{
-		  m_MousePosition{},
+	ASSERT(!s_Context, "Input::Input: an instance of 'Input' already exists, do not construct this class!");
-		  m_MouseDelta{},
-		  m_MouseWheelDelta{},
-		  m_UserInterfaceEvents(true),
-		  m_GameEvents(true)
-	{
-		LT_ENGINE_ASSERT(!s_Context, "Input::Input: an instance of 'Input' already exists, do not construct this class!");
 	s_Context = this;
 
 	RestartInputState();
-	}
+}
 
-	void Input::ReceiveUserInterfaceEventsImpl(bool receive, bool toggle /* = false */)
+void Input::ReceiveUserInterfaceEventsImpl(bool receive, bool toggle /* = false */)
-	{
+{
 	m_UserInterfaceEvents = toggle ? !m_UserInterfaceEvents : receive;
-	}
+}
 
-	void Input::ReceieveGameEventsImpl(bool receive, bool toggle /*= false*/)
+void Input::ReceieveGameEventsImpl(bool receive, bool toggle /*= false*/)
-	{
+{
 	bool prev    = m_GameEvents;
 	m_GameEvents = toggle ? !m_UserInterfaceEvents : receive;
 
-		if(m_GameEvents != prev)
+	if (m_GameEvents != prev)
 		RestartInputState();
-	}
+}
 
-	void Input::RestartInputState()
+void Input::RestartInputState()
-	{
+{
 	m_KeyboadKeys.fill(false);
 	m_MouseButtons.fill(false);
 
 	m_MousePosition   = glm::vec2(0.0f);
 	m_MouseDelta      = glm::vec2(0.0f);
 	m_MouseWheelDelta = 0.0f;
-	}
+}
 
-	void Input::OnEvent(const Event& inputEvent)
+void Input::OnEvent(const Event& inputEvent)
-	{
+{
 	ImGuiIO& io = ImGui::GetIO();
 	switch (inputEvent.GetEventType())
 	{
@@ -74,7 +67,7 @@ namespace Light {
 			m_MousePosition = event.GetPosition();
 		}
 
-			if(m_UserInterfaceEvents)
+		if (m_UserInterfaceEvents)
 			io.MousePos = ImVec2(event.GetX(), event.GetY());
 
 		return;
@@ -83,7 +76,7 @@ namespace Light {
 	{
 		const ButtonPressedEvent& event = (const ButtonPressedEvent&)inputEvent;
 
-			if(m_GameEvents)
+		if (m_GameEvents)
 			m_MouseButtons[event.GetButton()] = true;
 
 		if (m_UserInterfaceEvents)
@@ -146,7 +139,7 @@ namespace Light {
 	}
 	case EventType::SetChar:
 	{
-			if(m_UserInterfaceEvents)
+		if (m_UserInterfaceEvents)
 		{
 			const SetCharEvent& event = (const SetCharEvent&)inputEvent;
 			io.AddInputCharacter(event.GetCharacter());
@@ -155,6 +148,6 @@ namespace Light {
 		return;
 	}
 	}
-	}
-
 }
+
+} // namespace Light

Engine/src/Engine/Layer/LayerStack.cpp

@@ -1,54 +1,51 @@
 #include "LayerStack.h"
 
-#include "Layer.h"
-
 #include "Events/Event.h"
-#include "Events/MouseEvents.h"
 #include "Events/KeyboardEvents.h"
+#include "Events/MouseEvents.h"
 #include "Events/WindowEvents.h"
+#include "Layer.h"
 
 namespace Light {
 
-	LayerStack* LayerStack::s_Context = nullptr;
+LayerStack* LayerStack::s_Context = nullptr;
 
-	Scope<LayerStack> LayerStack::Create()
+Scope<LayerStack> LayerStack::Create()
-	{
+{
 	return MakeScope<LayerStack>(new LayerStack());
-	}
+}
 
-	LayerStack::LayerStack()
+LayerStack::LayerStack()
-		: m_Layers{},
+    : m_Layers {}, m_Begin(), m_End()
-		  m_Begin(),
+{
-		  m_End()
+	ASSERT(!s_Context, "An instance of 'LayerStack' already exists, do not construct this class!")
-	{
-		LT_ENGINE_ASSERT(!s_Context, "LayerStack::LayerStack: an instance of 'LayerStack' already exists, do not construct this class!")
 	s_Context = this;
-	}
+}
 
-	LayerStack::~LayerStack()
+LayerStack::~LayerStack()
-	{
+{
 	for (Layer* layer : m_Layers)
 		delete layer;
-	}
+}
 
-	void LayerStack::AttachLayerImpl(Layer* layer)
+void LayerStack::AttachLayerImpl(Layer* layer)
-	{
+{
 	// #todo: handle attaching layer inside a for loop
 	m_Layers.push_back(layer);
 	m_Begin = m_Layers.begin();
 	m_End   = m_Layers.end();
 
-		LT_ENGINE_TRACE("LayerStack::PushLayer: Attached [{}]", layer->GetName());
+	LOG(trace, "Attached [{}]", layer->GetName());
-	}
+}
 
-	void LayerStack::DetachLayerImpl(Layer* layer)
+void LayerStack::DetachLayerImpl(Layer* layer)
-	{
+{
 	// #todo: handle detaching layer inside a for loop
 	m_Layers.erase(std::find(m_Layers.begin(), m_Layers.end(), layer));
 	m_Begin = m_Layers.begin();
 	m_End   = m_Layers.end();
 
-		LT_ENGINE_TRACE("LayerStack::PushLayer: Detached[{}]", layer->GetName());
+	LOG(trace, "Detached [{}]", layer->GetName());
-	}
-
 }
+
+} // namespace Light

Engine/src/Engine/Scene/Scene.cpp

@@ -2,29 +2,26 @@
 
 #include "Components.h"
 #include "Entity.h"
-
 #include "Graphics/Renderer.h"
 
 #include <glm/glm.hpp>
 
 namespace Light {
 
-	Scene::Scene()
+Scene::Scene()
     : m_Registry()
-	{
+{
-	}
+}
 
-	Scene::~Scene()
+Scene::~Scene()
-	{
+{
-	}
+}
 
-	void Scene::OnCreate()
+void Scene::OnCreate()
-	{
+{
 	/* native scripts */
 	{
-			m_Registry.view<NativeScriptComponent>().
+		m_Registry.view<NativeScriptComponent>().each([](NativeScriptComponent& nsc) {
-			each([](NativeScriptComponent& nsc) 
-			{
 			if (nsc.instance == nullptr)
 			{
 				nsc.instance = nsc.CreateInstance();
@@ -32,31 +29,26 @@ namespace Light {
 			}
 		});
 	}
-	}
+}
 
-	void Scene::OnUpdate(float deltaTime)
+void Scene::OnUpdate(float deltaTime)
-	{
+{
 	/* native scripts */
 	{
-			m_Registry.view<NativeScriptComponent>().
+		m_Registry.view<NativeScriptComponent>().each([=](NativeScriptComponent& nsc) {
-			each([=](NativeScriptComponent& nsc) 
-			{
 			nsc.instance->OnUpdate(deltaTime);
 		});
 	}
-	}
+}
 
-	void Scene::OnRender(const Ref<Framebuffer>& targetFrameBuffer /* = nullptr */)
+void Scene::OnRender(const Ref<Framebuffer>& targetFrameBuffer /* = nullptr */)
-	{
+{
 	Camera* sceneCamera = nullptr;
 	TransformComponent* sceneCameraTransform;
 
 	/* scene camera */
 	{
-			m_Registry.group(entt::get<TransformComponent, CameraComponent>).
+		m_Registry.group(entt::get<TransformComponent, CameraComponent>).each([&](TransformComponent& transformComp, CameraComponent& cameraComp) {
-			each([&](TransformComponent& transformComp, CameraComponent& cameraComp)
-			{
-
 			if (cameraComp.isPrimary)
 			{
 				sceneCamera          = &cameraComp.camera;
@@ -71,53 +63,48 @@ namespace Light {
 		{
 			Renderer::BeginScene(sceneCamera, *sceneCameraTransform, targetFrameBuffer);
 
-				m_Registry.group(entt::get<TransformComponent, SpriteRendererComponent>).
+			m_Registry.group(entt::get<TransformComponent, SpriteRendererComponent>).each([](TransformComponent& transformComp, SpriteRendererComponent& spriteRendererComp) {
-				each([](TransformComponent& transformComp, SpriteRendererComponent& spriteRendererComp)
-				{
 				Renderer::DrawQuad(transformComp, spriteRendererComp.tint, spriteRendererComp.texture);
 			});
 
 			Renderer::EndScene();
 		}
 	}
-	}
+}
 
-	Entity Scene::CreateEntity(const std::string& name, const TransformComponent& transform)
+Entity Scene::CreateEntity(const std::string& name, const TransformComponent& transform)
-	{
+{
 	return CreateEntityWithUUID(name, UUID(), transform);
-	}
+}
 
-	Entity Scene::GetEntityByTag(const std::string& tag)
+Entity Scene::GetEntityByTag(const std::string& tag)
-	{
+{
 	// TagComponent tagComp(tag);
 	// entt::entity entity = entt::to_entity(m_Registry, tagComp);
 	Entity entity;
 
-		m_Registry.view<TagComponent>().
+	m_Registry.view<TagComponent>().each([&](TagComponent& tagComp) {
-		each([&](TagComponent& tagComp) 
-		{
 		if (tagComp.tag == tag)
 			entity = Entity(entt::to_entity(m_Registry, tagComp), this);
 	});
 
 	if (entity.IsValid())
 		return entity;
-		else {
+	else
-			LT_ENGINE_ERROR("Scene::GetEntityByTag: failed to find entity by tag: {}", tag);
+	{
+		ASSERT("Scene::GetEntityByTag: failed to find entity by tag: {}", tag);
 		return Entity();
 	}
+}
 
-
+Entity Scene::CreateEntityWithUUID(const std::string& name, UUID uuid, const TransformComponent& transform)
-	}
+{
-
-	Entity Scene::CreateEntityWithUUID(const std::string& name, UUID uuid, const TransformComponent& transform)
-	{
 	Entity entity { m_Registry.create(), this };
 	entity.AddComponent<TagComponent>(name);
 	entity.AddComponent<TransformComponent>(transform);
 	entity.AddComponent<UUIDComponent>(uuid);
 
 	return entity;
-	}
-
 }
+
+} // namespace Light

Engine/src/Engine/UserInterface/UserInterface.cpp

@@ -1,4 +1,5 @@
 #include "UserInterface.h"
+
 #include "OpenGL/glUserInterface.h"
 
 #ifdef LIGHT_PLATFORM_WINDOWS
@@ -6,23 +7,21 @@
 	#include "DirectX/dxSharedContext.h"
 #endif
 
-#include "Events/Event.h"
 #include "Events/CharEvent.h"
-#include "Events/MouseEvents.h"
+#include "Events/Event.h"
 #include "Events/KeyboardEvents.h"
-
+#include "Events/MouseEvents.h"
 #include "Graphics/GraphicsContext.h"
-
 #include "Input/KeyCodes.h"
 
 #include <imgui.h>
 
 namespace Light {
 
-	UserInterface* UserInterface::s_Context = nullptr;
+UserInterface* UserInterface::s_Context = nullptr;
 
-	Scope<UserInterface> UserInterface::Create(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
+Scope<UserInterface> UserInterface::Create(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
-	{
+{
 	Scope<UserInterface> scopeUserInterface = nullptr;
 
 	switch (GraphicsContext::GetGraphicsAPI())
@@ -31,30 +30,31 @@ namespace Light {
 		scopeUserInterface = CreateScope<glUserInterface>();
 		break;
 
-		case GraphicsAPI::DirectX: LT_WIN(
+	case GraphicsAPI::DirectX:
+		LT_WIN(
 		    scopeUserInterface = CreateScope<dxUserInterface>();)
 		break;
 
 	default:
-			LT_ENGINE_ASSERT(false, "UserInterface::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
+		ASSERT(false, "UserInterface::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
 		return nullptr;
 	}
 
 	scopeUserInterface->Init(windowHandle, sharedContext);
 	return std::move(scopeUserInterface);
-	}
+}
 
-	UserInterface::UserInterface()
+UserInterface::UserInterface()
     : m_DockspaceFlags(ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoDocking | ImGuiWindowFlags_NoTitleBar |
                        ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-		                   ImGuiWindowFlags_NoBringToFrontOnFocus                   | ImGuiWindowFlags_NoNavFocus )
+                       ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus)
-	{
+{
-		LT_ENGINE_ASSERT(!s_Context, "UserInterface::UserInterface: an instance of 'UserInterface' already exists, do not construct this class!");
+	ASSERT(!s_Context, "UserInterface::UserInterface: an instance of 'UserInterface' already exists, do not construct this class!");
 	s_Context = this;
-	}
+}
 
-	void UserInterface::Init(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
+void UserInterface::Init(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
-	{
+{
 	// create context
 	IMGUI_CHECKVERSION();
 	ImGui::CreateContext();
@@ -108,10 +108,10 @@ namespace Light {
 	io.FontDefault = io.Fonts->AddFontFromFileTTF("Assets/Fonts/OpenSans/OpenSans-Regular.ttf", 18.0f);
 
 	SetDarkThemeColors();
-	}
+}
 
-	void UserInterface::DockspaceBegin()
+void UserInterface::DockspaceBegin()
-	{
+{
 	ImGuiViewport* viewport = ImGui::GetMainViewport();
 	ImGui::SetNextWindowPos(viewport->Pos);
 	ImGui::SetNextWindowSize(viewport->Size);
@@ -128,17 +128,17 @@ namespace Light {
 	style.WindowMinSize.x = 370.0f;
 	ImGui::DockSpace(ImGui::GetID("MyDockSpace"), ImVec2(0.0f, 0.0f), ImGuiDockNodeFlags_None | ImGuiWindowFlags_NoBackground);
 	style.WindowMinSize.x = minWinSizeX;
-	}
+}
 
-	void UserInterface::DockspaceEnd()
+void UserInterface::DockspaceEnd()
-	{
+{
 	ImGui::End();
-	}
+}
 
-	void UserInterface::SetDarkThemeColors()
+void UserInterface::SetDarkThemeColors()
-	{
+{
 	ImGuiStyle& style   = ImGui::GetStyle();
-		ImVec4 (&colors)[55] = style.Colors;
+	ImVec4(&colors)[55] = style.Colors;
 
 	style.WindowPadding = ImVec2(0.0f, 0.0f);
 
@@ -217,6 +217,6 @@ namespace Light {
 	colors[ImGuiCol_NavWindowingDimBg]     = ImVec4(0.80f, 0.80f, 0.80f, 0.20f);
 
 	colors[ImGuiCol_ModalWindowDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.35f);
-	}
-
 }
+
+} // namespace Light

Engine/src/Engine/Utility/FileManager.cpp

@@ -4,8 +4,8 @@
 
 namespace Light {
 
-	BasicFileHandle FileManager::ReadTextFile(const std::string& path)
+BasicFileHandle FileManager::ReadTextFile(const std::string& path)
-	{
+{
 	// parse path info
 	std::string name      = path.substr(0, path.find('.') + -1);
 	std::string extension = path.substr(path.find('.') + 1);
@@ -16,7 +16,7 @@ namespace Light {
 	// check
 	if (!file)
 	{
-			LT_ENGINE_WARN("FileManager::ReadTextFile: failed to load text file: {}", path);
+		LOG(warn, "Failed to load text file: {}", path);
 		file.close();
 		return NULL;
 	}
@@ -27,7 +27,7 @@ namespace Light {
 	file.seekg(0, std::ios::beg);
 
 	if (!size)
-			LT_ENGINE_WARN("FileManager::ReadTextFile: empty text file: {}", path);
+		LOG(warn, "Empty text file: {}", path);
 
 	// read file
 	uint8_t* data = new uint8_t[size];
@@ -35,10 +35,10 @@ namespace Light {
 
 	file.close();
 	return BasicFileHandle(data, size, path, name, extension);
-	}
+}
 
-	ImageFileHandle FileManager::ReadImageFile(const std::string& path, int32_t desiredComponents)
+ImageFileHandle FileManager::ReadImageFile(const std::string& path, int32_t desiredComponents)
-	{
+{
 	// parse path info
 	std::string name      = path.substr(0, path.find('.') + -1);
 	std::string extension = path.substr(path.find('.') + 1);
@@ -48,12 +48,12 @@ namespace Light {
 	uint8_t* pixels = stbi_load(path.c_str(), &width, &height, &fetchedComponents, desiredComponents);
 
 	// check
-		if(!pixels)
+	if (!pixels)
-			LT_ENGINE_WARN("FileManager::LoadImageFile: failed to load image file: <{}>", path);
+		LOG(warn, "Failed to load image file: <{}>", path);
 	else if (fetchedComponents != desiredComponents)
-			LT_ENGINE_WARN("FileManager::LoadImageFile: mismatch of fetched/desired components: <{}> ({}/{})", name + '.' + extension, fetchedComponents, desiredComponents);
+		LOG(warn, "Mismatch of fetched/desired components: <{}> ({}/{})", name + '.' + extension, fetchedComponents, desiredComponents);
 
 	return ImageFileHandle(pixels, width * height, path, name, extension, width, height, fetchedComponents, desiredComponents);
-	}
-
 }
+
+} // namespace Light

Engine/src/Engine/Utility/ResourceManager.cpp

@@ -1,42 +1,40 @@
 #include "ResourceManager.h"
 
 #include "FileManager.h"
-
 #include "Graphics/GraphicsContext.h"
 #include "Graphics/Shader.h"
 #include "Graphics/Texture.h"
 
 namespace Light {
 
-	ResourceManager* ResourceManager::s_Context = nullptr;
+ResourceManager* ResourceManager::s_Context = nullptr;
 
-	Scope<ResourceManager> ResourceManager::Create()
+Scope<ResourceManager> ResourceManager::Create()
-	{
+{
 	return MakeScope(new ResourceManager());
-	}
+}
 
-	ResourceManager::ResourceManager() :
+ResourceManager::ResourceManager()
-		m_Shaders{},
+    : m_Shaders {}, m_Textures {}
-		m_Textures{}
+{
-	{
+	ASSERT(!s_Context, "Repeated singleton construction");
-		LT_ENGINE_ASSERT(!s_Context, "ResourceManager::ResourceManager: repeated singleton construction");
 	s_Context = this;
-	}
+}
 
-	void ResourceManager::LoadShaderImpl(const std::string& name, const std::string& vertexPath, const std::string& pixelPath)
+void ResourceManager::LoadShaderImpl(const std::string& name, const std::string& vertexPath, const std::string& pixelPath)
-	{
+{
 	// check
-		LT_ENGINE_ASSERT(s_Context, "ResourceManager::LoadShaderImpl: uninitliazed singleton");
+	ASSERT(s_Context, "Uninitliazed singleton");
-		LT_ENGINE_ASSERT(!vertexPath.empty(), "ResourceManager::LoadShaderImpl: empty 'vertexPath'");
+	ASSERT(!vertexPath.empty(), "Empty 'vertexPath'");
-		LT_ENGINE_ASSERT(!pixelPath.empty(), "ResourceManager::LoadShaderImpl: empty 'pixelPath'");
+	ASSERT(!pixelPath.empty(), "Empty 'pixelPath'");
 
 	// load files
 	BasicFileHandle vertexFile = FileManager::ReadTextFile(vertexPath);
 	BasicFileHandle pixelFile  = FileManager::ReadTextFile(pixelPath);
 
 	// check
-		LT_ENGINE_ASSERT(vertexFile.IsValid(), "ResourceManager::LoadShaderImpl: failed to read vertex file: {}", vertexPath);
+	ASSERT(vertexFile.IsValid(), "Failed to read vertex file: {}", vertexPath);
-		LT_ENGINE_ASSERT(pixelFile.IsValid(), "ResourceManager::LoadShaderImpl: failed to read vertex file: {}", pixelPath);
+	ASSERT(pixelFile.IsValid(), "Failed to read vertex file: {}", pixelPath);
 
 	// create shader
 	m_Shaders[name] = Ref<Shader>(Shader::Create(vertexFile, pixelFile, GraphicsContext::GetSharedContext()));
@@ -44,11 +42,11 @@ namespace Light {
 	// free file
 	vertexFile.Release();
 	pixelFile.Release();
-	}
+}
 
-	void ResourceManager::LoadTextureImpl(const std::string& name, const std::string& path, unsigned int desiredComponents /* = 4u */)
+void ResourceManager::LoadTextureImpl(const std::string& name, const std::string& path, unsigned int desiredComponents /* = 4u */)
-	{
+{
-		LT_ENGINE_ASSERT(s_Context, "ResourceManager::LoadShaderImpl: uninitliazed singleton");
+	ASSERT(s_Context, "Uninitliazed singleton");
 
 	// load file
 	ImageFileHandle imgFile = FileManager::ReadImageFile(path, desiredComponents);
@@ -58,17 +56,17 @@ namespace Light {
 
 	// free file
 	imgFile.Release();
-	}
+}
 
-	void ResourceManager::ReleaseTextureImpl(const std::string& name)
+void ResourceManager::ReleaseTextureImpl(const std::string& name)
-	{
+{
 	if (!m_Textures[name])
 	{
-			LT_ENGINE_WARN("ResourceManager::ReleaseTextureImpl: failed to find texture named: {}", name);
+		LOG(warn, "Failed to find texture named: {}", name);
 		return;
 	}
 
 	m_Textures[name] = nullptr;
-	}
-
 }
+
+} // namespace Light

Engine/src/Engine/Utility/Serializer.cpp

@@ -1,17 +1,15 @@
 #include "Serializer.h"
 
-#include "Scene/Components.h"
-
 #include "Graphics/Texture.h"
-
+#include "Scene/Components.h"
 #include "Utility/ResourceManager.h"
 
 namespace YAML {
 
-	template<>
+template<>
-	struct convert<glm::vec3>
+struct convert<glm::vec3>
-	{
+{
-		static Node encode(const glm::vec3 & rhs)
+	static Node encode(const glm::vec3& rhs)
 	{
 		Node node;
 		node.push_back(rhs.x);
@@ -30,11 +28,11 @@ namespace YAML {
 		rhs.z = node[2].as<float>();
 		return true;
 	}
-	};
+};
 
-	template<>
+template<>
-	struct convert<glm::vec4>
+struct convert<glm::vec4>
-	{
+{
 	static Node encode(const glm::vec4& rhs)
 	{
 		Node node;
@@ -56,39 +54,38 @@ namespace YAML {
 		rhs.w = node[3].as<float>();
 		return true;
 	}
-	};
+};
-}
+} // namespace YAML
 
 namespace Light {
 
-	static YAML::Emitter& operator << (YAML::Emitter& out, const glm::vec3& v)
+static YAML::Emitter& operator<<(YAML::Emitter& out, const glm::vec3& v)
-	{
+{
 	out << YAML::Flow;
 	out << YAML::BeginSeq << v.x << v.y << v.z << YAML::EndSeq;
 	return out;
-	}
+}
 
-	static YAML::Emitter& operator << (YAML::Emitter& out, const glm::vec4& v)
+static YAML::Emitter& operator<<(YAML::Emitter& out, const glm::vec4& v)
-	{
+{
 	out << YAML::Flow;
 	out << YAML::BeginSeq << v.x << v.y << v.z << v.w << YAML::EndSeq;
 	return out;
-	}
+}
 
-	SceneSerializer::SceneSerializer(const Ref<Scene>& scene):
+SceneSerializer::SceneSerializer(const Ref<Scene>& scene)
-		m_Scene(scene)
+    : m_Scene(scene)
-	{
+{
-	}
+}
 
-	void SceneSerializer::Serialize(const std::string& filePath)
+void SceneSerializer::Serialize(const std::string& filePath)
-	{
+{
 	YAML::Emitter out;
 	out << YAML::BeginMap; // Scene
 	out << YAML::Key << "Scene" << YAML::Value << "Untitled";
 
 	out << YAML::Key << "Entities" << YAML::Value << YAML::BeginSeq;
-		m_Scene->m_Registry.each([&](auto entityID)
+	m_Scene->m_Registry.each([&](auto entityID) {
-		{
 		Entity entity = { entityID, m_Scene.get() };
 		if (!entity.IsValid())
 			return;
@@ -102,12 +99,12 @@ namespace Light {
 
 	std::ofstream fout(filePath);
 	if (!fout.is_open())
-			LT_ENGINE_ERROR("SceneSerializer::Serialize: failed to create fout at: {}", filePath);
+		LOG(trace, "Failed to create fout at: {}", filePath);
 	fout << out.c_str();
-	}
+}
 
-	bool SceneSerializer::Deserialize(const std::string& filePath)
+bool SceneSerializer::Deserialize(const std::string& filePath)
-	{
+{
 	std::ifstream stream(filePath);
 	std::stringstream ss;
 	ss << stream.rdbuf();
@@ -117,7 +114,7 @@ namespace Light {
 		return false;
 
 	std::string sceneName = data["Scene"].as<std::string>();
-		LT_ENGINE_TRACE("SceneSerializer::Deserialize: Deserializing scene: '{}'", sceneName);
+	LOG(trace, "Deserializing scene: '{}'", sceneName);
 
 	auto entities = data["Entities"];
 	if (entities)
@@ -136,12 +133,12 @@ namespace Light {
 			if (tagComponent)
 				name = tagComponent["Tag"].as<std::string>();
 
-				LT_ENGINE_TRACE("SceneSerializer::Deserialize: Deserialized entity '{}' : '{}'", uuid, name);
+			LOG(trace, "Deserialized entity '{}' : '{}'", uuid, name);
 
 			Entity deserializedEntity = m_Scene->CreateEntityWithUUID(name, uuid);
 
 			TagComponent gg = deserializedEntity.GetComponent<TagComponent>();
-				LT_ENGINE_TRACE(gg.tag);
+			LOG(trace, gg.tag);
 			auto transformComponent = entity["TransformComponent"];
 			if (transformComponent)
 			{
@@ -172,7 +169,7 @@ namespace Light {
 			/* #TEMPORARY SOLUTION# */
 
 			auto cameraComponent = entity["CameraComponent"];
-				if(cameraComponent)
+			if (cameraComponent)
 			{
 				auto& entityCameraComponent = deserializedEntity.AddComponent<CameraComponent>();
 
@@ -197,21 +194,21 @@ namespace Light {
 	}
 
 	return false;
-	}
+}
 
-	void SceneSerializer::SerializeBinary(const std::string& filePath)
+void SceneSerializer::SerializeBinary(const std::string& filePath)
-	{
+{
-		LT_ENGINE_ERROR("SceneSerializer::SerializeRuntime: NO_IMPLEMENT");
+	LOG(err, "NO_IMPLEMENT");
-	}
+}
 
-	bool SceneSerializer::DeserializeBinary(const std::string& filePath)
+bool SceneSerializer::DeserializeBinary(const std::string& filePath)
-	{
+{
-		LT_ENGINE_ERROR("SceneSerializer::DeserializeBinary: NO_IMPLEMENT");
+	LOG(err, "NO_IMPLEMENT");
 	return false;
-	}
+}
 
-	void SceneSerializer::SerializeEntity(YAML::Emitter& out, Entity entity)
+void SceneSerializer::SerializeEntity(YAML::Emitter& out, Entity entity)
-	{
+{
 	out << YAML::BeginMap;                                           // entity
 	out << YAML::Key << "Entity" << YAML::Value << entity.GetUUID(); // dummy uuid
 
@@ -280,6 +277,6 @@ namespace Light {
 		out << YAML::EndMap; // camera component
 	}
 	out << YAML::EndMap; // entity
-	}
-
 }
+
+} // namespace Light

Engine/src/Platform/GraphicsAPI/DirectX/dxBuffers.cpp

@@ -1,15 +1,13 @@
 #include "dxBuffers.h"
+
 #include "dxSharedContext.h"
 
 namespace Light {
 
-	//======================================== CONSTANT_BUFFER ========================================//
+//======================================== CONSTANT_BUFFER ========================================//
-	dxConstantBuffer::dxConstantBuffer(ConstantBufferIndex index, unsigned int size, Ref<dxSharedContext> sharedContext)
+dxConstantBuffer::dxConstantBuffer(ConstantBufferIndex index, unsigned int size, Ref<dxSharedContext> sharedContext)
-		: m_Context(sharedContext),
+    : m_Context(sharedContext), m_Buffer(nullptr), m_Map {}, m_Index(static_cast<int>(index))
-		  m_Buffer(nullptr),
+{
-		  m_Map{},
-		  m_Index(static_cast<int>(index))
-	{
 	D3D11_BUFFER_DESC bDesc = {};
 
 	bDesc.ByteWidth      = size;
@@ -20,33 +18,30 @@ namespace Light {
 	HRESULT hr;
 	DXC(m_Context->GetDevice()->CreateBuffer(&bDesc, nullptr, &m_Buffer));
 	m_Context->GetDeviceContext()->VSSetConstantBuffers(m_Index, 1u, m_Buffer.GetAddressOf());
-	}
+}
 
-	void dxConstantBuffer::Bind()
+void dxConstantBuffer::Bind()
-	{
+{
 	m_Context->GetDeviceContext()->VSSetConstantBuffers(m_Index, 1u, m_Buffer.GetAddressOf());
-	}
+}
 
-	void* dxConstantBuffer::Map()
+void* dxConstantBuffer::Map()
-	{
+{
 	m_Context->GetDeviceContext()->VSSetConstantBuffers(m_Index, 1u, m_Buffer.GetAddressOf());
 	m_Context->GetDeviceContext()->Map(m_Buffer.Get(), NULL, D3D11_MAP_WRITE_DISCARD, NULL, &m_Map);
 	return m_Map.pData;
-	}
+}
 
-	void dxConstantBuffer::UnMap()
+void dxConstantBuffer::UnMap()
-	{
+{
 	m_Context->GetDeviceContext()->Unmap(m_Buffer.Get(), NULL);
-	}
+}
-	//======================================== CONSTANT_BUFFER ========================================//
+//======================================== CONSTANT_BUFFER ========================================//
 
-	//================================================== VERTEX_BUFFER ==================================================//
+//================================================== VERTEX_BUFFER ==================================================//
-	dxVertexBuffer::dxVertexBuffer(float* vertices, unsigned int stride, unsigned int count, Ref<dxSharedContext> sharedContext)
+dxVertexBuffer::dxVertexBuffer(float* vertices, unsigned int stride, unsigned int count, Ref<dxSharedContext> sharedContext)
-		: m_Context(sharedContext),
+    : m_Context(sharedContext), m_Buffer(nullptr), m_Map {}, m_Stride(stride)
-		  m_Buffer(nullptr),
+{
-		  m_Map{},
-		  m_Stride(stride)
-	{
 	// buffer desc
 	D3D11_BUFFER_DESC bDesc = {};
 
@@ -60,44 +55,43 @@ namespace Light {
 	// create buffer
 	HRESULT hr;
 	DXC(m_Context->GetDevice()->CreateBuffer(&bDesc, nullptr, &m_Buffer));
-	}
+}
 
-	dxVertexBuffer::~dxVertexBuffer()
+dxVertexBuffer::~dxVertexBuffer()
-	{
+{
 	UnBind();
-	}
+}
 
-	void* dxVertexBuffer::Map()
+void* dxVertexBuffer::Map()
-	{
+{
 	m_Context->GetDeviceContext()->Map(m_Buffer.Get(), NULL, D3D11_MAP_WRITE_DISCARD, NULL, &m_Map);
 	return m_Map.pData;
-	}
+}
 
-	void dxVertexBuffer::UnMap()
+void dxVertexBuffer::UnMap()
-	{
+{
 	m_Context->GetDeviceContext()->Unmap(m_Buffer.Get(), NULL);
-	}
+}
 
-	void dxVertexBuffer::Bind()
+void dxVertexBuffer::Bind()
-	{
+{
 	static const unsigned int offset = 0u;
 	m_Context->GetDeviceContext()->IASetVertexBuffers(0u, 1u, m_Buffer.GetAddressOf(), &m_Stride, &offset);
-	}
+}
 
-	void dxVertexBuffer::UnBind()
+void dxVertexBuffer::UnBind()
-	{
+{
 	static const unsigned int offset = 0u;
 	static ID3D11Buffer* buffer      = nullptr;
 
 	m_Context->GetDeviceContext()->IASetVertexBuffers(0u, 1u, &buffer, &m_Stride, &offset);
-	}
+}
-	//================================================== VERTEX_BUFFER ==================================================//
+//================================================== VERTEX_BUFFER ==================================================//
 
-	//======================================== INDEX_BUFFER ========================================//
+//======================================== INDEX_BUFFER ========================================//
-	dxIndexBuffer::dxIndexBuffer(unsigned int* indices, unsigned int count, Ref<dxSharedContext> sharedContext)
+dxIndexBuffer::dxIndexBuffer(unsigned int* indices, unsigned int count, Ref<dxSharedContext> sharedContext)
-		: m_Context(sharedContext),
+    : m_Context(sharedContext), m_Buffer(nullptr)
-		  m_Buffer(nullptr)
+{
-	{
 	// generate indices if not provided
 	bool hasIndices = !!indices;
 	if (!hasIndices)
@@ -105,8 +99,8 @@ namespace Light {
 		// check
 		if (count % 6 != 0)
 		{
-				LT_ENGINE_WARN("dxIndexBuffer::dxIndexBuffer: 'indices' can only be null if count is multiple of 6");
+			LOG(warn, "'indices' can only be null if count is multiple of 6");
-				LT_ENGINE_WARN("dxIndexBuffer::dxIndexBuffer: adding {} to 'count' -> {}", (6 - (count % 6)), count + (6 - (count % 6)));
+			LOG(warn, "Adding {} to 'count' -> {}", (6 - (count % 6)), count + (6 - (count % 6)));
 			count = count + (6 - (count % 6));
 		}
 
@@ -146,25 +140,25 @@ namespace Light {
 	// delete indices
 	if (!hasIndices)
 		delete[] indices;
-	}
+}
 
-	dxIndexBuffer::~dxIndexBuffer()
+dxIndexBuffer::~dxIndexBuffer()
-	{
+{
 	UnBind();
-	}
+}
 
-	void dxIndexBuffer::Bind()
+void dxIndexBuffer::Bind()
-	{
+{
 	m_Context->GetDeviceContext()->IASetIndexBuffer(m_Buffer.Get(), DXGI_FORMAT_R32_UINT, 0u);
-	}
+}
 
-	void dxIndexBuffer::UnBind()
+void dxIndexBuffer::UnBind()
-	{
+{
 	static const unsigned int offset = 0u;
 	static ID3D11Buffer* buffer      = nullptr;
 
 	m_Context->GetDeviceContext()->IASetIndexBuffer(buffer, DXGI_FORMAT_R32_UINT, offset);
-	}
-	//======================================== INDEX_BUFFER ========================================//
-
 }
+//======================================== INDEX_BUFFER ========================================//
+
+} // namespace Light

Engine/src/Platform/GraphicsAPI/DirectX/dxFramebuffer.cpp

@@ -1,17 +1,12 @@
 #include "dxFramebuffer.h"
+
 #include "dxSharedContext.h"
 
 namespace Light {
 
-	dxFramebuffer::dxFramebuffer(const FramebufferSpecification& specification, Ref<dxSharedContext> sharedContext)
+dxFramebuffer::dxFramebuffer(const FramebufferSpecification& specification, Ref<dxSharedContext> sharedContext)
-		: m_Context(sharedContext),
+    : m_Context(sharedContext), m_Specification(specification), m_RenderTargetView(nullptr), m_ColorAttachment(nullptr), m_DepthStencilAttachment(nullptr), m_ShaderResourceView(nullptr), m_DepthStencilView(nullptr)
-		  m_Specification(specification),
+{
-		  m_RenderTargetView(nullptr),
-		  m_ColorAttachment(nullptr),
-		  m_DepthStencilAttachment(nullptr),
-		  m_ShaderResourceView(nullptr),
-		  m_DepthStencilView(nullptr)
-	{
 	HRESULT hr;
 
 	D3D11_TEXTURE2D_DESC t2dDesc = {};
@@ -40,10 +35,10 @@ namespace Light {
 	rtvDesc.ViewDimension                 = D3D11_RTV_DIMENSION_TEXTURE2D;
 	rtvDesc.Texture2D.MipSlice            = 0u;
 	DXC(m_Context->GetDevice()->CreateRenderTargetView(m_ColorAttachment.Get(), &rtvDesc, &m_RenderTargetView));
-	}
+}
 
-	void dxFramebuffer::BindAsTarget(const glm::vec4& clearColor)
+void dxFramebuffer::BindAsTarget(const glm::vec4& clearColor)
-	{
+{
 	FLOAT color[] = {
 		clearColor.r,
 		clearColor.g,
@@ -67,17 +62,17 @@ namespace Light {
 
 	// set viewport
 	m_Context->GetDeviceContext()->RSSetViewports(1u, &viewport);
-	}
+}
 
-	void dxFramebuffer::BindAsResource()
+void dxFramebuffer::BindAsResource()
-	{
+{
-		LT_ENGINE_ERROR("dxFramebuffer::BindAsResource: NO_IMPLEMENT");
+	LOG(err, "NO_IMPLEMENT");
-	}
+}
 
-	void dxFramebuffer::Resize(const glm::uvec2& size)
+void dxFramebuffer::Resize(const glm::uvec2& size)
-	{
+{
 	m_Specification.width  = std::clamp(size.x, 1u, 16384u);
-		m_Specification.height= std::clamp(size.y, 1u, 16384u);  
+	m_Specification.height = std::clamp(size.y, 1u, 16384u);
 
 	D3D11_TEXTURE2D_DESC textureDesc;
 	D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
@@ -94,6 +89,6 @@ namespace Light {
 	DXC(m_Context->GetDevice()->CreateTexture2D(&textureDesc, nullptr, &m_ColorAttachment));
 	DXC(m_Context->GetDevice()->CreateRenderTargetView(m_ColorAttachment.Get(), &rtvDesc, &m_RenderTargetView));
 	DXC(m_Context->GetDevice()->CreateShaderResourceView(m_ColorAttachment.Get(), &srvDesc, &m_ShaderResourceView));
-	}
-
 }
+
+} // namespace Light

Engine/src/Platform/GraphicsAPI/DirectX/dxGraphicsContext.cpp

@@ -1,16 +1,13 @@
 #include "dxGraphicsContext.h"
-#include "dxSharedContext.h"
 
 #include "Events/WindowEvents.h"
-
 #include "Graphics/Blender.h"            // required for forward declaration
 #include "Graphics/Buffers.h"            // required for forward declaration
-#include "Graphics/Renderer.h" // required for forward declaration
 #include "Graphics/RenderCommand.h"      // required for forward declaration
-
+#include "Graphics/Renderer.h"           // required for forward declaration
 #include "UserInterface/UserInterface.h" // required for forward declaration
-
 #include "Utility/ResourceManager.h"     // required for forward declaration
+#include "dxSharedContext.h"
 
 #define GLFW_EXPOSE_NATIVE_WIN32
 #include <glfw/glfw3.h>
@@ -18,10 +15,9 @@
 
 namespace Light {
 
-	dxGraphicsContext::dxGraphicsContext(GLFWwindow* windowHandle)
+dxGraphicsContext::dxGraphicsContext(GLFWwindow* windowHandle)
-		: m_WindowHandle(windowHandle),
+    : m_WindowHandle(windowHandle), m_DebugInterface(nullptr)
-		  m_DebugInterface(nullptr)
+{
-	{
 	// set 'GraphicsAPI';
 	m_GraphicsAPI = GraphicsAPI::DirectX;
 
@@ -31,10 +27,10 @@ namespace Light {
 	SetupDeviceAndSwapChain(windowHandle);
 	SetupRenderTargets();
 	SetupDebugInterface();
-	}
+}
 
-	void dxGraphicsContext::SetupDeviceAndSwapChain(GLFWwindow* windowHandle)
+void dxGraphicsContext::SetupDeviceAndSwapChain(GLFWwindow* windowHandle)
-	{
+{
 	Ref<dxSharedContext> context = std::static_pointer_cast<dxSharedContext>(m_SharedContext);
 
 	// swap chain desc
@@ -84,11 +80,10 @@ namespace Light {
 	                                  &context->GetDeviceRef(),
 	                                  nullptr,
 	                                  &context->GetDeviceContextRef()));
+}
 
-	}
+void dxGraphicsContext::SetupRenderTargets()
-
+{
-	void dxGraphicsContext::SetupRenderTargets()
-	{
 	Ref<dxSharedContext> context = std::static_pointer_cast<dxSharedContext>(m_SharedContext);
 
 	// set primitive topology
@@ -102,10 +97,10 @@ namespace Light {
 
 	// set render target view
 	context->GetDeviceContext()->OMSetRenderTargets(1u, context->GetRenderTargetView().GetAddressOf(), nullptr);
-	}
+}
 
-	void dxGraphicsContext::SetupDebugInterface()
+void dxGraphicsContext::SetupDebugInterface()
-	{
+{
 #ifdef LIGHT_DEBUG
 	Ref<dxSharedContext> context = std::static_pointer_cast<dxSharedContext>(m_SharedContext);
 
@@ -119,22 +114,21 @@ namespace Light {
 	infoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, true);
 	infoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, true);
 
-		D3D11_MESSAGE_ID hide[] =
+	D3D11_MESSAGE_ID hide[] = {
-		{
 		D3D11_MESSAGE_ID_UNKNOWN,
 		// #todo: add more messages here as needed
 	};
 
-		D3D11_INFO_QUEUE_FILTER filter = { };
+	D3D11_INFO_QUEUE_FILTER filter = {};
 	filter.DenyList.NumIDs         = _countof(hide);
 	filter.DenyList.pIDList        = hide;
 	infoQueue->AddStorageFilterEntries(&filter);
 	infoQueue->Release();
 #endif
-	}
+}
 
-	void dxGraphicsContext::LogDebugData()
+void dxGraphicsContext::LogDebugData()
-	{
+{
 	Ref<dxSharedContext> context = std::static_pointer_cast<dxSharedContext>(m_SharedContext);
 
 	// locals
@@ -157,10 +151,10 @@ namespace Light {
 	DXGIAdapter->Release();
 
 	// #todo: log more information
-		LT_ENGINE_INFO("________________________________________");
+	LOG(info, "________________________________________");
-		LT_ENGINE_INFO("dxGraphicsContext:");
+	LOG(info, "dxGraphicsContext:");
-		LT_ENGINE_INFO("        Renderer: {}", adapterDesc);
+	LOG(info, "        Renderer: {}", adapterDesc);
-		LT_ENGINE_INFO("________________________________________");
+	LOG(info, "________________________________________");
-	}
-
 }
+
+} // namespace Light

Engine/src/Platform/GraphicsAPI/DirectX/dxRenderCommand.cpp

@@ -1,53 +1,54 @@
 #include "dxRenderCommand.h"
+
 #include "dxSharedContext.h"
 
 namespace Light {
 
-	dxRenderCommand::dxRenderCommand(Ref<dxSharedContext> sharedContext)
+dxRenderCommand::dxRenderCommand(Ref<dxSharedContext> sharedContext)
     : m_Context(sharedContext)
-	{
+{
-	}
+}
 
-	void dxRenderCommand::SwapBuffers()
+void dxRenderCommand::SwapBuffers()
-	{
+{
 #ifdef LIGHT_DEBUG
 	HRESULT hr;
 	if (FAILED(hr = m_Context->GetSwapChain()->Present(1u, 0u)))
 	{
 		if (hr == DXGI_ERROR_DEVICE_REMOVED)
 		{
-				LT_ENGINE_CRITICAL("dxRenderCommand::SwapBuffers: DeviceRemoved:");
+			LOG(critical, "dxRenderCommand::SwapBuffers: DeviceRemoved:");
-				LT_ENGINE_CRITICAL("        {}", m_Context->GetDevice()->GetDeviceRemovedReason());
+			LOG(critical, "        {}", m_Context->GetDevice()->GetDeviceRemovedReason());
 			throw dxException(hr, __FILE__, __LINE__);
 		}
 	}
 #else
 	m_Context->GetSwapChain()->Present(0u, 0u);
 #endif
-	}
+}
 
-	void dxRenderCommand::ClearBackBuffer(const glm::vec4& clearColor)
+void dxRenderCommand::ClearBackBuffer(const glm::vec4& clearColor)
-	{
+{
 	m_Context->GetDeviceContext()->ClearRenderTargetView(m_Context->GetRenderTargetView().Get(), &clearColor[0]);
-	}
+}
 
-	void dxRenderCommand::Draw(unsigned int count)
+void dxRenderCommand::Draw(unsigned int count)
-	{
+{
 	m_Context->GetDeviceContext()->Draw(count, 0u);
-	}
+}
 
-	void dxRenderCommand::DrawIndexed(unsigned int count)
+void dxRenderCommand::DrawIndexed(unsigned int count)
-	{
+{
 	m_Context->GetDeviceContext()->DrawIndexed(count, 0u, 0u);
-	}
+}
 
-	void dxRenderCommand::DefaultTargetFramebuffer()
+void dxRenderCommand::DefaultTargetFramebuffer()
-	{
+{
 	m_Context->GetDeviceContext()->OMSetRenderTargets(1, m_Context->GetRenderTargetView().GetAddressOf(), nullptr);
-	}
+}
 
-	void dxRenderCommand::SetViewport(unsigned int x, unsigned int y, unsigned int width, unsigned int height)
+void dxRenderCommand::SetViewport(unsigned int x, unsigned int y, unsigned int width, unsigned int height)
-	{
+{
 	// #todo: maybe call this somewhere else??
 	SetResolution(width, height);
 
@@ -65,10 +66,10 @@ namespace Light {
 
 	// set viewport
 	m_Context->GetDeviceContext()->RSSetViewports(1u, &viewport);
-	}
+}
 
-	void dxRenderCommand::SetResolution(unsigned int width, unsigned int height)
+void dxRenderCommand::SetResolution(unsigned int width, unsigned int height)
-	{
+{
 	HRESULT hr;
 
 	// remove render target
@@ -86,6 +87,6 @@ namespace Light {
 
 	// set render target
 	m_Context->GetDeviceContext()->OMSetRenderTargets(1u, m_Context->GetRenderTargetView().GetAddressOf(), nullptr);
-	}
-
 }
+
+} // namespace Light

Engine/src/Platform/GraphicsAPI/DirectX/dxShader.cpp

@@ -1,16 +1,14 @@
 #include "dxShader.h"
+
 #include "dxSharedContext.h"
 
 #include <d3dcompiler.h>
 
 namespace Light {
 
-	dxShader::dxShader(BasicFileHandle vertexFile, BasicFileHandle pixelFile, Ref<dxSharedContext> sharedContext)
+dxShader::dxShader(BasicFileHandle vertexFile, BasicFileHandle pixelFile, Ref<dxSharedContext> sharedContext)
-		: m_Context(sharedContext),
+    : m_Context(sharedContext), m_VertexShader(nullptr), m_PixelShader(nullptr), m_VertexBlob(nullptr)
-		  m_VertexShader(nullptr),
+{
-		  m_PixelShader(nullptr),
-		  m_VertexBlob(nullptr)
-	{
 	Microsoft::WRL::ComPtr<ID3DBlob> ps = nullptr, vsErr = nullptr, psErr = nullptr;
 
 	// compile shaders (we don't use DXC here because if D3DCompile fails it throws a dxException without logging the vsErr/psErr
@@ -18,30 +16,30 @@ namespace Light {
 	D3DCompile(pixelFile.GetData(), pixelFile.GetSize(), NULL, nullptr, nullptr, "main", "ps_4_0", NULL, NULL, &ps, &psErr);
 
 	// check
-		LT_ENGINE_ASSERT(!vsErr.Get(), "dxShader::dxShader: vertex shader compile error: {}", (char*)vsErr->GetBufferPointer());
+	ASSERT(!vsErr.Get(), "Vertex shader compile error: {}", (char*)vsErr->GetBufferPointer());
-		LT_ENGINE_ASSERT(!psErr.Get(), "dxShader::dxShader: pixels shader compile error: {}", (char*)psErr->GetBufferPointer());
+	ASSERT(!psErr.Get(), "Pixels shader compile error: {}", (char*)psErr->GetBufferPointer());
 
 	// create shaders
 	HRESULT hr;
 	DXC(m_Context->GetDevice()->CreateVertexShader(m_VertexBlob->GetBufferPointer(), m_VertexBlob->GetBufferSize(), NULL, &m_VertexShader));
 	DXC(m_Context->GetDevice()->CreatePixelShader(ps->GetBufferPointer(), ps->GetBufferSize(), NULL, &m_PixelShader));
-	}
+}
 
-	dxShader::~dxShader()
+dxShader::~dxShader()
-	{
+{
 	UnBind();
-	}
+}
 
-	void dxShader::Bind()
+void dxShader::Bind()
-	{
+{
 	m_Context->GetDeviceContext()->VSSetShader(m_VertexShader.Get(), nullptr, 0u);
 	m_Context->GetDeviceContext()->PSSetShader(m_PixelShader.Get(), nullptr, 0u);
-	}
+}
 
-	void dxShader::UnBind()
+void dxShader::UnBind()
-	{
+{
 	m_Context->GetDeviceContext()->VSSetShader(nullptr, nullptr, 0u);
 	m_Context->GetDeviceContext()->PSSetShader(nullptr, nullptr, 0u);
-	}
-
 }
+
+} // namespace Light

Engine/src/Platform/GraphicsAPI/DirectX/dxUserInterface.cpp

@@ -1,29 +1,28 @@
 #include "dxUserInterface.h"
-#include "dxSharedContext.h"
 
 #include "Input/KeyCodes.h"
+#include "dxSharedContext.h"
 
 #define GLFW_EXPOSE_NATIVE_WIN32
+#include <backends/imgui_impl_dx11.h>
+#include <backends/imgui_impl_win32.h>
 #include <glfw/glfw3.h>
 #include <glfw/glfw3native.h>
-
 #include <imgui.h>
-#include <backends/imgui_impl_win32.h>
-#include <backends/imgui_impl_dx11.h>
 
 namespace Light {
 
-	void dxUserInterface::PlatformImplementation(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
+void dxUserInterface::PlatformImplementation(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
-	{
+{
 	ImGuiIO& io                  = ImGui::GetIO();
 	Ref<dxSharedContext> context = std::dynamic_pointer_cast<dxSharedContext>(sharedContext);
 
 	ImGui_ImplWin32_Init(glfwGetWin32Window(windowHandle));
 	ImGui_ImplDX11_Init(context->GetDevice().Get(), context->GetDeviceContext().Get());
-	}
+}
 
-	dxUserInterface::~dxUserInterface()
+dxUserInterface::~dxUserInterface()
-	{
+{
 	// #todo: handle this in a better way
 	ImGuiIO& io = ImGui::GetIO();
 
@@ -33,33 +32,33 @@ namespace Light {
 	ImGui_ImplDX11_Shutdown();
 	ImGui_ImplWin32_Shutdown();
 	ImGui::DestroyContext();
-	}
+}
 
-	void dxUserInterface::Begin()
+void dxUserInterface::Begin()
-	{
+{
 	ImGui_ImplDX11_NewFrame();
 	ImGui_ImplWin32_NewFrame();
 	ImGui::NewFrame();
-	}
+}
 
-	void dxUserInterface::End()
+void dxUserInterface::End()
-	{
+{
 	ImGui::Render();
 	ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
 
 	ImGui::UpdatePlatformWindows();
 	ImGui::RenderPlatformWindowsDefault();
-	}
-
-	void dxUserInterface::LogDebugData()
-	{
-		// #todo: improve
-		LT_ENGINE_INFO("________________________________________");
-		LT_ENGINE_INFO("UserInterface::");
-		LT_ENGINE_INFO("       API    : ImGui");
-		LT_ENGINE_INFO("       Version: {}", ImGui::GetVersion());
-		LT_ENGINE_INFO("  GraphicsAPI : DirectX");
-		LT_ENGINE_INFO("________________________________________");
-	}
-
 }
+
+void dxUserInterface::LogDebugData()
+{
+	// #todo: improve
+	LOG(info, "________________________________________");
+	LOG(info, "UserInterface::");
+	LOG(info, "       API    : ImGui");
+	LOG(info, "       Version: {}", ImGui::GetVersion());
+	LOG(info, "  GraphicsAPI : DirectX");
+	LOG(info, "________________________________________");
+}
+
+} // namespace Light

Engine/src/Platform/GraphicsAPI/DirectX/dxVertexLayout.cpp

@@ -1,14 +1,13 @@
 #include "dxVertexLayout.h"
-#include "dxSharedContext.h"
 
 #include "dxShader.h"
+#include "dxSharedContext.h"
 
 namespace Light {
 
-	dxVertexLayout::dxVertexLayout(Ref<Shader> shader, const std::vector<std::pair<std::string, VertexElementType>>& elements, Ref<dxSharedContext> sharedContext)
+dxVertexLayout::dxVertexLayout(Ref<Shader> shader, const std::vector<std::pair<std::string, VertexElementType>>& elements, Ref<dxSharedContext> sharedContext)
-		: m_Context(sharedContext),
+    : m_Context(sharedContext), m_InputLayout(nullptr)
-		  m_InputLayout(nullptr)
+{
-	{
 	// occupy space for input elements
 	std::vector<D3D11_INPUT_ELEMENT_DESC> inputElementsDesc;
 	inputElementsDesc.reserve(elements.size());
@@ -16,7 +15,7 @@ namespace Light {
 	// extract elements desc
 	for (const auto& element : elements)
 	{
-			inputElementsDesc.emplace_back(D3D11_INPUT_ELEMENT_DESC{ element.first.c_str(),
+		inputElementsDesc.emplace_back(D3D11_INPUT_ELEMENT_DESC { element.first.c_str(),
 		                                                          NULL,
 		                                                          GetDxgiFormat(element.second),
 		                                                          0u,
@@ -26,30 +25,30 @@ namespace Light {
 	}
 
 	Ref<dxShader> dxpShader = std::dynamic_pointer_cast<dxShader>(shader);
-		LT_ENGINE_ASSERT(dxpShader, "dxVertexLayout::dxVertexLayout: failed to cast 'Shader' to 'dxShader'");
+	ASSERT(dxpShader, "Failed to cast 'Shader' to 'dxShader'");
 
 	// create input layout (vertex layout)
 	HRESULT hr;
 	DXC(m_Context->GetDevice()->CreateInputLayout(&inputElementsDesc[0], inputElementsDesc.size(), dxpShader->GetVertexBlob().Get()->GetBufferPointer(), dxpShader->GetVertexBlob().Get()->GetBufferSize(), &m_InputLayout));
-	}
+}
 
-	dxVertexLayout::~dxVertexLayout()
+dxVertexLayout::~dxVertexLayout()
-	{
+{
 	UnBind();
-	}
+}
 
-	void dxVertexLayout::Bind()
+void dxVertexLayout::Bind()
-	{
+{
 	m_Context->GetDeviceContext()->IASetInputLayout(m_InputLayout.Get());
-	}
+}
 
-	void dxVertexLayout::UnBind()
+void dxVertexLayout::UnBind()
-	{
+{
 	m_Context->GetDeviceContext()->IASetInputLayout(nullptr);
-	}
+}
 
-	DXGI_FORMAT dxVertexLayout::GetDxgiFormat(VertexElementType type)
+DXGI_FORMAT dxVertexLayout::GetDxgiFormat(VertexElementType type)
-	{
+{
 	switch (type)
 	{
 	/* byte */
@@ -81,9 +80,9 @@ namespace Light {
 	case Light::VertexElementType::Float4: return DXGI_FORMAT_R32G32B32A32_FLOAT;
 
 	default:
-			LT_ENGINE_ASSERT(false, "dxVertexLayout::GetDxgiFormat: invalid 'VertexElementType'");
+		ASSERT(false, "Invalid 'VertexElementType'");
 		return DXGI_FORMAT_UNKNOWN;
 	}
-	}
-
 }
+
+} // namespace Light

Engine/src/Platform/GraphicsAPI/OpenGL/glBuffers.cpp

@@ -4,77 +4,76 @@
 
 namespace Light {
 
-	//==================== CONSTANT_BUFFER ====================//
+//==================== CONSTANT_BUFFER ====================//
-	glConstantBuffer::glConstantBuffer(ConstantBufferIndex index, unsigned int size)
+glConstantBuffer::glConstantBuffer(ConstantBufferIndex index, unsigned int size)
-		: m_BufferID(NULL),
+    : m_BufferID(NULL), m_Index(static_cast<int>(index))
-		  m_Index(static_cast<int>(index))
+{
-	{
 	glCreateBuffers(1, &m_BufferID);
 	glNamedBufferData(m_BufferID, size, nullptr, GL_DYNAMIC_DRAW);
 
 	Bind();
-	}
+}
 
-	glConstantBuffer::~glConstantBuffer()
+glConstantBuffer::~glConstantBuffer()
-	{
+{
 	glDeleteBuffers(1, &m_BufferID);
-	}
+}
 
-	void glConstantBuffer::Bind()
+void glConstantBuffer::Bind()
-	{
+{
 	glBindBufferBase(GL_UNIFORM_BUFFER, m_Index, m_BufferID);
-	}
+}
 
-	void* glConstantBuffer::Map()
+void* glConstantBuffer::Map()
-	{
+{
 	void* map = glMapNamedBuffer(m_BufferID, GL_WRITE_ONLY);
 	return map;
-	}
+}
 
-	void glConstantBuffer::UnMap()
+void glConstantBuffer::UnMap()
-	{
+{
 	glUnmapNamedBuffer(m_BufferID);
-	}
+}
-	//==================== CONSTANT_BUFFER ====================//
+//==================== CONSTANT_BUFFER ====================//
 
-	//==================== VERTEX_BUFFER ====================//
+//==================== VERTEX_BUFFER ====================//
-	glVertexBuffer::glVertexBuffer(float* vertices, unsigned int stride, unsigned int count)
+glVertexBuffer::glVertexBuffer(float* vertices, unsigned int stride, unsigned int count)
     : m_BufferID(NULL)
-	{
+{
 	glCreateBuffers(1, &m_BufferID);
 	glNamedBufferData(m_BufferID, stride * count, vertices, GL_DYNAMIC_DRAW);
-	}
+}
 
-	glVertexBuffer::~glVertexBuffer()
+glVertexBuffer::~glVertexBuffer()
-	{
+{
 	glDeleteBuffers(1, &m_BufferID);
-	}
+}
 
-	void glVertexBuffer::Bind()
+void glVertexBuffer::Bind()
-	{
+{
 	glBindBuffer(GL_ARRAY_BUFFER, m_BufferID);
-	}
+}
 
-	void glVertexBuffer::UnBind()
+void glVertexBuffer::UnBind()
-	{
+{
 	glBindBuffer(GL_ARRAY_BUFFER, NULL);
-	}
+}
 
-	void* glVertexBuffer::Map()
+void* glVertexBuffer::Map()
-	{
+{
 	return glMapNamedBuffer(m_BufferID, GL_WRITE_ONLY);
-	}
+}
 
-	void glVertexBuffer::UnMap()
+void glVertexBuffer::UnMap()
-	{
+{
 	glUnmapNamedBuffer(m_BufferID);
-	}
+}
-	//==================== VERTEX_BUFFER ====================//
+//==================== VERTEX_BUFFER ====================//
 
-	//==================== INDEX_BUFFER ====================//
+//==================== INDEX_BUFFER ====================//
-	glIndexBuffer::glIndexBuffer(unsigned int* indices, unsigned int count)
+glIndexBuffer::glIndexBuffer(unsigned int* indices, unsigned int count)
     : m_BufferID(NULL)
-	{
+{
 	// generate indices if not provided
 	bool hasIndices = !!indices;
 	if (!hasIndices)
@@ -82,8 +81,8 @@ namespace Light {
 		// check
 		if (count % 6 != 0)
 		{
-				LT_ENGINE_WARN("glIndexBuffer::dxIndexBuffer: 'indices' can only be null if count is multiple of 6");
+			LOG(warn, "'indices' can only be null if count is multiple of 6");
-				LT_ENGINE_WARN("glIndexBuffer::glIndexBuffer: adding {} to 'count' -> {}", (6 - (count % 6)), count + (6 - (count % 6)));
+			LOG(warn, "Adding {} to 'count' -> {}", (6 - (count % 6)), count + (6 - (count % 6)));
 			count = count + (6 - (count % 6));
 		}
 
@@ -111,22 +110,22 @@ namespace Light {
 	// delete indices
 	if (!hasIndices)
 		delete[] indices;
-	}
-
-	glIndexBuffer::~glIndexBuffer()
-	{
-		glDeleteBuffers(1, &m_BufferID);
-	}
-
-	void glIndexBuffer::Bind()
-	{
-		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_BufferID);
-	}
-
-	void glIndexBuffer::UnBind()
-	{
-		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, NULL);
-	}
-	//==================== INDEX_BUFFER ====================//
-
 }
+
+glIndexBuffer::~glIndexBuffer()
+{
+	glDeleteBuffers(1, &m_BufferID);
+}
+
+void glIndexBuffer::Bind()
+{
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_BufferID);
+}
+
+void glIndexBuffer::UnBind()
+{
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, NULL);
+}
+//==================== INDEX_BUFFER ====================//
+
+} // namespace Light

Engine/src/Platform/GraphicsAPI/OpenGL/glFramebuffer.cpp

@@ -1,44 +1,40 @@
 #include "glFramebuffer.h"
 
 #include <glad/glad.h>
-
 #include <glm/glm.hpp>
 
 namespace Light {
 
-	glFramebuffer::glFramebuffer(const FramebufferSpecification& specification)
+glFramebuffer::glFramebuffer(const FramebufferSpecification& specification)
-		: m_Specification(specification),
+    : m_Specification(specification), m_BufferID(NULL), m_ColorAttachmentID(NULL), m_DepthStencilAttachmentID(NULL)
-		  m_BufferID(NULL),
+{
-		  m_ColorAttachmentID(NULL),
-		  m_DepthStencilAttachmentID(NULL)
-	{
 	Resize({ specification.width, specification.height });
-	}
+}
 
-	glFramebuffer::~glFramebuffer()
+glFramebuffer::~glFramebuffer()
-	{
+{
 	glDeleteFramebuffers(1, &m_BufferID);
 	glDeleteTextures(1, &m_ColorAttachmentID);
 	// glDeleteTextures(1, &m_DepthStencilAttachmentID);
-	}
+}
 
-	void glFramebuffer::BindAsTarget(const glm::vec4& clearColor)
+void glFramebuffer::BindAsTarget(const glm::vec4& clearColor)
-	{
+{
 	// #todo: use viewport instead of default x=0, y=0
 	glBindFramebuffer(GL_FRAMEBUFFER, m_BufferID);
 	glViewport(0, 0, m_Specification.width, m_Specification.height);
 
 	glClearColor(clearColor.r, clearColor.g, clearColor.b, clearColor.a);
 	glClear(GL_COLOR_BUFFER_BIT);
-	}
+}
 
-	void glFramebuffer::BindAsResource()
+void glFramebuffer::BindAsResource()
-	{
+{
-		LT_ENGINE_ERROR("glFramebuffer::BindAsResource: NO_IMPLEMENT!");
+	LOG(err, "NO_IMPLEMENT!");
-	}
+}
 
-	void glFramebuffer::Resize(const glm::uvec2& size)
+void glFramebuffer::Resize(const glm::uvec2& size)
-	{
+{
 	if (m_BufferID)
 	{
 		glDeleteFramebuffers(1, &m_BufferID);
@@ -68,9 +64,9 @@ namespace Light {
 	//	// glTextureStorage2D(m_DepthStencilAttachmentID, 0, GL_DEPTH24_STENCIL8, m_Specification.width, m_Specification.height);
 	//	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_DepthStencilAttachmentID, 0);
 
-		LT_ENGINE_ASSERT((glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE), "glFramebuffer::Validate: framebuffer is incomplete");
+	ASSERT((glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE), "Framebuffer is incomplete");
 
 	glBindFramebuffer(GL_FRAMEBUFFER, 0);
-	}
-
 }
+
+} // namespace Light

Engine/src/Platform/GraphicsAPI/OpenGL/glGraphicsContext.cpp

@@ -1,24 +1,24 @@
 #include "glGraphicsContext.h"
 
 #include "Events/WindowEvents.h"
-
 #include "Graphics/Blender.h"            // required for forward declaration
 #include "Graphics/Buffers.h"            // required for forward declaration
-#include "Graphics/Renderer.h" // required for forward declaration
 #include "Graphics/RenderCommand.h"      // required for forward declaration
-
+#include "Graphics/Renderer.h"           // required for forward declaration
 #include "UserInterface/UserInterface.h" // required for forward declaration
-
 #include "Utility/ResourceManager.h"     // required for forward declaration
 
 #include <glad/glad.h>
-#include <GLFW/glfw3.h>
+
+#ifndef STOP_FUCKING_ORDERING_THESE_THE_WRONG_WAY_CLANG_FORMAT____
+	#include <GLFW/glfw3.h>
+#endif
 
 namespace Light {
 
-	glGraphicsContext::glGraphicsContext(GLFWwindow* windowHandle)
+glGraphicsContext::glGraphicsContext(GLFWwindow* windowHandle)
     : m_WindowHandle(windowHandle)
-	{
+{
 	// set 'GraphicsAPI'
 	m_GraphicsAPI = GraphicsAPI::OpenGL;
 
@@ -26,32 +26,31 @@ namespace Light {
 	glfwMakeContextCurrent(windowHandle);
 
 	// load opengl (glad)
-		LT_ENGINE_ASSERT(gladLoadGLLoader((GLADloadproc)glfwGetProcAddress), "glGraphicsContext::glGraphicsContext: failed to initialize opengl (glad)");
+	ASSERT(gladLoadGLLoader((GLADloadproc)glfwGetProcAddress), "Failed to initialize opengl (glad)");
 
 	SetDebugMessageCallback();
-	}
+}
 
-	void glGraphicsContext::LogDebugData()
+void glGraphicsContext::LogDebugData()
-	{
+{
 	// #todo: log more information
-		LT_ENGINE_INFO("________________________________________");
+	LOG(info, "________________________________________");
-		LT_ENGINE_INFO("GraphicsContext::");
+	LOG(info, "GraphicsContext::");
-		LT_ENGINE_INFO("        API     : OpenGL");
+	LOG(info, "        API     : OpenGL");
-		LT_ENGINE_INFO("        Version : {}", glGetString(GL_VERSION));
+	LOG(info, "        Version : {}", glGetString(GL_VERSION));
-		LT_ENGINE_INFO("        Renderer: {}", glGetString(GL_RENDERER));
+	LOG(info, "        Renderer: {}", glGetString(GL_RENDERER));
-		LT_ENGINE_INFO("________________________________________");
+	LOG(info, "________________________________________");
-	}
+}
 
-	void glGraphicsContext::SetDebugMessageCallback()
+void glGraphicsContext::SetDebugMessageCallback()
-	{
+{
 	// determine log level
 	// #todo: set filters from config.h
 #if defined(LIGHT_DEBUG)
 	glEnable(GL_DEBUG_OUTPUT);
-		glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr , GL_TRUE);
+	glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
 
-		GLuint ids[] =
+	GLuint ids[] = {
-		{
 		131185
 	};
 	glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_OTHER, GL_DONT_CARE, _countof(ids), ids, GL_FALSE);
@@ -68,33 +67,34 @@ namespace Light {
 	glDebugMessageCallback([](unsigned int source, unsigned int type,
 	                          unsigned int id, unsigned int severity,
 	                          int length, const char* message,
-		                          const void* userParam) 
+	                          const void* userParam) {
-		{
 		switch (severity)
 		{
 		case GL_DEBUG_SEVERITY_HIGH:
 			// throw glException(source, type, id, message);
 			return;
 
-			case GL_DEBUG_SEVERITY_MEDIUM: case  GL_DEBUG_SEVERITY_LOW:
+		case GL_DEBUG_SEVERITY_MEDIUM:
-				LT_ENGINE_WARN("glMessageCallback: Severity: {} :: Source: {} :: Type: {} :: ID: {}",
+		case GL_DEBUG_SEVERITY_LOW:
+			LOG(warn, "glMessageCallback: Severity: {} :: Source: {} :: Type: {} :: ID: {}",
 			    Stringifier::glDebugMsgSeverity(severity),
 			    Stringifier::glDebugMsgSource(source),
 			    Stringifier::glDebugMsgType(type),
 			    id);
-				LT_ENGINE_WARN("        {}", message);
+			LOG(warn, "      {}", message);
 			return;
 
 		case GL_DEBUG_SEVERITY_NOTIFICATION:
-				LT_ENGINE_TRACE("glMessageCallback: Severity: {} :: Source: {} :: Type: {} :: ID: {}",
+			LOG(trace, "Severity: {} :: Source: {} :: Type: {} :: ID: {}",
 			    Stringifier::glDebugMsgSeverity(severity),
 			    Stringifier::glDebugMsgSource(source),
 			    Stringifier::glDebugMsgType(type),
 			    id);
-				LT_ENGINE_TRACE("        {}", message);
+			LOG(trace, "        {}", message);
 			return;
 		}
-		}, nullptr);
+	},
-	}
+	                       nullptr);
-
 }
+
+} // namespace Light

Engine/src/Platform/GraphicsAPI/OpenGL/glShader.cpp

@@ -61,8 +61,8 @@ shaderc::SpvCompilationResult glShader::CompileGLSL(BasicFileHandle file, Shader
 	// log error
 	if (result.GetCompilationStatus() != shaderc_compilation_status_success)
 	{
-		LT_ENGINE_ERROR("Failed to compile {} shader at {}...", stage == Shader::Stage::VERTEX ? "vertex" : "pixel", file.GetPath());
+		LOG(err, "Failed to compile {} shader at {}...", stage == Shader::Stage::VERTEX ? "vertex" : "pixel", file.GetPath());
-		LT_ENGINE_ERROR("    {}", result.GetErrorMessage());
+		LOG(err, "    {}", result.GetErrorMessage());
 	}
 
 	return result;
@@ -92,7 +92,7 @@ unsigned int glShader::CompileShader(std::string source, Shader::Stage stage)
 		char* errorLog = (char*)alloca(logLength);
 		glGetShaderInfoLog(shader, logLength, &logLength, &errorLog[0]);
 
-		LT_ENGINE_ERROR("glShader::glShader: failed to compile {} shader:\n        {}", stage == Shader::Stage::VERTEX ? "Vertex" : "Pixel", errorLog);
+		LOG(err, "glShader::glShader: failed to compile {} shader:\n        {}", stage == Shader::Stage::VERTEX ? "Vertex" : "Pixel", errorLog);
 
 		return NULL;
 	}
@@ -107,7 +107,7 @@ unsigned int glShader::CompileShader(std::string source, Shader::Stage stage)
 			char* infoLog = (char*)alloca(logLength);
 			glGetShaderInfoLog(shader, logLength, &logLength, &infoLog[0]);
 
-			LT_ENGINE_WARN(infoLog);
+			LOG(warn, infoLog);
 		}
 	}
 #endif

Engine/src/Platform/GraphicsAPI/OpenGL/glTexture.cpp

@@ -30,7 +30,7 @@ glTexture::glTexture(unsigned int width, unsigned int height, unsigned int compo
                                                       NULL;
 
 	// check
-	LT_ENGINE_ASSERT(format, "glTexture::glTexture: invalid number of components: {}", components);
+	ASSERT(format, "Invalid number of components: {}", components);
 
 
 	// #todo: isn't there something like glTextureImage2D ???

Engine/src/Platform/GraphicsAPI/OpenGL/glUserInterface.cpp

@@ -3,23 +3,22 @@
 #include "Input/KeyCodes.h"
 
 #include <GLFW/glfw3.h>
-
-#include <imgui.h>
 #include <backends/imgui_impl_glfw.h>
 #include <backends/imgui_impl_opengl3.h>
+#include <imgui.h>
 
 namespace Light {
 
-	void glUserInterface::PlatformImplementation(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
+void glUserInterface::PlatformImplementation(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
-	{
+{
 	m_WindowHandle = windowHandle;
 
 	ImGui_ImplGlfw_InitForOpenGL(windowHandle, false);
 	ImGui_ImplOpenGL3_Init();
-	}
+}
 
-	glUserInterface::~glUserInterface()
+glUserInterface::~glUserInterface()
-	{
+{
 	// #todo: handle this in a better way
 	ImGuiIO& io = ImGui::GetIO();
 
@@ -29,34 +28,34 @@ namespace Light {
 	ImGui_ImplOpenGL3_Shutdown();
 	ImGui_ImplGlfw_Shutdown();
 	ImGui::DestroyContext();
-	}
+}
 
-	void glUserInterface::Begin()
+void glUserInterface::Begin()
-	{
+{
 	ImGui_ImplOpenGL3_NewFrame();
 	ImGui_ImplGlfw_NewFrame();
 	ImGui::NewFrame();
-	}
+}
 
-	void glUserInterface::End()
+void glUserInterface::End()
-	{
+{
 	ImGui::Render();
 	ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
 
 	ImGui::UpdatePlatformWindows();
 	ImGui::RenderPlatformWindowsDefault();
 	glfwMakeContextCurrent(m_WindowHandle);
-	}
-
-	void glUserInterface::LogDebugData()
-	{
-		// #todo: improve
-		LT_ENGINE_INFO("________________________________________");
-		LT_ENGINE_INFO("UserInterface::");
-		LT_ENGINE_INFO("       API    : ImGui");
-		LT_ENGINE_INFO("       Version: {}", ImGui::GetVersion());
-		LT_ENGINE_INFO("  GraphicsAPI : OpenGL");
-		LT_ENGINE_INFO("________________________________________");
-	}
-
 }
+
+void glUserInterface::LogDebugData()
+{
+	// #todo: improve
+	LOG(info, "________________________________________");
+	LOG(info, "UserInterface::");
+	LOG(info, "       API    : ImGui");
+	LOG(info, "       Version: {}", ImGui::GetVersion());
+	LOG(info, "  GraphicsAPI : OpenGL");
+	LOG(info, "________________________________________");
+}
+
+} // namespace Light

Engine/src/Platform/GraphicsAPI/OpenGL/glVertexLayout.cpp

@@ -6,12 +6,12 @@
 
 namespace Light {
 
-	glVertexLayout::glVertexLayout(Ref<VertexBuffer> buffer, const std::vector<std::pair<std::string, VertexElementType>>& elements)
+glVertexLayout::glVertexLayout(Ref<VertexBuffer> buffer, const std::vector<std::pair<std::string, VertexElementType>>& elements)
     : m_ArrayID(NULL)
-	{
+{
 	// check
-		LT_ENGINE_ASSERT(std::dynamic_pointer_cast<glVertexBuffer>(buffer), "glVertexLayout::glVertexLayout: failed to cast 'VertexBuffer' to 'glVertexBuffer'");
+	ASSERT(std::dynamic_pointer_cast<glVertexBuffer>(buffer), "Failed to cast 'VertexBuffer' to 'glVertexBuffer'");
-		LT_ENGINE_ASSERT(!elements.empty(), "glVertexLayout::glVertexLayout: 'elements' is empty");
+	ASSERT(!elements.empty(), "'elements' is empty");
 
 	// local
 	std::vector<glVertexElementDesc> elementsDesc;
@@ -19,7 +19,7 @@ namespace Light {
 	unsigned int stride = 0u;
 
 	// extract elements desc
-		for(const auto& element : elements)
+	for (const auto& element : elements)
 	{
 		elementsDesc.push_back(GetElementDesc(element.second, stride));
 		stride += elementsDesc.back().typeSize * elementsDesc.back().count;
@@ -39,25 +39,25 @@ namespace Light {
 		glVertexAttribPointer(index, elementDesc.count, elementDesc.type, GL_FALSE, stride, (const void*)elementDesc.offset);
 		glEnableVertexAttribArray(index++);
 	}
-	}
+}
 
-	glVertexLayout::~glVertexLayout()
+glVertexLayout::~glVertexLayout()
-	{
+{
 	glDeleteVertexArrays(1, &m_ArrayID);
-	}
+}
 
-	void glVertexLayout::Bind()
+void glVertexLayout::Bind()
-	{
+{
 	glBindVertexArray(m_ArrayID);
-	}
+}
 
-	void glVertexLayout::UnBind()
+void glVertexLayout::UnBind()
-	{
+{
 	glBindVertexArray(NULL);
-	}
+}
 
-	glVertexElementDesc glVertexLayout::GetElementDesc(VertexElementType type, unsigned int offset)
+glVertexElementDesc glVertexLayout::GetElementDesc(VertexElementType type, unsigned int offset)
-	{
+{
 	switch (type)
 	{
 	/* byte */
@@ -89,9 +89,9 @@ namespace Light {
 	case VertexElementType::Float4: return { GL_FLOAT, 4u, sizeof(GLfloat), offset };
 
 	default:
-			LT_ENGINE_ASSERT(false, "glVertexLayout::GetElementDesc: invalid 'VertexElementType'");
+		ASSERT(false, "Invalid 'VertexElementType'");
 		return {};
 	}
-	}
-
 }
+
+} // namespace Light

Engine/src/Platform/OS/Linux/lWindow.cpp

@@ -1,28 +1,26 @@
 #include "lWindow.h"
 
-#include "Events/Event.h"
 #include "Events/CharEvent.h"
-#include "Events/MouseEvents.h"
+#include "Events/Event.h"
 #include "Events/KeyboardEvents.h"
+#include "Events/MouseEvents.h"
 #include "Events/WindowEvents.h"
-
 #include "Graphics/GraphicsContext.h"
 
 #include <GLFW/glfw3.h>
 
 namespace Light {
 
-	Scope<Window> Window::Create(std::function<void(Event&)> callback)
+Scope<Window> Window::Create(std::function<void(Event&)> callback)
-	{
+{
 	return CreateScope<lWindow>(callback);
-	}
+}
 
-	lWindow::lWindow(std::function<void(Event&)> callback)
+lWindow::lWindow(std::function<void(Event&)> callback)
-		: m_Handle(nullptr),
+    : m_Handle(nullptr), m_EventCallback(callback)
-		  m_EventCallback(callback)
+{
-	{
 	// init glfw
-		LT_ENGINE_ASSERT(glfwInit(), "lWindow::lWindow: failed to initialize 'glfw'");
+	ASSERT(glfwInit(), "lWindow::lWindow: failed to initialize 'glfw'");
 
 	// create window
 	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
@@ -31,7 +29,7 @@ namespace Light {
 	glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
 
 	m_Handle = glfwCreateWindow(1u, 1u, "", nullptr, nullptr);
-		LT_ENGINE_ASSERT(m_Handle, "lWindow::lWindow: failed to create 'GLFWwindow'");
+	ASSERT(m_Handle, "lWindow::lWindow: failed to create 'GLFWwindow'");
 
 	// bind event stuff
 	glfwSetWindowUserPointer(m_Handle, &m_EventCallback);
@@ -39,21 +37,21 @@ namespace Light {
 
 	// create graphics context
 	m_GraphicsContext = GraphicsContext::Create(GraphicsAPI::OpenGL, m_Handle);
-		LT_ENGINE_ASSERT(m_GraphicsContext, "lWindow::lWindow: failed to create 'GraphicsContext'");
+	ASSERT(m_GraphicsContext, "lWindow::lWindow: failed to create 'GraphicsContext'");
-	}
+}
 
-	lWindow::~lWindow()
+lWindow::~lWindow()
-	{
+{
 	glfwDestroyWindow(m_Handle);
-	}
+}
 
-	void lWindow::PollEvents()
+void lWindow::PollEvents()
-	{
+{
 	glfwPollEvents();
-	}
+}
 
-	void lWindow::OnEvent(const Event& event)
+void lWindow::OnEvent(const Event& event)
-	{
+{
 	switch (event.GetEventType())
 	{
 	/* closed */
@@ -66,15 +64,15 @@ namespace Light {
 		OnWindowResize((const WindowResizedEvent&)event);
 		break;
 	}
-	}
+}
 
-	void lWindow::OnWindowResize(const WindowResizedEvent& event)
+void lWindow::OnWindowResize(const WindowResizedEvent& event)
-	{
+{
 	m_Properties.size = event.GetSize();
-	}
+}
 
-	void lWindow::SetProperties(const WindowProperties& properties, bool overrideVisibility /* = false */)
+void lWindow::SetProperties(const WindowProperties& properties, bool overrideVisibility /* = false */)
-	{
+{
 	// save the visibility status and re-assign if 'overrideVisibility' is false
 	bool visible         = overrideVisibility ? properties.visible : m_Properties.visible;
 	m_Properties         = properties;
@@ -85,47 +83,48 @@ namespace Light {
 	SetSize(properties.size);
 	SetVSync(properties.vsync);
 	SetVisibility(visible);
-	}
+}
 
-	void lWindow::SetTitle(const std::string& title)
+void lWindow::SetTitle(const std::string& title)
-	{
+{
 	m_Properties.title = title;
 
 	glfwSetWindowTitle(m_Handle, title.c_str());
-	}
+}
 
-	void lWindow::SetSize(const glm::uvec2& size, bool additive /* = false */)
+void lWindow::SetSize(const glm::uvec2& size, bool additive /* = false */)
-	{
+{
-		m_Properties.size.x = size.x == 0u ? m_Properties.size.x : additive ? m_Properties.size.x + size.x : size.x;
+	m_Properties.size.x = size.x == 0u ? m_Properties.size.x : additive ? m_Properties.size.x + size.x :
-		m_Properties.size.y = size.y == 0u ? m_Properties.size.y : additive ? m_Properties.size.y + size.y : size.y;
+                                                                          size.x;
+	m_Properties.size.y = size.y == 0u ? m_Properties.size.y : additive ? m_Properties.size.y + size.y :
+                                                                          size.y;
 
 
 	glfwSetWindowSize(m_Handle, size.x, size.y);
-	}
+}
 
-	void lWindow::SetVSync(bool vsync, bool toggle /* = false */)
+void lWindow::SetVSync(bool vsync, bool toggle /* = false */)
-	{
+{
 	m_Properties.vsync = toggle ? !m_Properties.vsync : vsync;
 
 	glfwSwapInterval(m_Properties.vsync);
-	}
+}
 
-	void lWindow::SetVisibility(bool visible, bool toggle)
+void lWindow::SetVisibility(bool visible, bool toggle)
-	{
+{
 	m_Properties.visible = toggle ? !m_Properties.visible : visible;
 
-		if(m_Properties.visible)
+	if (m_Properties.visible)
 		glfwShowWindow(m_Handle);
 	else
 		glfwHideWindow(m_Handle);
-	}
+}
 
-	void lWindow::BindGlfwEvents()
+void lWindow::BindGlfwEvents()
-	{
+{
 	//============================== MOUSE_EVENTS ==============================//
 	/* cursor position */
-		glfwSetCursorPosCallback(m_Handle, [](GLFWwindow* window, double xpos, double ypos)
+	glfwSetCursorPosCallback(m_Handle, [](GLFWwindow* window, double xpos, double ypos) {
-		{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 
 		MouseMovedEvent event(xpos, ypos);
@@ -133,16 +132,15 @@ namespace Light {
 	});
 
 	/* mouse button */
-		glfwSetMouseButtonCallback(m_Handle, [](GLFWwindow* window, int button, int action, int mods)
+	glfwSetMouseButtonCallback(m_Handle, [](GLFWwindow* window, int button, int action, int mods) {
-		{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 
-			if(action == GLFW_PRESS)
+		if (action == GLFW_PRESS)
 		{
 			ButtonPressedEvent event(button);
 			callback(event);
 		}
-			else if(action == GLFW_RELEASE)
+		else if (action == GLFW_RELEASE)
 		{
 			ButtonReleasedEvent event(button);
 			callback(event);
@@ -150,8 +148,7 @@ namespace Light {
 	});
 
 	/* scroll */
-		glfwSetScrollCallback(m_Handle, [](GLFWwindow* window, double xoffset, double yoffset)
+	glfwSetScrollCallback(m_Handle, [](GLFWwindow* window, double xoffset, double yoffset) {
-		{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 
 		WheelScrolledEvent event(yoffset);
@@ -161,24 +158,22 @@ namespace Light {
 
 	//============================== KEYBOARD_EVENTS ==============================//
 	/* key */
-		glfwSetKeyCallback(m_Handle, [](GLFWwindow* window, int key, int scancode, int action, int mods)
+	glfwSetKeyCallback(m_Handle, [](GLFWwindow* window, int key, int scancode, int action, int mods) {
-		{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 
-			if(action == GLFW_PRESS)
+		if (action == GLFW_PRESS)
 		{
 			KeyPressedEvent event(key);
 			callback(event);
 		}
-			else if(action == GLFW_RELEASE)
+		else if (action == GLFW_RELEASE)
 		{
 			KeyReleasedEvent event(key);
 			callback(event);
 		}
 	});
 	/* char */
-		glfwSetCharCallback(m_Handle, [](GLFWwindow* window, unsigned int character)
+	glfwSetCharCallback(m_Handle, [](GLFWwindow* window, unsigned int character) {
-		{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 
 		SetCharEvent event(character);
@@ -189,8 +184,7 @@ namespace Light {
 
 	//============================== WINDOW_EVENTS ==============================//
 	/* window position */
-		glfwSetWindowPosCallback(m_Handle, [](GLFWwindow* window, int xpos, int ypos)
+	glfwSetWindowPosCallback(m_Handle, [](GLFWwindow* window, int xpos, int ypos) {
-		{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 		WindowMovedEvent event(xpos, ypos);
 
@@ -198,8 +192,7 @@ namespace Light {
 	});
 
 	/* window size */
-		glfwSetWindowSizeCallback(m_Handle, [](GLFWwindow* window, int width, int height)
+	glfwSetWindowSizeCallback(m_Handle, [](GLFWwindow* window, int width, int height) {
-		{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 		WindowResizedEvent event(width, height);
 
@@ -207,8 +200,7 @@ namespace Light {
 	});
 
 	/* window close */
-		glfwSetWindowCloseCallback(m_Handle, [](GLFWwindow* window)
+	glfwSetWindowCloseCallback(m_Handle, [](GLFWwindow* window) {
-		{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 		WindowClosedEvent event;
 
@@ -216,11 +208,10 @@ namespace Light {
 	});
 
 	/* window focus */
-		glfwSetWindowFocusCallback(m_Handle, [](GLFWwindow* window, int focus)
+	glfwSetWindowFocusCallback(m_Handle, [](GLFWwindow* window, int focus) {
-		{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 
-			if(focus == GLFW_TRUE)
+		if (focus == GLFW_TRUE)
 		{
 			WindowGainFocusEvent event;
 			callback(event);
@@ -232,6 +223,6 @@ namespace Light {
 		}
 	});
 	//============================== WINDOW_EVENTS ==============================//
-	}
-
 }
+
+} // namespace Light

Engine/src/Platform/OS/Windows/wWindow.cpp

@@ -1,12 +1,10 @@
 #include "wWindow.h"
 
-#include "Events/Event.h"
 #include "Events/CharEvent.h"
-#include "Events/MouseEvents.h"
+#include "Events/Event.h"
 #include "Events/KeyboardEvents.h"
+#include "Events/MouseEvents.h"
 #include "Events/WindowEvents.h"
-		
-
 #include "Graphics/GraphicsContext.h"
 
 #include <GLFW/glfw3.h>
@@ -20,17 +18,16 @@ extern "C"
 
 namespace Light {
 
-	Scope<Window> Window::Create(std::function<void(Event&)> callback)
+Scope<Window> Window::Create(std::function<void(Event&)> callback)
-	{
+{
 	return CreateScope<wWindow>(callback);
-	}
+}
 
-	wWindow::wWindow(std::function<void(Event&)> callback)
+wWindow::wWindow(std::function<void(Event&)> callback)
-		: m_Handle(nullptr),
+    : m_Handle(nullptr), m_EventCallback(callback)
-		  m_EventCallback(callback)
+{
-	{
 	// init glfw
-		LT_ENGINE_ASSERT(glfwInit(), "wWindow::wWindow: failed to initialize 'glfw'");
+	ASSERT(glfwInit(), "wWindow::wWindow: failed to initialize 'glfw'");
 
 	// create window
 	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
@@ -39,7 +36,7 @@ namespace Light {
 	glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
 
 	m_Handle = glfwCreateWindow(1u, 1u, "", nullptr, nullptr);
-		LT_ENGINE_ASSERT(m_Handle, "wWindow::wWindow: glfwCreateWindow: failed to create 'GLFWwindow'");
+	ASSERT(m_Handle, "wWindow::wWindow: glfwCreateWindow: failed to create 'GLFWwindow'");
 
 	// bind event stuff
 	glfwSetWindowUserPointer(m_Handle, &m_EventCallback);
@@ -47,21 +44,21 @@ namespace Light {
 
 	// create graphics context
 	m_GraphicsContext = GraphicsContext::Create(GraphicsAPI::DirectX, m_Handle);
-		LT_ENGINE_ASSERT(m_GraphicsContext, "wWindow::wWindow: failed to create 'GraphicsContext'");
+	ASSERT(m_GraphicsContext, "wWindow::wWindow: failed to create 'GraphicsContext'");
-	}
+}
 
-	wWindow::~wWindow()
+wWindow::~wWindow()
-	{
+{
 	glfwDestroyWindow(m_Handle);
-	}
+}
 
-	void wWindow::PollEvents()
+void wWindow::PollEvents()
-	{
+{
 	glfwPollEvents();
-	}
+}
 
-	void wWindow::OnEvent(const Event& event)
+void wWindow::OnEvent(const Event& event)
-	{
+{
 	switch (event.GetEventType())
 	{
 	/* closed */
@@ -74,15 +71,15 @@ namespace Light {
 		OnWindowResize((const WindowResizedEvent&)event);
 		break;
 	}
-	}
+}
 
-	void wWindow::OnWindowResize(const WindowResizedEvent& event)
+void wWindow::OnWindowResize(const WindowResizedEvent& event)
-	{
+{
 	m_Properties.size = event.GetSize();
-	}
+}
 
-	void wWindow::SetProperties(const WindowProperties& properties, bool overrideVisiblity /* = false */)
+void wWindow::SetProperties(const WindowProperties& properties, bool overrideVisiblity /* = false */)
-	{
+{
 	// save the visibility status and re-assign if 'overrideVisibility' is false
 	bool visible         = overrideVisiblity ? properties.visible : m_Properties.visible;
 	m_Properties         = properties;
@@ -93,47 +90,48 @@ namespace Light {
 	SetSize(properties.size);
 	SetVSync(properties.vsync);
 	SetVisibility(visible);
-	}
+}
 
-	void wWindow::SetTitle(const std::string& title)
+void wWindow::SetTitle(const std::string& title)
-	{
+{
 	m_Properties.title = title;
 
 	glfwSetWindowTitle(m_Handle, m_Properties.title.c_str());
-	}
+}
 
-	void wWindow::SetSize(const glm::uvec2& size, bool additive /* = false */)
+void wWindow::SetSize(const glm::uvec2& size, bool additive /* = false */)
-	{
+{
-		m_Properties.size.x = size.x == 0u ? m_Properties.size.x : additive ? m_Properties.size.x + size.x : size.x;
+	m_Properties.size.x = size.x == 0u ? m_Properties.size.x : additive ? m_Properties.size.x + size.x :
-		m_Properties.size.y = size.y == 0u ? m_Properties.size.y : additive ? m_Properties.size.y + size.y : size.y;
+                                                                          size.x;
+	m_Properties.size.y = size.y == 0u ? m_Properties.size.y : additive ? m_Properties.size.y + size.y :
+                                                                          size.y;
 
 
 	glfwSetWindowSize(m_Handle, size.x, size.y);
-	}
+}
 
-	void wWindow::SetVSync(bool vsync, bool toggle /* = false */)
+void wWindow::SetVSync(bool vsync, bool toggle /* = false */)
-	{
+{
 	m_Properties.vsync = toggle ? !m_Properties.vsync : vsync;
 
 	glfwSwapInterval(m_Properties.vsync);
-	}
+}
 
-	void wWindow::SetVisibility(bool visible, bool toggle)
+void wWindow::SetVisibility(bool visible, bool toggle)
-	{
+{
 	m_Properties.visible = toggle ? !m_Properties.visible : visible;
 
 	if (m_Properties.visible)
 		glfwShowWindow(m_Handle);
 	else
 		glfwHideWindow(m_Handle);
-	}
+}
 
-	void wWindow::BindGlfwEvents()
+void wWindow::BindGlfwEvents()
-	{
+{
 	//============================== MOUSE_EVENTS ==============================//
 	/* cursor position */
-		glfwSetCursorPosCallback(m_Handle, [](GLFWwindow* window, double xpos, double ypos)
+	glfwSetCursorPosCallback(m_Handle, [](GLFWwindow* window, double xpos, double ypos) {
-			{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 
 		MouseMovedEvent event(xpos, ypos);
@@ -141,8 +139,7 @@ namespace Light {
 	});
 
 	/* mouse button */
-		glfwSetMouseButtonCallback(m_Handle, [](GLFWwindow* window, int button, int action, int mods)
+	glfwSetMouseButtonCallback(m_Handle, [](GLFWwindow* window, int button, int action, int mods) {
-			{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 
 		if (action == GLFW_PRESS)
@@ -158,8 +155,7 @@ namespace Light {
 	});
 
 	/* scroll */
-		glfwSetScrollCallback(m_Handle, [](GLFWwindow* window, double xoffset, double yoffset)
+	glfwSetScrollCallback(m_Handle, [](GLFWwindow* window, double xoffset, double yoffset) {
-			{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 
 		WheelScrolledEvent event(yoffset);
@@ -169,8 +165,7 @@ namespace Light {
 
 	//============================== KEYBOARD_EVENTS ==============================//
 	/* key */
-		glfwSetKeyCallback(m_Handle, [](GLFWwindow* window, int key, int scancode, int action, int mods)
+	glfwSetKeyCallback(m_Handle, [](GLFWwindow* window, int key, int scancode, int action, int mods) {
-			{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 
 		if (action == GLFW_PRESS)
@@ -185,8 +180,7 @@ namespace Light {
 		}
 	});
 	/* char */
-		glfwSetCharCallback(m_Handle, [](GLFWwindow* window, unsigned int character)
+	glfwSetCharCallback(m_Handle, [](GLFWwindow* window, unsigned int character) {
-			{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 
 		SetCharEvent event(character);
@@ -197,8 +191,7 @@ namespace Light {
 
 	//============================== WINDOW_EVENTS ==============================//
 	/* window position */
-		glfwSetWindowPosCallback(m_Handle, [](GLFWwindow* window, int xpos, int ypos)
+	glfwSetWindowPosCallback(m_Handle, [](GLFWwindow* window, int xpos, int ypos) {
-			{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 		WindowMovedEvent event(xpos, ypos);
 
@@ -206,8 +199,7 @@ namespace Light {
 	});
 
 	/* window size */
-		glfwSetWindowSizeCallback(m_Handle, [](GLFWwindow* window, int width, int height)
+	glfwSetWindowSizeCallback(m_Handle, [](GLFWwindow* window, int width, int height) {
-			{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 		WindowResizedEvent event(width, height);
 
@@ -215,8 +207,7 @@ namespace Light {
 	});
 
 	/* window close */
-		glfwSetWindowCloseCallback(m_Handle, [](GLFWwindow* window)
+	glfwSetWindowCloseCallback(m_Handle, [](GLFWwindow* window) {
-			{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 		WindowClosedEvent event;
 
@@ -224,8 +215,7 @@ namespace Light {
 	});
 
 	/* window focus */
-		glfwSetWindowFocusCallback(m_Handle, [](GLFWwindow* window, int focus)
+	glfwSetWindowFocusCallback(m_Handle, [](GLFWwindow* window, int focus) {
-			{
 		std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
 
 		if (focus == GLFW_TRUE)
@@ -240,5 +230,5 @@ namespace Light {
 		}
 	});
 	//============================== WINDOW_EVENTS ==============================//	}
-	}
 }
+} // namespace Light

Mirror/src/EditorLayer.cpp

@@ -27,7 +27,7 @@ EditorLayer::EditorLayer(const std::string& name, const std::vector<std::string>
 	else
 	{
 		SceneSerializer serializer(m_Scene);
-		LT_ENGINE_ASSERT(serializer.Deserialize(m_SceneDir), "EditorLayer::EditorLayer: failed to de-serialize: ", m_SceneDir);
+		ASSERT(serializer.Deserialize(m_SceneDir), "Failed to de-serialize: {}", m_SceneDir);
 
 		m_CameraEntity = m_Scene->GetEntityByTag("Game Camera");
 	}

Mirror/src/EditorLayer.cpp~

@@ -1,5 +1,4 @@
 #include "EditorLayer.h"
-
 #include "Utility/Serializer.h"
 
 namespace Light {
@@ -27,7 +26,7 @@ EditorLayer::EditorLayer(const std::string& name, const std::vector<std::string>
 	else
 	{
 		SceneSerializer serializer(m_Scene);
-		LT_ENGINE_ASSERT(serializer.Deserialize(m_SceneDir), "EditorLayer::EditorLayer: failed to de-serialize: ", m_SceneDir);
+		ASSERT(serializer.Deserialize(m_SceneDir), "EditorLayer::EditorLayer: failed to de-serialize: ", m_SceneDir);
 
 		m_CameraEntity = m_Scene->GetEntityByTag("Game Camera");
 	}

Mirror/src/Panels/ContentBrowser.cpp

@@ -38,7 +38,6 @@ void AssetBrowserPanel::OnUserInterfaceUpdate()
 		m_DirectoryTexture->Bind(0u);
 		for (auto& dirEntry : std::filesystem::directory_iterator(m_CurrentDirectory))
 		{
-			LT_ENGINE_TRACE("File: ", dirEntry.path().string());
 			AssetType assetType;
 			std::string extension = dirEntry.path().extension().string();
 
@@ -71,7 +70,6 @@ void AssetBrowserPanel::OnUserInterfaceUpdate()
 				if (ImGui::ImageButton(m_DirectoryTexture->GetTexture(), ImVec2(m_FileSize, m_FileSize), ImVec2 { 0.0f, 0.0f }, ImVec2 { 1.0f, 1.0f }, 0, ImVec4 { 0.0f, 0.0f, 0.0f, 0.0f }, ImVec4 { 1.0f, 1.0f, 1.0f, 1.0f }))
 				{
 					m_CurrentDirectory /= path.filename();
-					LT_ENGINE_INFO(path.filename().string());
 				}
 				break;