component_serializer.h

#pragma once
 
#include <string>
#include <vector>
 
#include <nlohmann/json.hpp>
 
#include "ecs/entity_mapping.h"
#include "ecs/environment.h"
#include "resource/asset_type.h"
#include "ecs/component/animation/animation.h"
#include "ecs/component/animation/animator.h"
#include "ecs/component/animation/bone_socket.h"
#include "ecs/component/audio/audio_listener.h"
#include "ecs/component/audio/audio_source.h"
#include "ecs/component/core/hierarchy.h"
#include "ecs/component/core/name.h"
#include "ecs/component/core/transform.h"
#include "ecs/component/physics/character_controller.h"
#include "ecs/component/physics/collider.h"
#include "ecs/component/physics/joint.h"
#include "ecs/component/physics/ragdoll.h"
#include "ecs/component/physics/rigidbody.h"
#include "ecs/component/render/camera.h"
#include "ecs/component/render/decal.h"
#include "ecs/component/render/irradiance_volume.h"
#include "ecs/component/render/light.h"
#include "ecs/component/render/lod.h"
#include "ecs/component/render/mesh.h"
#include "ecs/component/render/particle_emitter.h"
#include "ecs/component/render/reflection_probe.h"
#include "ecs/component/ui/ui_button.h"
#include "ecs/component/ui/ui_canvas.h"
#include "ecs/component/ui/ui_element.h"
#include "ecs/component/ui/ui_image.h"
#include "ecs/component/ui/ui_scroll.h"
#include "ecs/component/ui/ui_text.h"
#include "system/script/script_component.h"
 
namespace Vkm::Engine {
 
class Scene;
 
class ResourceManager;

#define VKM_SCENE_COMPONENTS(P, R, E)             \
    P(Name,                "Name")                \
    P(Transform,           "Transform")           \
    P(Camera,              "Camera")              \
    P(Light,               "Light")               \
    P(Rigidbody,           "Rigidbody")           \
    R(Collider,            "Collider")            \
    P(CharacterController, "CharacterController") \
    E(Joint,               "Joint")               \
    E(Ragdoll,             "Ragdoll")             \
    R(Mesh,                "Mesh")                \
    R(LOD,                 "LOD")                 \
    R(Decal,               "Decal")               \
    P(ParticleEmitter,     "ParticleEmitter")     \
    R(AudioSource,         "AudioSource")         \
    P(AudioListener,       "AudioListener")       \
    P(IrradianceVolume,    "IrradianceVolume")    \
    P(ReflectionProbe,     "ReflectionProbe")     \
    P(Animation,           "Animation")           \
    R(Animator,            "Animator")            \
    P(BoneSocket,          "BoneSocket")          \
    P(ScriptComponent,     "Script")              \
    P(UICanvas,            "UICanvas")            \
    P(UIElement,           "UIElement")           \
    R(UIImage,             "UIImage")             \
    P(UIText,              "UIText")              \
    P(UIButton,            "UIButton")            \
    P(UIScroll,            "UIScroll")

namespace ComponentSerializer {
 
    nlohmann::json save(const PhysicsSettings&);
    void load(const nlohmann::json&, PhysicsSettings&);
 
    nlohmann::json save(const Name&);
    void load(const nlohmann::json&, Name&);

    nlohmann::json save(const Environment&);
    void load(const nlohmann::json&, Environment&);
 
    nlohmann::json save(const Transform&);
    void load(const nlohmann::json&, Transform&);
 
    nlohmann::json save(const Camera&);
    void load(const nlohmann::json&, Camera&);
 
    nlohmann::json save(const Light&);
    void load(const nlohmann::json&, Light&);

    nlohmann::json save(const Rigidbody&);
    void load(const nlohmann::json&, Rigidbody&);

    nlohmann::json save(const Collider&, const ResourceManager&);
    void load(const nlohmann::json&, Collider&, const ResourceManager&);

    nlohmann::json save(const CharacterController&);
    void load(const nlohmann::json&, CharacterController&);

    nlohmann::json save(const Joint&, const EntityNamer&);
    void load(const nlohmann::json&, Joint&, const EntityResolver&);

    nlohmann::json save(const Ragdoll&, const EntityNamer&);
    void load(const nlohmann::json&, Ragdoll&, const EntityResolver&);
 
    nlohmann::json save(const Mesh&, const ResourceManager&);
    void load(const nlohmann::json&, Mesh&, const ResourceManager&);

    nlohmann::json save(const Animator&, const ResourceManager&);
    void load(const nlohmann::json&, Animator&, const ResourceManager&);

    nlohmann::json save(const BoneSocket&);
    void load(const nlohmann::json&, BoneSocket&);
 
    nlohmann::json save(const LOD&, const ResourceManager&);
    void load(const nlohmann::json&, LOD&, const ResourceManager&);
 
    nlohmann::json save(const Decal&, const ResourceManager&);
    void load(const nlohmann::json&, Decal&, const ResourceManager&);
 
    nlohmann::json save(const ParticleEmitter&);
    void load(const nlohmann::json&, ParticleEmitter&);

    nlohmann::json save(const AudioSource&, const ResourceManager&);
    void load(const nlohmann::json&, AudioSource&, const ResourceManager&);
 
    nlohmann::json save(const AudioListener&);
    void load(const nlohmann::json&, AudioListener&);
 
    nlohmann::json save(const IrradianceVolume&);
    void load(const nlohmann::json&, IrradianceVolume&);
 
    nlohmann::json save(const ReflectionProbe&);
    void load(const nlohmann::json&, ReflectionProbe&);
 
    nlohmann::json save(const UICanvas&);
    void load(const nlohmann::json&, UICanvas&);
 
    nlohmann::json save(const UIElement&);
    void load(const nlohmann::json&, UIElement&);
 
    nlohmann::json save(const UIImage&, const ResourceManager&);
    void load(const nlohmann::json&, UIImage&, const ResourceManager&);
 
    nlohmann::json save(const UIText&);
    void load(const nlohmann::json&, UIText&);
 
    nlohmann::json save(const UIButton&);
    void load(const nlohmann::json&, UIButton&);
 
    nlohmann::json save(const UIScroll&);
    void load(const nlohmann::json&, UIScroll&);

    nlohmann::json save(const Hierarchy&);
    uint32_t loadParentIndex(const nlohmann::json& json);

    nlohmann::json save(const Animation&);
    void load(const nlohmann::json&, Animation&);

    nlohmann::json save(const ScriptComponent&);
    void load(const nlohmann::json&, ScriptComponent&);

    struct AssetRefs {
        std::vector<MeshHandle>          meshes;
        std::vector<MaterialHandle>      materials;
        std::vector<SkeletonHandle>      skeletons;
        std::vector<TextureHandle>       textures;
        std::vector<AnimationClipHandle> clips;
        std::vector<AudioClipHandle>     sounds;
    };

    void emitAssetRefs(const Collider&,    AssetRefs&);
    void emitAssetRefs(const Mesh&,        AssetRefs&);
    void emitAssetRefs(const LOD&,         AssetRefs&);
    void emitAssetRefs(const Decal&,       AssetRefs&);
    void emitAssetRefs(const AudioSource&, AssetRefs&);
    void emitAssetRefs(const Animator&,    AssetRefs&);
    void emitAssetRefs(const UIImage&,     AssetRefs&);

    struct UnresolvedRef {
        std::string field;
        std::string name;
        AssetType   type = AssetType::Count;  
    };

    std::vector<UnresolvedRef> takeUnresolvedRefs();

    class UnresolvedScope {
        public:
            UnresolvedScope() = default;
            ~UnresolvedScope();
 
            UnresolvedScope(const UnresolvedScope& other) = delete;
            UnresolvedScope& operator=(const UnresolvedScope& other) = delete;
 
            UnresolvedScope(UnresolvedScope && other) = delete;
            UnresolvedScope& operator=(UnresolvedScope && other) = delete;
    };
 
} // namespace ComponentSerializer
 
} // namespace Vkm::Engine