BVB Source Codes

CRYENGINE Show AnimationDatabase.h Source code

Return Download CRYENGINE: download AnimationDatabase.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. //
  4. ////////////////////////////////////////////////////////////////////////////
  5. #ifndef __ANIMATIONDATABASE_H__
  6. #define __ANIMATIONDATABASE_H__
  7.  
  8. #include "ICryMannequin.h"
  9.  
  10. class CAnimationDatabase : public IAnimationDatabase
  11. {
  12. public:
  13.  
  14.         friend class CAnimationDatabaseManager;
  15.         friend class CAnimationDatabaseLibrary;
  16.  
  17.         CAnimationDatabase()
  18.                 : m_pFragDef(NULL)
  19.                 , m_pTagDef(NULL)
  20.                 , m_autoSort(true)
  21.         {
  22.         }
  23.  
  24.         explicit CAnimationDatabase(const char* normalizedFilename)
  25.                 : m_filename(normalizedFilename)
  26.                 , m_pFragDef(NULL)
  27.                 , m_pTagDef(NULL)
  28.                 , m_autoSort(true)
  29.         {
  30.         }
  31.  
  32.         virtual ~CAnimationDatabase();
  33.  
  34.         virtual bool Validate(const IAnimationSet* animSet, MannErrorCallback errorCallback, MannErrorCallback warningCallback, void* errorCallbackContext) const;
  35.         virtual void EnumerateAnimAssets(const IAnimationSet* animSet, MannAssetCallback assetCallback, void* callbackContext) const;
  36.  
  37.         uint32       GetTotalTagSets(FragmentID fragmentID) const
  38.         {
  39.                 const uint32 numFragmentTypes = m_fragmentList.size();
  40.                 if (fragmentID < numFragmentTypes)
  41.                 {
  42.                         const TOptFragmentTagSetList* pList = m_fragmentList[fragmentID]->compiledList;
  43.                         return pList ? pList->Size() : 0;
  44.                 }
  45.                 else
  46.                 {
  47.                         return 0;
  48.                 }
  49.         }
  50.         uint32 GetTagSetInfo(FragmentID fragmentID, uint32 tagSetID, SFragTagState& fragTagState) const
  51.         {
  52.                 const uint32 numFragmentTypes = m_fragmentList.size();
  53.                 if (fragmentID < numFragmentTypes)
  54.                 {
  55.                         const SFragmentEntry& fragmentEntry = *m_fragmentList[fragmentID];
  56.  
  57.                         const TOptFragmentTagSetList* pList = fragmentEntry.compiledList;
  58.                         if (pList && (tagSetID < pList->Size()))
  59.                         {
  60.                                 pList->GetKey(fragTagState, tagSetID);
  61.                                 return pList->Get(tagSetID)->size();
  62.                         }
  63.                 }
  64.  
  65.                 return 0;
  66.         }
  67.  
  68.         const CFragment* GetEntry(FragmentID fragmentID, const SFragTagState& tags, uint32 optionIdx) const
  69.         {
  70.                 const uint32 numFragmentTypes = m_fragmentList.size();
  71.                 if (fragmentID < numFragmentTypes)
  72.                 {
  73.                         const SFragmentEntry& fragmentEntry = *m_fragmentList[fragmentID];
  74.                         const TOptFragmentTagSetList* pList = fragmentEntry.compiledList;
  75.                         const TFragmentOptionList* pOptionList = pList ? pList->Find(tags) : NULL;
  76.                         if (pOptionList)
  77.                         {
  78.                                 if (optionIdx >= (uint32)pOptionList->size())
  79.                                 {
  80.                                         CRY_ASSERT(false);
  81.                                         return NULL;
  82.                                 }
  83.  
  84.                                 return (*pOptionList)[optionIdx].fragment;
  85.                         }
  86.                 }
  87.  
  88.                 return NULL;
  89.         }
  90.  
  91.         const CFragment* GetEntry(FragmentID fragmentID, uint32 fragSetIdx, uint32 optionIdx) const
  92.         {
  93.                 const uint32 numFragmentTypes = m_fragmentList.size();
  94.                 if (fragmentID < numFragmentTypes)
  95.                 {
  96.                         const SFragmentEntry& fragmentEntry = *m_fragmentList[fragmentID];
  97.                         const TOptFragmentTagSetList* pList = fragmentEntry.compiledList;
  98.                         const TFragmentOptionList* pOptionList = pList ? pList->Get(fragSetIdx) : NULL;
  99.  
  100.                         if (pOptionList)
  101.                         {
  102.                                 if (optionIdx >= (uint32)pOptionList->size())
  103.                                 {
  104.                                         CRY_ASSERT(false);
  105.                                         return NULL;
  106.                                 }
  107.  
  108.                                 return (*pOptionList)[optionIdx].fragment;
  109.                         }
  110.                 }
  111.  
  112.                 return NULL;
  113.         }
  114.  
  115.         virtual const CFragment* GetBestEntry(const SFragmentQuery& fragQuery, SFragmentSelection* fragSelection = NULL) const
  116.         {
  117.                 const uint32 numFragmentTypes = m_fragmentList.size();
  118.                 SFragTagState* pSelectedFragTags = NULL;
  119.                 if (fragSelection)
  120.                 {
  121.                         fragSelection->tagState.globalTags = TAG_STATE_EMPTY;
  122.                         fragSelection->tagState.fragmentTags = TAG_STATE_EMPTY;
  123.                         fragSelection->tagSetIdx = TAG_SET_IDX_INVALID;
  124.                         fragSelection->optionIdx = 0;
  125.                         pSelectedFragTags = &fragSelection->tagState;
  126.                 }
  127.  
  128.                 if (fragQuery.fragID < numFragmentTypes)
  129.                 {
  130.                         const CTagDefinition* fragTagDef = m_pFragDef->GetSubTagDefinition(fragQuery.fragID);
  131.                         const SFragmentEntry& fragmentEntry = *m_fragmentList[fragQuery.fragID];
  132.                         uint32 tagSetIdx = TAG_SET_IDX_INVALID;
  133.                         const TFragmentOptionList* pOptionList = fragmentEntry.compiledList ? fragmentEntry.compiledList->GetBestMatch(fragQuery.tagState, fragQuery.requiredTags, pSelectedFragTags, &tagSetIdx) : NULL;
  134.  
  135.                         if (pOptionList)
  136.                         {
  137.                                 const uint32 numOptions = pOptionList->size();
  138.  
  139.                                 CFragment* ret = NULL;
  140.                                 if (numOptions > 0)
  141.                                 {
  142.                                         uint32 option = fragQuery.optionIdx % numOptions;
  143.                                         ret = (*pOptionList)[option].fragment;
  144.  
  145.                                         if (fragSelection)
  146.                                         {
  147.                                                 fragSelection->tagSetIdx = tagSetIdx;
  148.                                                 fragSelection->optionIdx = option;
  149.                                         }
  150.                                 }
  151.  
  152.                                 return ret;
  153.                         }
  154.                 }
  155.                 else if (fragQuery.fragID != FRAGMENT_ID_INVALID)
  156.                 {
  157.                         CryWarning(VALIDATOR_MODULE_ANIMATION, VALIDATOR_WARNING, "AnimDatabase: Invalid fragment idx: %d passed to %s", fragQuery.fragID, m_filename.c_str());
  158.                 }
  159.  
  160.                 return NULL;
  161.         }
  162.  
  163.         virtual bool Query(SFragmentData& outFragmentData, const SFragmentQuery& inFragQuery, SFragmentSelection* outFragSelection = NULL) const
  164.         {
  165.                 const CFragment* fragment = GetBestEntry(inFragQuery, outFragSelection);
  166.  
  167.                 outFragmentData.animLayers.clear();
  168.                 outFragmentData.procLayers.clear();
  169.                 if (fragment)
  170.                 {
  171.                         outFragmentData.animLayers = fragment->m_animLayers;
  172.                         outFragmentData.procLayers = fragment->m_procLayers;
  173.                         return true;
  174.                 }
  175.                 return false;
  176.         }
  177.  
  178.         virtual uint32 Query(SFragmentData& outFragmentData, const SBlendQuery& inBlendQuery, uint32 inOptionIdx, const IAnimationSet* inAnimSet, SFragmentSelection* outFragSelection = NULL) const;
  179.  
  180.         virtual uint32 FindBestMatchingTag(const SFragmentQuery& inFragQuery, SFragTagState* matchedTagState /* = NULL*/, uint32* tagSetIdx /* = NULL*/) const
  181.         {
  182.                 if (m_pFragDef->IsValidTagID(inFragQuery.fragID))
  183.                 {
  184.                         SFragmentEntry& fragmentEntry = *m_fragmentList[inFragQuery.fragID];
  185.                         const CTagDefinition* fragTagDef = m_pFragDef->GetSubTagDefinition(inFragQuery.fragID);
  186.                         const TFragmentOptionList* pOptionList = fragmentEntry.compiledList ? fragmentEntry.compiledList->GetBestMatch(inFragQuery.tagState, inFragQuery.requiredTags, matchedTagState, tagSetIdx) : NULL;
  187.  
  188.                         if (pOptionList)
  189.                         {
  190.                                 return pOptionList->size();
  191.                         }
  192.                 }
  193.                 else
  194.                 {
  195.                         CryWarning(VALIDATOR_MODULE_ANIMATION, VALIDATOR_WARNING, "AnimDatabase: Invalid fragment idx: %d passed to %s", inFragQuery.fragID, m_filename.c_str());
  196.                 }
  197.  
  198.                 if (matchedTagState)
  199.                 {
  200.                         *matchedTagState = SFragTagState();
  201.                 }
  202.  
  203.                 if (tagSetIdx)
  204.                 {
  205.                         *tagSetIdx = TAG_SET_IDX_INVALID;
  206.                 }
  207.  
  208.                 return 0;
  209.         }
  210.  
  211.         virtual const CTagDefinition& GetTagDefs() const
  212.         {
  213.                 return *m_pTagDef;
  214.         }
  215.  
  216.         virtual const CTagDefinition& GetFragmentDefs() const
  217.         {
  218.                 return *m_pFragDef;
  219.         }
  220.  
  221.         virtual FragmentID GetFragmentID(const char* szFragmentName) const
  222.         {
  223.                 return m_pFragDef->Find(szFragmentName);
  224.         }
  225.  
  226.         //--- Transition queries
  227.  
  228.         virtual uint32                GetNumBlends(FragmentID fragmentIDFrom, FragmentID fragmentIDTo, const SFragTagState& tagFrom, const SFragTagState& tagTo) const;
  229.         virtual const SFragmentBlend* GetBlend(FragmentID fragmentIDFrom, FragmentID fragmentIDTo, const SFragTagState& tagFrom, const SFragTagState& tagTo, uint32 blendNum) const;
  230.         virtual const SFragmentBlend* GetBlend(FragmentID fragmentIDFrom, FragmentID fragmentIDTo, const SFragTagState& tagFrom, const SFragTagState& tagTo, SFragmentBlendUid uid) const;
  231.         virtual void                  FindBestBlends(const SBlendQuery& blendQuery, SBlendQueryResult& result1, SBlendQueryResult& result2) const;
  232.  
  233.         //--- Editor entries
  234.  
  235.         void   SetEntry(FragmentID fragmentID, const SFragTagState& tags, uint32 optionIdx, const CFragment& fragment);
  236.         bool   DeleteEntry(FragmentID fragmentID, const SFragTagState& tags, uint32 optionIdx);
  237.         uint32 AddEntry(FragmentID fragmentID, const SFragTagState& tags, const CFragment& fragment);
  238.  
  239.         void   SetAutoSort(bool autoSort)
  240.         {
  241.                 m_autoSort = autoSort;
  242.         }
  243.         void                Sort();
  244.         void                Compress();
  245.  
  246.         virtual const char* FindSubADBFilenameForID(FragmentID fragmentID) const;
  247.         virtual bool        RemoveSubADBFragmentFilter(FragmentID fragmentID);
  248.         virtual bool        AddSubADBFragmentFilter(const string& sADBFileName, FragmentID fragmentID);
  249.         virtual void        GetSubADBFragmentFilters(SMiniSubADB::TSubADBArray& outList) const;
  250.  
  251.         virtual bool        AddSubADBTagFilter(const string& sParentFilename, const string& sADBFileName, const TagState& tag);
  252.         virtual bool        MoveSubADBFilter(const string& sADBFileName, const bool bMoveUp);
  253.         virtual bool        DeleteSubADBFilter(const string& sADBFileName);
  254.         virtual bool        ClearSubADBFilter(const string& sADBFileName);
  255.  
  256.         virtual const char* GetFilename() const
  257.         {
  258.                 return m_filename.c_str();
  259.         }
  260.  
  261.         virtual void QueryUsedTags(const FragmentID fragmentID, const SFragTagState& filter, SFragTagState& usedTags) const;
  262.  
  263.         void         DeleteFragmentID(FragmentID fragmentID);
  264.  
  265.         static void  RegisterCVars();
  266.  
  267. private:
  268.  
  269.         void              EnumerateFragmentAnimAssets(const CFragment* pFragment, const IAnimationSet* animSet, SAnimAssetReport& assetReport, MannAssetCallback assetCallback, void* callbackContext) const;
  270.         bool              ValidateFragment(const CFragment* pFragment, const IAnimationSet* animSet, SMannequinErrorReport& errorReport, MannErrorCallback errorCallback, void* errorCallbackContext) const;
  271.         bool              ValidateAnimations(FragmentID fragID, uint32 tagSetID, uint32 numOptions, const SFragTagState& tagState, const IAnimationSet* animSet, MannErrorCallback errorCallback, void* errorCallbackContext) const;
  272.         bool              IsDuplicate(const CFragment* pFragmentA, const CFragment* pFragmentB) const;
  273.  
  274.         void              CompressFragmentID(FragmentID fragID);
  275.  
  276.         SFragmentBlendUid AddBlendInternal(FragmentID fragmentIDFrom, FragmentID fragmentIDTo, const SFragTagState& tagFrom, const SFragTagState& tagTo, const SFragmentBlend& fragBlend);
  277.         SFragmentBlendUid AddBlend(FragmentID fragmentIDFrom, FragmentID fragmentIDTo, const SFragTagState& tagFrom, const SFragTagState& tagTo, const SFragmentBlend& fragBlend);
  278.         void              SetBlend(FragmentID fragmentIDFrom, FragmentID fragmentIDTo, const SFragTagState& tagFrom, const SFragTagState& tagTo, SFragmentBlendUid blendUid, const SFragmentBlend& fragmentBlend);
  279.         void              DeleteBlend(FragmentID fragmentIDFrom, FragmentID fragmentIDTo, const SFragTagState& tagFrom, const SFragTagState& tagTo, SFragmentBlendUid blendUid);
  280.  
  281.         struct SExplicitBlend
  282.         {
  283.                 TagState   tag;
  284.                 SAnimBlend blend;
  285.         };
  286.  
  287.         struct SExplicitBlendList
  288.         {
  289.                 std::vector<SExplicitBlend> blendList;
  290.         };
  291.  
  292.         struct SFragmentOption
  293.         {
  294.                 SFragmentOption(CFragment* _fragment = NULL, uint32 _chance = 100)
  295.                         :
  296.                         fragment(_fragment),
  297.                         chance(_chance)
  298.                 {
  299.                 }
  300.  
  301.                 CFragment* fragment;
  302.                 uint32     chance;
  303.         };
  304.         typedef std::vector<SFragmentOption> TFragmentOptionList;
  305.  
  306.         //--- A group of fragments with a specific tag state
  307.         typedef TTagSortedList<TFragmentOptionList>          TFragmentTagSetList;
  308.  
  309.         typedef TOptimisedTagSortedList<TFragmentOptionList> TOptFragmentTagSetList;
  310.  
  311.         //--- The root fragment structure, holds all fragments for a specific FragmentID
  312.         struct SFragmentEntry
  313.         {
  314.                 SFragmentEntry()
  315.                         :
  316.                         compiledList(NULL)
  317.                 {
  318.                 }
  319.                 TFragmentTagSetList     tagSetList;
  320.                 TOptFragmentTagSetList* compiledList;
  321.         };
  322.         typedef std::vector<SFragmentEntry*> TFragmentList;
  323.  
  324.         //--- Fragment blends
  325.         typedef std::vector<SFragmentBlend> TFragmentBlendList;
  326.         struct SFragmentBlendVariant
  327.         {
  328.                 SFragTagState      tagsFrom;
  329.                 SFragTagState      tagsTo;
  330.  
  331.                 TFragmentBlendList blendList;
  332.  
  333.                 uint32             FindBlendIndexForUid(SFragmentBlendUid uid) const
  334.                 {
  335.                         for (uint32 i = 0; i < blendList.size(); ++i)
  336.                         {
  337.                                 if (blendList[i].uid == uid)
  338.                                         return i;
  339.                         }
  340.                         return uint32(-1);
  341.                 }
  342.  
  343.                 const SFragmentBlend* FindBlend(SFragmentBlendUid uid) const
  344.                 {
  345.                         uint32 idx = FindBlendIndexForUid(uid);
  346.                         return (idx < blendList.size()) ? &blendList[idx] : NULL;
  347.                 }
  348.  
  349.                 SFragmentBlend* FindBlend(SFragmentBlendUid uid)
  350.                 {
  351.                         uint32 idx = FindBlendIndexForUid(uid);
  352.                         return (idx < blendList.size()) ? &blendList[idx] : NULL;
  353.                 }
  354.         };
  355.  
  356.         typedef std::vector<SFragmentBlendVariant> TFragmentVariantList;
  357.         struct SFragmentBlendEntry
  358.         {
  359.                 TFragmentVariantList variantList;
  360.         };
  361.         struct SFragmentBlendID
  362.         {
  363.                 FragmentID fragFrom;
  364.                 FragmentID fragTo;
  365.  
  366.                 bool operator<(const SFragmentBlendID& blend) const
  367.                 {
  368.                         return (fragFrom < blend.fragFrom) || ((fragFrom == blend.fragFrom) && (fragTo < blend.fragTo));
  369.                 }
  370.         };
  371.         typedef std::map<SFragmentBlendID, SFragmentBlendEntry> TFragmentBlendDatabase;
  372.         TFragmentBlendDatabase m_fragmentBlendDB;
  373.  
  374.         struct SSubADB
  375.         {
  376.                 TagState              tags;
  377.                 TagState              comparisonMask;
  378.                 string                filename;
  379.                 const CTagDefinition* pFragDef;
  380.                 const CTagDefinition* pTagDef;
  381.                 TagState              knownTags;
  382.  
  383.                 typedef std::vector<FragmentID> TFragIDList;
  384.                 TFragIDList vFragIDs;
  385.  
  386.                 typedef std::vector<SSubADB> TSubADBList;
  387.                 TSubADBList subADBs;
  388.  
  389.                 bool        IsSubADB(const char* szSubADBFilename) const
  390.                 {
  391.                         return (filename.compareNoCase(szSubADBFilename) == 0);
  392.                 }
  393.  
  394.                 bool ContainsSubADB(const char* szSubADBFilename) const
  395.                 {
  396.                         for (TSubADBList::const_iterator cit = subADBs.begin(); cit != subADBs.end(); ++cit)
  397.                         {
  398.                                 const SSubADB& subADB = *cit;
  399.                                 if (subADB.IsSubADB(szSubADBFilename))
  400.                                 {
  401.                                         return true;
  402.                                 }
  403.  
  404.                                 if (subADB.ContainsSubADB(szSubADBFilename))
  405.                                 {
  406.                                         return true;
  407.                                 }
  408.                         }
  409.  
  410.                         return false;
  411.                 }
  412.         };
  413.         typedef SSubADB::TSubADBList TSubADBList;
  414.  
  415.         SSubADB*              FindSubADB(const char* szSubADBFilename, bool recursive);
  416.         const SSubADB*        FindSubADB(const char* szSubADBFilename, bool recursive) const;
  417.  
  418.         static const SSubADB* FindSubADB(const TSubADBList& subAdbList, const char* szSubADBFilename, bool recursive);
  419.  
  420.         struct SCompareBlendVariantFunctor : public std::binary_function<const SFragmentBlendVariant&, const SFragmentBlendVariant&, bool>
  421.         {
  422.                 SCompareBlendVariantFunctor(const CTagDefinition& tagDefs, const CTagDefinition* pFragTagDefsFrom, const CTagDefinition* pFragTagDefsTo)
  423.                         :
  424.                         m_tagDefs(tagDefs),
  425.                         m_pFragTagDefsFrom(pFragTagDefsFrom),
  426.                         m_pFragTagDefsTo(pFragTagDefsTo)
  427.                 {
  428.                 }
  429.  
  430.                 bool operator()(const SFragmentBlendVariant& lhs, const SFragmentBlendVariant& rhs);
  431.  
  432.                 const CTagDefinition& m_tagDefs;
  433.                 const CTagDefinition* m_pFragTagDefsFrom;
  434.                 const CTagDefinition* m_pFragTagDefsTo;
  435.         };
  436.  
  437.         SFragmentBlendVariant*       GetVariant(FragmentID fragmentIDFrom, FragmentID fragmentIDTo, const SFragTagState& tagFrom, const SFragTagState& tagTo) const;
  438.         const SFragmentBlendVariant* FindBestVariant(const SFragmentBlendID& fragmentBlendID, const SFragTagState& tagFrom, const SFragTagState& tagTo, const TagState& requiredTags, FragmentID& outFragmentFrom, FragmentID& outFragmentTo) const;
  439.         void                         FindBestBlendInVariant(const SFragmentBlendVariant& variant, const SBlendQuery& blendQuery, SBlendQueryResult& result) const;
  440.  
  441.         const char*                  FindSubADBFilenameForIDInternal(FragmentID fragmentID, const SSubADB& pSubADB) const;
  442.         bool                         RemoveSubADBFragmentFilterInternal(FragmentID fragmentID, SSubADB& subADB);
  443.         bool                         AddSubADBFragmentFilterInternal(const string& sADBFileName, FragmentID fragmentID, SSubADB& subADB);
  444.         void                         FillMiniSubADB(SMiniSubADB& outMiniSub, const SSubADB& inSub) const;
  445.         bool                         MoveSubADBFilterInternal(const string& sADBFileName, SSubADB& subADB, const bool bMoveUp);
  446.         bool                         DeleteSubADBFilterInternal(const string& sADBFileName, SSubADB& subADB);
  447.         bool                         ClearSubADBFilterInternal(const string& sADBFileName, SSubADB& subADB);
  448.         bool                         AddSubADBTagFilterInternal(const string& sParentFilename, const string& sADBFileName, const TagState& tag, SSubADB& subADB);
  449.  
  450.         static void                  AdjustSubADBListAfterFragmentIDDeletion(SSubADB::TSubADBList& subADBs, const FragmentID fragmentID);
  451.  
  452.         bool                         ValidateSet(const TFragmentTagSetList& tagSetList);
  453.  
  454.         string                m_filename;
  455.  
  456.         const CTagDefinition* m_pFragDef;
  457.         const CTagDefinition* m_pTagDef;
  458.  
  459.         TFragmentList         m_fragmentList;
  460.  
  461.         SSubADB::TSubADBList  m_subADBs;
  462.  
  463.         bool                  m_autoSort;
  464.  
  465.         static int            s_mnAllowEditableDatabasesInPureGame;
  466.         static bool           s_registeredCVars;
  467. };
  468.  
  469. #endif //__ANIMATIONDATABASE_H__
  470.  
downloadAnimationDatabase.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