Moved raw memory access to Game SA

codenulls · codenulls · commit 5966687111e3 · 2018-03-30T09:34:37.000+05:00
diff --git a/Client/game_sa/CAnimBlendSequenceSA.cpp b/Client/game_sa/CAnimBlendSequenceSA.cpp
@@ -58,3 +58,8 @@ void CAnimBlendSequenceSA::SetKeyFrames ( size_t cKeyFrames, bool bRoot, bool bC
         call    dwFunc
     }
 }
+
+void * CAnimBlendSequenceSA::GetKeyFrame ( size_t iFrame, uint32_t u32FrameSizeInBytes )
+{
+    return ( m_pInterface->pKeyFrames + u32FrameSizeInBytes * iFrame );
+}
diff --git a/Client/game_sa/CAnimBlendSequenceSA.h b/Client/game_sa/CAnimBlendSequenceSA.h
@@ -29,7 +29,7 @@ class CAnimBlendSequenceSAInterface
     };       
     unsigned short sFlags; 
     unsigned short sNumKeyFrames; 
-    void *         pKeyFrames;
+    BYTE *         pKeyFrames;
 };
 
 class CAnimBlendSequenceSA : public CAnimBlendSequence
@@ -40,9 +40,10 @@ class CAnimBlendSequenceSA : public CAnimBlendSequence
     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; }
-    void *                                  GetKeyFrames               ( void ) { return m_pInterface->pKeyFrames; }
+    BYTE *                                  GetKeyFrames               ( void ) { return m_pInterface->pKeyFrames; }
     unsigned short                          GetKeyFramesCount          ( void ) { return m_pInterface->sNumKeyFrames; }
     bool                                    IsBigChunkForAllSequences  ( void ) { return ( ( m_pInterface->sFlags >> 3) & 1 ); }
     CAnimBlendSequenceSAInterface *         GetInterface               ( void ) { return m_pInterface; }
diff --git a/Client/game_sa/CAnimBlockSA.cpp b/Client/game_sa/CAnimBlockSA.cpp
@@ -45,3 +45,14 @@ void CAnimBlockSA::Request ( EModelRequestType requestType, bool bAllowBlockingF
         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 );
+}
+
diff --git a/Client/game_sa/CAnimBlockSA.h b/Client/game_sa/CAnimBlockSA.h
@@ -36,15 +36,18 @@ class CAnimBlockSA : public CAnimBlock
 {
     friend class CAnimBlendAssocGroupSA;
 public:
-                                        CAnimBlockSA            ( CAnimBlockSAInterface * pInterface )     { m_pInterface = pInterface; }
-
-    CAnimBlockSAInterface *             GetInterface            ( void )    { return m_pInterface; }
-    char *                              GetName                 ( void )    { return m_pInterface->szName; }
-    int                                 GetIndex                ( void )    { return m_pInterface->GetIndex (); }
-    void                                AddRef                  ( void )    { m_pInterface->usRefs++; }
-    unsigned short                      GetRefs                 ( void )    { return m_pInterface->usRefs; }
-    void                                Request                 ( EModelRequestType requestType, bool bAllowBlockingFail = false );
-    bool                                IsLoaded                ( void )    { return m_pInterface->bLoaded; }
+                                        CAnimBlockSA                   ( CAnimBlockSAInterface * pInterface )     { m_pInterface = pInterface; }
+
+    CAnimBlockSAInterface *             GetInterface                   ( void )    { return m_pInterface; }
+    char *                              GetName                        ( void )    { return m_pInterface->szName; }
+    int                                 GetIndex                       ( void )    { return m_pInterface->GetIndex (); }
+    void                                AddRef                         ( void )    { m_pInterface->usRefs++; }
+    unsigned short                      GetRefs                        ( void )    { return m_pInterface->usRefs; }
+    bool                                IsLoaded                       ( void )    { return m_pInterface->bLoaded; }
+    int                                 GetIDOffset                    ( void )    { return m_pInterface->idOffset; }
+    size_t                              GetAnimationCount              ( void )    { return m_pInterface->nAnimations;}
+    void                                Request                        ( EModelRequestType requestType, bool bAllowBlockingFail = false );
+    CAnimBlendHierarchySAInterface *    GetAnimationHierarchyInterface ( size_t iAnimation );
 
 protected:
     CAnimBlockSAInterface *             m_pInterface;
diff --git a/Client/game_sa/CAnimManagerSA.h b/Client/game_sa/CAnimManagerSA.h
@@ -155,8 +155,8 @@ class CAnimManagerSA : public CAnimManager
     CAnimBlendHierarchy *       GetAnimBlendHierarchy                   ( CAnimBlendHierarchySAInterface * pInterface );
 
     // MTA members, but use this strictly for custom animations only
-    std::unique_ptr < CAnimBlendHierarchy > GetCustomAnimBlendHierarchy       ( CAnimBlendHierarchySAInterface * pInterface );
-    std::unique_ptr < CAnimBlendSequence >  GetCustomAnimBlendSequence        ( CAnimBlendSequenceSAInterface * pInterface );
+    std::unique_ptr < CAnimBlendHierarchy > GetCustomAnimBlendHierarchy ( CAnimBlendHierarchySAInterface * pInterface );
+    std::unique_ptr < CAnimBlendSequence >  GetCustomAnimBlendSequence  ( CAnimBlendSequenceSAInterface * pInterface );
 
     bool                        isGateWayAnimationHierarchy             ( CAnimBlendHierarchySAInterface * pInterface );
     const SString &             GetGateWayBlockName                     ( void );
diff --git a/Client/mods/deathmatch/logic/CClientIFP.cpp b/Client/mods/deathmatch/logic/CClientIFP.cpp
@@ -9,6 +9,7 @@ CClientIFP::CClientIFP ( class CClientManager* pManager, ElementID ID ) : CClien
     m_pIFPAnimations = std::make_shared < CIFPAnimations > ();
     m_pAnimManager = g_pGame->GetAnimManager ( );
     m_bVersion1    = false; 
+    m_u32Hashkey   = 0;
 }
 
 CClientIFP::~CClientIFP ( void )
@@ -24,6 +25,7 @@ bool CClientIFP::LoadIFP ( const char* szFilePath, const SString & strBlockName
 
     if ( LoadIFPFile ( szFilePath ) )
     {
+        m_u32Hashkey = g_pGame->GetKeyGen()->GetUppercaseKey ( strBlockName );
         return true;
     }
     return false;
@@ -246,7 +248,6 @@ void CClientIFP::ReadSequenceVersion2 ( Object & ObjectNode )
         if ( strCorrectBoneName.size ( ) == 0 )
         {
             strCorrectBoneName = GetCorrectBoneNameFromName ( BoneName );
-            printf("yes, size is zero\n");
         }
     }
 
@@ -260,7 +261,7 @@ bool CClientIFP::ReadSequenceKeyFrames ( std::unique_ptr < CAnimBlendSequence >
     {
         BYTE * pKeyFrames = m_pAnimManager->AllocateKeyFramesMemory ( iCompressedFrameSize * iFrames ); 
         pAnimationSequence->SetKeyFrames ( iFrames, IsKeyFramesTypeRoot ( iFrameType ), m_kbAllKeyFramesCompressed, pKeyFrames );
-        ReadKeyFramesAsCompressed ( iFrameType, pKeyFrames, iFrames );
+        ReadKeyFramesAsCompressed ( pAnimationSequence, iFrameType, iFrames );
         return true;
     }
     return false;
@@ -313,112 +314,97 @@ void CClientIFP::ReadAnimationHeaderVersion2 ( Animation & AnimationNode, bool b
     }
 }
 
-void CClientIFP::ReadKeyFramesAsCompressed ( IFP_FrameType iFrameType, BYTE * pKeyFrames, int32_t iFrames )
+void CClientIFP::ReadKeyFramesAsCompressed ( std::unique_ptr < CAnimBlendSequence > & pAnimationSequence, IFP_FrameType iFrameType, int32_t iFrames )
 {
     switch ( iFrameType )
     { 
         case IFP_FrameType::KRTS:
         {
-            ReadKrtsFramesAsCompressed ( pKeyFrames, iFrames );
+            ReadKrtsFramesAsCompressed ( pAnimationSequence, iFrames );
             break;
         }
         case IFP_FrameType::KRT0:
         {
-            ReadKrt0FramesAsCompressed ( pKeyFrames, iFrames );
+            ReadKrt0FramesAsCompressed ( pAnimationSequence, iFrames );
             break;
         }
         case IFP_FrameType::KR00:
         {
-            ReadKr00FramesAsCompressed ( pKeyFrames, iFrames );
+            ReadKr00FramesAsCompressed ( pAnimationSequence, iFrames );
             break;
         }
         case IFP_FrameType::KR00_COMPRESSED:
         {
-            ReadKr00CompressedFrames ( pKeyFrames, iFrames );
+            ReadCompressedFrames < IFP_Compressed_KR00 >  ( pAnimationSequence, iFrames );
             break;
         }
         case IFP_FrameType::KRT0_COMPRESSED:
         {
-            ReadKrt0CompressedFrames ( pKeyFrames, iFrames );
+            ReadCompressedFrames < IFP_Compressed_KRT0 >  ( pAnimationSequence, iFrames );
             break;
         }
     }
 }
 
-void CClientIFP::ReadKrtsFramesAsCompressed (  BYTE * pKeyFrames, int32_t TotalFrames )
+void CClientIFP::ReadKrtsFramesAsCompressed ( std::unique_ptr < CAnimBlendSequence > & pAnimationSequence, int32_t TotalFrames )
 {
-    for (int32_t FrameIndex = 0; FrameIndex < TotalFrames; FrameIndex++)
+    for ( int32_t FrameIndex = 0; FrameIndex < TotalFrames; FrameIndex++ )
     {
-        IFP_Compressed_KRT0 * CompressedKrt0 = (IFP_Compressed_KRT0 *)((BYTE*)pKeyFrames + sizeof(IFP_Compressed_KRT0) * FrameIndex);
-
+        IFP_Compressed_KRT0 * CompressedKrt0 = static_cast < IFP_Compressed_KRT0 * > ( pAnimationSequence->GetKeyFrame ( FrameIndex, sizeof ( IFP_Compressed_KRT0 ) ) );
         IFP_KRTS Krts;
-        ReadBuffer < IFP_KRTS >(&Krts);
+        ReadBuffer < IFP_KRTS > ( &Krts );
 
-        CompressedKrt0->Rotation.X    = static_cast < int16_t > ( ((-Krts.Rotation.X) * 4096.0f) );
-        CompressedKrt0->Rotation.Y    = static_cast < int16_t > ( ((-Krts.Rotation.Y) * 4096.0f) );
-        CompressedKrt0->Rotation.Z    = static_cast < int16_t > ( ((-Krts.Rotation.Z) * 4096.0f) );
-        CompressedKrt0->Rotation.W    = static_cast < int16_t > ( (Krts.Rotation.W  * 4096.0f) );
+        CompressedKrt0->Rotation.X    = static_cast < int16_t > ( ( ( -Krts.Rotation.X ) * 4096.0f ) );
+        CompressedKrt0->Rotation.Y    = static_cast < int16_t > ( ( ( -Krts.Rotation.Y ) * 4096.0f ) );
+        CompressedKrt0->Rotation.Z    = static_cast < int16_t > ( ( ( -Krts.Rotation.Z ) * 4096.0f ) );
+        CompressedKrt0->Rotation.W    = static_cast < int16_t > ( ( Krts.Rotation.W  * 4096.0f ) );
 
-        CompressedKrt0->Time          = static_cast < int16_t > ( (Krts.Time * 60.0f + 0.5f) );
+        CompressedKrt0->Time          = static_cast < int16_t > ( ( Krts.Time * 60.0f + 0.5f ) );
 
-        CompressedKrt0->Translation.X = static_cast < int16_t > ( (Krts.Translation.X * 1024.0f) );
-        CompressedKrt0->Translation.Y = static_cast < int16_t > ( (Krts.Translation.Y * 1024.0f) );
-        CompressedKrt0->Translation.Z = static_cast < int16_t > ( (Krts.Translation.Z * 1024.0f) );
+        CompressedKrt0->Translation.X = static_cast < int16_t > ( ( Krts.Translation.X * 1024.0f ) );
+        CompressedKrt0->Translation.Y = static_cast < int16_t > ( ( Krts.Translation.Y * 1024.0f ) );
+        CompressedKrt0->Translation.Z = static_cast < int16_t > ( ( Krts.Translation.Z * 1024.0f ) );
     }
 }
 
-void CClientIFP::ReadKrt0FramesAsCompressed (  BYTE * pKeyFrames, int32_t TotalFrames )
+void CClientIFP::ReadKrt0FramesAsCompressed ( std::unique_ptr < CAnimBlendSequence > & pAnimationSequence, int32_t TotalFrames )
 {
-    for (int32_t FrameIndex = 0; FrameIndex < TotalFrames; FrameIndex++)
+    for ( int32_t FrameIndex = 0; FrameIndex < TotalFrames; FrameIndex++ )
     {
-        IFP_Compressed_KRT0 * CompressedKrt0 = (IFP_Compressed_KRT0 *)((BYTE*)pKeyFrames + sizeof(IFP_Compressed_KRT0) * FrameIndex);
-
+        IFP_Compressed_KRT0 * CompressedKrt0 = static_cast < IFP_Compressed_KRT0 * > ( pAnimationSequence->GetKeyFrame ( FrameIndex, sizeof ( IFP_Compressed_KRT0 ) ) );
         IFP_KRT0 Krt0;
         ReadBuffer < IFP_KRT0 > ( &Krt0 );
 
-        CompressedKrt0->Rotation.X = static_cast < int16_t > ( ((-Krt0.Rotation.X) * 4096.0f) );
-        CompressedKrt0->Rotation.Y = static_cast < int16_t > ( ((-Krt0.Rotation.Y) * 4096.0f) );
-        CompressedKrt0->Rotation.Z = static_cast < int16_t > ( ((-Krt0.Rotation.Z) * 4096.0f) );
-        CompressedKrt0->Rotation.W = static_cast < int16_t > ( (Krt0.Rotation.W  * 4096.0f) );
+        CompressedKrt0->Rotation.X = static_cast < int16_t > ( ( ( -Krt0.Rotation.X ) * 4096.0f ) );
+        CompressedKrt0->Rotation.Y = static_cast < int16_t > ( ( ( -Krt0.Rotation.Y ) * 4096.0f ) );
+        CompressedKrt0->Rotation.Z = static_cast < int16_t > ( ( ( -Krt0.Rotation.Z ) * 4096.0f ) );
+        CompressedKrt0->Rotation.W = static_cast < int16_t > ( ( Krt0.Rotation.W  * 4096.0f ) );
 
-        CompressedKrt0->Time = static_cast < int16_t > ( (Krt0.Time * 60.0f + 0.5f) );
+        CompressedKrt0->Time = static_cast < int16_t > ( ( Krt0.Time * 60.0f + 0.5f ) );
 
-        CompressedKrt0->Translation.X = static_cast < int16_t > ( (Krt0.Translation.X * 1024.0f) ); 
-        CompressedKrt0->Translation.Y = static_cast < int16_t > ( (Krt0.Translation.Y * 1024.0f) );
-        CompressedKrt0->Translation.Z = static_cast < int16_t > ( (Krt0.Translation.Z * 1024.0f) );
+        CompressedKrt0->Translation.X = static_cast < int16_t > ( ( Krt0.Translation.X * 1024.0f ) ); 
+        CompressedKrt0->Translation.Y = static_cast < int16_t > ( ( Krt0.Translation.Y * 1024.0f ) );
+        CompressedKrt0->Translation.Z = static_cast < int16_t > ( ( Krt0.Translation.Z * 1024.0f ) );
     }
 }
 
-void CClientIFP::ReadKr00FramesAsCompressed (  BYTE * pKeyFrames, int32_t TotalFrames )
+void CClientIFP::ReadKr00FramesAsCompressed ( std::unique_ptr < CAnimBlendSequence > & pAnimationSequence, int32_t TotalFrames )
 {
-    for (int32_t FrameIndex = 0; FrameIndex < TotalFrames; FrameIndex++)
+    for ( int32_t FrameIndex = 0; FrameIndex < TotalFrames; FrameIndex++ )
     {
-        IFP_Compressed_KR00 * CompressedKr00 = (IFP_Compressed_KR00 *)((BYTE*)pKeyFrames + sizeof(IFP_Compressed_KR00) * FrameIndex);
-
+        IFP_Compressed_KR00 * CompressedKr00 = static_cast < IFP_Compressed_KR00 * > ( pAnimationSequence->GetKeyFrame ( FrameIndex, sizeof ( IFP_Compressed_KR00 ) ) );
         IFP_KR00 Kr00;
         ReadBuffer < IFP_KR00 > ( &Kr00 );
 
-        CompressedKr00->Rotation.X = static_cast < int16_t > ( ((-Kr00.Rotation.X) * 4096.0f) );
-        CompressedKr00->Rotation.Y = static_cast < int16_t > ( ((-Kr00.Rotation.Y) * 4096.0f) );
-        CompressedKr00->Rotation.Z = static_cast < int16_t > ( ((-Kr00.Rotation.Z) * 4096.0f) );
-        CompressedKr00->Rotation.W = static_cast < int16_t > ( (Kr00.Rotation.W  * 4096.0f) );
+        CompressedKr00->Rotation.X = static_cast < int16_t > ( ( ( -Kr00.Rotation.X ) * 4096.0f ) );
+        CompressedKr00->Rotation.Y = static_cast < int16_t > ( ( ( -Kr00.Rotation.Y ) * 4096.0f ) );
+        CompressedKr00->Rotation.Z = static_cast < int16_t > ( ( ( -Kr00.Rotation.Z ) * 4096.0f ) );
+        CompressedKr00->Rotation.W = static_cast < int16_t > ( ( Kr00.Rotation.W  * 4096.0f ) );
 
         CompressedKr00->Time = static_cast < int16_t > ( (Kr00.Time * 60.0f + 0.5f) );
     }
 }
 
-inline void CClientIFP::ReadKr00CompressedFrames (  BYTE * pKeyFrames, int32_t TotalFrames )
-{
-    size_t iSizeInBytes = sizeof ( IFP_Compressed_KR00 ) * TotalFrames;
-    ReadBytes ( pKeyFrames, iSizeInBytes );
-}
-
-inline void CClientIFP::ReadKrt0CompressedFrames (  BYTE * pKeyFrames, int32_t TotalFrames )
-{
-    size_t iSizeInBytes = sizeof ( IFP_Compressed_KRT0 ) * TotalFrames;
-    ReadBytes ( pKeyFrames, iSizeInBytes );
-}  
-
 size_t CClientIFP::GetSizeOfCompressedFrame ( IFP_FrameType iFrameType )
 {
     switch ( iFrameType )
diff --git a/Client/mods/deathmatch/logic/CClientIFP.h b/Client/mods/deathmatch/logic/CClientIFP.h
@@ -226,12 +226,18 @@ class CClientIFP: public CClientEntity, CFileReader
     void                            ReadAnimationHeaderVersion2  ( Animation & AnimationNode, bool bAnp3 );
 
     bool                            ReadSequenceKeyFrames        ( std::unique_ptr < CAnimBlendSequence > & pAnimationSequence, IFP_FrameType iFrameType, int32_t iFrames );
-    void                            ReadKeyFramesAsCompressed    ( IFP_FrameType iFrameType, BYTE * pKeyFrames, int32_t iFrames );
-    void                            ReadKrtsFramesAsCompressed   (  BYTE * pKeyFrames, int32_t TotalFrames );
-    void                            ReadKrt0FramesAsCompressed   (  BYTE * pKeyFrames, int32_t TotalFrames );
-    void                            ReadKr00FramesAsCompressed   (  BYTE * pKeyFrames, int32_t TotalFrames );
-    inline void                     ReadKr00CompressedFrames     (  BYTE * pKeyFrames, int32_t TotalFrames );
-    inline void                     ReadKrt0CompressedFrames     (  BYTE * pKeyFrames, int32_t TotalFrames );
+    void                            ReadKeyFramesAsCompressed    ( std::unique_ptr < CAnimBlendSequence > & pAnimationSequence, IFP_FrameType iFrameType, int32_t iFrames );
+    void                            ReadKrtsFramesAsCompressed   ( std::unique_ptr < CAnimBlendSequence > & pAnimationSequence, int32_t TotalFrames );
+    void                            ReadKrt0FramesAsCompressed   ( std::unique_ptr < CAnimBlendSequence > & pAnimationSequence, int32_t TotalFrames );
+    void                            ReadKr00FramesAsCompressed   ( std::unique_ptr < CAnimBlendSequence > & pAnimationSequence, int32_t TotalFrames );
+
+    template < class T > 
+    void                            ReadCompressedFrames         ( std::unique_ptr < CAnimBlendSequence > & pAnimationSequence, int32_t TotalFrames )
+    {
+        BYTE * pKeyFrames = pAnimationSequence->GetKeyFrames ( );
+        size_t iSizeInBytes = sizeof ( T ) * TotalFrames;
+        ReadBytes ( pKeyFrames, iSizeInBytes );
+    }  
 
     void                            InitializeAnimationHierarchy ( std::unique_ptr < CAnimBlendHierarchy > & pAnimationHierarchy, const char * szAnimationName, const int32_t iSequences );
     void                            InitializeAnimationSequence  ( std::unique_ptr < CAnimBlendSequence > & pAnimationSequence, const char * szName, const int32_t iBoneID );
@@ -264,6 +270,7 @@ class CClientIFP: public CClientEntity, CFileReader
 private:
     std::shared_ptr < CIFPAnimations > m_pIFPAnimations;
     SString                            m_strBlockName;
+    unsigned int                       m_u32Hashkey;
     std::vector < IFP_Animation > *    m_pVecAnimations;
     bool                               m_bVersion1;
     CAnimManager *                     m_pAnimManager;
diff --git a/Client/mods/deathmatch/logic/CClientPed.cpp b/Client/mods/deathmatch/logic/CClientPed.cpp
@@ -6216,18 +6216,13 @@ void CClientPed::RestoreAnimations ( const std::shared_ptr < CClientIFP > & IFP
     }
 }
 
-#include "../game_sa/CAnimBlockSA.h" // REMOVE THIS LATER, USE FACTORY METHOD!!!!!!
-
 void CClientPed::RestoreAnimations ( CAnimBlock & animationBlock )
 {
-    const CAnimBlockSAInterface * pInternalBlockInterface = animationBlock.GetInterface ( );
-    DWORD iAnimationIndex = pInternalBlockInterface->idOffset;
-    DWORD dwARRAY_CAnimManager_Animations = 0xb4ea40;
-    for ( size_t i = 0; i < pInternalBlockInterface->nAnimations; i++ )
+    const size_t cAnimations = animationBlock.GetAnimationCount ( );
+    for ( size_t i = 0; i < cAnimations; i++)
     {
-        auto pAnimHierarchyInterface = (CAnimBlendHierarchySAInterface*)((BYTE*)dwARRAY_CAnimManager_Animations + sizeof(CAnimBlendHierarchySAInterface) * iAnimationIndex);
+        auto pAnimHierarchyInterface = animationBlock.GetAnimationHierarchyInterface ( i );
         m_mapOfReplacedAnimations.erase ( pAnimHierarchyInterface );
-        iAnimationIndex ++;
     }
 }
 
diff --git a/Client/sdk/game/CAnimBlendSequence.h b/Client/sdk/game/CAnimBlendSequence.h
diff --git a/Client/sdk/game/CAnimBlock.h b/Client/sdk/game/CAnimBlock.h

Original file line number	Diff line number	Diff line change
`@@ -58,3 +58,8 @@ void CAnimBlendSequenceSA::SetKeyFrames ( size_t cKeyFrames, bool bRoot, bool bC`
`58`	`58`	`call dwFunc`
`59`	`59`	`}`
`60`	`60`	`}`
	`61`	`+`
	`62`	`+void * CAnimBlendSequenceSA::GetKeyFrame ( size_t iFrame, uint32_t u32FrameSizeInBytes )`
	`63`	`+{`
	`64`	`+ return ( m_pInterface->pKeyFrames + u32FrameSizeInBytes * iFrame );`
	`65`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@ CClientIFP::CClientIFP ( class CClientManager* pManager, ElementID ID ) : CClien`
`9`	`9`	`m_pIFPAnimations = std::make_shared < CIFPAnimations > ();`
`10`	`10`	`m_pAnimManager = g_pGame->GetAnimManager ( );`
`11`	`11`	`m_bVersion1 = false;`
	`12`	`+ m_u32Hashkey = 0;`
`12`	`13`	`}`
`13`	`14`
`14`	`15`	`CClientIFP::~CClientIFP ( void )`
`@@ -24,6 +25,7 @@ bool CClientIFP::LoadIFP ( const char* szFilePath, const SString & strBlockName`
`24`	`25`
`25`	`26`	`if ( LoadIFPFile ( szFilePath ) )`
`26`	`27`	`{`
	`28`	`+ m_u32Hashkey = g_pGame->GetKeyGen()->GetUppercaseKey ( strBlockName );`
`27`	`29`	`return true;`
`28`	`30`	`}`
`29`	`31`	`return false;`
`@@ -246,7 +248,6 @@ void CClientIFP::ReadSequenceVersion2 ( Object & ObjectNode )`
`246`	`248`	`if ( strCorrectBoneName.size ( ) == 0 )`
`247`	`249`	`{`
`248`	`250`	`strCorrectBoneName = GetCorrectBoneNameFromName ( BoneName );`
`249`		`- printf("yes, size is zero\n");`
`250`	`251`	`}`
`251`	`252`	`}`
`252`	`253`
`@@ -260,7 +261,7 @@ bool CClientIFP::ReadSequenceKeyFrames ( std::unique_ptr < CAnimBlendSequence >`
`260`	`261`	`{`
`261`	`262`	`BYTE * pKeyFrames = m_pAnimManager->AllocateKeyFramesMemory ( iCompressedFrameSize * iFrames );`
`262`	`263`	`pAnimationSequence->SetKeyFrames ( iFrames, IsKeyFramesTypeRoot ( iFrameType ), m_kbAllKeyFramesCompressed, pKeyFrames );`
`263`		`- ReadKeyFramesAsCompressed ( iFrameType, pKeyFrames, iFrames );`
	`264`	`+ ReadKeyFramesAsCompressed ( pAnimationSequence, iFrameType, iFrames );`
`264`	`265`	`return true;`
`265`	`266`	`}`
`266`	`267`	`return false;`
`@@ -313,112 +314,97 @@ void CClientIFP::ReadAnimationHeaderVersion2 ( Animation & AnimationNode, bool b`
`313`	`314`	`}`
`314`	`315`	`}`
`315`	`316`
`316`		`-void CClientIFP::ReadKeyFramesAsCompressed ( IFP_FrameType iFrameType, BYTE * pKeyFrames, int32_t iFrames )`
	`317`	`+void CClientIFP::ReadKeyFramesAsCompressed ( std::unique_ptr < CAnimBlendSequence > & pAnimationSequence, IFP_FrameType iFrameType, int32_t iFrames )`
`317`	`318`	`{`
`318`	`319`	`switch ( iFrameType )`
`319`	`320`	`{`
`320`	`321`	`case IFP_FrameType::KRTS:`
`321`	`322`	`{`
`322`		`- ReadKrtsFramesAsCompressed ( pKeyFrames, iFrames );`
	`323`	`+ ReadKrtsFramesAsCompressed ( pAnimationSequence, iFrames );`
`323`	`324`	`break;`
`324`	`325`	`}`
`325`	`326`	`case IFP_FrameType::KRT0:`
`326`	`327`	`{`
`327`		`- ReadKrt0FramesAsCompressed ( pKeyFrames, iFrames );`
	`328`	`+ ReadKrt0FramesAsCompressed ( pAnimationSequence, iFrames );`
`328`	`329`	`break;`
`329`	`330`	`}`
`330`	`331`	`case IFP_FrameType::KR00:`
`331`	`332`	`{`
`332`		`- ReadKr00FramesAsCompressed ( pKeyFrames, iFrames );`
	`333`	`+ ReadKr00FramesAsCompressed ( pAnimationSequence, iFrames );`
`333`	`334`	`break;`
`334`	`335`	`}`
`335`	`336`	`case IFP_FrameType::KR00_COMPRESSED:`
`336`	`337`	`{`
`337`		`- ReadKr00CompressedFrames ( pKeyFrames, iFrames );`
	`338`	`+ ReadCompressedFrames < IFP_Compressed_KR00 > ( pAnimationSequence, iFrames );`
`338`	`339`	`break;`
`339`	`340`	`}`
`340`	`341`	`case IFP_FrameType::KRT0_COMPRESSED:`
`341`	`342`	`{`
`342`		`- ReadKrt0CompressedFrames ( pKeyFrames, iFrames );`
	`343`	`+ ReadCompressedFrames < IFP_Compressed_KRT0 > ( pAnimationSequence, iFrames );`
`343`	`344`	`break;`
`344`	`345`	`}`
`345`	`346`	`}`
`346`	`347`	`}`
`347`	`348`
`348`		`-void CClientIFP::ReadKrtsFramesAsCompressed ( BYTE * pKeyFrames, int32_t TotalFrames )`
	`349`	`+void CClientIFP::ReadKrtsFramesAsCompressed ( std::unique_ptr < CAnimBlendSequence > & pAnimationSequence, int32_t TotalFrames )`
`349`	`350`	`{`
`350`		`- for (int32_t FrameIndex = 0; FrameIndex < TotalFrames; FrameIndex++)`
	`351`	`+ for ( int32_t FrameIndex = 0; FrameIndex < TotalFrames; FrameIndex++ )`
`351`	`352`	`{`
`352`		`- IFP_Compressed_KRT0 * CompressedKrt0 = (IFP_Compressed_KRT0 )((BYTE)pKeyFrames + sizeof(IFP_Compressed_KRT0) * FrameIndex);`
`353`		`-`
	`353`	`+ IFP_Compressed_KRT0 * CompressedKrt0 = static_cast < IFP_Compressed_KRT0 * > ( pAnimationSequence->GetKeyFrame ( FrameIndex, sizeof ( IFP_Compressed_KRT0 ) ) );`
`354`	`354`	`IFP_KRTS Krts;`
`355`		`- ReadBuffer < IFP_KRTS >(&Krts);`
	`355`	`+ ReadBuffer < IFP_KRTS > ( &Krts );`
`356`	`356`
`357`		`- CompressedKrt0->Rotation.X = static_cast < int16_t > ( ((-Krts.Rotation.X) * 4096.0f) );`
`358`		`- CompressedKrt0->Rotation.Y = static_cast < int16_t > ( ((-Krts.Rotation.Y) * 4096.0f) );`
`359`		`- CompressedKrt0->Rotation.Z = static_cast < int16_t > ( ((-Krts.Rotation.Z) * 4096.0f) );`
`360`		`- CompressedKrt0->Rotation.W = static_cast < int16_t > ( (Krts.Rotation.W * 4096.0f) );`
	`357`	`+ CompressedKrt0->Rotation.X = static_cast < int16_t > ( ( ( -Krts.Rotation.X ) * 4096.0f ) );`
	`358`	`+ CompressedKrt0->Rotation.Y = static_cast < int16_t > ( ( ( -Krts.Rotation.Y ) * 4096.0f ) );`
	`359`	`+ CompressedKrt0->Rotation.Z = static_cast < int16_t > ( ( ( -Krts.Rotation.Z ) * 4096.0f ) );`
	`360`	`+ CompressedKrt0->Rotation.W = static_cast < int16_t > ( ( Krts.Rotation.W * 4096.0f ) );`
`361`	`361`
`362`		`- CompressedKrt0->Time = static_cast < int16_t > ( (Krts.Time * 60.0f + 0.5f) );`
	`362`	`+ CompressedKrt0->Time = static_cast < int16_t > ( ( Krts.Time * 60.0f + 0.5f ) );`
`363`	`363`
`364`		`- CompressedKrt0->Translation.X = static_cast < int16_t > ( (Krts.Translation.X * 1024.0f) );`
`365`		`- CompressedKrt0->Translation.Y = static_cast < int16_t > ( (Krts.Translation.Y * 1024.0f) );`
`366`		`- CompressedKrt0->Translation.Z = static_cast < int16_t > ( (Krts.Translation.Z * 1024.0f) );`
	`364`	`+ CompressedKrt0->Translation.X = static_cast < int16_t > ( ( Krts.Translation.X * 1024.0f ) );`
	`365`	`+ CompressedKrt0->Translation.Y = static_cast < int16_t > ( ( Krts.Translation.Y * 1024.0f ) );`
	`366`	`+ CompressedKrt0->Translation.Z = static_cast < int16_t > ( ( Krts.Translation.Z * 1024.0f ) );`
`367`	`367`	`}`
`368`	`368`	`}`
`369`	`369`
`370`		`-void CClientIFP::ReadKrt0FramesAsCompressed ( BYTE * pKeyFrames, int32_t TotalFrames )`
	`370`	`+void CClientIFP::ReadKrt0FramesAsCompressed ( std::unique_ptr < CAnimBlendSequence > & pAnimationSequence, int32_t TotalFrames )`
`371`	`371`	`{`
`372`		`- for (int32_t FrameIndex = 0; FrameIndex < TotalFrames; FrameIndex++)`
	`372`	`+ for ( int32_t FrameIndex = 0; FrameIndex < TotalFrames; FrameIndex++ )`
`373`	`373`	`{`
`374`		`- IFP_Compressed_KRT0 * CompressedKrt0 = (IFP_Compressed_KRT0 )((BYTE)pKeyFrames + sizeof(IFP_Compressed_KRT0) * FrameIndex);`
`375`		`-`
	`374`	`+ IFP_Compressed_KRT0 * CompressedKrt0 = static_cast < IFP_Compressed_KRT0 * > ( pAnimationSequence->GetKeyFrame ( FrameIndex, sizeof ( IFP_Compressed_KRT0 ) ) );`
`376`	`375`	`IFP_KRT0 Krt0;`
`377`	`376`	`ReadBuffer < IFP_KRT0 > ( &Krt0 );`
`378`	`377`
`379`		`- CompressedKrt0->Rotation.X = static_cast < int16_t > ( ((-Krt0.Rotation.X) * 4096.0f) );`
`380`		`- CompressedKrt0->Rotation.Y = static_cast < int16_t > ( ((-Krt0.Rotation.Y) * 4096.0f) );`
`381`		`- CompressedKrt0->Rotation.Z = static_cast < int16_t > ( ((-Krt0.Rotation.Z) * 4096.0f) );`
`382`		`- CompressedKrt0->Rotation.W = static_cast < int16_t > ( (Krt0.Rotation.W * 4096.0f) );`
	`378`	`+ CompressedKrt0->Rotation.X = static_cast < int16_t > ( ( ( -Krt0.Rotation.X ) * 4096.0f ) );`
	`379`	`+ CompressedKrt0->Rotation.Y = static_cast < int16_t > ( ( ( -Krt0.Rotation.Y ) * 4096.0f ) );`
	`380`	`+ CompressedKrt0->Rotation.Z = static_cast < int16_t > ( ( ( -Krt0.Rotation.Z ) * 4096.0f ) );`
	`381`	`+ CompressedKrt0->Rotation.W = static_cast < int16_t > ( ( Krt0.Rotation.W * 4096.0f ) );`
`383`	`382`
`384`		`- CompressedKrt0->Time = static_cast < int16_t > ( (Krt0.Time * 60.0f + 0.5f) );`
	`383`	`+ CompressedKrt0->Time = static_cast < int16_t > ( ( Krt0.Time * 60.0f + 0.5f ) );`
`385`	`384`
`386`		`- CompressedKrt0->Translation.X = static_cast < int16_t > ( (Krt0.Translation.X * 1024.0f) );`
`387`		`- CompressedKrt0->Translation.Y = static_cast < int16_t > ( (Krt0.Translation.Y * 1024.0f) );`
`388`		`- CompressedKrt0->Translation.Z = static_cast < int16_t > ( (Krt0.Translation.Z * 1024.0f) );`
	`385`	`+ CompressedKrt0->Translation.X = static_cast < int16_t > ( ( Krt0.Translation.X * 1024.0f ) );`
	`386`	`+ CompressedKrt0->Translation.Y = static_cast < int16_t > ( ( Krt0.Translation.Y * 1024.0f ) );`
	`387`	`+ CompressedKrt0->Translation.Z = static_cast < int16_t > ( ( Krt0.Translation.Z * 1024.0f ) );`
`389`	`388`	`}`
`390`	`389`	`}`
`391`	`390`
`392`		`-void CClientIFP::ReadKr00FramesAsCompressed ( BYTE * pKeyFrames, int32_t TotalFrames )`
	`391`	`+void CClientIFP::ReadKr00FramesAsCompressed ( std::unique_ptr < CAnimBlendSequence > & pAnimationSequence, int32_t TotalFrames )`
`393`	`392`	`{`
`394`		`- for (int32_t FrameIndex = 0; FrameIndex < TotalFrames; FrameIndex++)`
	`393`	`+ for ( int32_t FrameIndex = 0; FrameIndex < TotalFrames; FrameIndex++ )`
`395`	`394`	`{`
`396`		`- IFP_Compressed_KR00 * CompressedKr00 = (IFP_Compressed_KR00 )((BYTE)pKeyFrames + sizeof(IFP_Compressed_KR00) * FrameIndex);`
`397`		`-`
	`395`	`+ IFP_Compressed_KR00 * CompressedKr00 = static_cast < IFP_Compressed_KR00 * > ( pAnimationSequence->GetKeyFrame ( FrameIndex, sizeof ( IFP_Compressed_KR00 ) ) );`
`398`	`396`	`IFP_KR00 Kr00;`
`399`	`397`	`ReadBuffer < IFP_KR00 > ( &Kr00 );`
`400`	`398`
`401`		`- CompressedKr00->Rotation.X = static_cast < int16_t > ( ((-Kr00.Rotation.X) * 4096.0f) );`
`402`		`- CompressedKr00->Rotation.Y = static_cast < int16_t > ( ((-Kr00.Rotation.Y) * 4096.0f) );`
`403`		`- CompressedKr00->Rotation.Z = static_cast < int16_t > ( ((-Kr00.Rotation.Z) * 4096.0f) );`
`404`		`- CompressedKr00->Rotation.W = static_cast < int16_t > ( (Kr00.Rotation.W * 4096.0f) );`
	`399`	`+ CompressedKr00->Rotation.X = static_cast < int16_t > ( ( ( -Kr00.Rotation.X ) * 4096.0f ) );`
	`400`	`+ CompressedKr00->Rotation.Y = static_cast < int16_t > ( ( ( -Kr00.Rotation.Y ) * 4096.0f ) );`
	`401`	`+ CompressedKr00->Rotation.Z = static_cast < int16_t > ( ( ( -Kr00.Rotation.Z ) * 4096.0f ) );`
	`402`	`+ CompressedKr00->Rotation.W = static_cast < int16_t > ( ( Kr00.Rotation.W * 4096.0f ) );`
`405`	`403`
`406`	`404`	`CompressedKr00->Time = static_cast < int16_t > ( (Kr00.Time * 60.0f + 0.5f) );`
`407`	`405`	`}`
`408`	`406`	`}`
`409`	`407`
`410`		`-inline void CClientIFP::ReadKr00CompressedFrames ( BYTE * pKeyFrames, int32_t TotalFrames )`
`411`		`-{`
`412`		`- size_t iSizeInBytes = sizeof ( IFP_Compressed_KR00 ) * TotalFrames;`
`413`		`- ReadBytes ( pKeyFrames, iSizeInBytes );`
`414`		`-}`
`415`		`-`
`416`		`-inline void CClientIFP::ReadKrt0CompressedFrames ( BYTE * pKeyFrames, int32_t TotalFrames )`
`417`		`-{`
`418`		`- size_t iSizeInBytes = sizeof ( IFP_Compressed_KRT0 ) * TotalFrames;`
`419`		`- ReadBytes ( pKeyFrames, iSizeInBytes );`
`420`		`-}`
`421`		`-`
`422`	`408`	`size_t CClientIFP::GetSizeOfCompressedFrame ( IFP_FrameType iFrameType )`
`423`	`409`	`{`
`424`	`410`	`switch ( iFrameType )`
Original file line number	Diff line number	Diff line change
`@@ -6216,18 +6216,13 @@ void CClientPed::RestoreAnimations ( const std::shared_ptr < CClientIFP > & IFP`
`6216`	`6216`	`}`
`6217`	`6217`	`}`
`6218`	`6218`
`6219`		`-#include "../game_sa/CAnimBlockSA.h" // REMOVE THIS LATER, USE FACTORY METHOD!!!!!!`
`6220`		`-`
`6221`	`6219`	`void CClientPed::RestoreAnimations ( CAnimBlock & animationBlock )`
`6222`	`6220`	`{`
`6223`		`- const CAnimBlockSAInterface * pInternalBlockInterface = animationBlock.GetInterface ( );`
`6224`		`- DWORD iAnimationIndex = pInternalBlockInterface->idOffset;`
`6225`		`- DWORD dwARRAY_CAnimManager_Animations = 0xb4ea40;`
`6226`		`- for ( size_t i = 0; i < pInternalBlockInterface->nAnimations; i++ )`
	`6221`	`+ const size_t cAnimations = animationBlock.GetAnimationCount ( );`
	`6222`	`+ for ( size_t i = 0; i < cAnimations; i++)`
`6227`	`6223`	`{`
`6228`		`- auto pAnimHierarchyInterface = (CAnimBlendHierarchySAInterface)((BYTE)dwARRAY_CAnimManager_Animations + sizeof(CAnimBlendHierarchySAInterface) * iAnimationIndex);`
	`6224`	`+ auto pAnimHierarchyInterface = animationBlock.GetAnimationHierarchyInterface ( i );`
`6229`	`6225`	`m_mapOfReplacedAnimations.erase ( pAnimHierarchyInterface );`
`6230`		`- iAnimationIndex ++;`
`6231`	`6226`	`}`
`6232`	`6227`	`}`
`6233`	`6228`