tb_component.hpp

 
#ifndef TurtleBrains_Component_hpp
#define TurtleBrains_Component_hpp
 
#include <turtle_brains/core/tb_configuration.hpp>
#include <turtle_brains/core/tb_noncopyable.hpp>
#include <turtle_brains/core/tb_uuid.hpp>
 
#include <vector>
#include <memory>
 
namespace TurtleBrains::Core
{
 
    class Node;
 
    namespace Implementation
    {
        enum class ComponentKeyType { };
        enum class ComponentTypeKeyType { };
    };
 
    typedef TypedUUID<Implementation::ComponentKeyType> ComponentKey;
    typedef TypedUUID<Implementation::ComponentTypeKeyType> ComponentTypeKey;
 
    class Component;
    typedef std::unique_ptr<Component> ComponentPointer;
 
    typedef std::function<ComponentPointer(Node&, const ComponentKey&)> CreateComponentFunction;
 
    namespace ComponentCreator
    {
        void RegisterComponent(const ComponentTypeKey& componentTypeKey, CreateComponentFunction createCallback);
        void UnregisterComponent(const ComponentTypeKey& componentTypeKey);
 
        void EnableComponent(const ComponentTypeKey& componentTypeKey);
        void DisableComponent(const ComponentTypeKey& componentTypeKey);
 
        template<typename ComponentType> void EnableComponent(void) { EnableComponent(ComponentType::ComponentTypeKey()); }
        template<typename ComponentType> void DisableComponent(void) { DisableComponent(ComponentType::ComponentTypeKey()); }
 
 
        ComponentPointer CreateComponent(Node& node, const ComponentKey& componentKey, const ComponentTypeKey& componentTypeKey);
 
        template<typename ComponentType> std::unique_ptr<ComponentType> CreateComponent(Node& node,
            const ComponentKey& componentKey = ComponentKey::Generate4())
        {
            ComponentPointer component = CreateComponent(node, componentKey, ComponentType::ComponentTypeKey());
            if (nullptr != component)
            {
                ComponentType* derivedComponent = dynamic_cast<ComponentType*>(component.get());
                if (nullptr != derivedComponent)
                {   // This will transfer the ownership to from the component unique_ptr into the returned ComponentType
                    //   unique_ptr.
                    component.release();
                    return std::unique_ptr<ComponentType>(derivedComponent);
                }
 
                tb_error("Expected a ComponentType to match the ComponentType...");
            }
 
            return nullptr;
        }
    };
 
    //    and since this is polymorphic use a virtual destructor. It is also required to add a static function
    class Component : tbCore::Noncopyable
    {
    public:
        const Node& mNode;
 
        virtual ~Component(void);
 
        virtual void OnAwake(void) { }
        virtual void OnDestroy(void) { }
 
        virtual void OnActivate(void) { }
        virtual void OnDeactivate(void) { }
 
        virtual void OnSimulate(void) { }
        virtual void OnUpdate(const float /*deltaTime*/) { }
        virtual void OnRender(void) const { }
 
        virtual void OnTriggerEnter(const Node& /*otherNode*/) { }
        virtual void OnTriggerStay(const Node& /*otherNode*/) { }
        virtual void OnTriggerLeave(const Node& /*otherNode*/) { }
 
        inline const Node& GetNode(void) const { return mNode; }
 
        bool IsValid(void) const { return (ComponentTypeKey::Invalid() != mComponentTypeKey && ComponentKey::Invalid() != mComponentKey); }
 
        bool IsActive(void) const;
        inline bool IsActiveSelf(void) const { return mIsActive; }
        void SetActive(const bool isActive);
 
        inline const ComponentKey& GetKey(void) const { return mComponentKey; }
        inline const ComponentTypeKey& GetTypeKey(void) const { return mComponentTypeKey; }
 
        template<typename ComponentType> static ComponentTypeKey RegisterComponent(void)
        {
            ComponentCreator::RegisterComponent(ComponentType::ComponentTypeKey(), [](Node& node, const ComponentKey& componentKey){
                return std::make_unique<ComponentType>(node, componentKey);
            });
            return ComponentType::ComponentTypeKey();
        }
 
    protected:
        Node& mMutableNode;
 
        Component(Node& node, const ComponentKey& componentKey, const ComponentTypeKey& componentTypeKey);
 
    private:
        friend class Node;
        const ComponentTypeKey mComponentTypeKey;
        const ComponentKey mComponentKey;
        bool mIsActive;
    };
 
}; /* namespace TurtleBrains::Core */
 
namespace tbCore = TurtleBrains::Core;
 
#endif /* TurtleBrains_Component_hpp */