Muto::SceneSerializer Class Reference

Handles serialization and deserialization of scenes. More...

#include <SceneSerializer.h>

Public Member Functions
bool	Deserialize (const std::string &filepath)
bool	DeserializeRuntime (const std::string &filepath)
	SceneSerializer (const Ref< Scene > &scene)
void	Serialize (const std::string &filepath)
void	SerializeRuntime (const std::string &filepath)

Private Attributes
Ref< Scene >	m_Scene

Detailed Description

Handles serialization and deserialization of scenes.

Note

Serialization is currently only Text-based (YAML) and is not optimized for performance. Future versions may include a binary format for faster loading times.

Constructor & Destructor Documentation

SceneSerializer()

Muto::SceneSerializer::SceneSerializer

(

const Ref< Scene > &

scene

)

        : m_Scene(scene)
    {
    }

References SceneSerializer().

Referenced by SceneSerializer().

Member Function Documentation

Deserialize()

bool Muto::SceneSerializer::Deserialize

(

const std::string &

filepath

)

                                                               {
 
        std::ifstream stream(filepath);
        std::stringstream strStream;
        strStream << stream.rdbuf();
 
        YAML::Node data = YAML::Load(strStream.str());
        if (!data["Scene"])
            return false;
 
        std::string sceneName = data["Scene"].as<std::string>();
        MU_CORE_TRACE("Deserializing scene: {0}", sceneName);
 
        YAML::Node entities = data["Entities"];
        if (entities)
        {
            for (auto entityNode : entities)
            {
                std::string uuid = entityNode["Entity"].as<std::string>();
                std::string name;
                YAML::Node nameNode = entityNode["NameComponent"];
                if (nameNode)
                    name = nameNode.as<std::string>();
                MU_CORE_TRACE("Deserialized entity with ID: {0}, name: {1}", uuid, name);
                Entity deserializedEntity = m_Scene->CreateEntity(name, uuid);
                YAML::Node transformNode = entityNode["TransformComponent"];
                if (transformNode)
                {
                    auto& tc = deserializedEntity.GetComponent<TransformComponent>();
                    tc.Translation = transformNode["Translation"].as<glm::vec3>();
                    tc.Rotation = transformNode["Rotation"].as<glm::vec3>();
                    tc.Scale = transformNode["Scale"].as<glm::vec3>();
                }
                YAML::Node cameraNode = entityNode["CameraComponent"];
                if (cameraNode)
                {
                    auto& cameraComp = deserializedEntity.AddComponent<CameraComponent>();
                    auto& camera = cameraComp.Camera;
                    YAML::Node camProps = cameraNode["Camera"];
                    camera.SetOrthographic(camProps["OrthographicSize"].as<float>(), camProps["OrthographicNear"].as<float>(), camProps["OrthographicFar"].as<float>());
                    camera.SetPerspective(camProps["PerspectiveFOV"].as<float>(), camProps["PerspectiveNear"].as<float>(), camProps["PerspectiveFar"].as<float>());
                    cameraComp.Primary = cameraNode["Primary"].as<bool>();
                    camera.SetProjectionType((SceneCamera::ProjectionType)cameraNode["ProjectionType"].as<int>());
                    cameraComp.FixedAspectRatio = cameraNode["FixedAspectRatio"].as<bool>();
                }
                YAML::Node spriteNode = entityNode["SpriteRendererComponent"];
                if (spriteNode)
                {
                    auto& src = deserializedEntity.AddComponent<SpriteRendererComponent>();
                    src.Color = spriteNode["Color"].as<glm::vec4>();
                }
            }
        }
        return true;
 
    }

Referenced by Muto::EditorLayer::OnAttach(), and Muto::EditorLayer::OpenScene().

DeserializeRuntime()

bool Muto::SceneSerializer::DeserializeRuntime

(

const std::string &

filepath

)

    {
        MU_CORE_ASSERT(false, "Not implemented");
        return false;
    }

Serialize()

void Muto::SceneSerializer::Serialize

(

const std::string &

filepath

)

                                                             {
        YAML::Emitter out;
        out << YAML::BeginMap; // Scene
        out << YAML::Key << "Scene" << YAML::Value << m_Scene->GetName();
        out << YAML::Key << "Entities" << YAML::Value << YAML::BeginSeq; // Entities
        m_Scene->m_Registry.view<entt::entity>().each([&](auto entityID) {
 
            Entity entity = { entityID, m_Scene.get() };
            if (!entity)
                return;
 
            SerializeEntity(out, entity);
 
            });
 
        out << YAML::EndSeq; // Entities
        out << YAML::EndMap; // Scene
 
        std::ofstream fout(filepath);
        fout << out.c_str();
    }

Referenced by Muto::EditorLayer::SaveSceneAs().

SerializeRuntime()

void Muto::SceneSerializer::SerializeRuntime

(

const std::string &

filepath

)

    {
        MU_CORE_ASSERT(false, "Not implemented");
    }

Member Data Documentation

m_Scene

Ref<Scene> Muto::SceneSerializer::m_Scene

private

---

The documentation for this class was generated from the following files:

• Muto/src/Scene/SceneSerializer.h
• Muto/src/Scene/SceneSerializer.cpp