[FIX] unloadIFP function works good now.

Author: codenulls

Client/mods/deathmatch/logic/CClientIFP.cpp

@@ -1,8 +1,11 @@
 #include <StdInc.h>
 
 h_CAnimBlendHierarchy_SetName OLD__CAnimBlendHierarchy_SetName = (h_CAnimBlendHierarchy_SetName)0x4CF2D0;
+hCAnimBlendHierarchy_RemoveAnimSequences OLD_CAnimBlendHierarchy_RemoveAnimSequences = (hCAnimBlendHierarchy_RemoveAnimSequences)0x4CF8E0;
+hCAnimBlendHierarchy_RemoveFromUncompressedCache OLD_CAnimBlendHierarchy_RemoveFromUncompressedCache = (hCAnimBlendHierarchy_RemoveFromUncompressedCache)0x004D42A0;
 
 hCMemoryMgr_Malloc               OLD_CMemoryMgr_Malloc = (hCMemoryMgr_Malloc)0x0072F420;
+hCMemoryMgr_Free                 OLD_CMemoryMgr_Free   = (hCMemoryMgr_Free)0x0072F430;
 h_CAnimBlendSequence_SetName      OLD__CAnimBlendSequence_SetName = (h_CAnimBlendSequence_SetName)0x4D0C50;
 h_CAnimBlendSequence_SetBoneTag   OLD__CAnimBlendSequence_SetBoneTag = (h_CAnimBlendSequence_SetBoneTag)0x4D0C70;
 h_CAnimBlendSequence_SetNumFrames OLD__CAnimBlendSequence_SetNumFrames = (h_CAnimBlendSequence_SetNumFrames)0x4D0CD0;
@@ -18,6 +21,7 @@ CClientIFP::CClientIFP ( class CClientManager* pManager, ElementID ID ) : CClien
     // Init
     m_pManager = pManager;
     SetTypeName ( "IFP" );
+    m_bisIFPLoaded = false;
 }
 
 CClientIFP::~CClientIFP ( void )
@@ -27,47 +31,59 @@ CClientIFP::~CClientIFP ( void )
 
 bool CClientIFP::LoadIFP ( const char* szFilePath, SString strBlockName )
 {
-    //printf ("\nCClientIFP::LoadIFP: szFilePath %s\n szBlockName: %s\n\n", szFilePath, szBlockName);
+    printf ("\nCClientIFP::LoadIFP: szFilePath %s\n szBlockName: %s\n\n", szFilePath, strBlockName.c_str());
 
     m_strBlockName = strBlockName;
 
-    return LoadIFPFile ( szFilePath );
+    if (LoadIFPFile(szFilePath))
+    {
+        m_bisIFPLoaded = true;
+        return true;
+    }
+    return false;
 }
 
-// Temporary method to avoid memory leaks, we'll need to rewrite the entire thing ;)
+
 void CClientIFP::UnloadIFP ( void )
 {
-   printf ("CClientIFP::UnloadIFP ( ) called, but IFP is not unloaded, PLEASE FIX THIS LATER!\n");
-/*
-    printf ("CClientIFP::UnloadIFP ( ) called!\n");
+    if ( m_bisIFPLoaded )
+    { 
+        printf ("CClientIFP::UnloadIFP ( ) called!\n");
 
-    for ( size_t i = 0; i < m_Animations.size(); i++ )
-    {
-        IFP_Animation * ifpAnimation = &m_Animations[i];
-        if ( isVersion1 )
-        { 
+        
+        for ( size_t i = 0; i < m_Animations.size(); i++ )
+        {
+            IFP_Animation * ifpAnimation = &m_Animations[i];
+        
+            OLD_CAnimBlendHierarchy_RemoveFromUncompressedCache ( (int)&ifpAnimation->Hierarchy );
+            
             for (unsigned short SequenceIndex = 0; SequenceIndex < ifpAnimation->Hierarchy.m_nSeqCount; SequenceIndex++)
             {
                 _CAnimBlendSequence * pSequence = (_CAnimBlendSequence*)((BYTE*)ifpAnimation->Hierarchy.m_pSequences + (sizeof(_CAnimBlendSequence) * SequenceIndex));
-                free ( pSequence->m_pFrames );
+
+                if ( !( (pSequence->m_nFlags >> 3) & 1 ) ) // If ( !OneBigChunkForAllSequences )
+                {
+                    OLD_CMemoryMgr_Free ( pSequence->m_pFrames ); //*(void **)(pThis + 8)); //pSequence->m_pFrames );
+                }
+                else
+                {
+                    if ( SequenceIndex == 0 )
+                    { 
+                        // All frames of all sequences are allocated on one memory block, so free that one
+                        // and break the loop 
+                        OLD_CMemoryMgr_Free ( pSequence->m_pFrames );
+                        break;
+                    }
+                }
+  
             }
-        }
-        else
-        {
-            free ( ifpAnimation->pFramesMemoryVersion2 );
+            delete ifpAnimation->pSequencesMemory;  
         }
 
-        delete ifpAnimation->pSequencesMemory;
-    }
+        g_pClientGame->RemoveIFPPointerFromMap ( m_strBlockName );
 
-    for (size_t DummySequenceIndex = 0; DummySequenceIndex <  m_DummySequencesKeyFrames.size(); DummySequenceIndex++)
-    {
-        unsigned char * pKeyFrames = m_DummySequencesKeyFrames [ DummySequenceIndex ];
-        free ( pKeyFrames );
-    }*/
-
-    g_pClientGame->RemoveIFPPointerFromMap ( m_strBlockName );
-    //printf ("IFP unloaded sucessfully, removed from map as well.\n"); 
+        printf ("IFP unloaded sucessfully, removed from map as well.\n");  
+    }
 }
 
 bool CClientIFP::LoadIFPFile(const char * FilePath)
@@ -136,17 +152,12 @@ void CClientIFP::ReadIFPVersion2( bool anp3)
 
         printf("Animation Name: %s    |  Index: %d \n", AnimationNode.Name, i);
 
-        unsigned char * pKeyFrames = nullptr;
         if (anp3)
         {
             readBuffer < int32_t >(&AnimationNode.FrameSize);
             readBuffer < int32_t >(&AnimationNode.isCompressed);
 
-            pAnimHierarchy->m_bRunningCompressed = AnimationNode.isCompressed & 1;
-
-            pKeyFrames = (unsigned char*) OLD_CMemoryMgr_Malloc(AnimationNode.FrameSize); //malloc(AnimationNode.FrameSize);
-
-            ifpAnimation.pFramesMemoryVersion2 = pKeyFrames;
+            pAnimHierarchy->m_bRunningCompressed = AnimationNode.isCompressed & 1;      
         }
 
         OLD__CAnimBlendHierarchy_SetName(pAnimHierarchy, AnimationNode.Name);
@@ -156,12 +167,9 @@ void CClientIFP::ReadIFPVersion2( bool anp3)
         pAnimHierarchy->field_B = 0;
 
         const unsigned short   TotalSequences = IFP_TOTAL_SEQUENCES + pAnimHierarchy->m_nSeqCount;
-        char           * pNewSequencesMemory  = ( char * ) operator new ( 12 * TotalSequences + 4 ); //  Allocate memory for sequences ( 12 * seq_count + 4 )
+        ifpAnimation.pSequencesMemory  = ( char * ) operator new ( 12 * TotalSequences + 4 ); //  Allocate memory for sequences ( 12 * seq_count + 4 )
 
-        // Okay, we have assigned the memory. We can free it when we want to
-        ifpAnimation.pSequencesMemory = pNewSequencesMemory;
-
-        pAnimHierarchy->m_pSequences          = ( _CAnimBlendSequence * )( pNewSequencesMemory + 4 );
+        pAnimHierarchy->m_pSequences          = ( _CAnimBlendSequence * )( ifpAnimation.pSequencesMemory + 4 );
 
         std::map < std::string, _CAnimBlendSequence > MapOfSequences;
 
@@ -265,6 +273,8 @@ void CClientIFP::ReadIFPVersion2( bool anp3)
             }
             if (!bInvalidType)
             {
+                unsigned char * pKeyFrames = (unsigned char*) OLD_CMemoryMgr_Malloc ( data_size ); 
+                
                 if ( bUnknownSequence )
                 { 
                     OLD__CAnimBlendSequence_SetNumFrames ( pUnkownSequence, ObjectNode.TotalFrames, bIsRoot, bIsCompressed, pKeyFrames );
@@ -274,13 +284,7 @@ void CClientIFP::ReadIFPVersion2( bool anp3)
                     OLD__CAnimBlendSequence_SetNumFrames ( &Sequence, ObjectNode.TotalFrames, bIsRoot, bIsCompressed, pKeyFrames );
                 }
 
-                readBytes ( Sequence.m_pFrames, data_size );
-
-                if (anp3)
-                {
-                    pKeyFrames += data_size;
-                    Sequence.m_nFlags |= 8u;
-                }
+                readBytes ( pKeyFrames, data_size );
 
                 if ( !bUnknownSequence )
                 { 
@@ -304,11 +308,11 @@ void CClientIFP::ReadIFPVersion2( bool anp3)
             }
             else
             {
-                insertAnimDummySequence(anp3, pAnimHierarchy, SequenceIndex);
+                insertAnimDummySequence ( pAnimHierarchy, SequenceIndex );
             }
         }
-
-        *(DWORD *)pNewSequencesMemory = IFP_TOTAL_SEQUENCES + TotalUnknownSequences;
+        
+        *(DWORD *)ifpAnimation.pSequencesMemory = IFP_TOTAL_SEQUENCES + TotalUnknownSequences;
 
         // This order is very important. As we need support for all 32 bones, we must change the total sequences count
         pAnimHierarchy->m_nSeqCount = IFP_TOTAL_SEQUENCES + TotalUnknownSequences;
@@ -383,12 +387,9 @@ void CClientIFP::ReadIFPVersion1 (  )
         pAnimHierarchy->field_B = 0;
 
         const unsigned short   TotalSequences = IFP_TOTAL_SEQUENCES + pAnimHierarchy->m_nSeqCount;
-        char           * pNewSequencesMemory  = ( char * ) operator new ( 12 * TotalSequences + 4 ); //  Allocate memory for sequences ( 12 * seq_count + 4 )
-        
-        // Okay, we have assigned the memory. We can free it when we want to
-        ifpAnimation.pSequencesMemory = pNewSequencesMemory;
+        ifpAnimation.pSequencesMemory  = ( char * ) operator new ( 12 * TotalSequences + 4 ); //  Allocate memory for sequences ( 12 * seq_count + 4 )
 
-        pAnimHierarchy->m_pSequences          = ( _CAnimBlendSequence * )( pNewSequencesMemory + 4 );
+        pAnimHierarchy->m_pSequences          = ( _CAnimBlendSequence * )( ifpAnimation.pSequencesMemory+ 4 );
 
         std::map < std::string, _CAnimBlendSequence > MapOfSequences;
 
@@ -496,7 +497,7 @@ void CClientIFP::ReadIFPVersion1 (  )
             else if (FrameType == IFP_FrameType::KR00)
             {
                 //ofs << "  |  FrameType: KR00" << std::endl;
-                ReadKr00FramesAsCompressed ( pKeyFrames, Anim.Frames, BoneID );
+                ReadKr00FramesAsCompressed ( pKeyFrames, Anim.Frames );
             }
 
             if (!bUnknownSequence)
@@ -523,11 +524,11 @@ void CClientIFP::ReadIFPVersion1 (  )
             }
             else
             {
-                insertAnimDummySequence ( false, pAnimHierarchy, SequenceIndex );
+                insertAnimDummySequence ( pAnimHierarchy, SequenceIndex );
             }
         }
 
-        *(DWORD *)pNewSequencesMemory = IFP_TOTAL_SEQUENCES + TotalUnknownSequences;
+        *(DWORD *)ifpAnimation.pSequencesMemory = IFP_TOTAL_SEQUENCES + TotalUnknownSequences;
 
         // This order is very important. As we need support for all 32 bones, we must change the total sequences count
         pAnimHierarchy->m_nSeqCount = IFP_TOTAL_SEQUENCES + TotalUnknownSequences;
@@ -588,7 +589,7 @@ void CClientIFP::ReadKrt0FramesAsCompressed (  BYTE * pKeyFrames, int32_t TotalF
     }
 }
 
-void CClientIFP::ReadKr00FramesAsCompressed (  BYTE * pKeyFrames, int32_t TotalFrames, int32_t BoneID )
+void CClientIFP::ReadKr00FramesAsCompressed (  BYTE * pKeyFrames, int32_t TotalFrames )
 {
     for (int32_t FrameIndex = 0; FrameIndex < TotalFrames; FrameIndex++)
     {
@@ -654,7 +655,7 @@ IFP_FrameType CClientIFP::getFrameTypeFromFourCC ( char * FourCC )
 }
 
 
-void CClientIFP::insertAnimDummySequence ( bool anp3, _CAnimBlendHierarchy * pAnimHierarchy, size_t SequenceIndex)
+void CClientIFP::insertAnimDummySequence ( _CAnimBlendHierarchy * pAnimHierarchy, size_t SequenceIndex)
 {
     const char * BoneName = BoneNames [SequenceIndex ];
     DWORD        BoneID   = BoneIds   [SequenceIndex];
@@ -927,11 +928,6 @@ void CClientIFP::insertAnimDummySequence ( bool anp3, _CAnimBlendHierarchy * pAn
             //ofs << " ERROR: BoneID is not being handled!" << std::endl;
         }
     }
-
-    if (anp3)
-    {
-        pSequence->m_nFlags |= 8u; //EXTERNAL_KEYFRAMES_MEM;
-    }
 }
 
 

Client/mods/deathmatch/logic/CClientIFP.h

@@ -30,10 +30,7 @@ class CClientIFP: public CClientEntity, FileLoader
     void                            ReadKrt0FramesAsCompressed (  BYTE * pKeyFrames, int32_t TotalFrames );
     void                            ReadKr00FramesAsCompressed (  BYTE * pKeyFrames, int32_t TotalFrames );
 
-    // Remove this ugly function and use ReadKr00FramesAsCompressed instead
-    void                            ReadKr00FramesAsCompressed (  BYTE * pKeyFrames, int32_t TotalFrames, int32_t BoneID );
-
-    void                            insertAnimDummySequence(bool anp3, _CAnimBlendHierarchy * pAnimHierarchy, size_t SequenceIndex);
+    void                            insertAnimDummySequence ( _CAnimBlendHierarchy * pAnimHierarchy, size_t SequenceIndex);
     int32_t                         getBoneIDFromName(std::string const& BoneName);
     std::string                     getCorrectBoneNameFromName(std::string const& BoneName);
     std::string                     getCorrectBoneNameFromID(int32_t & BoneID);
@@ -53,6 +50,7 @@ class CClientIFP: public CClientEntity, FileLoader
     std::vector < unsigned char * > m_DummySequencesKeyFrames;
     bool                            isVersion1;
     IFPHeaderV2                     HeaderV2;
+    bool                            m_bisIFPLoaded;
 
 };
 

Client/mods/deathmatch/logic/IFP/IFPLoader.h

@@ -209,6 +209,11 @@ typedef void *(__cdecl* hCMemoryMgr_Malloc)
 );
 
 
+typedef void *(__cdecl* hCMemoryMgr_Free)
+(
+    void *a1
+);
+
 void _CAnimBlendHierarchy_Constructor(_CAnimBlendHierarchy * pAnimHierarchy);
 void _CAnimBlendSequence_Constructor(_CAnimBlendSequence * pSequence);
 

Client/mods/deathmatch/logic/IFP/wrapper.h

@@ -249,6 +249,9 @@ typedef void (__cdecl *  hUncompressAnimation)
 _CAnimBlendHierarchy * pAnimBlendHierarchy 
 );
 
+typedef int (__cdecl *  hCAnimBlendHierarchy_RemoveFromUncompressedCache)
+(int a1);
+
 typedef CAnimBlendAssoc * (__thiscall *  hCAnimBlendAssoc_Constructor_staticAssocRef)
 (
 CAnimBlendAssoc * pThis,
@@ -345,6 +348,8 @@ void __cdecl NEW_UncompressAnimation
 _CAnimBlendHierarchy * pAnimBlendHierarchy 
 );
 
+typedef void (__thiscall* hCAnimBlendHierarchy_RemoveAnimSequences) 
+( DWORD * pThis);
 
 const char * GetNameFromHash(DWORD Hash);
 int GetNumAnimations(void);