EntitiesBase.hpp

#pragma once
#ifndef KJY_ANIM_ENGINE_ENTITIES_BASE_HPP_
#define KJY_ANIM_ENGINE_ENTITIES_BASE_HPP_

#include <string>
#include <map>
#include <components/inheritable/poseable.hpp>
#include <components/attachable/KeyframeAnimation.hpp>
#include <components/attachable/AttachableComponent.hpp>
#include <util/UUID.hpp>

#pragma warning(disable: 4250) // Disable warnings about dominance in MSVC

typedef uuid_t ent_uuid_t;

std::string uuid_to_string(ent_uuid_t uuid);

class Entity : virtual public PureComponent{
 public:
    Entity() : uuid(generate_uuid()) {}
    Entity(const std::string& name) : uuid(generate_uuid()), _name(name) {}

    inline const ent_uuid_t& UUID() const {return(uuid);}

    inline const std::string& getName() const {return(_name);}
    inline void setName(const std::string& name) {_name = name;}

    void addChild(Entity* entity);
    virtual void unlink();
    virtual void link(Entity* parent);

    virtual Entity* replace(Entity* replacement);
    
    inline const std::map<ent_uuid_t, Entity*>& getChildren() const {return(_children);}
    inline size_t numChildren() const {return(_children.size());}
    inline bool hasParent() const {return(_parent != nullptr);}
    inline Entity* getParent() {return(_parent);}
    inline const Entity* getParent() const {return(_parent);}

    unsigned int traversal_scratch = 0;

 protected:
    std::string _name;
    Entity* _parent = nullptr;
    std::map<ent_uuid_t, Entity*> _children;

    // Needed since sometimes the final world pose is needed for rendering, but determined during animation. 

 private:
    ent_uuid_t uuid;
};

class WorldEntity : virtual public Entity, virtual public PosedComponent{
 public:
    virtual ~WorldEntity() {};
};

class PoseableWorldEntity : virtual public WorldEntity, virtual public PoseableComponent{
 public:
    virtual ~PoseableWorldEntity() {};
};

class StaticEmptyEntity : virtual public WorldEntity{
 public:
    StaticEmptyEntity(){}
    StaticEmptyEntity(const Pose& pose) : pose(pose) {}
    virtual const Pose& getPose() const override {return(pose);}

 protected:
    Pose pose;
};

struct EmptyEntity : virtual public StaticEmptyEntity, virtual public PoseableWorldEntity{
    EmptyEntity(){}
    EmptyEntity(const Pose& aPose) : StaticEmptyEntity(aPose) {}
    virtual const Pose& getPose() const override {return(this->pose);}
    virtual Pose& getMutablePose() {return(this->pose);}
    virtual void setPose(const Pose& aPose) override {this->pose = aPose;}
};

class CachedFinalPose
{
 public:
    virtual const Pose& getCachedFinalPose() const {return(_mCachedFinalPose);}
    virtual void setCachedFinalPose(const Pose& aPose) {_mCachedFinalPose = aPose;}

 protected:
    Pose _mCachedFinalPose;
};

#endif