Code quality improvements

codenulls · codenulls · commit 43f90fe49a6b · 2018-04-05T14:51:55.000+05:00
Replaced uint32_t, int32_t, and int16_t with std::* from &lt;cstdint&gt;
- Suggested by Necktrox

Used std::find_if in CClientIFP::GetAnimationHierarchy
&amp; improved iterator loops by using
for (auto&amp; Animation : m_pIFPAnimations-&gt;vecAnimations)  in CClientIFP::ReadIFPVersion2 and CClientIFP::ReadIFPVersion1
- earlier suggested by sbx320

Replaced std::string with SString.

Changed CIFPAnimations::SIFPAnimation::pSequencesMemory type to BYTE*. Removed casting where this member of struct was accessed.

Used const where applicable in CClientIFP.cpp.

Renamed ConvertStringToMapKey to ConvertStringToKey.

Applied source formatting again
diff --git a/Client/mods/deathmatch/StdInc.h b/Client/mods/deathmatch/StdInc.h
@@ -95,6 +95,8 @@
 #include <CMapEventManager.h>
 #include <CModelNames.h>
 #include <CIFPEngine.h>
+#include <CFileReader.h>
+#include <CIFPAnimations.h>
 #include <CScriptFile.h>
 #include <CWeaponNames.h>
 #include <CVehicleNames.h>
diff --git a/Client/mods/deathmatch/logic/CClientGame.cpp b/Client/mods/deathmatch/logic/CClientGame.cpp
@@ -6820,7 +6820,7 @@ void CClientGame::RemovePedPointerFromSet(CClientPed* pPed)
 CClientPed* CClientGame::GetClientPedByClump(const RpClump& Clump)
 {
     std::lock_guard<std::mutex> mutexGuardedLock(m_MutexOfPedPointersSet);
-    for (auto &pPed : m_setOfPedPointers)
+    for (auto& pPed : m_setOfPedPointers)
     {
         CEntity* pEntity = pPed->GetGameEntity();
         if (pEntity != nullptr)
@@ -6842,7 +6842,7 @@ void CClientGame::OnClientIFPUnload(const std::shared_ptr<CClientIFP>& IFP)
 {
     std::lock_guard<std::mutex> mutexGuardedLock(m_MutexOfPedPointersSet);
     IFP->MarkAsUnloading();
-    for (auto &pPed : m_setOfPedPointers)
+    for (auto& pPed : m_setOfPedPointers)
     {
         // Remove IFP animations from replaced animations of peds/players
         pPed->RestoreAnimations(IFP);
diff --git a/Client/mods/deathmatch/logic/CClientIFP.cpp b/Client/mods/deathmatch/logic/CClientIFP.cpp
diff --git a/Client/mods/deathmatch/logic/CClientIFP.h b/Client/mods/deathmatch/logic/CClientIFP.h
@@ -12,15 +12,15 @@ class CClientIFP : public CClientEntity, CFileReader
 
     struct SBase
     {
-        char     FourCC[4];
-        uint32_t Size;
+        char          FourCC[4];
+        std::uint32_t Size;
     };
 
     struct SInfo
     {
-        SBase   Base;
-        int32_t Entries;
-        char    Name[24];
+        SBase        Base;
+        std::int32_t Entries;
+        char         Name[24];
     };
 
     struct SAnpk
@@ -47,16 +47,16 @@ class CClientIFP : public CClientEntity, CFileReader
 
     struct SAnim
     {
-        SBase   Base;
-        char    Name[28];
-        int32_t Frames;
-        int32_t Unk;
-        int32_t Next;
-        int32_t Previous;
+        SBase        Base;
+        char         Name[28];
+        std::int32_t Frames;
+        std::int32_t Unk;
+        std::int32_t Next;
+        std::int32_t Previous;
 
         // According to https://www.gtamodding.com/wiki/IFP, Unk2 should not exist, but for some reason, it's there
         // I don't know why. Let's just go with the flow and ignore it. The value seems to be always zero.
-        int32_t Unk2;
+        std::int32_t Unk2;
     };
 
     struct SKfrm
@@ -97,18 +97,18 @@ class CClientIFP : public CClientEntity, CFileReader
 
     struct SCompressedQuaternion
     {
-        int16_t X, Y, Z, W;
+        std::int16_t X, Y, Z, W;
     };
 
     struct SCompressedCVector
     {
-        int16_t X, Y, Z;
+        std::int16_t X, Y, Z;
     };
 
     struct SCompressed_KR00
     {
         SCompressedQuaternion Rotation;
-        int16_t               Time;
+        std::int16_t          Time;
     };
 
     struct SCompressed_KRT0 : SCompressed_KR00
@@ -128,27 +128,25 @@ class CClientIFP : public CClientEntity, CFileReader
 
     struct SIFPHeaderV2
     {
-        int32_t OffsetEOF;
-        char    InternalFileName[24];
-        int32_t TotalAnimations;
+        std::int32_t OffsetEOF;
+        char         InternalFileName[24];
+        std::int32_t TotalAnimations;
     };
 
     struct SAnimationHeaderV2
     {
-        char    Name[24];
-        int32_t TotalObjects;
-        int32_t FrameSize;
-        int32_t isCompressed;            // The value is always 1
+        char         Name[24];
+        std::int32_t TotalObjects;
+        std::int32_t FrameSize;
+        std::int32_t isCompressed;            // The value is always 1
     };
 
     struct SSequenceHeaderV2
     {
-        // 24 + 4 + 4 + 4 = 36 bytes
-
-        char    Name[24];
-        int32_t FrameType;
-        int32_t TotalFrames;
-        int32_t BoneID;
+        char         Name[24];
+        std::int32_t FrameType;
+        std::int32_t TotalFrames;
+        std::int32_t BoneID;
     };
 
     enum eBoneType
@@ -213,51 +211,52 @@ class CClientIFP : public CClientEntity, CFileReader
     void ReadIFPVersion1(void);
     void ReadIFPVersion2(bool bAnp3);
 
-    WORD    ReadSequencesWithDummies(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy);
-    WORD    ReadSequences(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, std::map<DWORD, CAnimBlendSequenceSAInterface>& MapOfSequences);
-    WORD    ReadSequencesVersion1(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, std::map<DWORD, CAnimBlendSequenceSAInterface>& MapOfSequences);
-    WORD    ReadSequencesVersion2(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, std::map<DWORD, CAnimBlendSequenceSAInterface>& MapOfSequences);
-    int32_t ReadSequenceVersion1(SAnim& Anim);
-    void    ReadSequenceVersion2(SSequenceHeaderV2& ObjectNode);
+    WORD ReadSequencesWithDummies(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy);
+    WORD ReadSequences(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, std::map<DWORD, CAnimBlendSequenceSAInterface>& MapOfSequences);
+    WORD ReadSequencesVersion1(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, std::map<DWORD, CAnimBlendSequenceSAInterface>& MapOfSequences);
+    WORD ReadSequencesVersion2(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, std::map<DWORD, CAnimBlendSequenceSAInterface>& MapOfSequences);
+    std::int32_t ReadSequenceVersion1(SAnim& Anim);
+    void         ReadSequenceVersion2(SSequenceHeaderV2& ObjectNode);
 
     void                   ReadHeaderVersion1(SInfo& Info);
     void                   ReadAnimationNameVersion1(SAnimation& IfpAnimation);
     void                   ReadDgan(SDgan& Dgan);
     CClientIFP::eFrameType ReadKfrm(void);
     void                   ReadAnimationHeaderVersion2(SAnimationHeaderV2& AnimationNode, bool bAnp3);
 
-    bool ReadSequenceKeyFrames(std::unique_ptr<CAnimBlendSequence>& pAnimationSequence, eFrameType iFrameType, int32_t iFrames);
-    void ReadKeyFramesAsCompressed(std::unique_ptr<CAnimBlendSequence>& pAnimationSequence, eFrameType 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);
+    bool ReadSequenceKeyFrames(std::unique_ptr<CAnimBlendSequence>& pAnimationSequence, eFrameType iFrameType, const std::int32_t& cFrames);
+    void ReadKeyFramesAsCompressed(std::unique_ptr<CAnimBlendSequence>& pAnimationSequence, eFrameType iFrameType, const std::int32_t& cFrames);
+    void ReadKrtsFramesAsCompressed(std::unique_ptr<CAnimBlendSequence>& pAnimationSequence, const std::int32_t& cFrames);
+    void ReadKrt0FramesAsCompressed(std::unique_ptr<CAnimBlendSequence>& pAnimationSequence, const std::int32_t& cFrames);
+    void ReadKr00FramesAsCompressed(std::unique_ptr<CAnimBlendSequence>& pAnimationSequence, const std::int32_t& cFrames);
 
     template <class T>
-    void ReadCompressedFrames(std::unique_ptr<CAnimBlendSequence>& pAnimationSequence, int32_t iFrames)
+    void ReadCompressedFrames(std::unique_ptr<CAnimBlendSequence>& pAnimationSequence, std::int32_t iFrames)
     {
         BYTE*  pKeyFrames = pAnimationSequence->GetKeyFrames();
         size_t iSizeInBytes = sizeof(T) * iFrames;
         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);
+    void  InitializeAnimationHierarchy(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, const SString& strAnimationName,
+                                       const std::int32_t& iSequences);
+    void  InitializeAnimationSequence(std::unique_ptr<CAnimBlendSequence>& pAnimationSequence, const SString& strName, const std::int32_t& iBoneID);
     void  PreProcessAnimationHierarchy(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy);
     void  CopySequencesWithDummies(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, std::map<DWORD, CAnimBlendSequenceSAInterface>& mapOfSequences);
     BYTE* AllocateSequencesMemory(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy);
 
-    void        InsertAnimationDummySequence(std::unique_ptr<CAnimBlendSequence>& pAnimationSequence, std::string& BoneName, DWORD& dwBoneID);
-    void        CopyDummyKeyFrameByBoneID(BYTE* pKeyFrames, DWORD dwBoneID);
-    std::string ConvertStringToMapKey(const char* szString);
+    void    InsertAnimationDummySequence(std::unique_ptr<CAnimBlendSequence>& pAnimationSequence, const SString& BoneName, const DWORD& dwBoneID);
+    void    CopyDummyKeyFrameByBoneID(BYTE* pKeyFrames, DWORD dwBoneID);
+    SString ConvertStringToKey(const SString& strBoneName);
 
-    constexpr void RoundSize(uint32_t& u32Size);
+    constexpr void RoundSize(std::uint32_t& u32Size);
     constexpr bool IsKeyFramesTypeRoot(eFrameType iFrameType);
 
-    eFrameType  GetFrameTypeFromFourCC(const char* szFourCC);
-    size_t      GetSizeOfCompressedFrame(eFrameType FrameType);
-    int32_t     GetBoneIDFromName(std::string const& BoneName);
-    std::string GetCorrectBoneNameFromName(std::string const& BoneName);
-    std::string GetCorrectBoneNameFromID(int32_t& BoneID);
+    eFrameType   GetFrameTypeFromFourCC(const char* szFourCC);
+    size_t       GetSizeOfCompressedFrame(eFrameType FrameType);
+    std::int32_t GetBoneIDFromName(const SString& strBoneName);
+    SString      GetCorrectBoneNameFromName(const SString& strBoneName);
+    SString      GetCorrectBoneNameFromID(const std::int32_t& iBoneID);
 
     std::shared_ptr<CIFPAnimations> m_pIFPAnimations;
     SString                         m_strBlockName;
diff --git a/Client/mods/deathmatch/logic/CElementDeleter.cpp b/Client/mods/deathmatch/logic/CElementDeleter.cpp
@@ -94,11 +94,8 @@ void CElementDeleter::DeleteIFP(CClientEntity* pElement)
     const unsigned int u32BlockNameHash = IFP.GetBlockNameHash();
 
     auto it = std::find_if(m_vecIFPElements.begin(), m_vecIFPElements.end(),
-    [&u32BlockNameHash](std::shared_ptr<CClientIFP> const& pIFP)
-    {
-		return pIFP->GetBlockNameHash() == u32BlockNameHash;
-	});
-    if(it != m_vecIFPElements.end())
+                           [&u32BlockNameHash](std::shared_ptr<CClientIFP> const& pIFP) { return pIFP->GetBlockNameHash() == u32BlockNameHash; });
+    if (it != m_vecIFPElements.end())
     {
         m_vecIFPElements.erase(it);
     }
diff --git a/Client/mods/deathmatch/logic/CFileReader.cpp b/Client/mods/deathmatch/logic/CFileReader.cpp
@@ -8,7 +8,7 @@ CFileReader::CFileReader(void)
 
 void CFileReader::FreeFileReaderMemory(void)
 {
-    std::vector<char>().swap( vecFileDataBuffer );
+    std::vector<char>().swap(vecFileDataBuffer);
     u32BytesReadFromBuffer = 0;
 }
 
@@ -34,15 +34,15 @@ void CFileReader::SkipBytes(const std::uint32_t u32BytesToSkip)
 
 bool CFileReader::LoadFileToMemory(const SString& strFilePath)
 {
-    std::ifstream fileStream(strFilePath, std::ios::binary | std::ios::ate); 
+    std::ifstream   fileStream(strFilePath, std::ios::binary | std::ios::ate);
     std::streamsize iFileSize = fileStream.tellg();
     if (iFileSize == eIFSTREAM::SIZE_ERROR)
     {
         return false;
     }
 
     fileStream.seekg(0, std::ios::beg);
-    vecFileDataBuffer.reserve (static_cast < size_t > ( iFileSize ));
+    vecFileDataBuffer.reserve(static_cast<size_t>(iFileSize));
     if (fileStream.read(vecFileDataBuffer.data(), iFileSize))
     {
         return true;
diff --git a/Client/mods/deathmatch/logic/CFileReader.h b/Client/mods/deathmatch/logic/CFileReader.h
@@ -7,7 +7,7 @@ class CFileReader
 {
 public:
     enum eIFSTREAM
-    { 
+    {
         SIZE_ERROR = -1
     };
 
@@ -24,9 +24,9 @@ class CFileReader
         *pDestination = *reinterpret_cast<T*>(&vecFileDataBuffer[u32ReadOffset]);
     }
 
-    void        ReadBytes(void* pDestination, const std::uint32_t u32BytesToRead);
-    void        ReadStringNullTerminated(char* pDestination, const std::uint32_t u32BytesToRead);
-    void        SkipBytes(const std::uint32_t u32BytesToSkip);
+    void ReadBytes(void* pDestination, const std::uint32_t u32BytesToRead);
+    void ReadStringNullTerminated(char* pDestination, const std::uint32_t u32BytesToRead);
+    void SkipBytes(const std::uint32_t u32BytesToSkip);
 
 private:
     std::vector<char> vecFileDataBuffer;
diff --git a/Client/mods/deathmatch/logic/CIFPAnimations.cpp b/Client/mods/deathmatch/logic/CIFPAnimations.cpp
@@ -9,9 +9,9 @@ CIFPAnimations::~CIFPAnimations(void)
 void CIFPAnimations::DeleteAnimations(void)
 {
     CAnimManager* pAnimManager = g_pGame->GetAnimManager();
-    for (auto it = vecAnimations.begin(); it != vecAnimations.end(); ++it)
+    for (auto& Animation : vecAnimations)
     {
-        auto pAnimationHierarchy = pAnimManager->GetCustomAnimBlendHierarchy(&it->Hierarchy);
+        auto pAnimationHierarchy = pAnimManager->GetCustomAnimBlendHierarchy(&Animation.Hierarchy);
         for (unsigned short SequenceIndex = 0; SequenceIndex < pAnimationHierarchy->GetNumSequences(); SequenceIndex++)
         {
             pAnimManager->RemoveFromUncompressedCache(pAnimationHierarchy->GetInterface());
@@ -32,6 +32,6 @@ void CIFPAnimations::DeleteAnimations(void)
                 }
             }
         }
-        delete it->pSequencesMemory;
+        delete Animation.pSequencesMemory;
     }
 }
diff --git a/Client/mods/deathmatch/logic/CIFPAnimations.h b/Client/mods/deathmatch/logic/CIFPAnimations.h
@@ -1,4 +1,3 @@
-#pragma
 #ifndef __CIFPANIMATIONS_H
 #define __CIFPANIMATIONS_H
 #include "../Client/mods/deathmatch/logic/CClientIFP.h"
@@ -9,9 +8,9 @@ class CIFPAnimations
     struct SAnimation
     {
         SString                        Name;
-        unsigned int                   u32NameHash;
+        unsigned int                   uiNameHash;
         CAnimBlendHierarchySAInterface Hierarchy;
-        char*                          pSequencesMemory;
+        BYTE*                          pSequencesMemory;
     };
 
     std::vector<SAnimation> vecAnimations;

Original file line number	Diff line number	Diff line change
`@@ -6820,7 +6820,7 @@ void CClientGame::RemovePedPointerFromSet(CClientPed* pPed)`
`6820`	`6820`	`CClientPed* CClientGame::GetClientPedByClump(const RpClump& Clump)`
`6821`	`6821`	`{`
`6822`	`6822`	`std::lock_guard<std::mutex> mutexGuardedLock(m_MutexOfPedPointersSet);`
`6823`		`- for (auto &pPed : m_setOfPedPointers)`
	`6823`	`+ for (auto& pPed : m_setOfPedPointers)`
`6824`	`6824`	`{`
`6825`	`6825`	`CEntity* pEntity = pPed->GetGameEntity();`
`6826`	`6826`	`if (pEntity != nullptr)`
`@@ -6842,7 +6842,7 @@ void CClientGame::OnClientIFPUnload(const std::shared_ptr<CClientIFP>& IFP)`
`6842`	`6842`	`{`
`6843`	`6843`	`std::lock_guard<std::mutex> mutexGuardedLock(m_MutexOfPedPointersSet);`
`6844`	`6844`	`IFP->MarkAsUnloading();`
`6845`		`- for (auto &pPed : m_setOfPedPointers)`
	`6845`	`+ for (auto& pPed : m_setOfPedPointers)`
`6846`	`6846`	`{`
`6847`	`6847`	`// Remove IFP animations from replaced animations of peds/players`
`6848`	`6848`	`pPed->RestoreAnimations(IFP);`
Original file line number	Diff line number	Diff line change
`@@ -94,11 +94,8 @@ void CElementDeleter::DeleteIFP(CClientEntity* pElement)`
`94`	`94`	`const unsigned int u32BlockNameHash = IFP.GetBlockNameHash();`
`95`	`95`
`96`	`96`	`auto it = std::find_if(m_vecIFPElements.begin(), m_vecIFPElements.end(),`
`97`		`- [&u32BlockNameHash](std::shared_ptr<CClientIFP> const& pIFP)`
`98`		`- {`
`99`		`- return pIFP->GetBlockNameHash() == u32BlockNameHash;`
`100`		`- });`
`101`		`- if(it != m_vecIFPElements.end())`
	`97`	`+ [&u32BlockNameHash](std::shared_ptr<CClientIFP> const& pIFP) { return pIFP->GetBlockNameHash() == u32BlockNameHash; });`
	`98`	`+ if (it != m_vecIFPElements.end())`
`102`	`99`	`{`
`103`	`100`	`m_vecIFPElements.erase(it);`
`104`	`101`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ CFileReader::CFileReader(void)`
`8`	`8`
`9`	`9`	`void CFileReader::FreeFileReaderMemory(void)`
`10`	`10`	`{`
`11`		`- std::vector<char>().swap( vecFileDataBuffer );`
	`11`	`+ std::vector<char>().swap(vecFileDataBuffer);`
`12`	`12`	`u32BytesReadFromBuffer = 0;`
`13`	`13`	`}`
`14`	`14`
`@@ -34,15 +34,15 @@ void CFileReader::SkipBytes(const std::uint32_t u32BytesToSkip)`
`34`	`34`
`35`	`35`	`bool CFileReader::LoadFileToMemory(const SString& strFilePath)`
`36`	`36`	`{`
`37`		`- std::ifstream fileStream(strFilePath, std::ios::binary \| std::ios::ate);`
	`37`	`+ std::ifstream fileStream(strFilePath, std::ios::binary \| std::ios::ate);`
`38`	`38`	`std::streamsize iFileSize = fileStream.tellg();`
`39`	`39`	`if (iFileSize == eIFSTREAM::SIZE_ERROR)`
`40`	`40`	`{`
`41`	`41`	`return false;`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`fileStream.seekg(0, std::ios::beg);`
`45`		`- vecFileDataBuffer.reserve (static_cast < size_t > ( iFileSize ));`
	`45`	`+ vecFileDataBuffer.reserve(static_cast<size_t>(iFileSize));`
`46`	`46`	`if (fileStream.read(vecFileDataBuffer.data(), iFileSize))`
`47`	`47`	`{`
`48`	`48`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -9,9 +9,9 @@ CIFPAnimations::~CIFPAnimations(void)`
`9`	`9`	`void CIFPAnimations::DeleteAnimations(void)`
`10`	`10`	`{`
`11`	`11`	`CAnimManager* pAnimManager = g_pGame->GetAnimManager();`
`12`		`- for (auto it = vecAnimations.begin(); it != vecAnimations.end(); ++it)`
	`12`	`+ for (auto& Animation : vecAnimations)`
`13`	`13`	`{`
`14`		`- auto pAnimationHierarchy = pAnimManager->GetCustomAnimBlendHierarchy(&it->Hierarchy);`
	`14`	`+ auto pAnimationHierarchy = pAnimManager->GetCustomAnimBlendHierarchy(&Animation.Hierarchy);`
`15`	`15`	`for (unsigned short SequenceIndex = 0; SequenceIndex < pAnimationHierarchy->GetNumSequences(); SequenceIndex++)`
`16`	`16`	`{`
`17`	`17`	`pAnimManager->RemoveFromUncompressedCache(pAnimationHierarchy->GetInterface());`
`@@ -32,6 +32,6 @@ void CIFPAnimations::DeleteAnimations(void)`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`	`}`
`35`		`- delete it->pSequencesMemory;`
	`35`	`+ delete Animation.pSequencesMemory;`
`36`	`36`	`}`
`37`	`37`	`}`