component.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
 
#include <rtti/object.h>
#include <rtti/objectptr.h>
#include <utility/dllexport.h>
#include <nap/resource.h>
 
#include <cassert>
 
namespace nap
{
    // Forward Declares
    namespace utility
    {
        class ErrorState;
    }
 
    class Entity;
    class EntityInstance;
    class Component;
    struct EntityCreationParameters;
 
    template<class TargetComponentType>
    class ComponentInstancePtr;
 
    template<class ComponentType>
    class ComponentPtr;
 
    class EntityPtr;
    class EntityInstancePtr;
 
    class NAPAPI ComponentInstance : public rtti::Object
    {
        RTTI_ENABLE(rtti::Object)
 
    public:
        using Object::init;
        
        ComponentInstance(EntityInstance& entity, Component& resource) : 
            mEntityInstance(&entity),
            mResource(&resource)
        { }
 
        virtual void update(double deltaTime)               { }
 
        nap::EntityInstance* getEntityInstance() const      { return mEntityInstance; }
 
        nap::Component* getComponent() const                { return mResource; }
 
        template<typename T>
        T* getComponent() const;
 
        virtual bool init(utility::ErrorState& errorState);
 
    private:
        template<typename TargetComponentType, typename SourceComponentType>
        friend std::vector<ComponentInstancePtr<TargetComponentType>> initComponentInstancePtr(ComponentInstance* sourceComponentInstance, std::vector<ComponentPtr<TargetComponentType>>(SourceComponentType::*componentMemberPointer));
 
        template<typename SourceComponentType>
        friend std::vector<EntityInstancePtr> initEntityInstancePtr(ComponentInstance* sourceComponentInstance, std::vector<EntityPtr>(SourceComponentType::*entityMemberPointer));
 
        template<class TargetComponentType> friend class ComponentInstancePtr;
        friend class EntityInstancePtr;
        friend class SceneInstantiation;
        
        void addToComponentLinkMap(Component* targetResource, const std::string& instancePath, ComponentInstance** targetInstancePtr);
 
        void addToEntityLinkMap(Entity* targetResource, const std::string& instancePath, EntityInstance** targetInstancePtr);
 
    private:
        template<class INSTANCETYPE>
        struct TargetInstanceLink
        {
            INSTANCETYPE**      mTargetPtr;     
            std::string         mInstancePath;  
        };
 
        using TargetComponentLink = TargetInstanceLink<ComponentInstance>;
        using TargetEntityLink = TargetInstanceLink<EntityInstance>;
 
        using ComponentLinkMap  = std::unordered_map<Component*, std::vector<TargetComponentLink>>;
        using EntityLinkMap     = std::unordered_map<Entity*, std::vector<TargetEntityLink>>;
 
        ComponentLinkMap    mComponentLinkMap;  // Map containing component instance link information that is used to resolve pointers
        EntityLinkMap       mEntityLinkMap;     // Map containing entity instance link information that is used to resolve pointers
        EntityInstance*     mEntityInstance;    // The entity this component belongs to
        Component*          mResource;          // The resource this instance was created from
    };
 
    // Component
 
    class NAPAPI Component : public Resource
    {
        RTTI_ENABLE(Resource)
 
    public:
        virtual void getDependentComponents(std::vector<rtti::TypeInfo>& components) const { }
 
        virtual const rtti::TypeInfo getInstanceType() const = 0;
    
    private:
        const std::string& getOriginalID() const;
 
    private:
        friend class Scene;
        friend class SceneInstantiation;
        Component* mOriginalComponent = nullptr;    // If this Component was cloned from another component (for instance properties), this property holds the Component it was cloned from
    };
 
 
    template<typename T>
    T* ComponentInstance::getComponent() const
    {
        T* comp = rtti_cast<T>(mResource);
        assert(comp != nullptr);
        return comp;
    }
 
 
#define DECLARE_COMPONENT(ComponentType, ComponentInstanceType)             \
    public:                                                                 \
        using InstanceType = ComponentInstanceType;                         \
        virtual const rtti::TypeInfo getInstanceType() const override       \
        {                                                                   \
            return nap::rtti::TypeInfo::get<InstanceType>();                \
        }                                                                   \
    private:
 
}