entity.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "componentptr.h"
#include "component.h"
#include "instanceproperty.h"
 
// External Includes
#include <utility/uniqueptrvectoriterator.h>
#include <nap/resource.h>
#include <nap/resourceptr.h>
 
namespace nap
{
    // Forward Declares
    class Core;
    class Component;
    class Entity;
    class EntityInstance;   
    class Scene;
 
    // Using
    using EntityList = std::vector<EntityInstance*>;
 
    class NAPAPI EntityInstance : public rtti::Object
    {
        RTTI_ENABLE(rtti::Object)
 
    public:
        using rtti::Object::init;
        
        using ComponentList = std::vector<std::unique_ptr<ComponentInstance>>;
        using ChildList = std::vector<EntityInstance*>;
        using ComponentIterator = utility::UniquePtrVectorWrapper<ComponentList, ComponentInstance*>;
        using ComponentConstIterator = utility::UniquePtrConstVectorWrapper<ComponentList, ComponentInstance*>;
 
        EntityInstance(Core& core, const Entity* entity);
 
        bool init(Scene& scene, EntityCreationParameters& entityCreationParams, utility::ErrorState& errorState);
 
        virtual void onDestroy() override {}
 
        void update(double deltaTime);
 
        void addComponent(std::unique_ptr<ComponentInstance> component);
 
        ComponentInstance* findComponent(const std::string& type) const;
        
        ComponentInstance* findComponentByID(const std::string& identifier) const;
 
        template<class T >
        T* findComponentByID(const std::string& identifier) const;
 
        ComponentInstance* findComponent(const rtti::TypeInfo& type) const;
 
        template<class T>
        T* findComponent() const;
 
        bool hasComponent(const rtti::TypeInfo& type) const;
 
        template<class T>
        bool hasComponent() const;
 
        ComponentInstance& getComponent(const rtti::TypeInfo& type) const;
 
        template<class T>
        T& getComponent() const;
 
        void getComponentsOfType(const rtti::TypeInfo& type, std::vector<ComponentInstance*>& components) const;
 
        template<class T>
        void getComponentsOfType(std::vector<T*>& outComponents) const;
 
        template<class T>
        void getComponentsOfTypeRecursive(std::vector<T*>& outComponents);
 
        bool hasComponentsOfType(const rtti::TypeInfo& type) const;
 
        template<class T>
        bool hasComponentsOfType() const;
 
        void addChild(EntityInstance& child);
 
        void clearChildren();
 
        void removeChild(const EntityInstance& entityInstance);
 
        const ChildList& getChildren() const;
 
        EntityInstance* getParent() const;
 
        const Entity* getEntity() const;
 
        Core* getCore() const;
 
        ComponentIterator getComponents()                                   { return ComponentIterator(mComponents); }
        
        ComponentConstIterator getComponents() const                        { return ComponentConstIterator(mComponents); }
 
        EntityInstance& operator[](std::size_t index)                       { assert(index < mChildren.size()); return *(mChildren[index]); }
 
        const EntityInstance& operator[](std::size_t index) const           { assert(index < mChildren.size()); return *(mChildren[index]); }
 
    private:
        Core*           mCore = nullptr;
        const Entity*   mResource = nullptr;    // Resource of this entity
        EntityInstance* mParent = nullptr;      // Parent of this entity
        ComponentList   mComponents;            // The components of this entity
        ChildList       mChildren;              // The children of this entity
    };
 
    class NAPAPI SpawnedEntityInstance
    {
    public:
        SpawnedEntityInstance() = default;
 
        rtti::ObjectPtr<EntityInstance>& get() { return mEntityInstance; }
 
        const rtti::ObjectPtr<EntityInstance>& get() const { return mEntityInstance; }
 
        const EntityInstance& operator*() const
        {
            assert(mEntityInstance != nullptr);
            return *mEntityInstance;
        }
 
        EntityInstance& operator*()
        {
            assert(mEntityInstance != nullptr);
            return *mEntityInstance;
        }
 
        EntityInstance* operator->() const
        {
            assert(mEntityInstance != nullptr);
            return mEntityInstance.get();
        }
 
        EntityInstance* operator->()
        {
            assert(mEntityInstance != nullptr);
            return mEntityInstance.get();
        }
 
        bool operator==(const SpawnedEntityInstance& other) const
        {
            return mEntityInstance == other.mEntityInstance;
        }
 
        bool operator==(const EntityInstance* ptr) const
        {
            return mEntityInstance == ptr;
        }
 
        bool operator!=(const SpawnedEntityInstance& other) const
        {
            return mEntityInstance != other.mEntityInstance;
        }
 
        bool operator!=(const EntityInstance* ptr) const
        {
            return mEntityInstance != ptr;
        }
 
        bool operator<(const SpawnedEntityInstance& other) const
        {
            return mEntityInstance < other.mEntityInstance;
        }
 
        bool operator>(const SpawnedEntityInstance& other) const
        {
            return mEntityInstance > other.mEntityInstance;
        }
 
        bool operator<=(const SpawnedEntityInstance& other) const
        {
            return mEntityInstance <= other.mEntityInstance;
        }
 
        bool operator>=(const SpawnedEntityInstance& other) const
        {
            return mEntityInstance >= other.mEntityInstance;
        }
 
    private:
        friend class Scene;
 
        SpawnedEntityInstance(EntityInstance* entityInstance) :
            mEntityInstance(entityInstance)
        {
        }
 
    private:
        rtti::ObjectPtr<EntityInstance> mEntityInstance;
    };
 
    // Entity Resource
 
    class NAPAPI Entity : public Resource
    {
        RTTI_ENABLE(Resource)
    public:
        using ComponentList = std::vector<rtti::ObjectPtr<Component>>;
        using EntityList = std::vector<rtti::ObjectPtr<Entity>>;
 
        rtti::ObjectPtr<Component> findComponent(const rtti::TypeInfo& type) const;
 
        bool hasComponent(const rtti::TypeInfo& type) const;
 
        template<class T>
        bool hasComponent() const;
 
        const ComponentList& getComponents() const                          { return mComponents; }
 
        static constexpr const char* componentsPropertyName()               { return "Components"; }
 
        static constexpr const char* childrenPropertyName()                 { return "Children"; }
 
    public:
        ComponentList   mComponents;            // The components of this entity
        EntityList      mChildren;              // The children of this entity
    };
 
 
    template<class T>
    void EntityInstance::getComponentsOfType(std::vector<T*>& components) const
    {
        const rtti::TypeInfo type = rtti::TypeInfo::get<T>();
        for (auto& component : mComponents)
            if (rtti::isTypeMatch(component->get_type(), type, rtti::ETypeCheck::IS_DERIVED_FROM))
                components.emplace_back(rtti_cast<T>(component.get()));
    }
 
 
    template<typename T>
    void getComponentsOfTypeRecursive(nap::EntityInstance& entity, std::vector<T*>& outComponents)
    {
        entity.getComponentsOfType<T>(outComponents);
        for (auto& child : entity.getChildren())
            getComponentsOfTypeRecursive<T>(*child, outComponents);
    }
 
 
    template<class T>
    void EntityInstance::getComponentsOfTypeRecursive(std::vector<T*>& outComponents)
    {
        nap::getComponentsOfTypeRecursive<T>(*this, outComponents);
    }
 
 
    template<class T>
    bool EntityInstance::hasComponentsOfType() const
    {
        return hasComponentsOfType(rtti::TypeInfo::get<T>());
    }
 
    template<class T >
    T* EntityInstance::findComponentByID(const std::string& identifier) const
    {
        T* element = rtti_cast<T>(findComponentByID(identifier));
        if (element == nullptr)
            return nullptr;
        return rtti::isTypeMatch(element->get_type(), RTTI_OF(T), rtti::ETypeCheck::IS_DERIVED_FROM) ? element : nullptr;
    }
 
    template<class T>
    T* EntityInstance::findComponent() const
    {
        return rtti_cast<T>(findComponent(rtti::TypeInfo::get<T>()));
    }
 
    template<class T>
    bool EntityInstance::hasComponent() const
    {
        return hasComponent(rtti::TypeInfo::get<T>());
    }
 
    template<class T>
    T& EntityInstance::getComponent() const
    {
        return *rtti_cast<T>(&getComponent(rtti::TypeInfo::get<T>()));
    }
 
 
    template<class T>
    bool Entity::hasComponent() const
    {
        return hasComponent(rtti::TypeInfo::get<T>());
    }
}