AgentGroup.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
#include <Atoms/Globals.h>
#include <Atoms/BehaviourModule.h>
#include <Atoms/LayoutGenerators/LayoutGenerator.h>
#include <Atoms/Agent.h>
#include <Atoms/SimulationTime.h>
#include <Atoms/HeightFields.h>
#include <Atoms/NavigationMeshes.h>
#include <Atoms/Graph/OperatorComputeData.h>
#include <AtomsUtils/KdTreePoint.h>
#include <AtomsCore/Metadata/MapMetadata.h>
#include <AtomsCore/Metadata/ArrayMetadata.h>
#include <map>
#include <vector>
#include <atomic>
#include <mutex>
#include <functional>
 
namespace Atoms
{
    class AtomsPhysx;
 
 
    class ATOMS_EXPORT AgentGroup
    {
    public:
 
        enum ProfileType
        {
            kInitSimulation = 0,
            kPreFrame,
            kAgentsCreated,
            kInitFrame,
            kEndFrame,
            kPrePhysics,
            kPostPhysics,
            kAgentsKilled,
            kEndSimulation,
            kResetSimulation,
            kComputePose,
            kGenerateAgents,
            kClearAgents
        };
 
 
 
        class  ATOMS_EXPORT Cache
        {
        public:
 
            enum CacheState
            {
                Empty = 0,
                Dirty,
                Updated
            };
 
            class Frame
            {
            public:
                std::vector<Atoms::Agent*> agents;
                std::vector<unsigned int> agentsCreated;
                std::vector<unsigned int> agentsKilled;
                AtomsCore::Matrix matrix;
                std::unordered_map<std::string, std::vector<Agent*>> agentTypeMapper;
                std::unordered_map<int, Agent*> localAgents;
                std::map<size_t, AtomsPtr<Atoms::Agent>> agentsCached;
                AtomsCore::MurmurHash3 hash;
            };
 
            Cache();
 
            ~Cache();
 
            void clear();
 
            void setCacheState(short value);
 
            short cacheState() const;
 
            std::vector<int> cacheFrames() const;
 
        public:
 
            std::map<long, Frame> frames;
            //std::map<size_t, AtomsPtr<Atoms::Agent>> agents;
            short m_cacheState;
            double m_prevCacheFrame;
            double m_oldSimtime;
            int m_oldEnableCacheValue;
            bool m_isCachePlaying;
            bool m_saveFrame;
            bool m_validFrame;
        };
 
        AgentGroup();
 
        ~AgentGroup();
 
 
        void addBehaviourModule(const std::string& name, const std::string& moduleTypeName);
        void addBehaviourModule(const std::string& name, AtomsPtr<BehaviourModule>& module);
 
 
        void removeBehaviourModule(const std::string& name);
 
 
        void reorderBehaviourModule(const std::string& name, unsigned int newPosition);
 
 
        const std::vector<std::string>& behaviourModuleNames() const;
 
 
        AtomsPtr<BehaviourModule> behaviourModule(const std::string& name);
 
 
        AtomsCore::MapMetadata agentGroupData();
 
 
        AtomsCore::MapMetadata behaviourModuleData(const std::string& name);
 
 
        void reloadBehaviourModule(const std::string& name);
 
 
        const std::vector<Agent*>& agents() const;
 
 
        void removeAgent(Agent* agent);
 
 
        const std::string& name() const;
 
        /*
        \param name Name
        */
        void setName(const std::string& name);
 
 
        const std::string& simulationName() const;
 
        /*
        \param name Name
        */
        void setSimulationName(const std::string& name);
 
 
        const AtomsCore::Matrix& matrix() const;
 
        /*
        \param matrix Matrix
        */
        void setMatrix(const AtomsCore::Matrix& matrix);
 
        void initializeNewAgents(std::vector<AgentInitData>& newAgentsData);
 
        void runAgentsCreatedOnAgent(Atoms::Agent *agent, const std::string& breakAtModuleName);
 
 
        void killAgents(const std::vector<unsigned int>& localIds);
 
 
        void generateAgents(double time);
 
 
        void initSimulation();
 
 
        void preFrame();
 
 
        void initFrame();
 
 
        void computePose();
 
 
        void endFrame();
 
 
        void prePhysics();
 
 
        void postPhysics();
 
 
        void endSimulation();
 
 
        void resetSimulation();
 
        void setLayoutGenerator(LayoutGeneratorPtr& layoutGen);
 
        void addLayoutGenerator(LayoutGeneratorPtr& layoutGen);
 
        const std::vector<LayoutGeneratorPtr>& layoutGenerators();
 
        LayoutGeneratorPtr getLayoutGenerator(const std::string& name) const;
 
        void removeLayoutGenerators();
 
 
        void clear();
 
 
        void clearAgents();
 
        void reset();
 
 
        bool multithread();
 
 
        void setMultithread(bool value);
 
 
        const std::unordered_map<std::string, std::vector<Agent*>> agentTypeMapper() const;
 
 
        const std::unordered_map<std::string, std::vector<Agent*>>& agentTypeMapperRef() const;
 
        void updateAgentTypeMapper();
 
 
        const std::unordered_map<int, int>& agentsSelection() const;
 
 
        void setAgentsSelection(std::unordered_map<int, int>& selectionData);
 
 
        void setActive(bool value);
 
        bool isActive() const;
 
 
        const std::unordered_map<int, Agent*>& localAgents() const;
 
        Agent* agent(unsigned int groupId);
 
 
        void filterAgent(unsigned int agentId);
 
        void filterAgents(const std::vector<int>& agentIds, bool invert = false);
 
        bool isAgentFilterInverted() const;
 
        void setAgentFilterMap(const std::unordered_map<int, bool>& data, bool invert = false);
 
        const std::unordered_map<int, bool>& agentFilter() const;
 
        void clearAgentFilter();
 
        AtomsPtr<Atoms::AgentGroup> parent();
 
        void setParent(AtomsPtr<Atoms::AgentGroup>& parent);
 
        const std::vector<unsigned int>& agentsCreated() const;
 
        const std::vector<unsigned int>& agentsKilled() const;
 
        void setCacheData(const std::vector<Agent*>& agents,
            const std::vector<unsigned int>& agentsCreated,
            const std::vector<unsigned int>& agentsKilled);
 
        const AtomsCore::MapMetadata& metadata() const;
 
        AtomsCore::MapMetadata& metadata();
 
        SimulationTime& simulationTime();
 
        const SimulationTime& simulationTime() const;
 
        HeightFields& heightFields();
 
        const HeightFields& heightFields() const;
 
        NavigationMeshes& navigationMeshes();
 
        const NavigationMeshes& navigationMeshes() const;
 
        AtomsPhysx* physics();
 
        void setPhysics(AtomsPhysx* physic);
 
        size_t profileTime(unsigned short index) const;
 
        void setProfileTime(unsigned short index, size_t us);
 
        void lock() const;
 
        void unlock() const;
 
        void enableCache(bool value);
 
        bool isCacheEnabled() const;
 
        void clearCache();
 
        const Cache& cache() const;
 
        Cache& cache();
 
        void enablePositionsKdtree(bool value);
 
        void enablePositionsKdTreeCache(bool value);
 
        const AtomsUtils::KdTreePoint& positionsKdTree() const;
 
        void updatePositionsKdTree();   
 
        void setAgentInitializationCallback(std::function<void(Agent*)>& callback);
 
        bool hasTag(const std::string& tag) const;
 
        inline std::vector<std::string>& tags() { return m_tags; }
 
        inline const std::vector<std::string>& tags() const { return m_tags; }
 
    private:
 
        std::function<void(Agent*)> m_agentInitializationCallBack;
 
        Cache m_cache;
 
        AtomsUtils::KdTreePoint m_positionsKdtree;
 
        AtomsCore::MapMetadata m_metadata;
 
        std::map<std::string, AtomsPtr<BehaviourModule>> m_behaviourModules;
 
 
        std::vector<std::string> m_moduleOrder;
 
        std::vector<Agent*> m_agents;
 
 
        std::unordered_map<std::string, std::vector<Agent*>> m_agentTypeMapper;
 
        std::unordered_map<int, int> m_agentsSelection;
 
        std::unordered_map<int, Agent*> m_localAgents;
 
        std::unordered_map<int, bool> m_agentFilter;
 
        std::vector<unsigned int> m_agentsCreated;
 
        std::vector<unsigned int> m_agentsKilled;
 
        std::string m_name;
 
        std::string m_simulationName;
 
        AtomsCore::Matrix m_matrix;
 
        std::vector<LayoutGeneratorPtr> m_layoutGenerators;
 
        std::atomic<size_t> m_localIdCounter;
 
        AtomsPtr<AgentGroup> m_parent;
 
        SimulationTime m_simTime;
 
        HeightFields m_heightFields;
 
        NavigationMeshes m_navigationMeshes;
 
        AtomsPhysx* m_physx;
 
        OperatorComputeData m_computeData;
 
        std::vector<std::string> m_tags;
 
        size_t m_profileTime[14];
 
        mutable std::mutex m_mutex;
 
        bool m_active;
 
        bool m_multiThread;
 
        bool m_status;
 
        bool m_cacheEnabled;
 
        bool m_invertAgentFilter;
 
        bool m_enableKdTree;
 
        bool m_cacheKdTree;
    };
}
 
#include "AgentGroup.impl.h"