Component.hpp

Go to the documentation of this file.

#pragma once

#include "Engine/api.hpp"

#include <ThirdParty/cereal/include/cereal/cereal.hpp>
#include <ThirdParty/EASTL-master/include/EASTL/shared_ptr.h>
#include <ThirdParty/EASTL-master/include/EASTL/vector.h>

namespace Engine
{
    class Entity;

    class ENGINE_API Component
    {
    public:
        virtual ~Component() = default;
        eastl::weak_ptr<Entity> GetOwner() const;

        bool isEnabled;

    protected:
        friend class Entity;
        explicit Component();

        virtual void InitializeComponent();

        virtual void Update();

        virtual void OnComponentAdded(eastl::weak_ptr<Component> addedComponent);

        virtual void OnComponentRemoved(eastl::weak_ptr<Component> removedComponent);

        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) const;

        template <typename ComponentType>
        void RemoveAllComponents() const;

        template <typename archive>
        void SaveBaseComponent(archive ar);

        template <typename archive>
        void LoadBaseComponent(archive ar);

        virtual void OnBeginContact(eastl::weak_ptr<Entity> entity);
        virtual void OnEndContact(eastl::weak_ptr<Entity> entity);

        eastl::weak_ptr<Component> GetPointerRefence() const;

        template <typename ComponentType>
        eastl::weak_ptr<ComponentType> GetPointerRefence();
    private:
        void SetOwner(eastl::weak_ptr<Entity> owner);

        void SetPointerReference(eastl::weak_ptr<Component> pointerReference);

        eastl::weak_ptr<Entity> owner;
        eastl::weak_ptr<Component> pointerReference;

    };

    template <typename ComponentType>
    eastl::weak_ptr<ComponentType> Component::GetComponent()
    {
        return owner.lock()->GetComponent<ComponentType>();
    }

    template <typename ComponentType>
    eastl::vector<eastl::weak_ptr<ComponentType>> Component::GetComponents()
    {
        return owner.lock()->GetComponents<ComponentType>();
    }

    template <class ComponentType, class ... Args>
    eastl::weak_ptr<ComponentType> Component::AddComponent(Args&&... args)
    {
        return owner.lock()->AddComponent<ComponentType>(&args...);
    }

    template <class ComponentType, class ... Args>
    eastl::vector<eastl::weak_ptr<ComponentType>> Component::AddComponents(size_t count, Args&&... args)
    {
        return owner.lock()->AddComponents<ComponentType>(count, &args...);
    }

    template <typename ComponentType>
    void Component::RemoveComponent(size_t amountToRemove) const
    {
        owner.lock()->RemoveComponent<ComponentType>(amountToRemove);
    }

    template <typename ComponentType>
    void Component::RemoveAllComponents() const
    {
        owner.lock()->RemoveAllComponents<ComponentType>();
    }

    template <typename ComponentType>
    eastl::weak_ptr<ComponentType> Component::GetPointerRefence()
    {
        return eastl::dynamic_pointer_cast<ComponentType, Component>(pointerReference.lock());
    }
} // namespace Engine