Update FindInvalidDataProcess.cpp

-Fix some review findings.

code/FindInvalidDataProcess.cpp

@@ -68,22 +68,19 @@ FindInvalidDataProcess::FindInvalidDataProcess()
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-FindInvalidDataProcess::~FindInvalidDataProcess()
-{
+FindInvalidDataProcess::~FindInvalidDataProcess() {
     // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool FindInvalidDataProcess::IsActive( unsigned int pFlags) const
-{
+bool FindInvalidDataProcess::IsActive( unsigned int pFlags) const {
     return 0 != (pFlags & aiProcess_FindInvalidData);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup import configuration
-void FindInvalidDataProcess::SetupProperties(const Importer* pImp)
-{
+void FindInvalidDataProcess::SetupProperties(const Importer* pImp) {
     // Get the current value of AI_CONFIG_PP_FID_ANIM_ACCURACY
     configEpsilon = (0 != pImp->GetPropertyFloat(AI_CONFIG_PP_FID_ANIM_ACCURACY,0.f));
     mIgnoreTexCoods = pImp->GetPropertyBool(AI_CONFIG_PP_FID_IGNORE_TEXTURECOORDS, false);
@@ -91,8 +88,7 @@ void FindInvalidDataProcess::SetupProperties(const Importer* pImp)
 
 // ------------------------------------------------------------------------------------------------
 // Update mesh references in the node graph
-void UpdateMeshReferences(aiNode* node, const std::vector<unsigned int>& meshMapping)
-{
+void UpdateMeshReferences(aiNode* node, const std::vector<unsigned int>& meshMapping) {
     if (node->mNumMeshes)   {
         unsigned int out = 0;
         for (unsigned int a = 0; a < node->mNumMeshes;++a)  {
@@ -118,8 +114,7 @@ void UpdateMeshReferences(aiNode* node, const std::vector<unsigned int>& meshMap
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void FindInvalidDataProcess::Execute( aiScene* pScene)
-{
+void FindInvalidDataProcess::Execute( aiScene* pScene) {
     ASSIMP_LOG_DEBUG("FindInvalidDataProcess begin");
 
     bool out = false;
@@ -175,17 +170,16 @@ void FindInvalidDataProcess::Execute( aiScene* pScene)
 template <typename T>
 inline
 const char* ValidateArrayContents(const T* /*arr*/, unsigned int /*size*/,
-    const std::vector<bool>& /*dirtyMask*/, bool /*mayBeIdentical = false*/, bool /*mayBeZero = true*/)
+        const std::vector<bool>& /*dirtyMask*/, bool /*mayBeIdentical = false*/, bool /*mayBeZero = true*/)
 {
-    return NULL;
+    return nullptr;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <>
 inline
 const char* ValidateArrayContents<aiVector3D>(const aiVector3D* arr, unsigned int size,
-    const std::vector<bool>& dirtyMask, bool mayBeIdentical , bool mayBeZero )
-{
+        const std::vector<bool>& dirtyMask, bool mayBeIdentical , bool mayBeZero ) {
     bool b = false;
     unsigned int cnt = 0;
     for (unsigned int i = 0; i < size;++i)  {
@@ -207,14 +201,14 @@ const char* ValidateArrayContents<aiVector3D>(const aiVector3D* arr, unsigned in
     if (cnt > 1 && !b && !mayBeIdentical) {
         return "All vectors are identical";
     }
-    return NULL;
+    return nullptr;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename T>
-inline bool ProcessArray(T*& in, unsigned int num,const char* name,
-    const std::vector<bool>& dirtyMask, bool mayBeIdentical = false, bool mayBeZero = true)
-{
+inline 
+bool ProcessArray(T*& in, unsigned int num,const char* name,
+        const std::vector<bool>& dirtyMask, bool mayBeIdentical = false, bool mayBeZero = true) {
     const char* err = ValidateArrayContents(in,num,dirtyMask,mayBeIdentical,mayBeZero);
     if (err)    {
         ASSIMP_LOG_ERROR_F( "FindInvalidDataProcess fails on mesh ", name, ": ", err);
@@ -261,17 +255,14 @@ bool AllIdentical(T* in, unsigned int num, ai_real epsilon) {
         return true;
     }
 
-    if (epsilon > 0.f) {
+    if (fabs(epsilon) > 0.f) {
         for (unsigned int i = 0; i < num-1;++i) {
-
             if (!EpsilonCompare(in[i],in[i+1],epsilon)) {
                 return false;
             }
         }
-    }
-    else {
+    } else {
         for (unsigned int i = 0; i < num-1;++i) {
-
             if (in[i] != in[i+1]) {
                 return false;
             }
@@ -282,27 +273,24 @@ bool AllIdentical(T* in, unsigned int num, ai_real epsilon) {
 
 // ------------------------------------------------------------------------------------------------
 // Search an animation for invalid content
-void FindInvalidDataProcess::ProcessAnimation (aiAnimation* anim)
-{
+void FindInvalidDataProcess::ProcessAnimation (aiAnimation* anim) {
     // Process all animation channels
-    for (unsigned int a = 0; a < anim->mNumChannels;++a) {
+    for ( unsigned int a = 0; a < anim->mNumChannels; ++a ) {
         ProcessAnimationChannel( anim->mChannels[a]);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim)
-{
-    int i = 0;
-
-    // ScenePreprocessor's work ...
-    ai_assert((0 != anim->mPositionKeys && 0 != anim->mRotationKeys && 0 != anim->mScalingKeys));
+void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim) {
+    ai_assert( 0 != anim->mPositionKeys );
+    ai_assert( 0 != anim->mRotationKeys );
+    ai_assert( 0 != anim->mScalingKeys );
 
     // Check whether all values in a tracks are identical - in this case
     // we can remove al keys except one.
     // POSITIONS
-    if (anim->mNumPositionKeys > 1 && AllIdentical(anim->mPositionKeys,anim->mNumPositionKeys,configEpsilon))
-    {
+    int i = 0;
+    if (anim->mNumPositionKeys > 1 && AllIdentical(anim->mPositionKeys,anim->mNumPositionKeys,configEpsilon)) {
         aiVectorKey v = anim->mPositionKeys[0];
 
         // Reallocate ... we need just ONE element, it makes no sense to reuse the array
@@ -313,8 +301,7 @@ void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim)
     }
 
     // ROTATIONS
-    if (anim->mNumRotationKeys > 1 && AllIdentical(anim->mRotationKeys,anim->mNumRotationKeys,configEpsilon))
-    {
+    if (anim->mNumRotationKeys > 1 && AllIdentical(anim->mRotationKeys,anim->mNumRotationKeys,configEpsilon)) {
         aiQuatKey v = anim->mRotationKeys[0];
 
         // Reallocate ... we need just ONE element, it makes no sense to reuse the array
@@ -325,8 +312,7 @@ void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim)
     }
 
     // SCALINGS
-    if (anim->mNumScalingKeys > 1 && AllIdentical(anim->mScalingKeys,anim->mNumScalingKeys,configEpsilon))
-    {
+    if (anim->mNumScalingKeys > 1 && AllIdentical(anim->mScalingKeys,anim->mNumScalingKeys,configEpsilon)) {
         aiVectorKey v = anim->mScalingKeys[0];
 
         // Reallocate ... we need just ONE element, it makes no sense to reuse the array
@@ -335,8 +321,9 @@ void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim)
         anim->mScalingKeys[0] = v;
         i = 1;
     }
-    if (1 == i)
+    if ( 1 == i ) {
         ASSIMP_LOG_WARN("Simplified dummy tracks with just one key");
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -364,8 +351,8 @@ int FindInvalidDataProcess::ProcessMesh (aiMesh* pMesh)
     }
 
     // process texture coordinates
-    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS && pMesh->mTextureCoords[i]; ++i) {
-        if (!mIgnoreTexCoods) {
+    if (!mIgnoreTexCoods) {
+        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS && pMesh->mTextureCoords[i]; ++i) {
             if (ProcessArray(pMesh->mTextureCoords[i], pMesh->mNumVertices, "uvcoords", dirtyMask)) {
                 pMesh->mNumUVComponents[i] = 0;
 
@@ -394,13 +381,11 @@ int FindInvalidDataProcess::ProcessMesh (aiMesh* pMesh)
                 aiPrimitiveType_POLYGON  & pMesh->mPrimitiveTypes)
             {
                 // We need to update the lookup-table
-                for (unsigned int m = 0; m < pMesh->mNumFaces;++m)
-                {
-                    const aiFace& f = pMesh->mFaces[m];
+                for (unsigned int m = 0; m < pMesh->mNumFaces;++m) {
+                    const aiFace& f = pMesh->mFaces[ m ];
 
                     if (f.mNumIndices < 3)  {
                         dirtyMask[f.mIndices[0]] = true;
-
                         if (f.mNumIndices == 2) {
                             dirtyMask[f.mIndices[1]] = true;
                         }
@@ -409,7 +394,9 @@ int FindInvalidDataProcess::ProcessMesh (aiMesh* pMesh)
             }
             // Normals, tangents and bitangents are undefined for
             // the whole mesh (and should not even be there)
-            else return ret;
+            else {
+                return ret;
+            }
         }
 
         // Process mesh normals
@@ -432,5 +419,4 @@ int FindInvalidDataProcess::ProcessMesh (aiMesh* pMesh)
     return ret ? 1 : 0;
 }
 
-
 #endif // !! ASSIMP_BUILD_NO_FINDINVALIDDATA_PROCESS