Entity.hpp

Go to the documentation of this file.

#pragma once
#include "Engine/api.hpp"
#include "Engine/Utility/Logging.hpp"
#include "Engine/Components/Component.hpp"

#include <ThirdParty/EASTL-master/include/EASTL/string.h>

namespace Engine
{
    class ENGINE_API Entity
    {
    public:

        virtual ~Entity() = default;

        template<typename ComponentType>
        eastl::weak_ptr<ComponentType> GetComponent();

        template<typename ComponentType>
        eastl::vector<eastl::weak_ptr<ComponentType>> GetComponents();

        eastl::vector<eastl::shared_ptr<Component>> GetAllComponents() const;

        template <class ComponentType, class... Args>
        eastl::weak_ptr<ComponentType> AddComponent(Args&&... args);

        //template <class ComponentType, class... Args, eastl::enable_if_t<eastl::extent<ComponentType>::value != 0, int> = 0>
        //eastl::weak_ptr<ComponentType> AddComponent(Args&&... args) = delete;

        template <class ComponentType, class... Args>
        eastl::vector<eastl::weak_ptr<ComponentType>> AddComponents(size_t count, Args&&... args);

        template <typename ComponentType>
        void RemoveComponent(size_t amountToRemove = 1);

        template <typename ComponentType>
        void RemoveAllComponents();

        eastl::shared_ptr<Entity> GetPointer() const;

        virtual void Update();

        size_t ComponentCount() const;

        uint64_t GetID() const;

        eastl::string name;

        bool GetIsActive() const;

        void SetIsActive(bool isActive);

    protected:
        uint64_t Id;
        friend class EntitySystem;
        friend class Map;
        eastl::vector<eastl::shared_ptr<Component>> components;
        explicit Entity(eastl::string name = "");
        virtual void InitializeEntity();

    private:

        bool isActive;
        void SetID(uint64_t Id);
        void OnComponentAdded(eastl::weak_ptr<Component> addedComponent);
        void OnComponentRemoved(eastl::weak_ptr<Component> removedComponent);

        // Allows use of OnBeginContact and OnEndContact by EntityContact Callback class
        friend class EntityContact;
        void OnBeginContact(eastl::weak_ptr<Entity> entity);
        void OnEndContact(eastl::weak_ptr<Entity> entity);
    };

    template <typename ComponentType>
    eastl::weak_ptr<ComponentType> Entity::GetComponent()
    {
        for (size_t i = 0, size = components.size(); i < size; ++i)
        {
            if (dynamic_cast<ComponentType*>(components[i].get()))
            {
                return eastl::dynamic_pointer_cast<ComponentType>(components[i]);
            }
        }
        return eastl::weak_ptr<ComponentType>();
    }

    template <typename ComponentType>
    eastl::vector<eastl::weak_ptr<ComponentType>> Entity::GetComponents()
    {
        eastl::vector<eastl::weak_ptr<ComponentType>> componentsToReturn;

        for (size_t i = 0, size = components.size(); i < size; ++i)
        {
            if (dynamic_cast<ComponentType*>(components[i].get()))
                componentsToReturn.push_back(eastl::dynamic_pointer_cast<ComponentType>(components[i]));
        }

        return componentsToReturn;
    }

    template <class ComponentType, class... Args>
    eastl::weak_ptr<ComponentType> Entity::AddComponent(Args&&... args)
    {
        eastl::shared_ptr<ComponentType> componentToAdd = eastl::shared_ptr<ComponentType>(new ComponentType(eastl::forward<Args>(args)...));
        components.push_back(eastl::move(componentToAdd));

        eastl::shared_ptr<Component> componentToReturn = components.back();
        componentToReturn->SetOwner(GetPointer());
        componentToReturn->SetPointerReference(componentToReturn);
        OnComponentAdded(componentToReturn);

        for (size_t j = 0, size = components.size(); j < size; ++j)
            componentToReturn->OnComponentAdded(components[j]);

        componentToReturn->InitializeComponent();

        return eastl::static_pointer_cast<ComponentType>(componentToReturn);
    }

    template <class ComponentType, class... Args>
    eastl::vector<eastl::weak_ptr<ComponentType>> Entity::AddComponents(size_t count, Args&&... args)
    {
        eastl::vector<eastl::weak_ptr<ComponentType>> componentsToReturn;

        for (size_t i = 0; i < count; ++i)
        {
            eastl::shared_ptr<ComponentType> componentToAdd = eastl::shared_ptr<ComponentType>(new ComponentType(eastl::forward<Args>(args)...));
            components.push_back(eastl::move(componentToAdd));

            eastl::shared_ptr<Component> componentToReturn = components.back();
            componentToReturn->SetOwner(GetPointer());
            componentToReturn->SetPointerReference(componentToReturn);
            OnComponentAdded(componentToReturn);

            for (size_t j = 0, size = components.size(); j < size; ++j)
                componentToReturn->OnComponentAdded(components[j]);

            componentToReturn->InitializeComponent();

            componentsToReturn.push_back(eastl::static_pointer_cast<ComponentType>(componentToReturn));
        }
        return componentsToReturn;
    }

    template <typename ComponentType>
    void Entity::RemoveComponent(size_t amountToRemove)
    {
        if (amountToRemove != 1 && amountToRemove > components.size())
            amountToRemove = components.size();

        for (size_t i = components.size() - 1; i != -1; --i)
        {
            if (dynamic_cast<ComponentType*>(components[i].get()))
            {
                eastl::weak_ptr<Component> componentToRemove = components[i];
                components.erase(components.begin() + i);
                OnComponentRemoved(componentToRemove);
            }
            amountToRemove--;
            if (amountToRemove == 0)
                break;
        }
    }

    template <typename ComponentType>
    void Entity::RemoveAllComponents()
    {
        for (size_t i = components.size() - 1; i != -1; --i)
        {
            if (dynamic_cast<ComponentType*>(components[i].get()))
            {
                eastl::weak_ptr<Component> componentToRemove = components[i];
                components.erase(components.begin() + i);
                OnComponentRemoved(componentToRemove);
            }
        }
    }
} // namespace Engine