fsCEntity.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           fsCEntity.h
*
*       Purpose:        Core container for components.
*
*                               Interface components via fsCUniqueId which is also
*                               handily wrapped up using templates to make the client
*                               code cleaner.
*
*                               Based on fsCUniqueId so you can't remove the interface
*                               to it!
*
*********************************************************************/
 
#ifndef fsCEntityhdr
#define fsCEntityhdr
 
#include <typeinfo>
#include <map>
#include <vector>
#include <algorithm>
#include <memory>
 
 
#include "../fsINode.h"
 
class fsIComponent;
class fsCUniqueId;
class fsIRenderableComponent;
class fsISpriteComponent;
class fsIScene;
class fsITextSpriteComponent;
class fsCComponentFactory;
class fsCEntityFactory;
class fsCTaggableComponent;
 
class fsCEntity : public fsINode
{
        friend class fsCEntityFactory;
        friend class gfCTestLoadGuis;
        friend class fsIGuiComponent;
 
public:
  fsCEntity *grandparentGet() const;
 
        void listenersRegister();
        void listenersDeRegister();
 
        static void componentFactorySet(std::shared_ptr<fsCComponentFactory> pComponentFactory);
        fsCComponentFactory *componentFactoryGet();
        static void entityFactorySet(std::shared_ptr<fsCEntityFactory> pEntityFactory);
        fsCEntityFactory *entityFactoryGet();
 
        fsITextSpriteComponent *textComponentGet() const;
        fsITextSpriteComponent *textComponentAdd();
 
        fsISpriteComponent *spriteComponentGet() const;
        fsISpriteComponent *spriteComponentAdd();
 
        fsBool tagExists(fsStr const& pTag) const;
        void tagAdd(fsStr const& pTag);
 
        template <typename TComponent>
        TComponent* componentAdd();
        fsIComponent *componentAdd(const fsCUniqueId& pTypeId);
 
        template <typename TComponent>
        TComponent* componentGet() const;
        fsIComponent *componentGet(const fsCUniqueId& pTypeId) const;
 
        void componentDestroy(const fsCUniqueId& pTypeId);
 
        template <typename TInterface>
        TInterface* firstComponentOfFamilyType() const;
 
        template <typename TLamda>
        void forMyChildren(TLamda&& pLamda);
        template <typename TLamda>
        void forAllChildren(TLamda&& pLamda);
 
        fsCEntity* childFind(const fsStr& pName, fsBool pCaseless = false);
 
        template <typename TInterface>
        std::vector<TInterface*> componentsOfFamilyTypeGet() const;
        template <typename TInterface>
        std::vector<fsCEntity*> childEntitiesWithComponentsOfFamilyType();
        std::vector<fsCEntity*> childEntitiesWithComponentsOfTypeGet(
                const std::vector<const std::type_info*>& pPossibleComponentTypes);
        std::vector<fsCEntity*> childEntitiesTaggedWithGet(std::vector<fsStr> pTags);
 
        template <typename TInterface>
        fsCEntity *firstChildEntityWithComponentsOfFamilyType();
 
protected:
 
        fsCEntity(const fsStr& pName);
        virtual ~fsCEntity();
 
        void initialiseFromVariableTableDo(const fsCVariableTable& pVars) override;
 
        void updateDo(fsS32 pDeltaMs) override;
        void renderDo() override;
        void updatedMatrixProcess() override;
 
        void initDo() override;
        void resetDo() override;
        void serialiseDo() override;
        void deserialiseDo() override;
        void postLoad() override;
        void postLinkDo() override;
 
private:
 
 
        void componentUpdateMethodExecute(void (fsIComponent::*pMethod)());
 
        void deferredComponentsAdd();
        void deferredComponentsRemove();
 
        void componentUnregisterAndDestroy(const fsCUniqueId& pTypeId);
 
        void childEntitiesWithComponentsOfTypeGetDo(std::vector<fsCEntity*>& pVectorToFill,
                                                    const std::vector<const std::type_info*>& pPossibleComponentTypes);
        void childEntitiesTaggedWithGetDo(std::vector<fsStr> pTags, std::vector<fsCEntity*>& pEnts);
 
        std::map<fsU32, fsIComponent*> mComponentsMap;
        std::vector<fsIComponent*> mComponentsVector;
 
        std::vector<std::pair<fsIComponent*, fsU32>> mComponentsToAdd;
        std::vector<fsCUniqueId> mComponentsToDestroy;
 
        fsBool mInComponentUpdate;
 
        static std::shared_ptr<fsCEntityFactory> mEntityFactory;
        static std::shared_ptr<fsCComponentFactory> mComponentFactory;
};
 
 
template <typename TInterface>
TInterface* fsCEntity::firstComponentOfFamilyType() const
{
        for (auto iter = mComponentsMap.begin(); iter != mComponentsMap.end(); ++iter)
        {
                if (auto* result = dynamic_cast<TInterface*>(iter->second))
                {
                        return result;
                }
        }
 
        for (auto iter = mComponentsToAdd.begin(); iter != mComponentsToAdd.end(); ++iter)
        {
                if (auto* result = dynamic_cast<TInterface*>(iter->first))
                {
                        return result;
                }
        }
        return nullptr;
}
 
template <typename TInterface>
std::vector<TInterface*> fsCEntity::componentsOfFamilyTypeGet() const
{
        std::vector<TInterface*> comps;
        for (auto iter = mComponentsMap.begin(); iter != mComponentsMap.end(); ++iter)
        {
                if (auto* result = dynamic_cast<TInterface*>(iter->second))
                {
                        comps.push_back(result);
                }
        }
 
        for (auto compIt = mComponentsToAdd.begin(); compIt != mComponentsToAdd.end(); ++compIt)
        {
                if (auto* result = dynamic_cast<TInterface*>(compIt->first))
                {
                        comps.push_back(result);
                }
        }
        return comps;
}
 
 
template <typename TInterface>
std::vector<fsCEntity*> fsCEntity::childEntitiesWithComponentsOfFamilyType()
{
        std::vector<fsCEntity*> ents;
 
        for (fsINode* child : mChildren)
        {
                if (fsCEntity* childEnt = dynamic_cast<fsCEntity*>(child))
                {
                        auto ret = childEnt->childEntitiesWithComponentsOfFamilyType<TInterface>();
                        ents.insert(ents.end(), ret.begin(), ret.end());
                }
        }
 
        for (auto iter = mComponentsMap.begin(); iter != mComponentsMap.end(); ++iter)
        {
                if (dynamic_cast<TInterface*>(iter->second))
                {
                        ents.push_back(this);
                }
        }
        return ents;
}
 
template <typename TComponent>
TComponent* fsCEntity::componentGet() const
{
        return dynamic_cast<TComponent* const>(componentGet(TComponent::mTypeId));
}
 
template <typename TComponent>
TComponent* fsCEntity::componentAdd()
{
        return dynamic_cast<TComponent* const>(componentAdd(TComponent::mTypeId));
}
 
template <typename TInterface>
fsCEntity *fsCEntity::firstChildEntityWithComponentsOfFamilyType()
{
        for (fsINode* child : mChildren)
        {
                if (fsCEntity* childEnt = dynamic_cast<fsCEntity*>(child))
                {
                        if (auto matchEnt = childEnt->firstChildEntityWithComponentsOfFamilyType<TInterface>())
                        {
                                return matchEnt;
                        }
                }
        }
 
        for (auto component : mComponentsMap)
        {
                if (dynamic_cast<TInterface*>(component.second))
                {
                        return this;
                }
        }
        return nullptr;
}
 
template <typename TLamda>
void fsCEntity::forAllChildren(TLamda&& pLamda)
{
        std::for_each(mChildren.begin(), mChildren.end(),
                      [&pLamda](fsINode* node)
                      {
                              if (fsCEntity* const ent = dynamic_cast<fsCEntity*>(node))
                              {
                                      ent->forAllChildren(pLamda);
                              }
                      });
        pLamda(this);
}
 
template <typename TLamda>
void fsCEntity::forMyChildren(TLamda&& pLamda)
{
        std::for_each(mChildren.begin(), mChildren.end(), pLamda);
}
 
#endif