multitheftauto
diff --git a/‎Client/game_sa/CAnimBlendAssocGroupSA.cpp‎
Lines changed: 16 additions & 0 deletions b/‎Client/game_sa/CAnimBlendAssocGroupSA.cpp‎
Lines changed: 16 additions & 0 deletions
diff --git a/‎Client/game_sa/CAnimBlendAssocGroupSA.h‎
Lines changed: 9 additions & 6 deletions b/‎Client/game_sa/CAnimBlendAssocGroupSA.h‎
Lines changed: 9 additions & 6 deletions
diff --git a/‎Client/game_sa/CAnimBlendAssociationSA.h‎
Lines changed: 3 additions & 0 deletions b/‎Client/game_sa/CAnimBlendAssociationSA.h‎
Lines changed: 3 additions & 0 deletions
diff --git a/‎Client/game_sa/CAnimBlendHierarchySA.cpp‎
Lines changed: 74 additions & 0 deletions b/‎Client/game_sa/CAnimBlendHierarchySA.cpp‎
Lines changed: 74 additions & 0 deletions
diff --git a/‎Client/game_sa/CAnimBlendHierarchySA.h‎
Lines changed: 33 additions & 12 deletions b/‎Client/game_sa/CAnimBlendHierarchySA.h‎
Lines changed: 33 additions & 12 deletions
diff --git a/‎Client/game_sa/CAnimBlendSequenceSA.cpp‎
Lines changed: 57 additions & 0 deletions b/‎Client/game_sa/CAnimBlendSequenceSA.cpp‎
Lines changed: 57 additions & 0 deletions
diff --git a/‎Client/game_sa/CAnimBlendSequenceSA.h‎
Lines changed: 23 additions & 4 deletions b/‎Client/game_sa/CAnimBlendSequenceSA.h‎
Lines changed: 23 additions & 4 deletions
diff --git a/‎Client/game_sa/CAnimBlendStaticAssociationSA.cpp‎
Lines changed: 10 additions & 2 deletions b/‎Client/game_sa/CAnimBlendStaticAssociationSA.cpp‎
Lines changed: 10 additions & 2 deletions
diff --git a/‎Client/game_sa/CAnimBlendStaticAssociationSA.h‎
Lines changed: 18 additions & 4 deletions b/‎Client/game_sa/CAnimBlendStaticAssociationSA.h‎
Lines changed: 18 additions & 4 deletions
diff --git a/‎Client/game_sa/CAnimBlockSA.cpp‎
Lines changed: 10 additions & 0 deletions b/‎Client/game_sa/CAnimBlockSA.cpp‎
Lines changed: 10 additions & 0 deletions
@@ -18,6 +18,22 @@ CAnimBlendAssocGroupSA::CAnimBlendAssocGroupSA(CAnimBlendAssocGroupSAInterface*
     SetupAnimBlock();
 }
 
+CAnimBlendAssociationSAInterface* CAnimBlendAssocGroupSA::CopyAnimation(unsigned int AnimID)
+{
+    CAnimBlendAssociationSAInterface* pAnimAssociationReturn = nullptr;
+
+    DWORD dwThis = (DWORD)m_pInterface;
+    DWORD dwFunc = FUNC_CAnimBlendAssocGroup_CopyAnimation;
+    _asm
+    {
+        mov     ecx, dwThis
+        push    AnimID
+        call    dwFunc
+        mov     pAnimAssociationReturn, eax
+    }
+    return pAnimAssociationReturn;
+}
+
 void CAnimBlendAssocGroupSA::InitEmptyAssociations(RpClump* pClump)
 {
     DWORD dwThis = (DWORD)m_pInterface;
 
@@ -17,6 +17,7 @@
 #include "Common.h"
 
 #define FUNC_CAnimBlendAssocGroup_InitEmptyAssociations 0x4cdfb0
+#define FUNC_CAnimBlendAssocGroup_CopyAnimation         0x4ce130
 #define FUNC_CAnimBlendAssocGroup_IsCreated             0x4d37a0
 #define FUNC_CAnimBlendAssocGroup_GetNumAnimations      0x45b050
 #define FUNC_CAnimBlendAssocGroup_GetAnimBlock          0x45b060
@@ -44,12 +45,14 @@ class CAnimBlendAssocGroupSA : public CAnimBlendAssocGroup
 public:
     CAnimBlendAssocGroupSA(CAnimBlendAssocGroupSAInterface* pInterface);
 
-    void                         InitEmptyAssociations(RpClump* pClump);
-    bool                         IsCreated(void);
-    int                          GetNumAnimations(void);
-    CAnimBlock*                  GetAnimBlock(void);
-    CAnimBlendStaticAssociation* GetAnimation(unsigned int ID);
-    void                         CreateAssociations(const char* szBlockName);
+    CAnimBlendAssociationSAInterface* CopyAnimation(unsigned int AnimID);
+    void                              InitEmptyAssociations(RpClump* pClump);
+    bool                              IsCreated(void);
+    int                               GetNumAnimations(void);
+    CAnimBlock*                       GetAnimBlock(void);
+    CAnimBlendStaticAssociation*      GetAnimation(unsigned int ID);
+    AssocGroupId                      GetGroupID(void) { return m_pInterface->groupID; };
+    void                              CreateAssociations(const char* szBlockName);
 
     bool IsLoaded(void);
     void SetIDOffset(int iOffset) { m_pInterface->iIDOffset = iOffset; }
 
@@ -35,6 +35,9 @@ class CAnimBlendAssociationSAInterface
     short                           sAnimID;                        // 44
     short                           sFlags;                         // or1 = started?, or64 = referenced?   // 46
     DWORD*                          pCallback;                      // 48
+    DWORD*                          pCallbackFunc;                  // 52
+    DWORD*                          pCallbackData;                  // 56
+                                                                    // Total: 60 bytes
 };
 
 class CAnimBlendAssociationSA : public CAnimBlendAssociation
 
@@ -11,7 +11,81 @@
 
 #include "StdInc.h"
 
+// Careful, GetIndex will not work for custom animations
 int CAnimBlendHierarchySAInterface::GetIndex(void)
 {
     return (((DWORD)this - ARRAY_CAnimManager_Animations) / 24);
 }
+
+void CAnimBlendHierarchySA::Initialize(void)
+{
+    m_pInterface->pSequences = 0;
+    m_pInterface->usNumSequences = 0;
+    m_pInterface->bRunningCompressed = 0;
+    m_pInterface->pad = 0;
+    m_pInterface->iAnimBlockID = -1;
+    m_pInterface->fTotalTime = 0;
+    m_pInterface->pLinkPtr = 0;
+}
+
+void CAnimBlendHierarchySA::SetName(const char* szName)
+{
+    DWORD dwThis = (DWORD)m_pInterface;
+    DWORD dwFunc = FUNC_CAnimBlendHierarchy_SetName;
+    _asm
+    {
+        push    szName
+        mov     ecx, dwThis
+        call    dwFunc
+    }
+}
+
+void CAnimBlendHierarchySA::RemoveAnimSequences(void)
+{
+    DWORD dwThis = (DWORD)m_pInterface;
+    DWORD dwFunc = FUNC_CAnimBlendHierarchy_RemoveAnimSequences;
+    _asm
+    {
+        mov     ecx, dwThis
+        call    dwFunc
+    }
+}
+
+void CAnimBlendHierarchySA::RemoveFromUncompressedCache(void)
+{
+    DWORD dwThis = (DWORD)m_pInterface;
+    DWORD dwFunc = FUNC_CAnimBlendHierarchy_RemoveFromUncompressedCache;
+    _asm
+    {
+        mov     ecx, dwThis
+        call    dwFunc
+    }
+}
+
+void CAnimBlendHierarchySA::RemoveQuaternionFlips(void)
+{
+    DWORD dwThis = (DWORD)m_pInterface;
+    DWORD dwFunc = FUNC_CAnimBlendHierarchy_RemoveQuaternionFlips;
+    _asm
+    {
+        mov     ecx, dwThis
+        call    dwFunc
+    }
+}
+
+void CAnimBlendHierarchySA::CalculateTotalTime(void)
+{
+    DWORD dwThis = (DWORD)m_pInterface;
+    DWORD dwFunc = FUNC_CAnimBlendHierarchy_CalculateTotalTime;
+    _asm
+    {
+        mov     ecx, dwThis
+        call    dwFunc
+    }
+}
+
+CAnimBlendSequenceSAInterface* CAnimBlendHierarchySA::GetSequence(DWORD dwIndex)
+{
+    BYTE* pSequences = reinterpret_cast<BYTE*>(m_pInterface->pSequences);
+    return reinterpret_cast<CAnimBlendSequenceSAInterface*>(pSequences + (sizeof(CAnimBlendSequenceSAInterface) * dwIndex));
+}
@@ -17,32 +17,53 @@
 #include <game/CAnimBlendHierarchy.h>
 #include "Common.h"
 
-#define FUNC_CAnimBlendHierarchy_GetAnimSequence    0x4ce8f0
-#define FUNC_CAnimBlendHierarchy_GetAnimSequences   0x4d1350
+#define FUNC_CAnimBlendHierarchy_SetName                     0x4CF2D0
+#define FUNC_CAnimBlendHierarchy_RemoveAnimSequences         0x4CF8E0
+#define FUNC_CAnimBlendHierarchy_RemoveFromUncompressedCache 0x4D42A0
+#define FUNC_CAnimBlendHierarchy_RemoveQuaternionFlips       0x4CF4E0
+#define FUNC_CAnimBlendHierarchy_CalculateTotalTime          0x4CF2F0
+#define FUNC_CAnimBlendHierarchy_GetAnimSequence             0x4ce8f0
+#define FUNC_CAnimBlendHierarchy_GetAnimSequences            0x4d1350
 
 class CAnimBlendSequence;
 
 class CAnimBlendHierarchySAInterface
 {
 public:
-    int                 GetIndex(void);
-    int                 iHashKey;
-    CAnimBlendSequence* pSequences;
-    unsigned short      usNumSequences;
-    BYTE                pad;
-    bool                bRunningCompressed;
-    int                 iAnimBlockID;
-    float               fTotalTime;
+    // Careful, GetIndex will not work for custom animations
+    int GetIndex(void);
+
+    unsigned int                   iHashKey;
+    CAnimBlendSequenceSAInterface* pSequences;
+    unsigned short                 usNumSequences;
+    bool                           bRunningCompressed;
+    BYTE                           pad;
+    int                            iAnimBlockID;
+    float                          fTotalTime;
+    DWORD*                         pLinkPtr;
     // class CLink<class CAnimBlendHierarchy *> *      pLinkPtr;
 };
 
 class CAnimBlendHierarchySA : public CAnimBlendHierarchy
 {
 public:
     CAnimBlendHierarchySA(CAnimBlendHierarchySAInterface* pInterface) { m_pInterface = pInterface; }
-
-    CAnimBlendHierarchySAInterface* GetInterface(void) { return m_pInterface; }
+    void                            Initialize(void);
+    void                            SetName(const char* szName);
+    void                            SetSequences(CAnimBlendSequenceSAInterface* pSequences) { m_pInterface->pSequences = pSequences; }
+    void                            SetNumSequences(unsigned short uNumSequences) { m_pInterface->usNumSequences = uNumSequences; }
+    void                            SetRunningCompressed(bool bCompressed) { m_pInterface->bRunningCompressed = bCompressed; }
+    void                            SetAnimationBlockID(int iBlockID) { m_pInterface->iAnimBlockID = iBlockID; }
+    void                            RemoveAnimSequences(void);
+    void                            RemoveFromUncompressedCache(void);
+    void                            RemoveQuaternionFlips(void);
+    void                            CalculateTotalTime(void);
+    CAnimBlendSequenceSAInterface*  GetSequence(DWORD dwIndex);
+    CAnimBlendSequenceSAInterface*  GetSequences(void) { return m_pInterface->pSequences; }
+    unsigned short                  GetNumSequences(void) { return m_pInterface->usNumSequences; }
+    bool                            isRunningCompressed(void) { return m_pInterface->bRunningCompressed; }
     int                             GetAnimBlockID(void) { return m_pInterface->iAnimBlockID; }
+    CAnimBlendHierarchySAInterface* GetInterface(void) { return m_pInterface; }
 
 protected:
     CAnimBlendHierarchySAInterface* m_pInterface;
 
@@ -10,3 +10,60 @@
  *****************************************************************************/
 
 #include "StdInc.h"
+
+void CAnimBlendSequenceSA::Initialize(void)
+{
+    m_pInterface->m_boneId = -1;
+    m_pInterface->sFlags = 0;
+    m_pInterface->sNumKeyFrames = 0;
+    m_pInterface->pKeyFrames = 0;
+}
+
+void CAnimBlendSequenceSA::SetName(const char* szName)
+{
+    DWORD dwThis = (DWORD)m_pInterface;
+    DWORD dwFunc = FUNC_CAnimBlendSequence_SetName;
+    _asm
+    {
+        push    szName
+        mov     ecx, dwThis
+        call    dwFunc
+    }
+}
+
+void CAnimBlendSequenceSA::SetBoneTag(int32_t i32BoneID)
+{
+    DWORD dwThis = (DWORD)m_pInterface;
+    DWORD dwFunc = FUNC_CAnimBlendSequence_SetBoneTag;
+    _asm
+    {
+        push    i32BoneID
+        mov     ecx, dwThis
+        call    dwFunc
+    }
+}
+
+void CAnimBlendSequenceSA::SetKeyFrames(size_t cKeyFrames, bool bRoot, bool bCompressed, void* pKeyFrames)
+{
+    DWORD dwThis = (DWORD)m_pInterface;
+    DWORD dwFunc = FUNC_CAnimBlendSequence_SetKeyFrames;
+    _asm
+    {
+        push    pKeyFrames
+        push    bCompressed
+        push    bRoot
+        push    cKeyFrames
+        mov     ecx, dwThis
+        call    dwFunc
+    }
+}
+
+void CAnimBlendSequenceSA::CopySequenceProperties(CAnimBlendSequenceSAInterface* pAnimSequenceInterface)
+{
+    *m_pInterface = *pAnimSequenceInterface;
+}
+
+void* CAnimBlendSequenceSA::GetKeyFrame(size_t iFrame, uint32_t u32FrameSizeInBytes)
+{
+    return (m_pInterface->pKeyFrames + u32FrameSizeInBytes * iFrame);
+}
@@ -14,19 +14,38 @@
 
 #include <game/CAnimBlendSequence.h>
 
+#define FUNC_CAnimBlendSequence_SetName      0x4D0C50
+#define FUNC_CAnimBlendSequence_SetBoneTag   0x4D0C70
+#define FUNC_CAnimBlendSequence_SetKeyFrames 0x4D0CD0
+
 class CAnimBlendSequenceSAInterface
 {
 public:
-    unsigned int              iHashKey;                 // Get/SetBoneTag accesses the first? 2 bytes here
-    short                     sFlags;                   // 4    // or16=bHasBoneTag
-    short                     sNumKeyFrames;            // 6
-    class CAnimBlendKeyFrame* pKeyFrames;               // ?
+    union {
+        uint16_t m_boneId;            // m_boneId is set if ( sFlags & 0x10u ) is true
+        uint32_t m_hash;              // otherwise m_hash is set
+    };
+    unsigned short sFlags;
+    unsigned short sNumKeyFrames;
+    BYTE*          pKeyFrames;
 };
 
 class CAnimBlendSequenceSA : public CAnimBlendSequence
 {
 public:
     CAnimBlendSequenceSA(CAnimBlendSequenceSAInterface* pInterface) { m_pInterface = pInterface; }
+    void                           Initialize(void);
+    void                           SetName(const char* szName);
+    void                           SetBoneTag(int32_t i32BoneID);
+    void                           SetKeyFrames(size_t cKeyFrames, bool bRoot, bool bCompressed, void* pKeyFrames);
+    void*                          GetKeyFrame(size_t iFrame, uint32_t u32FrameSizeInBytes);
+    uint32_t                       GetHash(void) { return m_pInterface->m_hash; }
+    uint16_t                       GetBoneTag(void) { return m_pInterface->m_boneId; }
+    BYTE*                          GetKeyFrames(void) { return m_pInterface->pKeyFrames; }
+    unsigned short                 GetKeyFramesCount(void) { return m_pInterface->sNumKeyFrames; }
+    bool                           IsBigChunkForAllSequences(void) { return ((m_pInterface->sFlags >> 3) & 1); }
+    void                           CopySequenceProperties(CAnimBlendSequenceSAInterface* pAnimSequenceInterface);
+    CAnimBlendSequenceSAInterface* GetInterface(void) { return m_pInterface; }
 
 protected:
     CAnimBlendSequenceSAInterface* m_pInterface;
 
@@ -11,7 +11,15 @@
 
 #include "StdInc.h"
 
-CAnimBlendHierarchy* CAnimBlendStaticAssociationSA::GetAnimHierachy(void)
+void CAnimBlendStaticAssociationSA::Initialize(RpClump* pClump, CAnimBlendHierarchySAInterface* pAnimBlendHierarchyInterface)
 {
-    return NULL;
+    DWORD dwThis = (DWORD)m_pInterface;
+    DWORD dwFunc = FUNC_CAnimBlendStaticAssociation_Initialize;
+    _asm
+    {
+        push    pAnimBlendHierarchyInterface
+        push    pClump
+        mov     ecx, dwThis
+        call    dwFunc
+    }
 }
@@ -17,27 +17,41 @@
 #include <game/CAnimBlendStaticAssociation.h>
 #include "Common.h"
 
+#define FUNC_CAnimBlendStaticAssociation_Initialize 0x4CEC20
+
 class CAnimBlendAssocGroupSA;
 class CAnimBlendHierarchySAInterface;
 class CAnimBlendHierarchy;
 
 class CAnimBlendStaticAssociationSAInterface
 {
+protected:
+    void* vTable;
+
 public:
-    BYTE                            pad[6];
+    unsigned short                  nNumBlendNodes;
     short                           sAnimID;
     short                           sAnimGroup;
     short                           sFlags;
-    BYTE                            pad2[4];
+    int*                            pAnimBlendNodesSequenceArray;
     CAnimBlendHierarchySAInterface* pAnimHeirarchy;
 };
 
 class CAnimBlendStaticAssociationSA : public CAnimBlendStaticAssociation
 {
 public:
     CAnimBlendStaticAssociationSA(CAnimBlendStaticAssociationSAInterface* pInterface) { m_pInterface = pInterface; }
-
-    CAnimBlendHierarchy* GetAnimHierachy(void);
+    void Initialize(RpClump* pClump, CAnimBlendHierarchySAInterface* pAnimBlendHierarchyInterface);
+    void SetNumBlendNodes(unsigned short nNumBlendNodes) { m_pInterface->nNumBlendNodes = nNumBlendNodes; };
+    void SetAnimID(short sAnimID) { m_pInterface->sAnimID = sAnimID; }
+    void SetAnimGroup(short sAnimGroup) { m_pInterface->sAnimGroup = sAnimGroup; }
+    void SetFlags(short sFlags) { m_pInterface->sFlags = sFlags; }
+
+    unsigned short                  GetNumBlendNodes(void) { return m_pInterface->nNumBlendNodes; };
+    short                           GetAnimID(void) { return m_pInterface->sAnimID; }
+    short                           GetAnimGroup(void) { return m_pInterface->sAnimGroup; }
+    short                           GetFlags(void) { return m_pInterface->sFlags; }
+    CAnimBlendHierarchySAInterface* GetAnimHierachyInterface(void) { return m_pInterface->pAnimHeirarchy; }
 
 protected:
     CAnimBlendStaticAssociationSAInterface* m_pInterface;
 
@@ -43,3 +43,13 @@ void CAnimBlockSA::Request(EModelRequestType requestType, bool bAllowBlockingFai
         AddRef();
     }
 }
+
+CAnimBlendHierarchySAInterface* CAnimBlockSA::GetAnimationHierarchyInterface(size_t iAnimation)
+{
+    if (!IsLoaded())
+        return nullptr;
+
+    iAnimation += m_pInterface->idOffset;
+    BYTE* arrAnimations = reinterpret_cast<BYTE*>(ARRAY_CAnimManager_Animations);
+    return reinterpret_cast<CAnimBlendHierarchySAInterface*>(arrAnimations + sizeof(CAnimBlendHierarchySAInterface) * iAnimation);
+}
Original file line number	Diff line number	Diff line change
`@@ -43,3 +43,13 @@ void CAnimBlockSA::Request(EModelRequestType requestType, bool bAllowBlockingFai`
`43`	`43`	`AddRef();`
`44`	`44`	`}`
`45`	`45`	`}`
	`46`	`+`
	`47`	`+CAnimBlendHierarchySAInterface* CAnimBlockSA::GetAnimationHierarchyInterface(size_t iAnimation)`
	`48`	`+{`
	`49`	`+ if (!IsLoaded())`
	`50`	`+ return nullptr;`
	`51`	`+`
	`52`	`+ iAnimation += m_pInterface->idOffset;`
	`53`	`+ BYTE* arrAnimations = reinterpret_cast<BYTE*>(ARRAY_CAnimManager_Animations);`
	`54`	`+ return reinterpret_cast<CAnimBlendHierarchySAInterface>(arrAnimations + sizeof(CAnimBlendHierarchySAInterface) iAnimation);`
	`55`	`+}`