SDK/_simulator_8h_source.html

 #pragma once

 using namespace StdUtils;


 #include "MaterialType.h"

 #include "Materials.h"

 #include "SimulationWindow.h"

 #include "HudItem.h"

 #include "Hud.h"

 #include "SimulationWindowMgr.h"

 #include "ThreadProcessor.h"

 #include "ModuleThreadProcessor.h"

 #include "ScriptProcessor.h"


 namespace AnimatSim

 {

                 class ANIMAT_PORT Simulator : public AnimatBase

                 {

                 protected:


 #pragma region Variables


 #pragma region ProjectVariables


                         std::string m_strProjectPath;


                         std::string m_strExecutablePath;


                         std::string m_strSimulationFile;


                         CStdPtrMap<std::string, Organism> m_aryOrganisms;


                         CStdPtrMap<std::string, Structure> m_aryStructures;


                         CStdMap<std::string, Structure *> m_aryAllStructures;


                         CStdPtrMap<std::string, OdorType> m_aryOdorTypes;


                         CStdArray<RigidBody *> m_aryFoodSources;


                         CStdMap<std::string, IStdClassFactory *> m_aryNeuralModuleFactories;


                         IStdClassFactory *m_lpAnimatClassFactory;


                         CStdMap<std::string, AnimatBase *> m_aryObjectList;


                         CStdArray<Adapter *> m_arySourcePhysicsAdapters;


                         CStdArray<Adapter *> m_aryTargetPhysicsAdapters;


             CStdArray<BodyPart *> m_aryExtraDataParts;


                         int m_iTargetAdapterCount;


             int m_iExtraDataCount;


                         DataChartMgr m_oDataChartMgr;


                         ExternalStimuliMgr m_oExternalStimuliMgr;


                         SimulationRecorder *m_lpSimRecorder;


                         Materials m_oMaterialMgr;


                         SimulationWindowMgr *m_lpWinMgr;


                         LightManager m_oLightMgr;


                         int m_iSelectionMode;


                         bool m_bAddBodiesMode;


                         bool m_bBlockSimulation;


                         bool m_bSimBlockConfirm;


                         ISimGUICallback *m_lpSimCallback;


                         bool m_bStopSimulation;


                         bool m_bForceSimulationStop;


                         bool m_bManualStepSimulation;


                         bool m_bPaused;


                         bool m_bInitialized;


                         bool m_bSimRunning;


                         bool m_bSteppingSim;


                         bool m_bForceFastMoving;


                         bool m_bShuttingDown;


             bool m_bInDrag;


             bool m_bIsResetting;


             ThreadProcessor *m_lpNeuralThread;


             ThreadProcessor *m_lpPhysicsThread;


             ThreadProcessor *m_lpIOThread;


                         //Script processor for running python or other scripting systems related to the simulation.

                         ScriptProcessor *m_lpScript;


 #pragma endregion


 #pragma region UnitScalingVariables


                         float m_fltDistanceUnits;


                         float m_fltInverseDistanceUnits;


                         float m_fltDenominatorDistanceUnits;


                         float m_fltMassUnits;


                         float m_fltInverseMassUnits;


                         float m_fltDisplayMassUnits;


 #pragma endregion


 #pragma region EnvironmentVariables


                         float m_fltGravity;


                         float m_fltStabilityScale;


                         float m_fltLinearCompliance;


                         float m_fltAngularCompliance;


                         float m_fltLinearDamping;


                         float m_fltAngularDamping;


                         float m_fltLinearKineticLoss;


                         float m_fltAngularKineticLoss;


                         bool m_bSimulateHydrodynamics;


                         float m_fltTimeStep;

                         double m_dblTimeStep;


             int m_iPhysicsSubsteps;


             float m_fltPhysicsSubstepTime;


                         long m_lTimeSlice;


                         float m_fltTime;

                         double m_dblTime;


                         bool m_bSetEndSim;


                         float m_fltEndSimTime;


                         float m_lEndSimTimeSlice;


                         unsigned long long m_lStartSimTick;


                         long m_lPhysicsSliceCount;


                         short m_iPhysicsStepInterval;


                         float m_fltPhysicsTimeStep;


                         int m_iPhysicsStepCount;


                         bool m_bAutoGenerateRandomSeed;


                         int m_iManualRandomSeed;


                         float m_fltMouseSpringStiffness;


                         float m_ftlMouseSpringDamping;


                         float m_fltMouseSpringForceMagnitude;


                         float m_fltMouseSpringDampingForceMagnitude;


                         float m_fltMouseSpringLengthMagnitude;


                         CStdColor m_vBackgroundColor;


                         float m_fltAlphaThreshold;


                         float m_fltRecFieldSelRadius;


                         int m_iPhysicsBodyCount;


                         bool m_bRobotAdpaterSynch;


 #pragma endregion


 #pragma region TimingVariables


                         int m_iPlaybackControlMode;


                         float m_fltPresetPlaybackTimeStep;


                         unsigned long long m_lStepStartTick;


                         unsigned long long m_lStepSimEndTick;


                         float m_fltSimulationRealTimeToStep;


                         float m_fltTotalRealTimeForStep;


                         float m_fltPrevTotalRealTimeForStep;


                         float m_fltTotalRealTimeForStepSmooth;


                         float m_fltRealTime;


                         float m_fltPlaybackAdditionRealTimeToStep;


                         int m_iDesiredFrameRate;


                         float m_fltDesiredFrameStep;


                         unsigned long long m_lVideoFrameStartTick;


                         float m_fltActualFrameRate;


                         unsigned long long m_lLastTickTaken;


                         float m_fltPhysicsStepTime;


                         float m_fltPrevPhysicsStepTime;


                         float m_fltTotalNeuralStepTime;


                         float m_fltExternalStimuliStepTime;


                         float m_fltDataChartStepTime;


                         float m_fltSimRecorderStepTime;


                         float m_fltRemainingStepTime;


                         float m_fltTotalMicroSleepTime;


                         float m_fltTotalMicroSleepCount;


                         float m_fltTotalMicroWaitTime;


                         float m_fltTotalMicroWaitCount;


                         double m_dblTotalStepTime;


                         long m_lStepTimeCount;


                         bool m_bForceNoWindows;


 #pragma endregion


 #pragma region RecordingVariables


                         bool m_bEnableSimRecording;


                         long m_lSnapshotByteSize;


                         long m_lVideoSliceCount;


                         int m_iVideoLoops;


                         KeyFrame *m_lpVideoRecorder;


                         KeyFrame *m_lpVideoPlayback;


                         KeyFrame *m_lpSimStopPoint;


                         //Video variables

                         bool m_bRecordVideo;


                         std::string m_strVideoFilename;


                         float m_fltVideoRecordFrameTime;


                         float m_fltVideoPlaybackFrameTime;


                         float m_fltVideoStartTime;


                         float m_fltVideoEndTime;


                         int m_iVideoStepSize;


                         int m_iVideoStep;


                         long m_lVideoStartSlice;


                         long m_lVideoEndSlice;


                         long m_lVideoFrame;


 #pragma endregion


 #pragma region TempVariables

                         //These variables are just used on and off. They are defined here so we do not have to keep redefining them.


                         CStdMap<std::string, Organism *>::iterator m_oOrganismIterator;


                         CStdMap<std::string, Structure *>::iterator m_oStructureIterator;


                         Organism *m_lpSelOrganism;


                         Structure *m_lpSelStructure;


 #pragma endregion


 #pragma endregion


 #pragma region ProtectedMethods


 #pragma region LoadMethods


                         virtual void LoadEnvironment(CStdXml &oXml);

                         Structure *LoadStructure(CStdXml &oXml);

                         Organism *LoadOrganism(CStdXml &oXml);

                         OdorType *LoadOdorType(CStdXml &oXml);


                         static void LoadAnimatModuleName(std::string strFile, std::string &strAnimatModule);

                         static void LoadAnimatModuleName(CStdXml &oXml, std::string &strAnimatModule);


                         virtual ScriptProcessor *LoadScript(CStdXml &oXml);


 #pragma endregion


 #pragma region AddRemoveMethods


                         virtual void AddOrganism(Organism *lpOrganism);

                         virtual void AddOrganism(std::string strXml);

                         virtual void RemoveOrganism(std::string strID, bool bThrowError = true);


                         virtual void AddStructure(Structure *lpStructure);

                         virtual void AddStructure(std::string strXml);

                         virtual void RemoveStructure(std::string strID, bool bThrowError = true);


                         virtual int FindAdapterListIndex(CStdArray<Adapter *> aryAdapters, std::string strID, bool bThrowError = true);

                         virtual int FindFoodSourceIndex(RigidBody *lpFood);

             virtual int FindExtraDataIndex(BodyPart *lpPart);


                         virtual void AddOdorType(OdorType *lpOdorType);

                         virtual void AddOdorType(std::string strXml, bool bDoNotInit);

                         virtual void RemoveOdorType(std::string strID, bool bThrowError = true);


                         virtual void AddScript(std::string strXml);

                         virtual void RemoveScript(std::string strID, bool bThrowError = true);


 #pragma endregion


 #pragma region UnitScaleMethods


                         float ConvertDistanceUnits(std::string strUnits);

                         float ConvertDenominatorDistanceUnits(std::string strUnits);

                         float ConvertMassUnits(std::string strUnits);

                         float ConvertDisplayMassUnits(std::string strUnits);


 #pragma endregion


 #pragma region SimulationMethods


                         virtual void InitializeRandomNumbers();

                         virtual void InitializeStructures();


                         virtual void NotifyTimeStepModified();


                         virtual bool CheckSimulationBlock();

                         virtual void CheckEndSimulationTime();


                         virtual void StepNeuralEngine();

                         virtual void StepPhysicsEngine();

                         virtual void StepExternalStimuli();

                         virtual void StepDataCharts();

                         virtual void StepSimRecorder();

                         virtual void AfterStepSimulation();

                         virtual void Step();

                         virtual void ResetSimulationTimingParams();


                         virtual void ProcessSimulationStep();

                         virtual void StepSimulation();

                         virtual void StepVideoFrame();

                         virtual void StepPlaybackControl();

                         virtual void SimulateBegin();

                         virtual void SimulateEnd();


                         //These functions are called internally when the simulation is about to start up or pause.

                         virtual void SimStarting();

                         virtual void SimPausing();

                         virtual void SimStopping();


                         virtual void GenerateAutoSeed();


                         virtual void HandleCriticalError(std::string strError);

                         virtual void HandleNonCriticalError(std::string strError);


                         virtual void UpdateSimulationWindows() = 0;


                         //Timing Methods

                         virtual void StartSimulationStepTimer();

                         virtual void RecordSimulationStepTimer();

                         virtual void RecordSimulationTotalStepTimer();

                         virtual double CurrentRealTimeForStep_n();

                         virtual double CurrentRealTimeForStep_s();

                         virtual double CalculateRemainingPlaybackTime();

                         virtual void RecordAddedPlaybackTime();

                         virtual void StartVideoFrameTimer();

                         virtual double TimeBetweenVideoFrames();

                         virtual double RemainingVideoFrameTime();


 #pragma endregion


 #pragma region RecorderMethods


                         virtual SimulationRecorder *CreateSimulationRecorder() = 0;


                         virtual long CalculateSnapshotByteSize();


                         virtual void SnapshotStopFrame() = 0;


                         virtual void RecordVideoFrame();


 #pragma endregion


 #pragma endregion


                 public:

                         Simulator();

                         virtual ~Simulator();


                         static Simulator *CastToDerived(AnimatBase *lpBase) {return static_cast<Simulator*>(lpBase);}


 #pragma region AccessorMutators


 #pragma region ProjectVariables


                         virtual std::string ProjectPath();

                         virtual void ProjectPath(std::string strPath);


                         virtual std::string ExecutablePath();

                         virtual void ExecutablePath(std::string strPath);


                         virtual std::string SimulationFile();

                         virtual void SimulationFile(std::string strFile);


                         virtual bool Paused();

                         virtual void Paused(bool bVal);


                         virtual bool Initialized();

                         virtual void Initialized(bool bVal);


                         virtual CStdMap<std::string, AnimatBase *> *ObjectList();


                         virtual DataChartMgr *GetDataChartMgr();

                         virtual ExternalStimuliMgr *GetExternalStimuliMgr();

                         virtual SimulationRecorder *GetSimulationRecorder();

                         virtual Materials *GetMaterialMgr();

                         virtual SimulationWindowMgr *GetWindowMgr();

                         virtual LightManager *GetLightMgr();


                         virtual int VisualSelectionMode();

                         virtual void VisualSelectionMode(int iVal);


                         virtual bool AddBodiesMode();

                         virtual void AddBodiesMode(bool bVal);


                         virtual ISimGUICallback *SimCallback();

                         virtual void SimCallBack(ISimGUICallback *lpCallback);


             virtual bool IsResetting();


 #pragma endregion


 #pragma region EnvironmentVariables


                         virtual float Time();

                         virtual long Millisecond();

                         virtual long MillisecondToSlice(long lMillisecond);

                         virtual long SliceToMillisecond(long lSlice);

                         virtual unsigned long long StartSimTick();


                         virtual float MinTimeStep();

                         virtual float TimeStep();


                         virtual bool SetEndSimTime();

                         virtual void SetEndSimTime(bool bVal);


                         virtual float EndSimTime();

                         virtual void EndSimTime(float fltVal);


                         virtual long EndSimTimeSlice();

                         virtual void EndSimTimeSlice(long lVal);


                         virtual long TimeSlice();

                         virtual void TimeSlice(long lVal);


                         virtual long PhysicsSliceCount();

                         virtual void PhysicsSliceCount(long lVal);


                         virtual bool ManualStepSimulation();

                         virtual void ManualStepSimulation(bool bVal);


                         virtual bool SimRunning();


                         virtual bool ShuttingDown();


                         virtual bool ForceFastMoving();

                         virtual void ForceFastMoving(bool bVal);


                         virtual bool AutoGenerateRandomSeed();

                         virtual void AutoGenerateRandomSeed(bool bVal);


                         virtual int ManualRandomSeed();

                         virtual void ManualRandomSeed(int iSeed);


                         virtual float StabilityScale();

                         virtual void StabilityScale(float fltVal);


                         virtual float LinearCompliance();

                         virtual void LinearCompliance(float fltVal, bool bUseScaling = true);


                         virtual float AngularCompliance();

                         virtual void AngularCompliance(float fltVal, bool bUseScaling = true);


                         virtual float LinearDamping();

                         virtual void LinearDamping(float fltVal, bool bUseScaling = true);


                         virtual float AngularDamping();

                         virtual void AngularDamping(float fltVal, bool bUseScaling = true);


                         virtual float LinearKineticLoss();

                         virtual void LinearKineticLoss(float fltVal, bool bUseScaling = true);


                         virtual float AngularKineticLoss();

                         virtual void AngularKineticLoss(float fltVal, bool bUseScaling = true);


                         virtual bool Stopped();


                         virtual short PhysicsStepInterval();

                         virtual void PhysicsStepInterval(short iVal);


                         virtual void PhysicsTimeStep(float fltVal);

                         virtual float PhysicsTimeStep();

                         virtual long PhysicsStepCount();


             virtual void PhysicsSubsteps(int iVal);

             virtual int PhysicsSubsteps();

             virtual float PhysicsSubstepTime();


                         virtual float Gravity();

                         virtual void Gravity(float fltVal, bool bUseScaling = true);


                         virtual float MouseSpringStiffness();

                         virtual void MouseSpringStiffness(float fltVal, bool bUseScaling = true);


                         virtual float MouseSpringDamping();

                         virtual void MouseSpringDamping(float fltVal, bool bUseScaling = true);


                         virtual float MouseSpringForceMagnitude();

                         virtual void MouseSpringForceMagnitude(float fltVal, bool bUseScaling = true);


                         virtual float MouseSpringDampingForceMagnitude();

                         virtual void MouseSpringDampingForceMagnitude(float fltVal, bool bUseScaling = true);


                         virtual float MouseSpringLengthMagnitude();

                         virtual void MouseSpringLengthMagnitude(float fltVal, bool bUseScaling = true);


                         virtual bool SimulateHydrodynamics();

                         virtual void SimulateHydrodynamics(bool bVal);


                         virtual int GetMaterialID(std::string strID);


                         virtual bool IsPhysicsBeingUpdated();


                         virtual CStdColor *BackgroundColor();

                         virtual void BackgroundColor(CStdColor &aryColor);

                         virtual void BackgroundColor(float *aryColor);

                         virtual void BackgroundColor(std::string strXml);


                         virtual float AlphaThreshold();

                         virtual void AlphaThreshold(float fltValue);


                         virtual float RecFieldSelRadius();

                         virtual void RecFieldSelRadius(float fltValue, bool bUseScaling = true, bool bUpdateAllBodies = true);


                         virtual int PlaybackControlMode();

                         virtual void PlaybackControlMode(int iMode);


                         virtual float PresetPlaybackTimeStep();

                         virtual void PresetPlaybackTimeStep(float fltTimeStep);


                         virtual unsigned long long StepStartTick();

                         virtual unsigned long long StepSimEndTick();


                         virtual int DesiredFrameRate();

                         virtual float DesiredFrameStep();

                         virtual void DesiredFrameRate(int iVal);


                         virtual float RealTime();


             virtual bool InDrag() {return m_bInDrag;};

             virtual void InDrag(bool bVal) {m_bInDrag = bVal;};


                         virtual bool RobotAdpaterSynch();

                         virtual void RobotAdpaterSynch(bool bVal);


                         virtual bool InSimulation();


                         virtual bool ForceNoWindows();

                         virtual void ForceNoWindows(bool bVal);


                         virtual void Script(ScriptProcessor *lpScript);

                         virtual ScriptProcessor *Script();


 #pragma endregion


 #pragma region UnitScalingVariables


                         virtual void DistanceUnits(std::string strUnits);

                         virtual float DistanceUnits();

                         virtual float InverseDistanceUnits();

                         virtual float DenominatorDistanceUnits();


                         virtual void MassUnits(std::string strUnits);

                         virtual float MassUnits();

                         virtual float InverseMassUnits();

                         virtual float DisplayMassUnits();


 #pragma endregion


 #pragma region HelperMethods


                 virtual void GetPositionAndRotationFromD3DMatrix(float (&aryTransform)[4][4], CStdFPoint &vPos, CStdFPoint &vRot) = 0;


                 //Timer Methods

                 virtual unsigned long long GetTimerTick() = 0;

                 virtual double TimerDiff_u(unsigned long long lStart, unsigned long long lEnd) = 0;

                 virtual double TimerDiff_m(unsigned long long lStart, unsigned long long lEnd) = 0;

                 virtual double TimerDiff_s(unsigned long long lStart, unsigned long long lEnd) = 0;

                 virtual void MicroSleep(unsigned int iMicroTime) = 0;

                 virtual void MicroWait(unsigned int iMicroTime);


                 virtual void WriteToConsole(std::string strMessage) = 0;


         virtual void NotifyRigidBodyAdded(std::string strID);

         virtual void NotifyRigidBodyRemoved(std::string strID);


 #pragma endregion


 #pragma region RecordingVariables


                         virtual long VideoSliceCount();

                         virtual void VideoSliceCount(long lVal);


                         virtual int VideoLoops();

                         virtual void VideoLoops(int iVal);


                         virtual KeyFrame *VideoRecorder();


                         virtual void VideoRecorder(KeyFrame *lpFrame);


                         virtual KeyFrame *VideoPlayback();


                         virtual void VideoPlayback(KeyFrame *lpFrame);


                         virtual bool EnableSimRecording();

                         virtual void EnableSimRecording(bool bVal);


                         virtual long SnapshotByteSize();


 #pragma endregion


 #pragma endregion


 #pragma region PublicMethods


 #pragma region SimulationMethods


                         virtual void BlockSimulation();

                         virtual void UnblockSimulation();

                         virtual bool SimulationBlockConfirm();

                         virtual bool WaitForSimulationBlock(long lTimeout = 6000);


                         virtual void Reset(); //Resets the entire application back to the default state

                         virtual void ResetSimulation(); //Resets the current simulation back to time 0.0


                         virtual void Initialize(int argc, const char **argv) = 0;


                         virtual void Initialize();


                         virtual void Simulate();


                         virtual void ShutdownSimulation() = 0;


                         virtual void ToggleSimulation() = 0;


                         virtual void StopSimulation() = 0;


                         virtual bool StartSimulation() = 0;


                         virtual bool PauseSimulation() = 0;


                         virtual void RunSimulation();


 #pragma endregion


 #pragma region LoadMethods


                         virtual void Load(std::string strFileName = "");

                         virtual void Load(CStdXml &oXml);

                         virtual void Save(std::string strFilename);


                         static IStdClassFactory *LoadClassFactory(std::string strModuleName, bool bThrowError = true);


                         virtual void IncrementPhysicsBodyCount();


 #pragma endregion


 #pragma region CreateMethods


                         virtual CStdSerialize *CreateObject(std::string strModule, std::string strClassName, std::string strType, bool bThrowError = true);

                         static Simulator *CreateSimulator(std::string strAnimatModule, std::string strSimulationFile, bool bForceNoWindows = false);

                         static Simulator *CreateSimulator(std::string strSimFile, bool bForceNoWindows = false);

                         static Simulator *CreateAndInitializeSimulator(std::string strSimFile, bool bForceNoWindows = false);

                         static Simulator *CreateSimulator(std::string strAnimatModule, CStdXml &oXml);

                         static Simulator *CreateSimulator(std::string strAnimatModule, std::string strProjectPath, std::string strExecutablePath);

                         static Simulator *CreateSimulator(int argc, const char **argv);

                         virtual void GenerateCollisionMeshFile(std::string strOriginalMeshFile, std::string strCollisionMeshFile, float fltScaleX, float fltScaleY, float fltScaleZ) = 0;

                         virtual void ConvertV1MeshFile(std::string strOriginalMeshFile, std::string strNewMeshFile, std::string strTexture) = 0;


 #pragma endregion


 #pragma region FindMethods


                         virtual IStdClassFactory *FindNeuralModuleFactory(std::string strModuleName, bool bThrowError = false);

                         virtual Organism *FindOrganism(std::string strOrganismID, bool bThrowError = true);

                         virtual Structure *FindStructure(std::string strStructureID, bool bThrowError = true);

                         virtual Structure *FindStructureFromAll(std::string strStructureID, bool bThrowError = true);

                         virtual Joint *FindJoint(std::string strStructureID, std::string strJointID, bool bThrowError = true);

                         virtual RigidBody *FindRigidBody(std::string strStructureID, std::string strBodyID, bool bThrowError = true);

                         virtual OdorType *FindOdorType(std::string strOdorID, bool bThrowError = true);

                         virtual void FindClosestFoodSources(CStdFPoint &oMouthPos, float fltMinRadius, CStdArray<RigidBody *> &arySources, CStdArray<float> &aryDistances);

                         virtual AnimatBase *FindByID(std::string strID, bool bThrowError = true);


 #pragma endregion


 #pragma region AddRemoveMethods


                         virtual void AddToObjectList(AnimatBase *lpItem);

                         virtual void RemoveFromObjectList(AnimatBase *lpItem);

                         virtual void AddNeuralModuleFactory(std::string strModuleName, NeuralModule *lpModule);


                         virtual void AddFoodSource(RigidBody *lpFood);

                         virtual void RemoveFoodSource(RigidBody *lpFood);


                         virtual void AttachSourceAdapter(Structure *lpStructure, Adapter *lpAdapter);

                         virtual void RemoveSourceAdapter(Structure *lpStructure, Adapter *lpAdapter);

                         virtual void AttachTargetAdapter(Structure *lpStructure, Adapter *lpAdapter);

                         virtual void RemoveTargetAdapter(Structure *lpStructure, Adapter *lpAdapter);

                         virtual bool IsPhysicsAdapter(Adapter *lpAdapter);


             virtual void AddToExtractExtraData(BodyPart *lpPart);

             virtual void RemoveFromExtractExtraData(BodyPart *lpPart);


 #pragma endregion


 #pragma region DataAccesMethods


                         virtual float *GetDataPointer(const std::string &strDataType);

                         virtual bool SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError = true);

                         virtual void QueryProperties(CStdPtrArray<TypeProperty> &aryProperties);

                         virtual bool AddItem(const std::string &strItemType, const std::string &strXml, bool bThrowError = true, bool bDoNotInit = false);

                         virtual bool RemoveItem(const std::string &strItemType, const std::string &strID, bool bThrowError = true);


 #pragma endregion


 #pragma region RecorderMethods


                         virtual void EnableVideoPlayback(std::string strKeyFrameID);

                         virtual void DisableVideoPlayback();

                         virtual void StartVideoPlayback();

                         virtual void StopVideoPlayback();

                         virtual void StepVideoPlayback(int iFrameCount = 1);

                         virtual void SaveVideo(std::string strPath);


                         virtual std::string AddKeyFrame(std::string strType, long lStart, long lEnd);

                         virtual void RemoveKeyFrame(std::string strID);

                         virtual std::string MoveKeyFrame(std::string strID, long lStart, long lEnd);

                         virtual void MoveSimulationToKeyFrame(std::string strKeyFrameID);

                         virtual void SaveKeyFrameSnapshot(byte *aryBytes, long &lIndex);

                         virtual void LoadKeyFrameSnapshot(byte *aryBytes, long &lIndex);


 #pragma endregion


 #pragma region CollisionMethods


                         virtual void EnableCollisions(Structure *lpStruct, CStdPtrArray<CollisionPair> &m_aryCollisionList);

                         virtual void DisableCollisions(Structure *lpStruct, CStdPtrArray<CollisionPair> &m_aryCollisionList);


                         virtual void EnableCollision(RigidBody *lpBody);


                         virtual void DisableCollision(RigidBody *lpBody);


 #pragma endregion


 #pragma endregion


                 };


                 Simulator ANIMAT_PORT *GetSimulator();


 }                       //AnimatSim

AnimatSim::Simulator::m_lVideoFrame
long m_lVideoFrame
The video frame.
Definition: Simulator.h:482

AnimatSim::Simulator::m_fltPrevTotalRealTimeForStep
float m_fltPrevTotalRealTimeForStep
Previous total time for the step. Used for exponential smoothing algorithm.
Definition: Simulator.h:352

AnimatSim::Simulator::m_aryOrganisms
CStdPtrMap< std::string, Organism > m_aryOrganisms
Definition: Simulator.h:50

AnimatSim::Simulator::m_fltMouseSpringForceMagnitude
float m_fltMouseSpringForceMagnitude
The magnitude of the force being applied by the mosue spring at each step.
Definition: Simulator.h:300

AnimatSim::Simulator::m_bSetEndSim
bool m_bSetEndSim
true if we the user has manually set the simulation end time.
Definition: Simulator.h:258

AnimatSim::Simulator::m_lSnapshotByteSize
long m_lSnapshotByteSize
Size of a memory snapshot in bytes.
Definition: Simulator.h:433

AnimatSim::Simulator::m_bRobotAdpaterSynch
bool m_bRobotAdpaterSynch
Definition: Simulator.h:325

AnimatSim::Simulator::m_lpSimStopPoint
KeyFrame * m_lpSimStopPoint
The pointer to a simulation stop point.
Definition: Simulator.h:448

AnimatSim::Simulator::m_bPaused
bool m_bPaused
true if the simulation is paused.
Definition: Simulator.h:143

StdUtils::CStdColor
Standard color class.
Definition: StdColor.h:22

AnimatSim::Simulator::m_aryStructures
CStdPtrMap< std::string, Structure > m_aryStructures
Definition: Simulator.h:55

AnimatSim::Simulator::m_fltAngularDamping
float m_fltAngularDamping
The angular damping of the simulation environment.
Definition: Simulator.h:222

AnimatSim::Simulator::m_fltTotalMicroSleepTime
float m_fltTotalMicroSleepTime
Total time we were in microsleep during playback pause calculations;.
Definition: Simulator.h:405

AnimatSim::Simulator
Simulates the entire environment.
Definition: Simulator.h:31

AnimatSim
Root namespace for the base simulation library for AnimatLab.
Definition: ActivatedItem.cpp:37

AnimatSim::Simulator::m_iPhysicsStepInterval
short m_iPhysicsStepInterval
Definition: Simulator.h:275

AnimatSim::Simulator::m_fltSimulationRealTimeToStep
float m_fltSimulationRealTimeToStep
Definition: Simulator.h:346

AnimatSim::Simulator::m_iVideoLoops
int m_iVideoLoops
Zero-based index of the video loops.
Definition: Simulator.h:439

AnimatSim::Simulator::m_bEnableSimRecording
bool m_bEnableSimRecording
true to enable simulation recording
Definition: Simulator.h:430

AnimatSim::Simulator::m_oOrganismIterator
CStdMap< std::string, Organism * >::iterator m_oOrganismIterator
An organism iterator.
Definition: Simulator.h:490

AnimatSim::Simulator::m_fltPhysicsStepTime
float m_fltPhysicsStepTime
This is the time pers step for the physics engine.
Definition: Simulator.h:381

AnimatSim::Simulator::m_oExternalStimuliMgr
ExternalStimuliMgr m_oExternalStimuliMgr
Manager for external stimuli.
Definition: Simulator.h:103

AnimatSim::ThreadProcessor
Handles processing of a single thread of the simulation.
Definition: ThreadProcessor.h:22

AnimatSim::Simulator::m_fltLinearCompliance
float m_fltLinearCompliance
The linear compliance of the simulation environment.
Definition: Simulator.h:213

AnimatSim::Simulator::m_aryAllStructures
CStdMap< std::string, Structure * > m_aryAllStructures
Definition: Simulator.h:59

AnimatSim::Simulator::m_bInitialized
bool m_bInitialized
true if the simulation has been initialized.
Definition: Simulator.h:146

AnimatSim::Simulator::m_lpSelOrganism
Organism * m_lpSelOrganism
The pointer to a selected organism.
Definition: Simulator.h:496

AnimatSim::Simulator::m_iDesiredFrameRate
int m_iDesiredFrameRate
Desired frame rate of the simulation video.
Definition: Simulator.h:366

AnimatSim::Simulator::m_bInDrag
bool m_bInDrag
Tells if we are in the middle of a mouse drag operation to move or rotate a part. ...
Definition: Simulator.h:161

AnimatSim::Simulator::m_bManualStepSimulation
bool m_bManualStepSimulation
If true then the user is manually stepping the simulation.
Definition: Simulator.h:140

AnimatSim::Simulator::m_fltPlaybackAdditionRealTimeToStep
float m_fltPlaybackAdditionRealTimeToStep
Definition: Simulator.h:363

AnimatSim::Simulator::m_fltActualFrameRate
float m_fltActualFrameRate
The frame rate for the current frame.
Definition: Simulator.h:375

AnimatSim::Simulator::m_bAutoGenerateRandomSeed
bool m_bAutoGenerateRandomSeed
Definition: Simulator.h:287

AnimatSim::Simulator::m_lPhysicsSliceCount
long m_lPhysicsSliceCount
The number of slices that the physics engine has been updated.
Definition: Simulator.h:270

AnimatSim::Simulator::m_bForceNoWindows
bool m_bForceNoWindows
If this is set to true then no graphical simulation windows will be created regardless of what the co...
Definition: Simulator.h:423

AnimatSim::Simulator::m_fltDesiredFrameStep
float m_fltDesiredFrameStep
The desired time value duration of the video frame step.
Definition: Simulator.h:369

AnimatSim::Simulator::m_fltInverseDistanceUnits
float m_fltInverseDistanceUnits
The inverse of the distance units.
Definition: Simulator.h:186

AnimatSim::Simulator::m_fltDataChartStepTime
float m_fltDataChartStepTime
time to process data charts for this step.
Definition: Simulator.h:395

AnimatSim::Simulator::m_oLightMgr
LightManager m_oLightMgr
Manager for the light objects.
Definition: Simulator.h:115

SimulationWindowMgr.h
Declares the simulation window manager class.

AnimatSim::Simulator::m_lpVideoRecorder
KeyFrame * m_lpVideoRecorder
The pointer to a video recorder.
Definition: Simulator.h:442

AnimatSim::Simulator::m_bShuttingDown
bool m_bShuttingDown
True if the simulation is shutting down. This is used by other objects in their destructor to know wh...
Definition: Simulator.h:158

AnimatSim::Simulator::m_lStepSimEndTick
unsigned long long m_lStepSimEndTick
The tick count for when the simulation procressing of the step ends.
Definition: Simulator.h:342

AnimatSim::Simulator::m_aryExtraDataParts
CStdArray< BodyPart * > m_aryExtraDataParts
Definition: Simulator.h:91

AnimatSim::Simulator::m_fltDenominatorDistanceUnits
float m_fltDenominatorDistanceUnits
Definition: Simulator.h:191

AnimatSim::Simulator::m_bSimBlockConfirm
bool m_bSimBlockConfirm
true to confirm that a simulation block is in place.
Definition: Simulator.h:127

AnimatSim::Simulator::m_iSelectionMode
int m_iSelectionMode
This is the currect visual selection mode used within the GUI.
Definition: Simulator.h:118

AnimatSim::Simulator::m_lpPhysicsThread
ThreadProcessor * m_lpPhysicsThread
The pointer to the physics thread processor.
Definition: Simulator.h:170

AnimatSim::Simulator::m_fltExternalStimuliStepTime
float m_fltExternalStimuliStepTime
Time to process external stimuli for this step.
Definition: Simulator.h:392

AnimatSim::Simulator::m_iVideoStepSize
int m_iVideoStepSize
Size of the i video step.
Definition: Simulator.h:470

AnimatSim::Simulator::m_iPhysicsStepCount
int m_iPhysicsStepCount
Definition: Simulator.h:283

AnimatSim::Simulator::m_bSimulateHydrodynamics
bool m_bSimulateHydrodynamics
Definition: Simulator.h:234

AnimatSim::Simulator::m_bForceSimulationStop
bool m_bForceSimulationStop
Set to true to stop the simulation. This is a more forceful way of stopping the sim.
Definition: Simulator.h:137

AnimatSim::Simulator::m_lTimeSlice
long m_lTimeSlice
The current time slice. This a long value.
Definition: Simulator.h:251

AnimatSim::Simulator::m_iPhysicsBodyCount
int m_iPhysicsBodyCount
Definition: Simulator.h:321

AnimatSim::Simulator::m_aryFoodSources
CStdArray< RigidBody * > m_aryFoodSources
An Array of RigidBody parts that also act as food sources within the environment. ...
Definition: Simulator.h:66

AnimatSim::Simulator::m_fltAlphaThreshold
float m_fltAlphaThreshold
The threshold value to use when setting the AlphaFunc for the entire scene.
Definition: Simulator.h:312

AnimatSim::Simulator::m_iPhysicsSubsteps
int m_iPhysicsSubsteps
Definition: Simulator.h:244

AnimatSim::Simulator::m_fltTotalRealTimeForStep
float m_fltTotalRealTimeForStep
This is the total time it takes to complete one physics time step.
Definition: Simulator.h:349

AnimatSim::Simulator::m_ftlMouseSpringDamping
float m_ftlMouseSpringDamping
The damping of the user mouse spring.
Definition: Simulator.h:297

AnimatSim::Simulator::m_lVideoStartSlice
long m_lVideoStartSlice
The video start slice.
Definition: Simulator.h:476

StdUtils::IStdClassFactory
Standard class factory.
Definition: StdClassFactory.h:20

AnimatSim::Simulator::m_bSimRunning
bool m_bSimRunning
true if the simulation is running
Definition: Simulator.h:149

AnimatSim::Simulator::m_strProjectPath
std::string m_strProjectPath
The directory path where the simulation configuration files are located.
Definition: Simulator.h:40

AnimatSim::Simulator::m_oStructureIterator
CStdMap< std::string, Structure * >::iterator m_oStructureIterator
A structure iterator.
Definition: Simulator.h:493

AnimatSim::Simulator::m_lLastTickTaken
unsigned long long m_lLastTickTaken
This is the last tick taken by a GetTickCount. It is used in debugging.
Definition: Simulator.h:378

AnimatSim::Simulator::m_fltTotalMicroSleepCount
float m_fltTotalMicroSleepCount
Total number of times we called microsleep during playback pause calculations.
Definition: Simulator.h:408

AnimatSim::Simulator::m_lpWinMgr
SimulationWindowMgr * m_lpWinMgr
Manager for SimulationWindows.
Definition: Simulator.h:112

AnimatSim::Simulator::m_fltStabilityScale
float m_fltStabilityScale
A linear scaling factor for setting the simulation parameters.
Definition: Simulator.h:210

AnimatSim::Simulator::m_bStopSimulation
bool m_bStopSimulation
Set to true to stop the simulation.
Definition: Simulator.h:134

AnimatSim::Simulator::m_lEndSimTimeSlice
float m_lEndSimTimeSlice
The time slice when the simulation should end.
Definition: Simulator.h:264

SimulationWindow.h
Declares the simulation Windows Form.

AnimatSim::Simulator::m_oMaterialMgr
Materials m_oMaterialMgr
Manager for Materials.
Definition: Simulator.h:109

AnimatSim::Simulator::m_bBlockSimulation
bool m_bBlockSimulation
true to block simulation. See WaitForBlock for more info.
Definition: Simulator.h:124

AnimatSim::Simulator::m_fltRemainingStepTime
float m_fltRemainingStepTime
Definition: Simulator.h:402

AnimatSim::SimulationWindowMgr
Manager for simulation windows.
Definition: SimulationWindowMgr.h:20

AnimatSim::Simulator::m_aryObjectList
CStdMap< std::string, AnimatBase * > m_aryObjectList
A list of all animatbase objects in the simulation.
Definition: Simulator.h:81

AnimatSim::Simulator::m_fltAngularCompliance
float m_fltAngularCompliance
The angular compliance of the simulation environment.
Definition: Simulator.h:216

AnimatSim::ScriptProcessor
Definition: ScriptProcessor.h:6

StdUtils::CStdXml
A standard xml manipulation class.
Definition: StdXml.h:19

AnimatSim::Simulator::m_fltPhysicsSubstepTime
float m_fltPhysicsSubstepTime
Definition: Simulator.h:248

AnimatSim::Simulator::m_fltEndSimTime
float m_fltEndSimTime
The time when the simulation should end.
Definition: Simulator.h:261

AnimatSim::Simulator::m_fltDisplayMassUnits
float m_fltDisplayMassUnits
Tells how many kilograms/m^3 each unit of density is worth within the simulation environment.
Definition: Simulator.h:200

AnimatSim::Simulator::m_oDataChartMgr
DataChartMgr m_oDataChartMgr
Manager for data charts.
Definition: Simulator.h:100

AnimatSim::Simulator::m_iTargetAdapterCount
int m_iTargetAdapterCount
Number of target adapters.
Definition: Simulator.h:94

AnimatSim::Simulator::m_aryOdorTypes
CStdPtrMap< std::string, OdorType > m_aryOdorTypes
Definition: Simulator.h:63

AnimatSim::Simulator::m_fltTotalMicroWaitCount
float m_fltTotalMicroWaitCount
Total number of loop iterations for microwait during playback pause calculations. ...
Definition: Simulator.h:414

AnimatSim::Simulator::m_aryNeuralModuleFactories
CStdMap< std::string, IStdClassFactory * > m_aryNeuralModuleFactories
Definition: Simulator.h:71

AnimatSim::Simulator::m_iPlaybackControlMode
int m_iPlaybackControlMode
Determines the mode used for playback control. See the accessor method for more details.
Definition: Simulator.h:332

AnimatSim::Simulator::m_fltLinearDamping
float m_fltLinearDamping
The linear damping of the simulation environment.
Definition: Simulator.h:219

AnimatSim::Simulator::m_lpVideoPlayback
KeyFrame * m_lpVideoPlayback
The pointer to a video playback.
Definition: Simulator.h:445

AnimatSim::Simulator::m_fltMouseSpringLengthMagnitude
float m_fltMouseSpringLengthMagnitude
The magnitude of the length of the mouse spring at each step.
Definition: Simulator.h:306

AnimatSim::Simulator::m_fltSimRecorderStepTime
float m_fltSimRecorderStepTime
Time to process simulation recorder for this step.
Definition: Simulator.h:398

AnimatSim::Simulator::m_lpSimCallback
ISimGUICallback * m_lpSimCallback
Definition: Simulator.h:131

AnimatSim::Simulator::m_fltGravity
float m_fltGravity
The acceleration of gravity to use in the simulation.
Definition: Simulator.h:207

AnimatSim::Simulator::m_lVideoFrameStartTick
unsigned long long m_lVideoFrameStartTick
The tick when a new video frame time starts.
Definition: Simulator.h:372

AnimatSim::Simulator::m_lpSimRecorder
SimulationRecorder * m_lpSimRecorder
The pointer to a simulation recorder.
Definition: Simulator.h:106

StdUtils
Namespace for the standard utility objects.
Definition: MarkupSTL.cpp:19

AnimatSim::Simulator::m_lpSelStructure
Structure * m_lpSelStructure
The pointer to a selected structure.
Definition: Simulator.h:499

ThreadProcessor.h
Declares the thread processing class.

AnimatSim::Simulator::m_bIsResetting
bool m_bIsResetting
True if we are in the process of resetting the simulation. False otherwise.
Definition: Simulator.h:164

AnimatSim::ISimGUICallback
Callback methods for the simulation object.
Definition: ISimGUICallback.h:11

AnimatSim::Simulator::m_fltTimeStep
float m_fltTimeStep
This is the minimum integration time step taken for all neural modules and the physics engine...
Definition: Simulator.h:237

AnimatSim::Simulator::m_lStepTimeCount
long m_lStepTimeCount
This is a temp variable for measuring sim time for a set period for each simulation.
Definition: Simulator.h:420

AnimatSim::AnimatBase
Animat base class.
Definition: AnimatBase.h:36

AnimatSim::Simulator::m_lVideoSliceCount
long m_lVideoSliceCount
Current video slice time slice.
Definition: Simulator.h:436

AnimatSim::Simulator::m_fltVideoRecordFrameTime
float m_fltVideoRecordFrameTime
Time of the video record frame.
Definition: Simulator.h:458

AnimatSim::Simulator::m_strExecutablePath
std::string m_strExecutablePath
The directory path where the executable is located.
Definition: Simulator.h:43

AnimatSim::Simulator::m_aryTargetPhysicsAdapters
CStdArray< Adapter * > m_aryTargetPhysicsAdapters
Array of target physics adapters.
Definition: Simulator.h:87

AnimatSim::Simulator::m_lpNeuralThread
ThreadProcessor * m_lpNeuralThread
The pointer to a neural thread processor.
Definition: Simulator.h:167

MaterialType.h
Declares the material pair class.

AnimatSim::Simulator::m_bForceFastMoving
bool m_bForceFastMoving
true if we need to set the physics system to force handling of fast moving objects.
Definition: Simulator.h:155

AnimatSim::Simulator::m_fltVideoStartTime
float m_fltVideoStartTime
Time of the video start.
Definition: Simulator.h:464

AnimatSim::Simulator::m_fltDistanceUnits
float m_fltDistanceUnits
Tells how many meters each unit of distance is worth within the simulation environment.
Definition: Simulator.h:183

AnimatSim::Simulator::m_fltPrevPhysicsStepTime
float m_fltPrevPhysicsStepTime
Definition: Simulator.h:386

AnimatSim::Simulator::m_iVideoStep
int m_iVideoStep
Zero-based index of the video step.
Definition: Simulator.h:473

AnimatSim::Simulator::m_iManualRandomSeed
int m_iManualRandomSeed
Definition: Simulator.h:291

AnimatSim::Simulator::m_bSteppingSim
bool m_bSteppingSim
true if stepping of simulation has begun. This is set to true once the Simulate methods has been call...
Definition: Simulator.h:152

AnimatSim::Simulator::m_lStartSimTick
unsigned long long m_lStartSimTick
The tick count for when the simulation first begins running.
Definition: Simulator.h:267

AnimatSim::Simulator::m_bAddBodiesMode
bool m_bAddBodiesMode
true if the AddBodies mode is enabled within the GUI.
Definition: Simulator.h:121

AnimatSim::Simulator::m_lVideoEndSlice
long m_lVideoEndSlice
The video end slice.
Definition: Simulator.h:479

AnimatSim::Simulator::m_fltRealTime
float m_fltRealTime
This keeps track of the real time from the begginning of the simulation.
Definition: Simulator.h:358

AnimatSim::Simulator::m_fltTotalNeuralStepTime
float m_fltTotalNeuralStepTime
Total time for processing of all neural items for this step.
Definition: Simulator.h:389

AnimatSim::Simulator::m_arySourcePhysicsAdapters
CStdArray< Adapter * > m_arySourcePhysicsAdapters
Array of source physics adapters.
Definition: Simulator.h:84

AnimatSim::Simulator::m_fltVideoPlaybackFrameTime
float m_fltVideoPlaybackFrameTime
Time of the video playback frame.
Definition: Simulator.h:461

AnimatSim::Simulator::m_lpIOThread
ThreadProcessor * m_lpIOThread
The pointer to an i/o thread processor.
Definition: Simulator.h:173

AnimatSim::Simulator::m_strSimulationFile
std::string m_strSimulationFile
The name of the Animat Simulation (ASIM) file.
Definition: Simulator.h:46

AnimatSim::Simulator::m_bRecordVideo
bool m_bRecordVideo
true to record video
Definition: Simulator.h:452

AnimatSim::Simulator::m_dblTotalStepTime
double m_dblTotalStepTime
This is a temp variable for measuring sim time for a set period for each simulation.
Definition: Simulator.h:417

AnimatSim::Simulator::m_fltTime
float m_fltTime
The current simulation time.
Definition: Simulator.h:254

Materials.h
Declares the materials class.

AnimatSim::Simulator::m_strVideoFilename
std::string m_strVideoFilename
Filename of the video file.
Definition: Simulator.h:455

AnimatSim::Simulator::m_fltVideoEndTime
float m_fltVideoEndTime
Time of the video end.
Definition: Simulator.h:467

AnimatSim::Simulator::m_lStepStartTick
unsigned long long m_lStepStartTick
This is the tick count that is taken when a step is started.
Definition: Simulator.h:339

StdUtils::CStdSerialize
Standard serialize class.
Definition: StdSerialize.h:20

AnimatSim::Simulator::m_fltAngularKineticLoss
float m_fltAngularKineticLoss
The angular kinetic loss of the simulation environment.
Definition: Simulator.h:228

AnimatSim::Simulator::m_fltMassUnits
float m_fltMassUnits
Tells how many kilograms each unit of mass is worth within the simulation environment.
Definition: Simulator.h:194

AnimatSim::Simulator::m_fltRecFieldSelRadius
float m_fltRecFieldSelRadius
Definition: Simulator.h:317

AnimatSim::Simulator::m_fltTotalMicroWaitTime
float m_fltTotalMicroWaitTime
Total time we were in microwait during playback pause calculations;.
Definition: Simulator.h:411

ModuleThreadProcessor.h
Declares the thread processing class for a specific module.

AnimatSim::Simulator::m_fltLinearKineticLoss
float m_fltLinearKineticLoss
The linear kinetic loss of the simulation environment.
Definition: Simulator.h:225

AnimatSim::Simulator::m_fltTotalRealTimeForStepSmooth
float m_fltTotalRealTimeForStepSmooth
Current value of the exponential smoothing algorith for real time step.
Definition: Simulator.h:355

AnimatSim::Simulator::m_fltInverseMassUnits
float m_fltInverseMassUnits
The inverse of the mass units.
Definition: Simulator.h:197

AnimatSim::Simulator::m_iExtraDataCount
int m_iExtraDataCount
Number of parts that require extra data to be collected.
Definition: Simulator.h:97

AnimatSim::Simulator::m_fltPhysicsTimeStep
float m_fltPhysicsTimeStep
The time increment for each time slice of the physics simulation.
Definition: Simulator.h:278

AnimatSim::Simulator::m_fltPresetPlaybackTimeStep
float m_fltPresetPlaybackTimeStep
Definition: Simulator.h:336

AnimatSim::Simulator::m_fltMouseSpringDampingForceMagnitude
float m_fltMouseSpringDampingForceMagnitude
The magnitude of the damping component of the force being applied by the mosue spring at each step...
Definition: Simulator.h:303

AnimatSim::Simulator::m_lpAnimatClassFactory
IStdClassFactory * m_lpAnimatClassFactory
Definition: Simulator.h:78

AnimatSim::Simulator::m_fltMouseSpringStiffness
float m_fltMouseSpringStiffness
The stiffness of the user mouse spring.
Definition: Simulator.h:294

AnimatSim::Simulator::m_vBackgroundColor
CStdColor m_vBackgroundColor
The background color to use when drawing the environment.
Definition: Simulator.h:309