Creating a standalone simulation

#include <iostream>
#include <Atoms/Initialize.h>
#include <Atoms/AgentsSimulation.h>
#include <Atoms/AgentsSimulations.h>
#include <Atoms/SimulationTime.h>
#include <Atoms/AgentGroup.h>
#include <AtomsModules/Initialize.h>
#include <Atoms/BehaviourModules.h>
#include <chrono>
#include <Atoms/AnimationClip.h>
#include <Atoms/AnimationClips.h>
#include <Atoms/SimulationEvents.h>
#include <Atoms/GlobalNames.h>
#include <Atoms/SimulationEvent.h>
#include <AtomsCore/Metadata/Vector3Metadata.h>
#include <AtomsCore/Metadata/IntMetadata.h>
#include <AtomsCore/Metadata/BoolMetadata.h>
#include <AtomsCore/Metadata/DoubleMetadata.h>
#include <AtomsCore/Metadata/MapMetadata.h>
#include <AtomsCore/Metadata/StringMetadata.h>
 
// REGISTER CLIPS
 
template<const char* NAME, const char* CLIPNAME, int START, int END, int LOOP_BLEND, bool LOOP, bool IDLE>
class AtomsRobotClip : public Atoms::SimulationEvent
{
public:
    AtomsRobotClip() : Atoms::SimulationEvent()
    {
        setName(NAME);
    }
 
    virtual ~AtomsRobotClip()
    {
 
    }
 
    void load()
    {
        //CLIP = GLOBAL_NAMES.CLIP
        const char* eventName = NAME;
        const char* clipNameFile = CLIPNAME;
        const int blendFramesAfterFootUp = 4;
        const bool loop = LOOP;
        const int loopStart = START;
        const int loopEnd = END;
        const int loopBlend = 4;
        const bool idle = IDLE;
        const double direction[3] = { 1.0, 0.0, 0.0 };
        const int directionType = 1;
        const int directionFromJoints[2] = { 0, 1 };
 
        std::string clipPath = "";
        if (getenv("ATOMS_DATA"))
        {
            std::string dataPath = getenv("ATOMS_DATA");
            clipPath = dataPath + "/" + clipNameFile;
        }
 
        Atoms::AnimationClips& aClips = Atoms::AnimationClips::instance();
        aClips.addAnimationClip(eventName, clipPath, true);
        Atoms::AnimationClipPtr acPtr = aClips.animationClip(eventName);
        if (!acPtr)
            return;
 
        AtomsCore::MapMetadata& metadataMap = acPtr->metadata();
 
        metadataMap.addEntry(ATOMS_CLIP_BLEND_FRAMES_AFTER_FOOT_UP, &AtomsCore::IntMetadata(blendFramesAfterFootUp));
        metadataMap.addEntry(ATOMS_CLIP_LOOP, &AtomsCore::BoolMetadata(loop));
        metadataMap.addEntry(ATOMS_CLIP_LOOP_START, &AtomsCore::IntMetadata(loopStart));
        metadataMap.addEntry(ATOMS_CLIP_LOOP_END, &AtomsCore::IntMetadata(loopEnd));
        metadataMap.addEntry(ATOMS_CLIP_LOOP_NUM_BLEND_FRAMES, &AtomsCore::IntMetadata(loopBlend));
 
        if (directionType)
        {
            acPtr->setDirectionType(Atoms::AnimationClip::DirectionType::kStatic);
        }
        else if (directionType == 0)
        {
            acPtr->setDirectionType(Atoms::AnimationClip::DirectionType::kPelvis);
        }
        else
        {
            acPtr->setDirectionType(Atoms::AnimationClip::DirectionType::kJoints);
        }
        acPtr->setDirection(AtomsCore::Vector3(direction[0], direction[1], direction[2]));
        acPtr->setDirectionFromJoints(directionFromJoints[0], directionFromJoints[1]);
        acPtr->setIdle(idle);
    }
 
    static Atoms::SimulationEvent* creator(const std::string& parameter)
    {
        return new AtomsRobotClip();
    }
};
 
extern const char robotIdleName[] = "atomsRobotIdle";
extern const char robotIdleClip[] = "atomsRobot_idle.fbx";
typedef AtomsRobotClip<robotIdleName, robotIdleClip, 0, 1, 0, true, false> AtomsRobotIdleClip;
 
extern const char robotWalkName[] = "atomsRobotWalk";
extern const char robotWalkClip[] = "atomsRobot_walk.fbx";
typedef AtomsRobotClip<robotWalkName, robotWalkClip, 21, 50, 4, true, false> AtomsRobotWalkClip;
 
extern const char robotRunName[] = "atomsRobotRun";
extern const char robotRunClip[] = "atomsRobot_run.fbx";
typedef AtomsRobotClip<robotRunName, robotRunClip, 6, 26, 4, true, false> AtomsRobotRunClip;
 
extern const char robotIdleToWalkName[] = "atomsRobotIdleToWalk";
extern const char robotIdleToWalkClip[] = "atomsRobot_idleToWalk.fbx";
typedef AtomsRobotClip<robotIdleToWalkName, robotIdleToWalkClip, 17, 66, 6, false, false> AtomsRobotIdleToWalkClip;
 
extern const char robotWalkToRunName[] = "atomsRobotWalkToRun";
extern const char robotWalkToRunClip[] = "atomsRobot_walkToRun.fbx";
typedef AtomsRobotClip<robotWalkToRunName, robotWalkToRunClip, 0, 45, 3, false, false> AtomsRobotWalkToRunClip;
 
void registerAtomsClips(Atoms::AgentsSimulation& sim)
{
    Atoms::SimulationEvents& events = Atoms::SimulationEvents::instance();
    events.registerSimulationEvent(robotIdleName, AtomsRobotIdleClip::creator, Atoms::SimulationEvent::kAnimClipNative);
    events.registerSimulationEvent(robotWalkName, AtomsRobotWalkClip::creator, Atoms::SimulationEvent::kAnimClipNative);
    events.registerSimulationEvent(robotRunName, AtomsRobotRunClip::creator, Atoms::SimulationEvent::kAnimClipNative);
    events.registerSimulationEvent(robotIdleToWalkName, AtomsRobotIdleToWalkClip::creator, Atoms::SimulationEvent::kAnimClipNative);
    events.registerSimulationEvent(robotWalkToRunName, AtomsRobotWalkToRunClip::creator, Atoms::SimulationEvent::kAnimClipNative);
     
    sim.addAnimationClipEvent(events.createSimulationEvent(robotIdleName));
    sim.addAnimationClipEvent(events.createSimulationEvent(robotWalkName));
    sim.addAnimationClipEvent(events.createSimulationEvent(robotRunName));
    sim.addAnimationClipEvent(events.createSimulationEvent(robotIdleToWalkName));
    sim.addAnimationClipEvent(events.createSimulationEvent(robotWalkToRunName));
}
 
// REGISTER AGENT TYPE
 
template<
    const char* NAME,
    const char* SKEL_PATH,
    const char* GEO_PATH,
    const char* SKIN_PATH,
    const char* STATE_MACHINE>
class SimTestAgentType : public Atoms::SimulationEvent
{
public:
     
 
    SimTestAgentType() : Atoms::SimulationEvent()
    {
        setName(NAME);
    }
 
    virtual ~SimTestAgentType()
    {
 
    }
 
    void load()
    {
        const char* stateMachine = STATE_MACHINE;
        const double scaleMultiplier = 1.0;
 
        std::string skeletonPath = "";
        std::string geoPath = "";
        std::string skinPath = "";
        if (getenv("ATOMS_DATA"))
        {
            std::string dataPath = getenv("ATOMS_DATA");
            skeletonPath = dataPath + "/" + SKEL_PATH;
            geoPath = dataPath + "/" + GEO_PATH;
            skinPath = dataPath + "/" + SKIN_PATH;
        }
 
        AtomsCore::Skeleton skel(1);
        AtomsCore::Archive  skeletonArchive;
        if (skeletonArchive.readFromFile(skeletonPath))
        {
            skeletonArchive >> skel;
        }
        else
        {
            return;
        }
 
        Atoms::AgentType aType;
        aType.setSkeleton(skel);
 
        AtomsCore::MapMetadata meshMap;
        AtomsCore::Archive typeArchive;
        if (typeArchive.readFromFile(geoPath))
        {
            meshMap.deserialise(typeArchive);
            aType.metadata().addEntry(ATOMS_AGENT_TYPE_LOW_GEO, &meshMap);
        }
 
        AtomsCore::MapMetadata skinMap;
        AtomsCore::Archive skinArchive;
        if (skinArchive.readFromFile(skinPath))
        {
            skinMap.deserialise(skinArchive);
            aType.metadata().addEntry(ATOMS_AGENT_TYPE_SKIN_GEO, &skinMap);
        }
 
 
        aType.metadata().addEntry(ATOMS_AGENT_TYPE_STATE_MACHINE, &AtomsCore::StringMetadata(stateMachine));
        aType.metadata().addEntry(ATOMS_AGENT_TYPE_SCALE_MULTIPLIER, &AtomsCore::DoubleMetadata(scaleMultiplier));
 
        Atoms::AgentTypes::instance().addAgentType(NAME, aType);
    }
 
    void unload()
    {
        Atoms::AgentTypes::instance().removeAgentType(NAME);
    }
 
    static Atoms::SimulationEvent* creator(const std::string& parameter)
    {
        return new SimTestAgentType();
    }
};
 
extern const char atomsRobotName[] = "atomsRobot";
extern const char atomsRobotSkel[] = "atomsRobot.atomsskel";
extern const char atomsRobotGeo[] = "atomsRobot.geos";
extern const char atomsRobotSkin[] = "atomsRobot_skin.geos";
extern const char atomsRobotStateMachineName[] = "atomsRobotStateMachine";
typedef SimTestAgentType<atomsRobotName, atomsRobotSkel, atomsRobotGeo, atomsRobotSkin, atomsRobotStateMachineName> AtomsRobotAgentType;
 
void registerAgentType(Atoms::AgentsSimulation& sim)
{
    Atoms::SimulationEvents& events = Atoms::SimulationEvents::instance();
    events.registerSimulationEvent(atomsRobotName, AtomsRobotAgentType::creator, Atoms::SimulationEvent::kAgentTypeNative);
    sim.addAgentTypeEvent(events.createSimulationEvent(atomsRobotName));
}
 
// Register state machine
 
void registerStateMachine(Atoms::AgentsSimulation& sim)
{
    Atoms::StateMachines& stateMachineManager = Atoms::StateMachines::instance();
    Atoms::StateMachine stateMachine;
    Atoms::AnimationState currentAnimState("idle", 0, AtomsCore::Vector3(0.200000, 0.200000, 0.200000), 3, 3);
    currentAnimState.addClip(Atoms::AnimationStateClip("atomsRobotIdle", 0, 0, 0.000000, 0.000000));
    stateMachine.addAnimationState(currentAnimState);
    currentAnimState = Atoms::AnimationState("walk", 1, AtomsCore::Vector3(0.200000, 0.200000, 0.200000), 3, 3);
    currentAnimState.addClip(Atoms::AnimationStateClip("atomsRobotWalk", 0, 0, 0.000000, 0.000000));
    stateMachine.addAnimationState(currentAnimState);
    currentAnimState = Atoms::AnimationState("run", 2, AtomsCore::Vector3(0.200000, 0.200000, 0.200000), 3, 3);
    currentAnimState.addClip(Atoms::AnimationStateClip("atomsRobotRun", 0, 0, 0.000000, 0.000000));
    stateMachine.addAnimationState(currentAnimState);
    currentAnimState = Atoms::AnimationState("idleToWalk", -1, AtomsCore::Vector3(0.200000, 0.200000, 0.200000), 3, 3);
    currentAnimState.addClip(Atoms::AnimationStateClip("atomsRobotIdleToWalk", 0, 0, 0.000000, 0.000000));
    stateMachine.connect("idle", "walk", currentAnimState);
    currentAnimState = Atoms::AnimationState("walkToRun", -1, AtomsCore::Vector3(0.200000, 0.200000, 0.200000), 3, 3);
    currentAnimState.addClip(Atoms::AnimationStateClip("atomsRobotWalkToRun", 0, 0, 0.000000, 0.000000));
    stateMachine.connect("walk", "run", currentAnimState);
    stateMachineManager.addStateMachine("atomsRobotStateMachine", stateMachine, true);
}
 
// Main simulation
 
int main()
{
    Atoms::initAtoms();
    AtomsModules::initAtomsModules();
     
 
    Atoms::AgentsSimulation simulation;
    Atoms::AgentsSimulations::instance().addAgentsSimulation("main", &simulation);
 
    registerAtomsClips(simulation);
    registerStateMachine(simulation);
    registerAgentType(simulation);
 
 
    Atoms::BehaviourModules& modulesFactory = Atoms::BehaviourModules::instance();
    AtomsPtr<Atoms::AgentGroup> agGroup(new Atoms::AgentGroup());
    agGroup->setMultithread(true);
    simulation.addAgentGroup(agGroup);
 
    auto gridLayout = modulesFactory.createBehaviourModule("gridLayout");
    gridLayout->attributes().getTypedEntry<AtomsCore::StringMetadata>("agentType")->set("atomsRobot");
    gridLayout->attributes().getTypedEntry<AtomsCore::Vector3Metadata>("size")->set(AtomsCore::Vector3(50,0,50));
    auto stateMachine = modulesFactory.createBehaviourModule("stateMachine");
    stateMachine->attributes().getTypedEntry<AtomsCore::IntMetadata>("state")->set(1);
    agGroup->addBehaviourModule("gridLayout", gridLayout);
    agGroup->addBehaviourModule("stateMachine", stateMachine);
     
    Atoms::SimulationTime& atomsTime = Atoms::SimulationTime::instance();
    atomsTime.set(0);
    atomsTime.setFps(24.0);
 
     
    simulation.initSimulation();
 
    for (unsigned int i = 0; i < 50; i++)
    {
        atomsTime.set(i);
        auto start = std::chrono::high_resolution_clock::now();
        simulation.initFrame();
        simulation.computeFrame();
        simulation.endFrame();
        auto end = std::chrono::high_resolution_clock::now();
        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
        std::cout << "Frame " << i << " " << elapsed <<"ms " << 1.0 /(static_cast<double>(elapsed)*0.001) <<"fps" << std::endl;
    }
 
    simulation.endSimulation();
    return 0;
}