BehaviourModule.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 <AtomsCore/Metadata/MapMetadata.h>
#include <AtomsCore/Metadata/MetadataImpl.h>
#include <Atoms/BehaviourModuleAttributeCache.h>
#include <vector>
 
namespace Atoms
{
    class DrawContext;
 
    class AgentGroup;
 
    class Agent;    
 
 
    class ATOMS_EXPORT BehaviourModule
    {
        public:
            enum ProfileType
            {
                kInitSimulation = 0,
                kPreFrame,
                kAgentsCreated,
                kInitFrame,
                kEndFrame,
                kPrePhysics,
                kPostPhysics,
                kAgentsKilled,
                kEndSimulation,
                kResetSimulation
            };
 
            enum ModuleTpe
            {
                kNative = 0,
                kScript = 1
            };
            
            BehaviourModule();
 
            virtual ~BehaviourModule();
 
 
            virtual void agentsCreated(const std::vector<Agent*>& agents, AgentGroup* agentGroup = nullptr);
 
 
            virtual void agentsKilled(const std::vector<Agent*>& agents, AgentGroup* agentGroup = nullptr);
 
 
            virtual void initSimulation(AgentGroup* agentGroup = nullptr);
 
 
            virtual void preFrame(AgentGroup* agentGroup = nullptr);
 
 
            virtual void initFrame(const std::vector<Agent*>& agents, AgentGroup* agentGroup = nullptr);
 
 
            virtual void endFrame(const std::vector<Agent*>& agents, AgentGroup* agentGroup = nullptr);
 
 
            virtual void prePhysics(const std::vector<Agent*>& agents, AgentGroup* agentGroup = nullptr);
 
 
            virtual void postPhysics(const std::vector<Agent*>& agents, AgentGroup* agentGroup = nullptr);
 
 
            virtual void endSimulation(const std::vector<Agent*>& agents, AgentGroup* agentGroup = nullptr);
 
 
            virtual void resetSimulation(const std::vector<Agent*>& agents, AgentGroup* agentGroup = nullptr);
 
 
            virtual void preDraw(DrawContext* context, const std::vector<Agent*>& agents, AgentGroup* agentGroup = nullptr);
 
 
            virtual void draw(DrawContext* context, const std::vector<Agent*>& agents, AgentGroup* agentGroup = nullptr);
 
            virtual AtomsCore::MapMetadata& attributes() { return m_attributes; }
            
            virtual AtomsCore::MapMetadata& attributeProperties() { return m_attributeProperties; }
 
            virtual const std::string& typeName() const { return m_typeName; }
 
            virtual void setTypeName(const std::string& typeName) { m_typeName = typeName; }
 
            virtual void addAttribute(const std::string& attributeName, AtomsPtr<AtomsCore::Metadata>& metadata, bool perAgent = false);
            virtual void addAttribute(const std::string& attributeName, AtomsCore::Metadata* metadata, bool perAgent = false);
 
            virtual void addAttributeProperty(const std::string& attributeName, const std::string& propertyName, AtomsPtr<AtomsCore::Metadata>& metadata);
            virtual void addAttributeProperty(const std::string& attributeName, const std::string& propertyName, AtomsCore::Metadata* metadata);
 
            virtual bool removeAttribute(const std::string& attributeName);
 
            virtual void setEnabled(bool value) { m_enabled = value; }
 
            virtual bool isEnabled() const { return m_enabled; }
 
            void setSingleThread(bool value) { m_singleThread = value; }
 
            bool singleThread() const { return m_singleThread; }
 
            virtual const std::string& name() const { return m_name; }
 
            virtual void setName(const std::string& name) { m_name = name; }
 
            /* Use this function to add new attributes to the module based of external logic.
            * For example some modules store some data in a string attribute and then use this data to generate new attributes
            */
            virtual void refreshAttributes();
 
            virtual bool hasDynamicAttributes() const;
 
            template<typename T>
            T getAttributePerAgent(const T& defaultValue, AtomsCore::MapMetadata* overrideMap, const std::string& id);
 
            template<typename T>
            T getAttributePerAgent(const T& defaultValue, AtomsCore::MapMetadata* overrideMap, const std::string& id, const AtomsCore::MapMetadata& agentMetadata, const std::string& metadataName);
 
            size_t profileTime(unsigned short index) const;
 
            void setProfileTime(unsigned short index, size_t us);
 
            static bool ignoreCurrentModule(Atoms::Agent* agent, const std::string& currentModuleName, const std::vector<std::string>& moduleNames, const std::string& metadataName);
            static void enableCurrentActiveModuleMetadata(Atoms::Agent* agent, const std::string& currentModuleName, const std::string& metadataName, const bool enable);
 
            static void initializeAngularVelocity(Atoms::Agent* agent);
            static void setAngularVelocities(Atoms::Agent* agent, const AtomsCore::Vector3& newDir, const AtomsCore::Vector3& preMaxTurnAngleDir, const double fps);
            static void setAngularVelocities(Atoms::Agent* agent, const double angularVelocity, const double frameAngularVelocity);
 
    private:
 
        void addAttributeRandomization(const std::string& attributeName, AtomsCore::Metadata* metadata);
 
        void addAttributeExpression(const std::string& attributeName, AtomsCore::Metadata* metadata);
 
 
        AtomsCore::MapMetadata m_attributes;
        AtomsCore::MapMetadata m_attributeProperties;
 
        std::string m_typeName;
 
        std::string m_name;
 
        size_t m_profileTime[10];
 
        bool m_enabled;
 
        bool m_singleThread;
    };
 
    template<typename T>
    T BehaviourModule::getAttributePerAgent(const T& defaultValue, AtomsCore::MapMetadata* overrideMap, const std::string& id)
    {
        if (overrideMap)
        {
            auto dataPtr = overrideMap->getTypedEntry<AtomsCore::MetadataImpl<T>>(id);
            if (dataPtr) return dataPtr->value();
        }
        return defaultValue;
    }
 
    template<typename T>
    T BehaviourModule::getAttributePerAgent(const T& defaultValue, AtomsCore::MapMetadata* overrideMap, const std::string& id, const AtomsCore::MapMetadata& agentMetadata, const std::string& metadataName)
    {
        auto agentDataPtr = agentMetadata.getTypedEntry<AtomsCore::MetadataImpl<T>>(metadataName);
        if (agentDataPtr)
        {
            return agentDataPtr->value();
        }
 
        if (overrideMap)
        {
            auto dataPtr = overrideMap->getTypedEntry<AtomsCore::MetadataImpl<T>>(id);
            if (dataPtr) return dataPtr->value();
        }
 
        return defaultValue;
    }
 
}