General cleanup.

Author: OverShifted

.gitignore

@@ -34,6 +34,6 @@ OverEngineProfile-Runtime.json
 OverEngineProfile-Shutdown.json
 
 # Other
+Sandbox/SandboxScene.oes
 OverEngine.log
 imgui.ini
-

OverEngine/src/OverEngine/Core/Runtime/Serialization/ObjectSerializer.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "OverEngine/Core/Core.h"
+#include <yaml-cpp/yaml.h>
+
+namespace OverEngine
+{
+	template <typename T>
+	class YamlEmitter;
+
+	#define OE_DECL_EMITTER(T)                                   \
+		template<>                                            \
+		struct YamlEmitter<T>                                 \
+		{                                                     \
+			static void Emit(YAML::Emitter& out, const T& v); \
+		};
+
+	template <typename T>
+	class YamlDecoder;
+
+	#define OE_DECL_DECODER(T)                                     \
+		template<>                                              \
+		struct YamlDecoder<T>                                   \
+		{                                                       \
+			static bool Decode(const YAML::Node& node, T& rhs); \
+		};
+}
+
+namespace YAML
+{
+	template <typename T>
+	YAML::Emitter& operator<<(YAML::Emitter& out, const T& v)
+	{
+		::OverEngine::YamlEmitter<T>::Emit(out, v);
+		return out;
+	}
+
+	template <typename T>
+	struct convert<T, 0>
+	{
+	public:
+		static bool decode(const Node& node, T& rhs)
+		{
+			return ::OverEngine::YamlDecoder<T>::Decode(node, rhs);
+		}
+	};
+}

OverEngine/src/OverEngine/Core/Runtime/Serialization/Serialization.h

@@ -1,23 +1,56 @@
 #include "pcheader.h"
 #include "YamlConverters.h"
 
-YAML::Emitter& operator<<(YAML::Emitter& out, const OverEngine::Vector2& v)
+namespace OverEngine
 {
-	out << YAML::Flow;
-	out << YAML::BeginSeq << v.x << v.y << YAML::EndSeq;
-	return out;
-}
+	bool YamlDecoder<Vector2>::Decode(const YAML::Node& node, Vector2& rhs)
+	{
+		if (!node.IsSequence() || node.size() != 2)
+			return false;
 
-YAML::Emitter& operator<<(YAML::Emitter& out, const OverEngine::Vector3& v)
-{
-	out << YAML::Flow;
-	out << YAML::BeginSeq << v.x << v.y << v.z << YAML::EndSeq;
-	return out;
-}
+		rhs.x = node[0].as<float>();
+		rhs.y = node[1].as<float>();
+		return true;
+	}
 
-YAML::Emitter& operator<<(YAML::Emitter& out, const OverEngine::Vector4& v)
-{
-	out << YAML::Flow;
-	out << YAML::BeginSeq << v.x << v.y << v.z << v.w << YAML::EndSeq;
-	return out;
+	bool YamlDecoder<Vector3>::Decode(const YAML::Node& node, Vector3& rhs)
+	{
+		if (!node.IsSequence() || node.size() != 3)
+			return false;
+
+		rhs.x = node[0].as<float>();
+		rhs.y = node[1].as<float>();
+		rhs.z = node[2].as<float>();
+		return true;
+	}
+
+	bool YamlDecoder<Vector4>::Decode(const YAML::Node& node, Vector4& rhs)
+	{
+		if (!node.IsSequence() || node.size() != 4)
+			return false;
+
+		rhs.r = node[0].as<float>();
+		rhs.g = node[1].as<float>();
+		rhs.b = node[2].as<float>();
+		rhs.a = node[3].as<float>();
+		return true;
+	}
+
+	void YamlEmitter<Vector2>::Emit(YAML::Emitter& out, const Vector2& v)
+	{
+		out << YAML::Flow;
+		out << YAML::BeginSeq << v.x << v.y << YAML::EndSeq;
+	}
+
+	void YamlEmitter<Vector3>::Emit(YAML::Emitter& out, const Vector3& v)
+	{
+		out << YAML::Flow;
+		out << YAML::BeginSeq << v.x << v.y << v.z << YAML::EndSeq;
+	}
+
+	void YamlEmitter<Vector4>::Emit(YAML::Emitter& out, const Vector4& v)
+	{
+		out << YAML::Flow;
+		out << YAML::BeginSeq << v.x << v.y << v.z << v.w << YAML::EndSeq;
+	}
 }

OverEngine/src/OverEngine/Core/Runtime/Serialization/YamlConverters.cpp

@@ -1,87 +1,16 @@
 #pragma once
 
+#include "Serialization.h"
 #include "OverEngine/Core/Core.h"
 #include "OverEngine/Core/Math/Math.h"
 
-#include <yaml-cpp/yaml.h>
-
-namespace YAML
+namespace OverEngine
 {
-	template<>
-	struct convert<OverEngine::Vector2>
-	{
-		static Node encode(const OverEngine::Vector2& rhs)
-		{
-			Node node;
-			node.push_back(rhs.x);
-			node.push_back(rhs.y);
-			node.SetStyle(EmitterStyle::Flow);
-			return node;
-		}
-
-		static bool decode(const Node& node, OverEngine::Vector2& rhs)
-		{
-			if (!node.IsSequence() || node.size() != 2)
-				return false;
-
-			rhs.x = node[0].as<float>();
-			rhs.y = node[1].as<float>();
-			return true;
-		}
-	};
-
-	template<>
-	struct convert<OverEngine::Vector3>
-	{
-		static Node encode(const OverEngine::Vector3& rhs)
-		{
-			Node node;
-			node.push_back(rhs.x);
-			node.push_back(rhs.y);
-			node.SetStyle(EmitterStyle::Flow);
-			return node;
-		}
-
-		static bool decode(const Node& node, OverEngine::Vector3& rhs)
-		{
-			if (!node.IsSequence() || node.size() != 3)
-				return false;
+	OE_DECL_DECODER(Vector2)
+	OE_DECL_DECODER(Vector3)
+	OE_DECL_DECODER(Vector4)
 
-			rhs.x = node[0].as<float>();
-			rhs.y = node[1].as<float>();
-			rhs.z = node[2].as<float>();
-			return true;
-		}
-	};
-
-	template<>
-	struct convert<OverEngine::Vector4>
-	{
-		static Node encode(const OverEngine::Vector4& rhs)
-		{
-			Node node;
-			node.push_back(rhs.x);
-			node.push_back(rhs.y);
-			node.push_back(rhs.z);
-			node.push_back(rhs.w);
-			node.SetStyle(EmitterStyle::Flow);
-			return node;
-		}
-
-		static bool decode(const Node& node, OverEngine::Vector4& rhs)
-		{
-			if (!node.IsSequence() || node.size() != 4)
-				return false;
-
-			rhs.r = node[0].as<float>();
-			rhs.g = node[1].as<float>();
-			rhs.b = node[2].as<float>();
-			rhs.a = node[3].as<float>();
-			return true;
-		}
-	};
+	OE_DECL_EMITTER(Vector2)
+	OE_DECL_EMITTER(Vector3)
+	OE_DECL_EMITTER(Vector4)
 }
-
-YAML::Emitter& operator<<(YAML::Emitter& out, const OverEngine::Vector2& v);
-YAML::Emitter& operator<<(YAML::Emitter& out, const OverEngine::Vector3& v);
-YAML::Emitter& operator<<(YAML::Emitter& out, const OverEngine::Vector4& v);