[BAD DESIGN] added IFP loader. It works properly, but the design is horrible. We'll need to properly rewrite it according to MTA's coding guidelines. Also, there is no function for unloading IFP, so yeah there are memory leaks. Dynamic memory allocation is used for sequeneces and key frames only, so freeing this memory is important.

Author: codenulls

Client/mods/deathmatch/logic/CClientIFP.cpp

@@ -4,23 +4,55 @@
 #define __CCLIENTIFP_H
 
 #include "CClientEntity.h"
+#include "IFP/IFPLoader.h"
+#include <algorithm>
 
-class CClientIFP: public CClientEntity
+class CClientIFP: public CClientEntity, FileLoader
 {
 public:
                                     CClientIFP              ( class CClientManager* pManager, ElementID ID );
                                     ~CClientIFP             ( void );
 
     virtual eClientEntityType       GetType                 ( void ) const              { return CCLIENTIFP; }
 
-    bool                            LoadIFP                 ( const char* szFilePath, const char* szBlockName );
+    bool                            LoadIFP                 ( const char* szFilePath, SString strBlockName );
     void                            UnloadIFP               ( void );
 
+    bool                            LoadIFPFile(const char * FilePath);
+    void                            ReadIFPVersion1();
+    void                            ReadIFPVersion2( bool anp3);
+
+    std::string                     convertStringToMapKey(char * String);
+    IFP_FrameType                   getFrameTypeFromFourCC(char * FourCC);
+    size_t                          GetSizeOfCompressedFrame ( IFP_FrameType FrameType );
+
+    void                            ReadKrtsFramesAsCompressed (  BYTE * pKeyFrames, int32_t TotalFrames );
+    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);
+    int32_t                         getBoneIDFromName(std::string const& BoneName);
+    std::string                     getCorrectBoneNameFromName(std::string const& BoneName);
+    std::string                     getCorrectBoneNameFromID(int32_t & BoneID);
+    size_t                          getCorrectBoneIndexFromID(int32_t & BoneID);
+
     // Sorta a hack that these are required by CClientEntity...
     void                            Unlink                  ( void ) {};
     void                            GetPosition             ( CVector& vecPosition ) const {};
     void                            SetPosition             ( const CVector& vecPosition ) {};
 
+   
+private:
+    SString m_strBlockName;
+    bool isVersion1;
+    IFPHeaderV2 HeaderV2;
+    std::vector <_CAnimBlendHierarchy> AnimationHierarchies;
+    std::vector <_CAnimBlendSequence> AnimationSequences;
+    unsigned char * KeyFramesArray;
+
 };
 
 #endif

Client/mods/deathmatch/logic/CClientIFP.h

@@ -0,0 +1,20 @@
+#include <StdInc.h>
+#include "wrapper.h"
+
+h_CAnimBlendHierarchy_Constructor OLD__CAnimBlendHierarchy_Constructor = (h_CAnimBlendHierarchy_Constructor)0x4CF270;
+
+void _CAnimBlendHierarchy_Constructor ( _CAnimBlendHierarchy * pAnimHierarchy )
+{
+    int pThis = (int)pAnimHierarchy;
+
+
+    *(DWORD *)(pThis + 4) = 0;
+    *(WORD *)(pThis + 8) = 0;
+    *(BYTE *)(pThis + 10) = 0;
+    *(BYTE *)(pThis + 11) = 0;
+    *(DWORD *)(pThis + 12) = -1;
+    *(DWORD *)(pThis + 16) = 0;
+    *(DWORD *)(pThis + 20) = 0;
+    
+}
+

Client/mods/deathmatch/logic/IFP/CAnimBlendHierarchy.cpp

@@ -0,0 +1,26 @@
+#include <StdInc.h>
+#include "wrapper.h"
+
+h_CAnimBlendSequence_Constructor  OLD__CAnimBlendSequence_Constructor = (h_CAnimBlendSequence_Constructor)0x4D0C10;
+h_CAnimBlendSequence_Deconstructor OLD__CAnimBlendSequence_Deconstructor = (h_CAnimBlendSequence_Deconstructor)0x4D0C30; 
+
+void _CAnimBlendSequence_Constructor (_CAnimBlendSequence * pSequence)
+{
+    WORD * pThis = (WORD *)pSequence;
+
+    pThis[2] = 0;
+    pThis[3] = 0;
+    *((DWORD *)pThis + 2) = 0;
+    *pThis = -1;
+}
+
+/*
+// The keyframes will not be freed if the deconstructor is not there, but
+// it would be better to put the frames in a vector container for better control.
+// I prefer to not use the deconstructor, so I guess we don't need to uncomment this
+
+_CAnimBlendSequence::~_CAnimBlendSequence()
+{
+    OLD__CAnimBlendSequence_Deconstructor();
+}
+*/

Client/mods/deathmatch/logic/IFP/CAnimBlendSequence.cpp

@@ -0,0 +1,188 @@
+#pragma once
+#ifndef FILELOADER_H
+#define FILELOADER_H
+
+#include <Windows.h>
+#include <iostream>
+#include <fstream>
+
+class FileLoader
+{
+private:
+
+    const char * FilePath;
+    FILE *       FilePointer;
+    char *       FileDataBuffer;
+    UINT         FileLength = 0;
+    UINT         BytesReadFromBuffer = 0;
+
+    void setLoaderFilePath(const char * FileToRead)
+    {
+        FilePath = FileToRead;
+    }
+
+    BOOL getFileHandle(void)
+    {
+        errno_t FileOpen = fopen_s(&FilePointer, FilePath, "rb");
+
+        if (FileOpen != 0)
+        {
+            std::cout << "Failed to open file";
+            return FALSE;
+        }
+
+        return TRUE;
+    }
+
+    BOOL getFileLength(void)
+    {
+        if (!FilePointer)
+            return FALSE;
+
+        if (fseek(FilePointer, 0, SEEK_END) != 0)
+        {
+            std::cout << "Failed to set cursor to end of file." << std::endl;
+            return FALSE;
+        }
+
+        FileLength = ftell(FilePointer);
+        if (FileLength == -1L)
+        {
+            std::cout << "Failed to get length of file (ftell)" << std::endl;
+            return FALSE;
+        }
+
+        rewind(FilePointer);
+
+        return TRUE;
+    }
+
+    void AllocateBufferMemory(void)
+    {
+        if (!FilePointer)
+            return;
+
+        FileDataBuffer = new char[FileLength + 1];
+    }
+
+    BOOL loadToMemory(void)
+    {
+        if (!FilePointer)
+            return FALSE;
+
+        UINT ReadSize = fread(FileDataBuffer, sizeof(char), FileLength, FilePointer);
+
+        if (ReadSize != FileLength)
+        {
+            std::cout << "loadToMemory Failed. ReadSize != FileLength";
+            return FALSE;
+        }
+
+        return TRUE;
+    }
+
+
+public:
+
+    ~FileLoader(void)
+    {
+        unloadFile ();
+    }
+
+    FileLoader(void)
+    {
+
+    }
+
+    BOOL createLoader(const char * FileToRead)
+    {
+        setLoaderFilePath(FileToRead);
+
+        if (!getFileHandle() || !getFileLength())
+            return FALSE;
+
+        AllocateBufferMemory();
+
+        FileDataBuffer[FileLength] = '\0';
+
+        return TRUE;
+    }
+
+    BOOL loadFile(void)
+    {
+        if (!loadToMemory())
+            return FALSE;
+
+        std::cout << "Length: " << FileLength << std::endl;
+        return TRUE;
+    }
+
+    // This function does not unload IFP data, to unload IFP call unloadIFP function
+    void unloadFile(void)
+    {
+        if (FileDataBuffer != nullptr)
+        {
+            delete[] FileDataBuffer;
+            fclose(FilePointer);
+
+            FileDataBuffer = nullptr;
+        } 
+    }
+
+    void PrintReadOffset(void)
+    {
+        std::cout << "Bytes read from buffer: " << BytesReadFromBuffer << std::endl;
+    }
+
+
+    template < class T >
+    void readBuffer ( T * Destination )
+    {
+        const UINT ReadOffset = BytesReadFromBuffer;
+        BytesReadFromBuffer += sizeof ( T );
+
+        *Destination = *reinterpret_cast < T * > (FileDataBuffer + ReadOffset);
+
+    }
+
+    void readBytes(void * Destination, const UINT BytesToRead)
+    {
+        const UINT ReadOffset = BytesReadFromBuffer;
+        BytesReadFromBuffer += BytesToRead;
+
+        memcpy(Destination, FileDataBuffer + ReadOffset, BytesToRead);
+    }
+
+    std::string readString(UINT StringSizeInBytes)
+    {
+        std::string String;
+
+        String.resize(StringSizeInBytes);
+
+        for (UINT i = 0; i < StringSizeInBytes; i++)
+        {
+            const UINT ReadOffset = BytesReadFromBuffer;
+
+            String[i] = FileDataBuffer[ReadOffset];
+            BytesReadFromBuffer++;
+        }
+        return String;
+    }
+
+    void readCString (char * Destination, const UINT BytesToRead)
+    {
+        const UINT ReadOffset = BytesReadFromBuffer;
+        BytesReadFromBuffer += BytesToRead;
+
+        memcpy(Destination, FileDataBuffer + ReadOffset, BytesToRead);
+        
+        *(Destination + (BytesToRead - 1)) = '\0';
+    }
+
+    void skipBytes(UINT TotalBytesToSkip)
+    {
+        BytesReadFromBuffer += TotalBytesToSkip;
+    }
+};
+
+#endif