BVB Source Codes

CRYENGINE Show AIRecorder.h Source code

Return Download CRYENGINE: download AIRecorder.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /********************************************************************
  4.    -------------------------------------------------------------------------
  5.    File name:   AIRecorder.h
  6.    Description: Detailed event-based AI recorder for visual debugging
  7.  
  8.    -------------------------------------------------------------------------
  9.    History:
  10.    -01:07:2005 : Created by Kirill Bulatsev
  11.    -19:11:2008 : Separated from simple text CAIRecorder by Matthew
  12.  
  13.  *********************************************************************/
  14.  
  15. #ifndef __AIRECORDER_H__
  16. #define __AIRECORDER_H__
  17.  
  18. #pragma once
  19.  
  20. #ifdef CRYAISYSTEM_DEBUG
  21.  
  22.         #include <CryAISystem/IAIRecorder.h>
  23.         #include <CryCore/StlUtils.h>
  24.         #include "ObjectContainer.h"
  25.  
  26. typedef uint64 TAIRecorderUnitId;
  27. struct SAIRecorderUnitId
  28. {
  29.         explicit SAIRecorderUnitId(uint32 lifeIndex, tAIObjectID aiObjectId) : id(0) { Set(lifeIndex, aiObjectId); }
  30.         SAIRecorderUnitId(TAIRecorderUnitId _id) : id(_id) {}
  31.  
  32.         operator tAIObjectID() const { return tAIObjectID(id & 0xFFFFFFFF); }
  33.         operator TAIRecorderUnitId() const { return id; }
  34.  
  35.         inline void Set(uint32 lifeIndex, tAIObjectID aiObjectId)
  36.         {
  37.                 id = (uint64(lifeIndex) << 32) | aiObjectId;
  38.         }
  39.  
  40.         TAIRecorderUnitId id;
  41. };
  42.  
  43. class CAIRecorder;
  44.  
  45. class CRecorderUnit :
  46.         public IAIDebugRecord
  47. {
  48. public:
  49.         CRecorderUnit(CAIRecorder* pRecorder, CTimeValue startTime, CWeakRef<CAIObject> refUnit, uint32 uLifeIndex);
  50.         virtual ~CRecorderUnit();
  51.  
  52.         SAIRecorderUnitId GetId() const { return m_id; }
  53.  
  54.         IAIDebugStream*   GetStream(IAIRecordable::e_AIDbgEvent streamTag);
  55.         void              ResetStreams(CTimeValue startTime);
  56.  
  57.         void              RecordEvent(IAIRecordable::e_AIDbgEvent event, const IAIRecordable::RecorderEventData* pEventData);
  58.         bool              LoadEvent(IAIRecordable::e_AIDbgEvent stream);
  59.  
  60.         bool              Save(FILE* pFile);
  61.         bool              Load(FILE* pFile);
  62.  
  63.         void              SetName(const char* szName) { m_sName = szName; }
  64.         const char*       GetName() const             { return m_sName.c_str(); }
  65.  
  66. protected:
  67.  
  68.         struct StreamBase :
  69.                 public IAIDebugStream
  70.         {
  71.                 struct StreamUnitBase
  72.                 {
  73.                         float m_StartTime;
  74.                         StreamUnitBase(float time) : m_StartTime(time){}
  75.                 };
  76.                 typedef std::vector<StreamUnitBase*> TStream;
  77.  
  78.                 StreamBase(char const* name) : m_CurIdx(0), m_name(name) {}
  79.                 virtual ~StreamBase() { ClearImpl(); }
  80.                 virtual bool SaveStream(FILE* pFile) = 0;
  81.                 virtual bool LoadStream(FILE* pFile) = 0;
  82.                 virtual void AddValue(const IAIRecordable::RecorderEventData* pEventData, float t) = 0;
  83.                 virtual bool WriteValue(const IAIRecordable::RecorderEventData* pEventData, float t) = 0;
  84.                 virtual bool LoadValue(FILE* pFile) = 0;
  85.                 virtual void Clear() { ClearImpl(); }
  86.                 void         Seek(float whereTo);
  87.                 int          GetCurrentIdx();
  88.                 int          GetSize();
  89.                 float        GetStartTime();
  90.                 float        GetEndTime();
  91.                 bool         IsEmpty()       { return m_Stream.empty(); }
  92.  
  93.                 char const*  GetName() const { return m_name; }
  94.  
  95.                 // Needed for IO usage with string streams that use index lookups
  96.                 virtual bool LoadStringIndex(FILE* pFile) { return false; }
  97.                 virtual bool SaveStringIndex(FILE* pFile) { return false; }
  98.                 virtual bool IsUsingStringIndex() const   { return false; }
  99.  
  100.                 TStream     m_Stream;
  101.                 int         m_CurIdx;
  102.                 char const* m_name;
  103.  
  104.         private:
  105.                 void ClearImpl();
  106.  
  107.         };
  108.  
  109.         struct StreamStr :
  110.                 public StreamBase
  111.         {
  112.                 struct StreamUnit : public StreamBase::StreamUnitBase
  113.                 {
  114.                         string m_String;
  115.                         StreamUnit(float time, const char* pStr) : StreamUnitBase(time), m_String(pStr){}
  116.                 };
  117.                 StreamStr(char const* name, bool bUseIndex = false);
  118.                 bool  SaveStream(FILE* pFile);
  119.                 bool  LoadStream(FILE* pFile);
  120.                 void  AddValue(const IAIRecordable::RecorderEventData* pEventData, float t);
  121.                 bool  WriteValue(float t, const char* str, FILE* pFile);
  122.                 bool  WriteValue(const IAIRecordable::RecorderEventData* pEventData, float t);
  123.                 bool  LoadValue(float& t, string& name, FILE* pFile);
  124.                 bool  LoadValue(FILE* pFile);
  125.                 void  Clear();
  126.                 void* GetCurrent(float& startingFrom);
  127.                 bool  GetCurrentString(string& sOut, float& startingFrom);
  128.                 void* GetNext(float& startingFrom);
  129.  
  130.                 // Index usage for optimizing disk write usage
  131.                 virtual bool LoadStringIndex(FILE* pFile);
  132.                 virtual bool SaveStringIndex(FILE* pFile);
  133.                 virtual bool IsUsingStringIndex() const { return m_bUseIndex; }
  134.                 uint32       GetOrMakeStringIndex(const char* szString);
  135.                 bool         GetStringFromIndex(uint32 uIndex, string& sOut) const;
  136.  
  137.                 typedef std::unordered_map<string, uint32, stl::hash_strcmp<string>, stl::hash_strcmp<string>> TStrIndexLookup;
  138.                 TStrIndexLookup m_StrIndexLookup;
  139.                 uint32          m_uIndexGen;
  140.                 enum { INVALID_INDEX = 0 };
  141.                 bool            m_bUseIndex;
  142.         };
  143.  
  144.         struct StreamVec3 :
  145.                 public StreamBase
  146.         {
  147.                 struct StreamUnit : public StreamBase::StreamUnitBase
  148.                 {
  149.                         StreamUnit(float time, const Vec3& pos) : StreamUnitBase(time), m_Pos(pos) {}
  150.                         Vec3 m_Pos;
  151.                 };
  152.                 StreamVec3(char const* name, bool bUseFilter = false) : StreamBase(name), m_bUseFilter(bUseFilter) {}
  153.                 bool  SaveStream(FILE* pFile);
  154.                 bool  LoadStream(FILE* pFile);
  155.                 void  AddValue(const IAIRecordable::RecorderEventData* pEventData, float t);
  156.                 bool  WriteValue(float t, const Vec3& vec, FILE* pFile);
  157.                 bool  WriteValue(const IAIRecordable::RecorderEventData* pEventData, float t);
  158.                 bool  LoadValue(float& t, Vec3& vec, FILE* pFile);
  159.                 bool  LoadValue(FILE* pFile);
  160.                 void* GetCurrent(float& startingFrom);
  161.                 bool  GetCurrentString(string& sOut, float& startingFrom);
  162.                 void* GetNext(float& startingFrom);
  163.  
  164.                 // Returns TRUE if the point should be recorded
  165.                 bool FilterPoint(const IAIRecordable::RecorderEventData* pEventData) const;
  166.                 bool m_bUseFilter;
  167.         };
  168.  
  169.         struct StreamFloat :
  170.                 public StreamBase
  171.         {
  172.                 struct StreamUnit : public StreamBase::StreamUnitBase
  173.                 {
  174.                         StreamUnit(float time, float val) : StreamUnitBase(time), m_Val(val) {}
  175.                         float m_Val;
  176.                 };
  177.                 StreamFloat(char const* name, bool bUseFilter = false) : StreamBase(name), m_bUseFilter(bUseFilter) {}
  178.                 bool  SaveStream(FILE* pFile);
  179.                 bool  LoadStream(FILE* pFile);
  180.                 void  AddValue(const IAIRecordable::RecorderEventData* pEventData, float t);
  181.                 bool  WriteValue(float t, float val, FILE* pFile);
  182.                 bool  WriteValue(const IAIRecordable::RecorderEventData* pEventData, float t);
  183.                 bool  LoadValue(float& t, float& val, FILE* pFile);
  184.                 bool  LoadValue(FILE* pFile);
  185.                 void* GetCurrent(float& startingFrom);
  186.                 bool  GetCurrentString(string& sOut, float& startingFrom);
  187.                 void* GetNext(float& startingFrom);
  188.  
  189.                 // Returns TRUE if the point should be recorded
  190.                 bool FilterPoint(const IAIRecordable::RecorderEventData* pEventData) const;
  191.                 bool m_bUseFilter;
  192.         };
  193.  
  194.         typedef std::map<IAIRecordable::e_AIDbgEvent, StreamBase*> TStreamMap;
  195.  
  196.         TStreamMap        m_Streams;
  197.         CTimeValue        m_startTime;
  198.         string            m_sName;
  199.         CAIRecorder*      m_pRecorder;
  200.         SAIRecorderUnitId m_id;
  201. };
  202.  
  203. class CRecordable
  204. {
  205. public:
  206.         CRecordable();
  207.         virtual ~CRecordable() {}
  208.  
  209.         void ResetRecorderUnit()
  210.         {
  211.                 m_pMyRecord = NULL;
  212.         }
  213.  
  214. protected:
  215.         CRecorderUnit* GetOrCreateRecorderUnit(CAIObject* pAIObject, bool bForce = false);
  216.  
  217. protected:
  218.         CRecorderUnit*         m_pMyRecord;
  219.         CCountedRef<CAIObject> m_refUnit;
  220. };
  221.  
  222. class CAIRecorder : public IAIRecorder, public ISystemEventListener
  223. {
  224. public:
  225.         CAIRecorder();
  226.         ~CAIRecorder();
  227.  
  228.         // ISystemEventListener
  229.         virtual void OnSystemEvent(ESystemEvent event, UINT_PTR wparam, UINT_PTR lparam);
  230.         // ~ISystemEventListener
  231.  
  232.         bool IsRunning(void) const;
  233.  
  234.         // Initialise after construction
  235.         void Init(void);
  236.         void Shutdown(void);
  237.  
  238.         void Update();
  239.  
  240.         // Ignored while m_bStarted
  241.         bool Save(const char* filename = NULL);
  242.  
  243.         // Ignored while m_bStarted
  244.         bool Load(const char* filename = NULL);
  245.  
  246.         // Prepare to record events
  247.         void Start(EAIRecorderMode mode, const char* filename = NULL);
  248.  
  249.         // Finalise recording, stop recording events
  250.         void Stop(const char* filename = NULL);
  251.  
  252.         // Clear any recording in memory
  253.         void Reset(void);
  254.  
  255.         // Called from AI System when it is reset
  256.         void           OnReset(IAISystem::EResetReason reason);
  257.  
  258.         bool           AddListener(IAIRecorderListener* pListener);
  259.         bool           RemoveListener(IAIRecorderListener* pListener);
  260.  
  261.         CRecorderUnit* AddUnit(CWeakRef<CAIObject> refObject, bool force = false);
  262.  
  263.         //      void    ChangeOwnerName(const char* pOldName, const char* pNewName);
  264.  
  265.         static FILE* m_pFile; // Hack!
  266.  
  267. protected:
  268.  
  269.         // Get the complete filename
  270.         void GetCompleteFilename(char const* szFilename, bool bAppendFileCount, string& sOut) const;
  271.  
  272.         bool Read(FILE* pFile);
  273.  
  274.         bool Write(FILE* pFile);
  275.  
  276.         // Clear out any dummy objects previously created
  277.         void DestroyDummyObjects();
  278.  
  279.         EAIRecorderMode m_recordingMode;
  280.  
  281.         typedef std::map<TAIRecorderUnitId, CRecorderUnit*> TUnits;
  282.         TUnits m_Units;
  283.  
  284.         typedef std::vector<CCountedRef<CAIObject>> TDummyObjects;
  285.         TDummyObjects m_DummyObjects;
  286.  
  287.         typedef std::vector<IAIRecorderListener*> TListeners;
  288.         TListeners m_Listeners;
  289.  
  290.         ILog*      m_pLog;
  291.  
  292.         char*      m_lowLevelFileBuffer;
  293.         uint32     m_unitLifeCounter;
  294.         int        m_lowLevelFileBufferSize;
  295. };
  296.  
  297. #endif //CRYAISYSTEM_DEBUG
  298.  
  299. #endif //__AIRECORDER_H__
  300.  
downloadAIRecorder.h Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top