Added new functions to CAnimManager for CClientIFP

codenulls · codenulls · commit 8bbd104de683 · 2018-03-29T09:01:37.000+05:00
diff --git a/Client/game_sa/CAnimManagerSA.cpp b/Client/game_sa/CAnimManagerSA.cpp
@@ -521,6 +521,16 @@ void CAnimManagerSA::RemoveFromUncompressedCache ( CAnimBlendHierarchy * pHierar
     }
 }
 
+void CAnimManagerSA::RemoveFromUncompressedCache ( CAnimBlendHierarchySAInterface * pHierarchyInterface )
+{
+    DWORD dwFunc = FUNC_CAnimManager_RemoveFromUncompressedCache;
+    _asm
+    {
+        push    pHierarchyInterface
+        call    dwFunc
+        add     esp, 0x4
+    }
+}
 
 void CAnimManagerSA::LoadAnimFile ( const char * szFile )
 {
@@ -568,6 +578,33 @@ void CAnimManagerSA::RemoveLastAnimFile ( void )
 }
 
 
+BYTE * CAnimManagerSA::AllocateKeyFramesMemory ( uint32_t u32BytesToAllocate )
+{
+    BYTE * pKeyFrames = nullptr;
+    DWORD dwFunc = FUNC_CAnimManager_AllocateKeyFramesMemory;
+    _asm
+    {
+        push    u32BytesToAllocate
+        call    dwFunc
+        add     esp, 0x4
+        mov     pKeyFrames, eax
+    }
+    return pKeyFrames;
+}
+
+
+void CAnimManagerSA::FreeKeyFramesMemory ( void * pKeyFrames )
+{
+    DWORD dwFunc = FUNC_CAnimManager_FreeKeyFramesMemory;
+    _asm
+    {
+        push    pKeyFrames
+        call    dwFunc
+        add     esp, 0x4
+    }
+}
+
+
 bool CAnimManagerSA::HasAnimGroupLoaded ( AssocGroupId groupID )
 {
     bool bReturn;
diff --git a/Client/game_sa/CAnimManagerSA.h b/Client/game_sa/CAnimManagerSA.h
@@ -57,6 +57,8 @@
 #define FUNC_CAnimManager_LoadAnimFile                      0x4d55d0
 #define FUNC_CAnimManager_LoadAnimFile_stream               0x4d47f0
 #define FUNC_CAnimManager_LoadAnimFiles                     0x4d5620
+#define FUNC_CAnimManager_AllocateKeyFramesMemory           0x72F420       
+#define FUNC_CAnimManager_FreeKeyFramesMemory               0x72F430 
 #define ARRAY_CAnimManager_AnimAssocGroups                  0xb4ea34
 #define ARRAY_CAnimManager_Animations                       0xb4ea40
 #define ARRAY_CAnimManager_AnimBlocks                       0xb5d4a0
@@ -128,11 +130,13 @@ class CAnimManagerSA : public CAnimManager
 
     void                        UncompressAnimation                     ( CAnimBlendHierarchy * pHierarchy );
     void                        RemoveFromUncompressedCache             ( CAnimBlendHierarchy * pHierarchy );
-
+    void                        RemoveFromUncompressedCache             ( CAnimBlendHierarchySAInterface * pInterface );
     void                        LoadAnimFile                            ( const char * szFile );
     void                        LoadAnimFile                            ( RwStream * pStream, bool b1, const char * sz1 );
     void                        LoadAnimFiles                           ( void );
     void                        RemoveLastAnimFile                      ( void );
+    BYTE *                      AllocateKeyFramesMemory                 ( uint32_t u32BytesToAllocate );
+    void                        FreeKeyFramesMemory                     ( void * pKeyFrames );
 
     // Non members
     bool                        HasAnimGroupLoaded                      ( AssocGroupId groupID );
diff --git a/Client/mods/deathmatch/logic/CClientIFP.cpp b/Client/mods/deathmatch/logic/CClientIFP.cpp
@@ -1,12 +1,6 @@
 #include <StdInc.h>
 #include "../game_sa/CAnimBlendSequenceSA.h"
 
-hCMemoryMgr_Malloc               OLD_CMemoryMgr_Malloc = (hCMemoryMgr_Malloc)0x0072F420;
-hCMemoryMgr_Free                 OLD_CMemoryMgr_Free   = (hCMemoryMgr_Free)0x0072F430;
-
-extern DWORD BoneIds[];
-extern char BoneNames[][24];
-
 CClientIFP::CClientIFP ( class CClientManager* pManager, ElementID ID ) : CClientEntity ( ID )
 {
     // Init
@@ -21,7 +15,7 @@ CClientIFP::~CClientIFP ( void )
 {
 }
 
-bool CClientIFP::LoadIFP ( const char* szFilePath, SString strBlockName )
+bool CClientIFP::LoadIFP ( const char* szFilePath, const SString & strBlockName )
 {
     printf ("\nCClientIFP::LoadIFP: szFilePath %s\n szBlockName: %s\n\n", szFilePath, strBlockName.c_str());
     
@@ -37,14 +31,14 @@ bool CClientIFP::LoadIFP ( const char* szFilePath, SString strBlockName )
 
 bool CClientIFP::LoadIFPFile ( const char * szFilePath )
 {
-    createLoader ( szFilePath );
+    CreateLoader ( szFilePath );
 
-    if ( loadFile ( ) )
+    if ( LoadFile ( ) )
     {
         printf("IfpLoader: File loaded. Parsing it now.\n");
         
         char Version [ 4 ];
-        readBytes ( Version, sizeof ( Version ) );
+        ReadBytes ( Version, sizeof ( Version ) );
 
         bool bAnp3 = strncmp ( Version, "ANP3", sizeof ( Version ) ) == 0;
         bool bAnp2 = strncmp ( Version, "ANP2", sizeof ( Version ) ) == 0;
@@ -61,7 +55,7 @@ bool CClientIFP::LoadIFPFile ( const char * szFilePath )
 
         // We are unloading the data because we don't need to read it anymore. 
         // This function does not unload IFP, to unload ifp call unloadIFP function
-        unloadFile ( );
+        UnloadFile ( );
     }
     else
     {
@@ -80,11 +74,9 @@ void CClientIFP::ReadIFPVersion1 (  )
     ReadHeaderVersion1 ( Info );
 
     m_pVecAnimations->resize ( Info.Entries );
-
     for ( auto it = m_pVecAnimations->begin(); it != m_pVecAnimations->end(); ++it ) 
     {
         ReadAnimationNameVersion1 ( it->Name );
-     
         printf("Animation Name: %s  \n", it->Name.c_str ( ) );
       
         IFP_DGAN Dgan;
@@ -104,7 +96,7 @@ void CClientIFP::ReadIFPVersion1 (  )
 void CClientIFP::ReadIFPVersion2 ( bool bAnp3 )
 {
     IFPHeaderV2 Header;
-    readBuffer < IFPHeaderV2 > ( &Header );
+    ReadBuffer < IFPHeaderV2 > ( &Header );
 
     m_pVecAnimations->resize ( Header.TotalAnimations );
     for ( auto it = m_pVecAnimations->begin(); it != m_pVecAnimations->end(); ++it ) 
@@ -218,11 +210,11 @@ WORD CClientIFP::ReadSequencesVersion2 ( std::unique_ptr < CAnimBlendHierarchy >
 int32_t CClientIFP::ReadSequenceVersion1 ( IFP_ANIM & Anim )
 {
     IFP_CPAN Cpan;
-    readBuffer < IFP_CPAN > ( &Cpan );
+    ReadBuffer < IFP_CPAN > ( &Cpan );
     RoundSize ( Cpan.Base.Size );
-    readBytes ( &Anim, sizeof ( IFP_BASE ) );
+    ReadBytes ( &Anim, sizeof ( IFP_BASE ) );
     RoundSize ( Anim.Base.Size );
-    readBytes ( &Anim.Name, Anim.Base.Size );
+    ReadBytes ( &Anim.Name, Anim.Base.Size );
 
     int32_t iBoneID = -1;
     if ( Anim.Base.Size == 0x2C )
@@ -240,7 +232,7 @@ int32_t CClientIFP::ReadSequenceVersion1 ( IFP_ANIM & Anim )
 
 void CClientIFP::ReadSequenceVersion2 ( Object & ObjectNode )
 {
-    readBuffer < Object > ( &ObjectNode );
+    ReadBuffer < Object > ( &ObjectNode );
     std::string BoneName = ConvertStringToMapKey ( ObjectNode.Name );
     std::string strCorrectBoneName;
     if (ObjectNode.BoneID == -1)
@@ -266,7 +258,7 @@ bool CClientIFP::ReadSequenceKeyFrames ( std::unique_ptr < CAnimBlendSequence >
     size_t iCompressedFrameSize = GetSizeOfCompressedFrame ( iFrameType );
     if ( iCompressedFrameSize )
     {
-        BYTE * pKeyFrames = static_cast < BYTE * > (  OLD_CMemoryMgr_Malloc ( iCompressedFrameSize * iFrames ) ); 
+        BYTE * pKeyFrames = m_pAnimManager->AllocateKeyFramesMemory ( iCompressedFrameSize * iFrames ); 
         pAnimationSequence->SetKeyFrames ( iFrames, IsKeyFramesTypeRoot ( iFrameType ), m_kbAllKeyFramesCompressed, pKeyFrames );
         ReadKeyFramesAsCompressed ( iFrameType, pKeyFrames, iFrames );
         return true;
@@ -277,47 +269,47 @@ bool CClientIFP::ReadSequenceKeyFrames ( std::unique_ptr < CAnimBlendSequence >
 void CClientIFP::ReadHeaderVersion1 ( IFP_INFO & Info )
 {
     uint32_t OffsetEOF;
-    readBuffer < uint32_t > ( &OffsetEOF );
+    ReadBuffer < uint32_t > ( &OffsetEOF );
     RoundSize ( OffsetEOF );
-    readBytes ( &Info, sizeof ( IFP_BASE ) );
+    ReadBytes ( &Info, sizeof ( IFP_BASE ) );
     RoundSize ( Info.Base.Size );
-    readBytes ( &Info.Entries, Info.Base.Size );
+    ReadBytes ( &Info.Entries, Info.Base.Size );
 }
 
 void CClientIFP::ReadAnimationNameVersion1 ( SString & strAnimationName )
 {
     IFP_NAME Name;
-    readBuffer < IFP_NAME > ( &Name );
+    ReadBuffer < IFP_NAME > ( &Name );
     RoundSize ( Name.Base.Size );
 
     char szAnimationName [ 24 ];
-    readCString ( szAnimationName, Name.Base.Size );
+    ReadCString ( szAnimationName, Name.Base.Size );
     strAnimationName = szAnimationName;
 }
 
 void CClientIFP::ReadDgan ( IFP_DGAN & Dgan )
 {
-    readBytes ( &Dgan, sizeof ( IFP_BASE ) * 2 );
+    ReadBytes ( &Dgan, sizeof ( IFP_BASE ) * 2 );
     RoundSize ( Dgan.Base.Size );
     RoundSize ( Dgan.Info.Base.Size );
-    readBytes ( &Dgan.Info.Entries, Dgan.Info.Base.Size );
+    ReadBytes ( &Dgan.Info.Entries, Dgan.Info.Base.Size );
 }
 
 CClientIFP::IFP_FrameType CClientIFP::ReadKfrm ( void )
 {
     IFP_KFRM Kfrm;
-    readBuffer < IFP_KFRM > ( &Kfrm );
+    ReadBuffer < IFP_KFRM > ( &Kfrm );
     return GetFrameTypeFromFourCC ( Kfrm.Base.FourCC );
 }
 
 void CClientIFP::ReadAnimationHeaderVersion2 ( Animation & AnimationNode, bool bAnp3 )
 {
-    readCString ( ( char * ) &AnimationNode.Name, sizeof ( Animation::Name ) );
-    readBuffer < int32_t > ( &AnimationNode.TotalObjects );
+    ReadCString ( ( char * ) &AnimationNode.Name, sizeof ( Animation::Name ) );
+    ReadBuffer < int32_t > ( &AnimationNode.TotalObjects );
     if ( bAnp3 )
     {
-        readBuffer < int32_t > ( &AnimationNode.FrameSize );
-        readBuffer < int32_t > ( &AnimationNode.isCompressed );
+        ReadBuffer < int32_t > ( &AnimationNode.FrameSize );
+        ReadBuffer < int32_t > ( &AnimationNode.isCompressed );
     }
 }
 
@@ -360,7 +352,7 @@ void CClientIFP::ReadKrtsFramesAsCompressed (  BYTE * pKeyFrames, int32_t TotalF
         IFP_Compressed_KRT0 * CompressedKrt0 = (IFP_Compressed_KRT0 *)((BYTE*)pKeyFrames + sizeof(IFP_Compressed_KRT0) * FrameIndex);
 
         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) );
@@ -382,7 +374,7 @@ void CClientIFP::ReadKrt0FramesAsCompressed (  BYTE * pKeyFrames, int32_t TotalF
         IFP_Compressed_KRT0 * CompressedKrt0 = (IFP_Compressed_KRT0 *)((BYTE*)pKeyFrames + sizeof(IFP_Compressed_KRT0) * FrameIndex);
 
         IFP_KRT0 Krt0;
-        readBuffer < 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) );
@@ -404,7 +396,7 @@ void CClientIFP::ReadKr00FramesAsCompressed (  BYTE * pKeyFrames, int32_t TotalF
         IFP_Compressed_KR00 * CompressedKr00 = (IFP_Compressed_KR00 *)((BYTE*)pKeyFrames + sizeof(IFP_Compressed_KR00) * FrameIndex);
 
         IFP_KR00 Kr00;
-        readBuffer < 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) );
@@ -418,13 +410,13 @@ void CClientIFP::ReadKr00FramesAsCompressed (  BYTE * pKeyFrames, int32_t TotalF
 void CClientIFP::ReadKr00CompressedFrames (  BYTE * pKeyFrames, int32_t TotalFrames )
 {
     size_t iSizeInBytes = sizeof ( IFP_Compressed_KR00 ) * TotalFrames;
-    readBytes ( pKeyFrames, iSizeInBytes );
+    ReadBytes ( pKeyFrames, iSizeInBytes );
 }
 
 void CClientIFP::ReadKrt0CompressedFrames (  BYTE * pKeyFrames, int32_t TotalFrames )
 {
     size_t iSizeInBytes = sizeof ( IFP_Compressed_KRT0 ) * TotalFrames;
-    readBytes ( pKeyFrames, iSizeInBytes );
+    ReadBytes ( pKeyFrames, iSizeInBytes );
 }  
 
 size_t CClientIFP::GetSizeOfCompressedFrame ( IFP_FrameType iFrameType )
@@ -484,8 +476,8 @@ void CClientIFP::CopySequencesWithDummies ( std::unique_ptr < CAnimBlendHierarch
 {
     for (size_t SequenceIndex = 0; SequenceIndex < m_kcIFPSequences; SequenceIndex++)
     {
-        std::string  BoneName = BoneNames[SequenceIndex];
-        DWORD        BoneID   = BoneIds[SequenceIndex];
+        std::string  BoneName = m_karrstrBoneNames[SequenceIndex];
+        DWORD        BoneID   = m_karruBoneIds[SequenceIndex];
             
         CAnimBlendSequenceSAInterface * pAnimationSequenceInterface = pAnimationHierarchy->GetSequence ( SequenceIndex );
         auto it = mapOfSequences.find ( BoneID );
@@ -507,17 +499,17 @@ BYTE * CClientIFP::AllocateSequencesMemory ( std::unique_ptr < CAnimBlendHierarc
     return static_cast < BYTE * > ( operator new ( 12 * cMaxSequences + 4 ) ); 
 }
 
-CClientIFP::IFP_FrameType CClientIFP::GetFrameTypeFromFourCC ( char * FourCC )
+CClientIFP::IFP_FrameType CClientIFP::GetFrameTypeFromFourCC ( const char * szFourCC )
 {
-    if (strncmp(FourCC, "KRTS", 4) == 0)
+    if ( strncmp ( szFourCC, "KRTS", 4 ) == 0)
     {
         return IFP_FrameType::KRTS;
     }
-    else if (strncmp(FourCC, "KRT0", 4) == 0)
+    else if ( strncmp ( szFourCC, "KRT0", 4 ) == 0)
     {
         return IFP_FrameType::KRT0;
     }
-    else if (strncmp(FourCC, "KR00", 4) == 0)
+    else if ( strncmp ( szFourCC, "KR00", 4 ) == 0)
     {
         return IFP_FrameType::KR00;
     }
@@ -549,7 +541,7 @@ void CClientIFP::InsertAnimationDummySequence ( std::unique_ptr < CAnimBlendSequ
     }
 
     const size_t FramesDataSizeInBytes = FrameSize * cKeyFrames;
-    BYTE * pKeyFrames =  static_cast < BYTE * > ( OLD_CMemoryMgr_Malloc ( FramesDataSizeInBytes ) );
+    BYTE * pKeyFrames = m_pAnimManager->AllocateKeyFramesMemory ( FramesDataSizeInBytes );
     pAnimationSequence->SetKeyFrames ( cKeyFrames, bHasTranslationValues, bKeyFrameCompressed, pKeyFrames );
     CopyDummyKeyFrameByBoneID ( pKeyFrames, dwBoneID );
 }
@@ -769,7 +761,7 @@ std::string CClientIFP::ConvertStringToMapKey ( const char * szString )
 
 constexpr void CClientIFP::RoundSize ( uint32_t & u32Size ) 
 { 
-    if( u32Size & 3 ) 
+    if ( u32Size & 3 ) 
     { 
         u32Size += 4 - ( u32Size & 3 ); 
     }
diff --git a/Client/mods/deathmatch/logic/CClientIFP.h b/Client/mods/deathmatch/logic/CClientIFP.h
@@ -4,11 +4,11 @@
 #define __CCLIENTIFP_H
 
 #include "CClientEntity.h"
-#include "IFP/IFPLoader.h"
-#include "IFP/CIFPAnimations.h"
+#include "CFileReader.h"
+#include "CIFPAnimations.h"
 #include <algorithm>
 
-class CClientIFP: public CClientEntity, FileLoader
+class CClientIFP: public CClientEntity, CFileReader
 {
 public:
     typedef CIFPAnimations::IFP_Animation IFP_Animation;
@@ -206,7 +206,7 @@ class CClientIFP: public CClientEntity, FileLoader
     virtual eClientEntityType       GetType                      ( void ) const              { return CCLIENTIFP; }
 
     const SString &                 GetBlockName                 ( void ) { return m_strBlockName; }
-    bool                            LoadIFP                      ( const char* szFilePath, SString strBlockName );
+    bool                            LoadIFP                      ( const char* szFilePath, const SString & strBlockName );
 
     bool                            LoadIFPFile                  ( const char * szFilePath );
     void                            ReadIFPVersion1              ( void );
@@ -246,7 +246,7 @@ class CClientIFP: public CClientEntity, FileLoader
     constexpr void                  RoundSize                    ( uint32_t & u32Size );
     constexpr bool                  IsKeyFramesTypeRoot          ( IFP_FrameType iFrameType );
 
-    IFP_FrameType                   GetFrameTypeFromFourCC       ( char * FourCC );
+    IFP_FrameType                   GetFrameTypeFromFourCC       ( const char * szFourCC );
     size_t                          GetSizeOfCompressedFrame     ( IFP_FrameType FrameType );
     int32_t                         GetBoneIDFromName            ( std::string const& BoneName );
     std::string                     GetCorrectBoneNameFromName   ( std::string const& BoneName );
@@ -274,6 +274,16 @@ class CClientIFP: public CClientEntity, FileLoader
     // them, when it's going to play the animation. We don't need to worry about it.
     const bool                         m_kbAllKeyFramesCompressed = true;
 
+    const DWORD m_karruBoneIds [ 32 ] = 
+    { 
+        0, 1, 2, 3, 4, 5, 8, 6, 7, 31, 32, 33, 34, 35, 36, 21, 22, 23, 24, 25, 26, 302, 301, 201, 41, 42, 43, 44, 51, 52, 53, 54 
+    };
+    const char m_karrstrBoneNames [ 32 ] [ 24 ] = 
+    {
+        "Normal", "Pelvis", "Spine", "Spine1", "Neck", "Head", "Jaw", "L Brow", "R Brow", "Bip01 L Clavicle", "L UpperArm", 
+        "L ForeArm", "L Hand", "L Finger", "L Finger01", "Bip01 R Clavicle", "R UpperArm", "R ForeArm", "R Hand", "R Finger", 
+        "R Finger01", "L breast", "R breast", "Belly", "L Thigh", "L Calf", "L Foot", "L Toe0", "R Thigh", "R Calf", "R Foot", "R Toe0"
+    };
 };
 
 #endif
diff --git a/Client/mods/deathmatch/logic/CClientPed.cpp b/Client/mods/deathmatch/logic/CClientPed.cpp
@@ -6222,9 +6222,10 @@ 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++ )
     {
-        auto pAnimHierarchyInterface = (CAnimBlendHierarchySAInterface*)((BYTE*)ARRAY_CAnimManager_Animations + sizeof(CAnimBlendHierarchySAInterface) * iAnimationIndex);
+        auto pAnimHierarchyInterface = (CAnimBlendHierarchySAInterface*)((BYTE*)dwARRAY_CAnimManager_Animations + sizeof(CAnimBlendHierarchySAInterface) * iAnimationIndex);
         m_mapOfReplacedAnimations.erase ( pAnimHierarchyInterface );
         iAnimationIndex ++;
     }
diff --git a/Client/sdk/game/CAnimManager.h b/Client/sdk/game/CAnimManager.h

Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,6 @@`
`1`	`1`	`#include <StdInc.h>`
`2`	`2`	`#include "../game_sa/CAnimBlendSequenceSA.h"`
`3`	`3`
`4`		`-hCMemoryMgr_Malloc OLD_CMemoryMgr_Malloc = (hCMemoryMgr_Malloc)0x0072F420;`
`5`		`-hCMemoryMgr_Free OLD_CMemoryMgr_Free = (hCMemoryMgr_Free)0x0072F430;`
`6`		`-`
`7`		`-extern DWORD BoneIds[];`
`8`		`-extern char BoneNames[][24];`
`9`		`-`
`10`	`4`	`CClientIFP::CClientIFP ( class CClientManager* pManager, ElementID ID ) : CClientEntity ( ID )`
`11`	`5`	`{`
`12`	`6`	`// Init`
`@@ -21,7 +15,7 @@ CClientIFP::~CClientIFP ( void )`
`21`	`15`	`{`
`22`	`16`	`}`
`23`	`17`
`24`		`-bool CClientIFP::LoadIFP ( const char* szFilePath, SString strBlockName )`
	`18`	`+bool CClientIFP::LoadIFP ( const char* szFilePath, const SString & strBlockName )`
`25`	`19`	`{`
`26`	`20`	`printf ("\nCClientIFP::LoadIFP: szFilePath %s\n szBlockName: %s\n\n", szFilePath, strBlockName.c_str());`
`27`	`21`
`@@ -37,14 +31,14 @@ bool CClientIFP::LoadIFP ( const char* szFilePath, SString strBlockName )`
`37`	`31`
`38`	`32`	`bool CClientIFP::LoadIFPFile ( const char * szFilePath )`
`39`	`33`	`{`
`40`		`- createLoader ( szFilePath );`
	`34`	`+ CreateLoader ( szFilePath );`
`41`	`35`
`42`		`- if ( loadFile ( ) )`
	`36`	`+ if ( LoadFile ( ) )`
`43`	`37`	`{`
`44`	`38`	`printf("IfpLoader: File loaded. Parsing it now.\n");`
`45`	`39`
`46`	`40`	`char Version [ 4 ];`
`47`		`- readBytes ( Version, sizeof ( Version ) );`
	`41`	`+ ReadBytes ( Version, sizeof ( Version ) );`
`48`	`42`
`49`	`43`	`bool bAnp3 = strncmp ( Version, "ANP3", sizeof ( Version ) ) == 0;`
`50`	`44`	`bool bAnp2 = strncmp ( Version, "ANP2", sizeof ( Version ) ) == 0;`
`@@ -61,7 +55,7 @@ bool CClientIFP::LoadIFPFile ( const char * szFilePath )`
`61`	`55`
`62`	`56`	`// We are unloading the data because we don't need to read it anymore.`
`63`	`57`	`// This function does not unload IFP, to unload ifp call unloadIFP function`
`64`		`- unloadFile ( );`
	`58`	`+ UnloadFile ( );`
`65`	`59`	`}`
`66`	`60`	`else`
`67`	`61`	`{`
`@@ -80,11 +74,9 @@ void CClientIFP::ReadIFPVersion1 ( )`
`80`	`74`	`ReadHeaderVersion1 ( Info );`
`81`	`75`
`82`	`76`	`m_pVecAnimations->resize ( Info.Entries );`
`83`		`-`
`84`	`77`	`for ( auto it = m_pVecAnimations->begin(); it != m_pVecAnimations->end(); ++it )`
`85`	`78`	`{`
`86`	`79`	`ReadAnimationNameVersion1 ( it->Name );`
`87`		`-`
`88`	`80`	`printf("Animation Name: %s \n", it->Name.c_str ( ) );`
`89`	`81`
`90`	`82`	`IFP_DGAN Dgan;`
`@@ -104,7 +96,7 @@ void CClientIFP::ReadIFPVersion1 ( )`
`104`	`96`	`void CClientIFP::ReadIFPVersion2 ( bool bAnp3 )`
`105`	`97`	`{`
`106`	`98`	`IFPHeaderV2 Header;`
`107`		`- readBuffer < IFPHeaderV2 > ( &Header );`
	`99`	`+ ReadBuffer < IFPHeaderV2 > ( &Header );`
`108`	`100`
`109`	`101`	`m_pVecAnimations->resize ( Header.TotalAnimations );`
`110`	`102`	`for ( auto it = m_pVecAnimations->begin(); it != m_pVecAnimations->end(); ++it )`
`@@ -218,11 +210,11 @@ WORD CClientIFP::ReadSequencesVersion2 ( std::unique_ptr < CAnimBlendHierarchy >`
`218`	`210`	`int32_t CClientIFP::ReadSequenceVersion1 ( IFP_ANIM & Anim )`
`219`	`211`	`{`
`220`	`212`	`IFP_CPAN Cpan;`
`221`		`- readBuffer < IFP_CPAN > ( &Cpan );`
	`213`	`+ ReadBuffer < IFP_CPAN > ( &Cpan );`
`222`	`214`	`RoundSize ( Cpan.Base.Size );`
`223`		`- readBytes ( &Anim, sizeof ( IFP_BASE ) );`
	`215`	`+ ReadBytes ( &Anim, sizeof ( IFP_BASE ) );`
`224`	`216`	`RoundSize ( Anim.Base.Size );`
`225`		`- readBytes ( &Anim.Name, Anim.Base.Size );`
	`217`	`+ ReadBytes ( &Anim.Name, Anim.Base.Size );`
`226`	`218`
`227`	`219`	`int32_t iBoneID = -1;`
`228`	`220`	`if ( Anim.Base.Size == 0x2C )`
`@@ -240,7 +232,7 @@ int32_t CClientIFP::ReadSequenceVersion1 ( IFP_ANIM & Anim )`
`240`	`232`
`241`	`233`	`void CClientIFP::ReadSequenceVersion2 ( Object & ObjectNode )`
`242`	`234`	`{`
`243`		`- readBuffer < Object > ( &ObjectNode );`
	`235`	`+ ReadBuffer < Object > ( &ObjectNode );`
`244`	`236`	`std::string BoneName = ConvertStringToMapKey ( ObjectNode.Name );`
`245`	`237`	`std::string strCorrectBoneName;`
`246`	`238`	`if (ObjectNode.BoneID == -1)`
`@@ -266,7 +258,7 @@ bool CClientIFP::ReadSequenceKeyFrames ( std::unique_ptr < CAnimBlendSequence >`
`266`	`258`	`size_t iCompressedFrameSize = GetSizeOfCompressedFrame ( iFrameType );`
`267`	`259`	`if ( iCompressedFrameSize )`
`268`	`260`	`{`
`269`		`- BYTE * pKeyFrames = static_cast < BYTE * > ( OLD_CMemoryMgr_Malloc ( iCompressedFrameSize * iFrames ) );`
	`261`	`+ BYTE * pKeyFrames = m_pAnimManager->AllocateKeyFramesMemory ( iCompressedFrameSize * iFrames );`
`270`	`262`	`pAnimationSequence->SetKeyFrames ( iFrames, IsKeyFramesTypeRoot ( iFrameType ), m_kbAllKeyFramesCompressed, pKeyFrames );`
`271`	`263`	`ReadKeyFramesAsCompressed ( iFrameType, pKeyFrames, iFrames );`
`272`	`264`	`return true;`
`@@ -277,47 +269,47 @@ bool CClientIFP::ReadSequenceKeyFrames ( std::unique_ptr < CAnimBlendSequence >`
`277`	`269`	`void CClientIFP::ReadHeaderVersion1 ( IFP_INFO & Info )`
`278`	`270`	`{`
`279`	`271`	`uint32_t OffsetEOF;`
`280`		`- readBuffer < uint32_t > ( &OffsetEOF );`
	`272`	`+ ReadBuffer < uint32_t > ( &OffsetEOF );`
`281`	`273`	`RoundSize ( OffsetEOF );`
`282`		`- readBytes ( &Info, sizeof ( IFP_BASE ) );`
	`274`	`+ ReadBytes ( &Info, sizeof ( IFP_BASE ) );`
`283`	`275`	`RoundSize ( Info.Base.Size );`
`284`		`- readBytes ( &Info.Entries, Info.Base.Size );`
	`276`	`+ ReadBytes ( &Info.Entries, Info.Base.Size );`
`285`	`277`	`}`
`286`	`278`
`287`	`279`	`void CClientIFP::ReadAnimationNameVersion1 ( SString & strAnimationName )`
`288`	`280`	`{`
`289`	`281`	`IFP_NAME Name;`
`290`		`- readBuffer < IFP_NAME > ( &Name );`
	`282`	`+ ReadBuffer < IFP_NAME > ( &Name );`
`291`	`283`	`RoundSize ( Name.Base.Size );`
`292`	`284`
`293`	`285`	`char szAnimationName [ 24 ];`
`294`		`- readCString ( szAnimationName, Name.Base.Size );`
	`286`	`+ ReadCString ( szAnimationName, Name.Base.Size );`
`295`	`287`	`strAnimationName = szAnimationName;`
`296`	`288`	`}`
`297`	`289`
`298`	`290`	`void CClientIFP::ReadDgan ( IFP_DGAN & Dgan )`
`299`	`291`	`{`
`300`		`- readBytes ( &Dgan, sizeof ( IFP_BASE ) * 2 );`
	`292`	`+ ReadBytes ( &Dgan, sizeof ( IFP_BASE ) * 2 );`
`301`	`293`	`RoundSize ( Dgan.Base.Size );`
`302`	`294`	`RoundSize ( Dgan.Info.Base.Size );`
`303`		`- readBytes ( &Dgan.Info.Entries, Dgan.Info.Base.Size );`
	`295`	`+ ReadBytes ( &Dgan.Info.Entries, Dgan.Info.Base.Size );`
`304`	`296`	`}`
`305`	`297`
`306`	`298`	`CClientIFP::IFP_FrameType CClientIFP::ReadKfrm ( void )`
`307`	`299`	`{`
`308`	`300`	`IFP_KFRM Kfrm;`
`309`		`- readBuffer < IFP_KFRM > ( &Kfrm );`
	`301`	`+ ReadBuffer < IFP_KFRM > ( &Kfrm );`
`310`	`302`	`return GetFrameTypeFromFourCC ( Kfrm.Base.FourCC );`
`311`	`303`	`}`
`312`	`304`
`313`	`305`	`void CClientIFP::ReadAnimationHeaderVersion2 ( Animation & AnimationNode, bool bAnp3 )`
`314`	`306`	`{`
`315`		`- readCString ( ( char * ) &AnimationNode.Name, sizeof ( Animation::Name ) );`
`316`		`- readBuffer < int32_t > ( &AnimationNode.TotalObjects );`
	`307`	`+ ReadCString ( ( char * ) &AnimationNode.Name, sizeof ( Animation::Name ) );`
	`308`	`+ ReadBuffer < int32_t > ( &AnimationNode.TotalObjects );`
`317`	`309`	`if ( bAnp3 )`
`318`	`310`	`{`
`319`		`- readBuffer < int32_t > ( &AnimationNode.FrameSize );`
`320`		`- readBuffer < int32_t > ( &AnimationNode.isCompressed );`
	`311`	`+ ReadBuffer < int32_t > ( &AnimationNode.FrameSize );`
	`312`	`+ ReadBuffer < int32_t > ( &AnimationNode.isCompressed );`
`321`	`313`	`}`
`322`	`314`	`}`
`323`	`315`
`@@ -360,7 +352,7 @@ void CClientIFP::ReadKrtsFramesAsCompressed ( BYTE * pKeyFrames, int32_t TotalF`
`360`	`352`	`IFP_Compressed_KRT0 * CompressedKrt0 = (IFP_Compressed_KRT0 )((BYTE)pKeyFrames + sizeof(IFP_Compressed_KRT0) * FrameIndex);`
`361`	`353`
`362`	`354`	`IFP_KRTS Krts;`
`363`		`- readBuffer < IFP_KRTS >(&Krts);`
	`355`	`+ ReadBuffer < IFP_KRTS >(&Krts);`
`364`	`356`
`365`	`357`	`CompressedKrt0->Rotation.X = static_cast < int16_t > ( ((-Krts.Rotation.X) * 4096.0f) );`
`366`	`358`	`CompressedKrt0->Rotation.Y = static_cast < int16_t > ( ((-Krts.Rotation.Y) * 4096.0f) );`
`@@ -382,7 +374,7 @@ void CClientIFP::ReadKrt0FramesAsCompressed ( BYTE * pKeyFrames, int32_t TotalF`
`382`	`374`	`IFP_Compressed_KRT0 * CompressedKrt0 = (IFP_Compressed_KRT0 )((BYTE)pKeyFrames + sizeof(IFP_Compressed_KRT0) * FrameIndex);`
`383`	`375`
`384`	`376`	`IFP_KRT0 Krt0;`
`385`		`- readBuffer < IFP_KRT0 > ( &Krt0 );`
	`377`	`+ ReadBuffer < IFP_KRT0 > ( &Krt0 );`
`386`	`378`
`387`	`379`	`CompressedKrt0->Rotation.X = static_cast < int16_t > ( ((-Krt0.Rotation.X) * 4096.0f) );`
`388`	`380`	`CompressedKrt0->Rotation.Y = static_cast < int16_t > ( ((-Krt0.Rotation.Y) * 4096.0f) );`
`@@ -404,7 +396,7 @@ void CClientIFP::ReadKr00FramesAsCompressed ( BYTE * pKeyFrames, int32_t TotalF`
`404`	`396`	`IFP_Compressed_KR00 * CompressedKr00 = (IFP_Compressed_KR00 )((BYTE)pKeyFrames + sizeof(IFP_Compressed_KR00) * FrameIndex);`
`405`	`397`
`406`	`398`	`IFP_KR00 Kr00;`
`407`		`- readBuffer < IFP_KR00 > ( &Kr00 );`
	`399`	`+ ReadBuffer < IFP_KR00 > ( &Kr00 );`
`408`	`400`
`409`	`401`	`CompressedKr00->Rotation.X = static_cast < int16_t > ( ((-Kr00.Rotation.X) * 4096.0f) );`
`410`	`402`	`CompressedKr00->Rotation.Y = static_cast < int16_t > ( ((-Kr00.Rotation.Y) * 4096.0f) );`
`@@ -418,13 +410,13 @@ void CClientIFP::ReadKr00FramesAsCompressed ( BYTE * pKeyFrames, int32_t TotalF`
`418`	`410`	`void CClientIFP::ReadKr00CompressedFrames ( BYTE * pKeyFrames, int32_t TotalFrames )`
`419`	`411`	`{`
`420`	`412`	`size_t iSizeInBytes = sizeof ( IFP_Compressed_KR00 ) * TotalFrames;`
`421`		`- readBytes ( pKeyFrames, iSizeInBytes );`
	`413`	`+ ReadBytes ( pKeyFrames, iSizeInBytes );`
`422`	`414`	`}`
`423`	`415`
`424`	`416`	`void CClientIFP::ReadKrt0CompressedFrames ( BYTE * pKeyFrames, int32_t TotalFrames )`
`425`	`417`	`{`
`426`	`418`	`size_t iSizeInBytes = sizeof ( IFP_Compressed_KRT0 ) * TotalFrames;`
`427`		`- readBytes ( pKeyFrames, iSizeInBytes );`
	`419`	`+ ReadBytes ( pKeyFrames, iSizeInBytes );`
`428`	`420`	`}`
`429`	`421`
`430`	`422`	`size_t CClientIFP::GetSizeOfCompressedFrame ( IFP_FrameType iFrameType )`
`@@ -484,8 +476,8 @@ void CClientIFP::CopySequencesWithDummies ( std::unique_ptr < CAnimBlendHierarch`
`484`	`476`	`{`
`485`	`477`	`for (size_t SequenceIndex = 0; SequenceIndex < m_kcIFPSequences; SequenceIndex++)`
`486`	`478`	`{`
`487`		`- std::string BoneName = BoneNames[SequenceIndex];`
`488`		`- DWORD BoneID = BoneIds[SequenceIndex];`
	`479`	`+ std::string BoneName = m_karrstrBoneNames[SequenceIndex];`
	`480`	`+ DWORD BoneID = m_karruBoneIds[SequenceIndex];`
`489`	`481`
`490`	`482`	`CAnimBlendSequenceSAInterface * pAnimationSequenceInterface = pAnimationHierarchy->GetSequence ( SequenceIndex );`
`491`	`483`	`auto it = mapOfSequences.find ( BoneID );`
`@@ -507,17 +499,17 @@ BYTE * CClientIFP::AllocateSequencesMemory ( std::unique_ptr < CAnimBlendHierarc`
`507`	`499`	`return static_cast < BYTE * > ( operator new ( 12 * cMaxSequences + 4 ) );`
`508`	`500`	`}`
`509`	`501`
`510`		`-CClientIFP::IFP_FrameType CClientIFP::GetFrameTypeFromFourCC ( char * FourCC )`
	`502`	`+CClientIFP::IFP_FrameType CClientIFP::GetFrameTypeFromFourCC ( const char * szFourCC )`
`511`	`503`	`{`
`512`		`- if (strncmp(FourCC, "KRTS", 4) == 0)`
	`504`	`+ if ( strncmp ( szFourCC, "KRTS", 4 ) == 0)`
`513`	`505`	`{`
`514`	`506`	`return IFP_FrameType::KRTS;`
`515`	`507`	`}`
`516`		`- else if (strncmp(FourCC, "KRT0", 4) == 0)`
	`508`	`+ else if ( strncmp ( szFourCC, "KRT0", 4 ) == 0)`
`517`	`509`	`{`
`518`	`510`	`return IFP_FrameType::KRT0;`
`519`	`511`	`}`
`520`		`- else if (strncmp(FourCC, "KR00", 4) == 0)`
	`512`	`+ else if ( strncmp ( szFourCC, "KR00", 4 ) == 0)`
`521`	`513`	`{`
`522`	`514`	`return IFP_FrameType::KR00;`
`523`	`515`	`}`
`@@ -549,7 +541,7 @@ void CClientIFP::InsertAnimationDummySequence ( std::unique_ptr < CAnimBlendSequ`
`549`	`541`	`}`
`550`	`542`
`551`	`543`	`const size_t FramesDataSizeInBytes = FrameSize * cKeyFrames;`
`552`		`- BYTE * pKeyFrames = static_cast < BYTE * > ( OLD_CMemoryMgr_Malloc ( FramesDataSizeInBytes ) );`
	`544`	`+ BYTE * pKeyFrames = m_pAnimManager->AllocateKeyFramesMemory ( FramesDataSizeInBytes );`
`553`	`545`	`pAnimationSequence->SetKeyFrames ( cKeyFrames, bHasTranslationValues, bKeyFrameCompressed, pKeyFrames );`
`554`	`546`	`CopyDummyKeyFrameByBoneID ( pKeyFrames, dwBoneID );`
`555`	`547`	`}`
`@@ -769,7 +761,7 @@ std::string CClientIFP::ConvertStringToMapKey ( const char * szString )`
`769`	`761`
`770`	`762`	`constexpr void CClientIFP::RoundSize ( uint32_t & u32Size )`
`771`	`763`	`{`
`772`		`- if( u32Size & 3 )`
	`764`	`+ if ( u32Size & 3 )`
`773`	`765`	`{`
`774`	`766`	`u32Size += 4 - ( u32Size & 3 );`
`775`	`767`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6222,9 +6222,10 @@ void CClientPed::RestoreAnimations ( CAnimBlock & animationBlock )`
`6222`	`6222`	`{`
`6223`	`6223`	`const CAnimBlockSAInterface * pInternalBlockInterface = animationBlock.GetInterface ( );`
`6224`	`6224`	`DWORD iAnimationIndex = pInternalBlockInterface->idOffset;`
	`6225`	`+ DWORD dwARRAY_CAnimManager_Animations = 0xb4ea40;`
`6225`	`6226`	`for ( size_t i = 0; i < pInternalBlockInterface->nAnimations; i++ )`
`6226`	`6227`	`{`
`6227`		`- auto pAnimHierarchyInterface = (CAnimBlendHierarchySAInterface)((BYTE)ARRAY_CAnimManager_Animations + sizeof(CAnimBlendHierarchySAInterface) * iAnimationIndex);`
	`6228`	`+ auto pAnimHierarchyInterface = (CAnimBlendHierarchySAInterface)((BYTE)dwARRAY_CAnimManager_Animations + sizeof(CAnimBlendHierarchySAInterface) * iAnimationIndex);`
`6228`	`6229`	`m_mapOfReplacedAnimations.erase ( pAnimHierarchyInterface );`
`6229`	`6230`	`iAnimationIndex ++;`
`6230`	`6231`	`}`