YoggieEngine/Editor/src/SceneSerializer.h

#pragma once
#include <yaml-cpp/yaml.h>
#include <yaml-cpp/node/type.h>

#include <string>
#include <filesystem>
#include <fstream>

#include "../../YoggieEngine/src/Scene/Entity.h"

void WriteFile(std::string& emitter, std::filesystem::path path) 
{
	std::cout << "Writing Scene file to: "  << path.u8string() << std::endl;
	std::ofstream sceneFile;
	sceneFile.open(path.u8string());

	sceneFile << emitter.c_str();

	sceneFile.close();
}

YAML::Emitter& operator<< (YAML::Emitter& emitter, glm::vec3& vector) {
	emitter << YAML::Flow << YAML::BeginSeq   << vector.x << vector.y << vector.x << YAML::EndSeq;
	return emitter;
}

 std::string Serialize( Scene& scene) {
	YAML::Emitter emitter;
	
	emitter << YAML::BeginMap;
	emitter << YAML::Key << "Scene" << YAML::Value << "test-Scene";
	emitter << YAML::Key << "Entities" << YAML::Value << YAML::BeginSeq;

	scene.getReg().each([&scene, &emitter](auto enttNumber) {
		Entity entity = Entity(enttNumber, &scene);
		
		emitter << YAML::BeginMap;
		emitter << YAML::Key << "Entity" << YAML::Value << entity.GetComponent<IdentifierComponent>().name;

		if (entity.HasComponent<IdentifierComponent>()) {
			emitter << YAML::Key << "Ident";
			emitter << YAML::BeginMap;
			emitter << YAML::Value << entity.GetComponent<IdentifierComponent>().name;
			emitter << YAML::EndMap;
		}

		if (entity.HasComponent<TransformComponent>()) {
			emitter << YAML::Key << "Transform" << YAML::Value ;

			emitter << YAML::BeginMap;

			emitter << YAML::Key << "Position";
			emitter << YAML::Value << entity.GetComponent<TransformComponent>().Position;

			emitter << YAML::Key << "Rotation";
			emitter << YAML::Value << entity.GetComponent<TransformComponent>().Rotation;

			emitter << YAML::Key << "Scale";
			emitter << YAML::Value << entity.GetComponent<TransformComponent>().Scale;

			emitter << YAML::EndMap;
		}

		
		if (entity.HasComponent<LightComponent>()) {
			emitter << YAML::Key << "Light";
			emitter << YAML::Value;
			emitter << YAML::BeginMap;
			emitter << YAML::Key << "Color";
			emitter << YAML::Value << entity.GetComponent<LightComponent>().Color;
			emitter << YAML::EndMap;	
		}


		emitter << YAML::EndMap;

		});

	emitter << YAML::EndSeq;
	emitter << YAML::EndMap;

	return std::string(emitter.c_str());
}
 

 void SaveScene(std::filesystem::path path, Scene& scene) {
	 std::string YAMLString = Serialize(scene);
	 WriteFile(YAMLString, path);
 }


 void LoadScene(std::filesystem::path path, Scene& scene)
 {
	auto sceneYAML = YAML::LoadFile(path.u8string());

	if (!sceneYAML["Scene"]) {
		 spdlog::error("Not a scene file!");
		 return;
	}
	
	scene.getReg().clear();



	std::string SceneName = sceneYAML["Scene"].as<std::string>();


	auto entities = sceneYAML["Entities"];
	 
	for (const auto& entity : entities) {
	
		std::string entityID = entity["Ident"].as<std::string>();
		YoggieEngine::Entity SE = scene.AddEntity(entityID);
		if (entity["Transform"]) 
		{
			TransformComponent tc = SE.GetComponent<TransformComponent>();
			auto positionNode = entity["Transform"]["Position"];
			tc.Position =  glm::vec3(positionNode[0].as<float>(), positionNode[1].as<float>(), positionNode[2].as<float>());

			auto rotationNode = entity["Transform"]["Rotation"];
			tc.Rotation = glm::vec3(rotationNode[0].as<float>(), rotationNode[1].as<float>(), rotationNode[2].as<float>());

			auto scaleNode = entity["Transform"]["Scale"];
			tc.Scale = glm::vec3(scaleNode[0].as<float>(), scaleNode[1].as<float>(), scaleNode[2].as<float>());
		}
		if (entity["Light"]) {
			LightComponent lc = SE.AddComponent<LightComponent>();
			lc.Color = glm::vec3(entity["Light"]["Color"][0].as<float>(), entity["Light"]["Color"][1].as<float>(), entity["Light"]["Color"][2].as<float>());
		}

	}
	 

 }