diff --git a/code/Obj/ObjFileMtlImporter.cpp b/code/Obj/ObjFileMtlImporter.cpp index 79783c51b..8b529758e 100644 --- a/code/Obj/ObjFileMtlImporter.cpp +++ b/code/Obj/ObjFileMtlImporter.cpp @@ -89,9 +89,12 @@ ObjFileMtlImporter::ObjFileMtlImporter(std::vector &buffer, m_DataIt(buffer.begin()), m_DataItEnd(buffer.end()), m_pModel(pModel), - m_uiLine(0) { - ai_assert(NULL != m_pModel); - if (NULL == m_pModel->m_pDefaultMaterial) { + m_uiLine(0), + m_buffer() { + ai_assert(nullptr != m_pModel); + m_buffer.resize(BUFFERSIZE); + std::fill(m_buffer.begin(), m_buffer.end(), '\0'); + if (nullptr == m_pModel->m_pDefaultMaterial) { m_pModel->m_pDefaultMaterial = new ObjFile::Material; m_pModel->m_pDefaultMaterial->MaterialName.Set("default"); } @@ -104,18 +107,6 @@ ObjFileMtlImporter::~ObjFileMtlImporter() { // empty } -// ------------------------------------------------------------------- -// Private copy constructor -ObjFileMtlImporter::ObjFileMtlImporter(const ObjFileMtlImporter &) { - // empty -} - -// ------------------------------------------------------------------- -// Private copy constructor -ObjFileMtlImporter &ObjFileMtlImporter::operator=(const ObjFileMtlImporter &) { - return *this; -} - // ------------------------------------------------------------------- // Loads the material description void ObjFileMtlImporter::load() { @@ -227,15 +218,15 @@ void ObjFileMtlImporter::getColorRGBA(aiColor3D *pColor) { // ------------------------------------------------------------------- // Loads the kind of illumination model. void ObjFileMtlImporter::getIlluminationModel(int &illum_model) { - m_DataIt = CopyNextWord(m_DataIt, m_DataItEnd, m_buffer, BUFFERSIZE); - illum_model = atoi(m_buffer); + m_DataIt = CopyNextWord(m_DataIt, m_DataItEnd, &m_buffer[0], BUFFERSIZE); + illum_model = atoi(&m_buffer[0]); } // ------------------------------------------------------------------- // Loads a single float value. void ObjFileMtlImporter::getFloatValue(ai_real &value) { - m_DataIt = CopyNextWord(m_DataIt, m_DataItEnd, m_buffer, BUFFERSIZE); - value = (ai_real)fast_atof(m_buffer); + m_DataIt = CopyNextWord(m_DataIt, m_DataItEnd, &m_buffer[0], BUFFERSIZE); + value = (ai_real)fast_atof(&m_buffer[0]); } // ------------------------------------------------------------------- diff --git a/code/Obj/ObjFileMtlImporter.h b/code/Obj/ObjFileMtlImporter.h index 4c48756f1..a48ee78e0 100644 --- a/code/Obj/ObjFileMtlImporter.h +++ b/code/Obj/ObjFileMtlImporter.h @@ -65,19 +65,18 @@ public: typedef std::vector::iterator DataArrayIt; typedef std::vector::const_iterator ConstDataArrayIt; -public: - //! \brief Default constructor + //! \brief The class default constructor ObjFileMtlImporter(std::vector &buffer, const std::string &strAbsPath, ObjFile::Model *pModel); - //! \brief DEstructor + //! \brief The class destructor ~ObjFileMtlImporter(); + ObjFileMtlImporter(const ObjFileMtlImporter &rOther) = delete; + ObjFileMtlImporter &operator=(const ObjFileMtlImporter &rOther) = delete; + private: /// Copy constructor, empty. - ObjFileMtlImporter(const ObjFileMtlImporter &rOther); - /// \brief Assignment operator, returns only a reference of this instance. - ObjFileMtlImporter &operator=(const ObjFileMtlImporter &rOther); /// Load the whole material description void load(); /// Get color data. @@ -104,7 +103,7 @@ private: //! Current line in file unsigned int m_uiLine; //! Helper buffer - char m_buffer[BUFFERSIZE]; + std::vector m_buffer; }; // ------------------------------------------------------------------------------------------------ diff --git a/code/Ply/PlyLoader.cpp b/code/Ply/PlyLoader.cpp index 02c7c2caa..51a04f324 100644 --- a/code/Ply/PlyLoader.cpp +++ b/code/Ply/PlyLoader.cpp @@ -5,7 +5,6 @@ Open Asset Import Library (assimp) Copyright (c) 2006-2020, assimp team - All rights reserved. Redistribution and use of this software in source and binary forms, @@ -47,12 +46,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef ASSIMP_BUILD_NO_PLY_IMPORTER // internal headers -#include "PlyLoader.h" -#include -#include -#include -#include -#include +# include "PlyLoader.h" +# include +# include +# include +# include +# include using namespace ::Assimp; @@ -87,7 +86,9 @@ inline const T &GetProperty(const std::vector &props, int idx) { // ------------------------------------------------------------------------------------------------ // Constructor to be privately used by Importer PLYImporter::PLYImporter() : - mBuffer(nullptr), pcDOM(nullptr), mGeneratedMesh(nullptr) { + mBuffer(nullptr), + pcDOM(nullptr), + mGeneratedMesh(nullptr) { // empty } @@ -127,15 +128,15 @@ static bool isBigEndian(const char *szMe) { // binary_little_endian // binary_big_endian bool isBigEndian(false); -#if (defined AI_BUILD_BIG_ENDIAN) +# if (defined AI_BUILD_BIG_ENDIAN) if ('l' == *szMe || 'L' == *szMe) { isBigEndian = true; } -#else +# else if ('b' == *szMe || 'B' == *szMe) { isBigEndian = true; } -#endif // ! AI_BUILD_BIG_ENDIAN +# endif // ! AI_BUILD_BIG_ENDIAN return isBigEndian; } diff --git a/code/Ply/PlyLoader.h b/code/Ply/PlyLoader.h index 41620e6b0..b87422c3f 100644 --- a/code/Ply/PlyLoader.h +++ b/code/Ply/PlyLoader.h @@ -4,7 +4,6 @@ Open Asset Import Library (assimp) Copyright (c) 2006-2020, assimp team - All rights reserved. Redistribution and use of this software in source and binary forms, @@ -46,9 +45,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef AI_PLYLOADER_H_INCLUDED #define AI_PLYLOADER_H_INCLUDED +#include "PlyParser.h" #include #include -#include "PlyParser.h" #include struct aiNode; @@ -62,77 +61,72 @@ using namespace PLY; // --------------------------------------------------------------------------- /** Importer class to load the stanford PLY file format */ -class PLYImporter : public BaseImporter -{ +class PLYImporter : public BaseImporter { public: PLYImporter(); ~PLYImporter(); -public: - // ------------------------------------------------------------------- /** Returns whether the class can handle the format of the given file. * See BaseImporter::CanRead() for details. */ - bool CanRead( const std::string& pFile, IOSystem* pIOHandler, - bool checkSig) const; + bool CanRead(const std::string &pFile, IOSystem *pIOHandler, + bool checkSig) const; // ------------------------------------------------------------------- /** Extract a vertex from the DOM */ - void LoadVertex(const PLY::Element* pcElement, const PLY::ElementInstance* instElement, unsigned int pos); + void LoadVertex(const PLY::Element *pcElement, const PLY::ElementInstance *instElement, unsigned int pos); // ------------------------------------------------------------------- /** Extract a face from the DOM */ - void LoadFace(const PLY::Element* pcElement, const PLY::ElementInstance* instElement, unsigned int pos); + void LoadFace(const PLY::Element *pcElement, const PLY::ElementInstance *instElement, unsigned int pos); protected: - // ------------------------------------------------------------------- /** Return importer meta information. * See #BaseImporter::GetInfo for the details */ - const aiImporterDesc* GetInfo () const; + const aiImporterDesc *GetInfo() const; // ------------------------------------------------------------------- /** Imports the given file into the given scene structure. * See BaseImporter::InternReadFile() for details */ - void InternReadFile( const std::string& pFile, aiScene* pScene, - IOSystem* pIOHandler); + void InternReadFile(const std::string &pFile, aiScene *pScene, + IOSystem *pIOHandler); -protected: // ------------------------------------------------------------------- /** Extract a material list from the DOM */ - void LoadMaterial(std::vector* pvOut, std::string &defaultTexture, const bool pointsOnly); + void LoadMaterial(std::vector *pvOut, std::string &defaultTexture, const bool pointsOnly); // ------------------------------------------------------------------- /** Static helper to parse a color from four single channels in */ static void GetMaterialColor( - const std::vector& avList, - unsigned int aiPositions[4], - PLY::EDataType aiTypes[4], - aiColor4D* clrOut); + const std::vector &avList, + unsigned int aiPositions[4], + PLY::EDataType aiTypes[4], + aiColor4D *clrOut); // ------------------------------------------------------------------- /** Static helper to parse a color channel value. The input value * is normalized to 0-1. */ - static ai_real NormalizeColorValue ( - PLY::PropertyInstance::ValueUnion val, - PLY::EDataType eType); + static ai_real NormalizeColorValue( + PLY::PropertyInstance::ValueUnion val, + PLY::EDataType eType); /** Buffer to hold the loaded file */ - unsigned char* mBuffer; + unsigned char *mBuffer; /** Document object model representation extracted from the file */ - PLY::DOM* pcDOM; + PLY::DOM *pcDOM; /** Mesh generated by loader */ - aiMesh* mGeneratedMesh; + aiMesh *mGeneratedMesh; }; } // end of namespace Assimp diff --git a/code/PostProcessing/FindInvalidDataProcess.cpp b/code/PostProcessing/FindInvalidDataProcess.cpp index 36975fcfe..99be52fa4 100644 --- a/code/PostProcessing/FindInvalidDataProcess.cpp +++ b/code/PostProcessing/FindInvalidDataProcess.cpp @@ -5,8 +5,6 @@ Open Asset Import Library (assimp) Copyright (c) 2006-2020, assimp team - - All rights reserved. Redistribution and use of this software in source and binary forms, @@ -44,24 +42,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. /** @file Defines a post processing step to search an importer's output for data that is obviously invalid */ - - #ifndef ASSIMP_BUILD_NO_FINDINVALIDDATA_PROCESS // internal headers -#include "FindInvalidDataProcess.h" -#include "ProcessHelper.h" +# include "FindInvalidDataProcess.h" +# include "ProcessHelper.h" -#include -#include +# include +# include using namespace Assimp; // ------------------------------------------------------------------------------------------------ // Constructor to be privately used by Importer -FindInvalidDataProcess::FindInvalidDataProcess() -: configEpsilon(0.0) -, mIgnoreTexCoods( false ){ +FindInvalidDataProcess::FindInvalidDataProcess() : + configEpsilon(0.0), mIgnoreTexCoods(false) { // nothing to do here } @@ -73,47 +68,47 @@ FindInvalidDataProcess::~FindInvalidDataProcess() { // ------------------------------------------------------------------------------------------------ // 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)); + configEpsilon = (0 != pImp->GetPropertyFloat(AI_CONFIG_PP_FID_ANIM_ACCURACY, 0.f)); mIgnoreTexCoods = pImp->GetPropertyBool(AI_CONFIG_PP_FID_IGNORE_TEXTURECOORDS, false); } // ------------------------------------------------------------------------------------------------ // Update mesh references in the node graph -void UpdateMeshReferences(aiNode* node, const std::vector& meshMapping) { - if (node->mNumMeshes) { +void UpdateMeshReferences(aiNode *node, const std::vector &meshMapping) { + if (node->mNumMeshes) { unsigned int out = 0; - for (unsigned int a = 0; a < node->mNumMeshes;++a) { + for (unsigned int a = 0; a < node->mNumMeshes; ++a) { unsigned int ref = node->mMeshes[a]; - if (UINT_MAX != (ref = meshMapping[ref])) { + if (UINT_MAX != (ref = meshMapping[ref])) { node->mMeshes[out++] = ref; } } // just let the members that are unused, that's much cheaper // than a full array realloc'n'copy party ... - node->mNumMeshes = out; - if ( 0 == out ) { + node->mNumMeshes = out; + if (0 == out) { delete[] node->mMeshes; node->mMeshes = NULL; } } // recursively update all children - for (unsigned int i = 0; i < node->mNumChildren;++i) { - UpdateMeshReferences(node->mChildren[i],meshMapping); + for (unsigned int i = 0; i < node->mNumChildren; ++i) { + UpdateMeshReferences(node->mChildren[i], meshMapping); } } // ------------------------------------------------------------------------------------------------ // 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; @@ -121,32 +116,31 @@ void FindInvalidDataProcess::Execute( aiScene* pScene) { unsigned int real = 0; // Process meshes - for( unsigned int a = 0; a < pScene->mNumMeshes; a++) { + for (unsigned int a = 0; a < pScene->mNumMeshes; a++) { int result = ProcessMesh(pScene->mMeshes[a]); - if (0 == result ) { + if (0 == result) { out = true; - - if (2 == result) { - // remove this mesh - delete pScene->mMeshes[a]; - AI_DEBUG_INVALIDATE_PTR(pScene->mMeshes[a]); - - meshMapping[a] = UINT_MAX; - continue; - } } + if (2 == result) { + // remove this mesh + delete pScene->mMeshes[a]; + AI_DEBUG_INVALIDATE_PTR(pScene->mMeshes[a]); + + meshMapping[a] = UINT_MAX; + continue; + } + pScene->mMeshes[real] = pScene->mMeshes[a]; meshMapping[a] = real++; } // Process animations - for (unsigned int animIdx = 0; animIdx < pScene->mNumAnimations; ++animIdx) { - ProcessAnimation(pScene->mAnimations[animIdx]); + for (unsigned int animIdx = 0; animIdx < pScene->mNumAnimations; ++animIdx) { + ProcessAnimation(pScene->mAnimations[animIdx]); } - - if (out) { - if ( real != pScene->mNumMeshes) { + if (out) { + if (real != pScene->mNumMeshes) { if (!real) { throw DeadlyImportError("No meshes remaining"); } @@ -154,7 +148,7 @@ void FindInvalidDataProcess::Execute( aiScene* pScene) { // we need to remove some meshes. // therefore we'll also need to remove all references // to them from the scenegraph - UpdateMeshReferences(pScene->mRootNode,meshMapping); + UpdateMeshReferences(pScene->mRootNode, meshMapping); pScene->mNumMeshes = real; } @@ -166,35 +160,32 @@ void FindInvalidDataProcess::Execute( aiScene* pScene) { // ------------------------------------------------------------------------------------------------ template -inline -const char* ValidateArrayContents(const T* /*arr*/, unsigned int /*size*/, - const std::vector& /*dirtyMask*/, bool /*mayBeIdentical = false*/, bool /*mayBeZero = true*/) -{ +inline const char *ValidateArrayContents(const T * /*arr*/, unsigned int /*size*/, + const std::vector & /*dirtyMask*/, bool /*mayBeIdentical = false*/, bool /*mayBeZero = true*/) { return nullptr; } // ------------------------------------------------------------------------------------------------ template <> -inline -const char* ValidateArrayContents(const aiVector3D* arr, unsigned int size, - const std::vector& dirtyMask, bool mayBeIdentical , bool mayBeZero ) { +inline const char *ValidateArrayContents(const aiVector3D *arr, unsigned int size, + const std::vector &dirtyMask, bool mayBeIdentical, bool mayBeZero) { bool b = false; unsigned int cnt = 0; - for (unsigned int i = 0; i < size;++i) { + for (unsigned int i = 0; i < size; ++i) { if (dirtyMask.size() && dirtyMask[i]) { continue; } ++cnt; - const aiVector3D& v = arr[i]; - if (is_special_float(v.x) || is_special_float(v.y) || is_special_float(v.z)) { + const aiVector3D &v = arr[i]; + if (is_special_float(v.x) || is_special_float(v.y) || is_special_float(v.z)) { return "INF/NAN was found in a vector component"; } - if (!mayBeZero && !v.x && !v.y && !v.z ) { + if (!mayBeZero && !v.x && !v.y && !v.z) { return "Found zero-length vector"; } - if (i && v != arr[i-1])b = true; + if (i && v != arr[i - 1]) b = true; } if (cnt > 1 && !b && !mayBeIdentical) { return "All vectors are identical"; @@ -204,12 +195,11 @@ const char* ValidateArrayContents(const aiVector3D* arr, unsigned in // ------------------------------------------------------------------------------------------------ template -inline -bool ProcessArray(T*& in, unsigned int num,const char* name, - const std::vector& 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); +inline bool ProcessArray(T *&in, unsigned int num, const char *name, + const std::vector &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); delete[] in; in = NULL; return true; @@ -219,49 +209,46 @@ bool ProcessArray(T*& in, unsigned int num,const char* name, // ------------------------------------------------------------------------------------------------ template -AI_FORCE_INLINE bool EpsilonCompare(const T& n, const T& s, ai_real epsilon); +AI_FORCE_INLINE bool EpsilonCompare(const T &n, const T &s, ai_real epsilon); // ------------------------------------------------------------------------------------------------ AI_FORCE_INLINE bool EpsilonCompare(ai_real n, ai_real s, ai_real epsilon) { - return std::fabs(n-s)>epsilon; + return std::fabs(n - s) > epsilon; } // ------------------------------------------------------------------------------------------------ template <> -bool EpsilonCompare(const aiVectorKey& n, const aiVectorKey& s, ai_real epsilon) { - return - EpsilonCompare(n.mValue.x,s.mValue.x,epsilon) && - EpsilonCompare(n.mValue.y,s.mValue.y,epsilon) && - EpsilonCompare(n.mValue.z,s.mValue.z,epsilon); +bool EpsilonCompare(const aiVectorKey &n, const aiVectorKey &s, ai_real epsilon) { + return EpsilonCompare(n.mValue.x, s.mValue.x, epsilon) && + EpsilonCompare(n.mValue.y, s.mValue.y, epsilon) && + EpsilonCompare(n.mValue.z, s.mValue.z, epsilon); } // ------------------------------------------------------------------------------------------------ template <> -bool EpsilonCompare(const aiQuatKey& n, const aiQuatKey& s, ai_real epsilon) { - return - EpsilonCompare(n.mValue.x,s.mValue.x,epsilon) && - EpsilonCompare(n.mValue.y,s.mValue.y,epsilon) && - EpsilonCompare(n.mValue.z,s.mValue.z,epsilon) && - EpsilonCompare(n.mValue.w,s.mValue.w,epsilon); +bool EpsilonCompare(const aiQuatKey &n, const aiQuatKey &s, ai_real epsilon) { + return EpsilonCompare(n.mValue.x, s.mValue.x, epsilon) && + EpsilonCompare(n.mValue.y, s.mValue.y, epsilon) && + EpsilonCompare(n.mValue.z, s.mValue.z, epsilon) && + EpsilonCompare(n.mValue.w, s.mValue.w, epsilon); } // ------------------------------------------------------------------------------------------------ template -inline -bool AllIdentical(T* in, unsigned int num, ai_real epsilon) { +inline bool AllIdentical(T *in, unsigned int num, ai_real epsilon) { if (num <= 1) { return true; } if (fabs(epsilon) > 0.f) { - for (unsigned int i = 0; i < num-1;++i) { - if (!EpsilonCompare(in[i],in[i+1],epsilon)) { + for (unsigned int i = 0; i < num - 1; ++i) { + if (!EpsilonCompare(in[i], in[i + 1], epsilon)) { return false; } } } else { - for (unsigned int i = 0; i < num-1;++i) { - if (in[i] != in[i+1]) { + for (unsigned int i = 0; i < num - 1; ++i) { + if (in[i] != in[i + 1]) { return false; } } @@ -271,16 +258,16 @@ 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 ) { - ProcessAnimationChannel( anim->mChannels[a]); + for (unsigned int a = 0; a < anim->mNumChannels; ++a) { + ProcessAnimationChannel(anim->mChannels[a]); } } // ------------------------------------------------------------------------------------------------ -void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim) { - ai_assert( nullptr != anim ); +void FindInvalidDataProcess::ProcessAnimationChannel(aiNodeAnim *anim) { + ai_assert(nullptr != anim); if (anim->mNumPositionKeys == 0 && anim->mNumRotationKeys == 0 && anim->mNumScalingKeys == 0) { ai_assert_entry(); return; @@ -290,7 +277,7 @@ void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim) { // we can remove al keys except one. // POSITIONS int i = 0; - if (anim->mNumPositionKeys > 1 && AllIdentical(anim->mPositionKeys,anim->mNumPositionKeys,configEpsilon)) { + 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 @@ -301,7 +288,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 @@ -312,7 +299,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 @@ -321,22 +308,21 @@ 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"); } } // ------------------------------------------------------------------------------------------------ // Search a mesh for invalid contents -int FindInvalidDataProcess::ProcessMesh(aiMesh* pMesh) -{ +int FindInvalidDataProcess::ProcessMesh(aiMesh *pMesh) { bool ret = false; std::vector dirtyMask(pMesh->mNumVertices, pMesh->mNumFaces != 0); // Ignore elements that are not referenced by vertices. // (they are, for example, caused by the FindDegenerates step) for (unsigned int m = 0; m < pMesh->mNumFaces; ++m) { - const aiFace& f = pMesh->mFaces[m]; + const aiFace &f = pMesh->mFaces[m]; for (unsigned int i = 0; i < f.mNumIndices; ++i) { dirtyMask[f.mIndices[i]] = false; @@ -372,19 +358,17 @@ int FindInvalidDataProcess::ProcessMesh(aiMesh* pMesh) // they are invalid or not. // Normals and tangents are undefined for point and line faces. - if (pMesh->mNormals || pMesh->mTangents) { + if (pMesh->mNormals || pMesh->mTangents) { if (aiPrimitiveType_POINT & pMesh->mPrimitiveTypes || - aiPrimitiveType_LINE & pMesh->mPrimitiveTypes) - { + aiPrimitiveType_LINE & pMesh->mPrimitiveTypes) { if (aiPrimitiveType_TRIANGLE & pMesh->mPrimitiveTypes || - aiPrimitiveType_POLYGON & pMesh->mPrimitiveTypes) - { + 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) { + if (f.mNumIndices < 3) { dirtyMask[f.mIndices[0]] = true; if (f.mNumIndices == 2) { dirtyMask[f.mIndices[1]] = true; @@ -400,19 +384,21 @@ int FindInvalidDataProcess::ProcessMesh(aiMesh* pMesh) } // Process mesh normals - if (pMesh->mNormals && ProcessArray(pMesh->mNormals,pMesh->mNumVertices, - "normals",dirtyMask,true,false)) + if (pMesh->mNormals && ProcessArray(pMesh->mNormals, pMesh->mNumVertices, + "normals", dirtyMask, true, false)) ret = true; // Process mesh tangents - if (pMesh->mTangents && ProcessArray(pMesh->mTangents,pMesh->mNumVertices,"tangents",dirtyMask)) { - delete[] pMesh->mBitangents; pMesh->mBitangents = NULL; + if (pMesh->mTangents && ProcessArray(pMesh->mTangents, pMesh->mNumVertices, "tangents", dirtyMask)) { + delete[] pMesh->mBitangents; + pMesh->mBitangents = NULL; ret = true; } // Process mesh bitangents - if (pMesh->mBitangents && ProcessArray(pMesh->mBitangents,pMesh->mNumVertices,"bitangents",dirtyMask)) { - delete[] pMesh->mTangents; pMesh->mTangents = NULL; + if (pMesh->mBitangents && ProcessArray(pMesh->mBitangents, pMesh->mNumVertices, "bitangents", dirtyMask)) { + delete[] pMesh->mTangents; + pMesh->mTangents = NULL; ret = true; } } diff --git a/code/PostProcessing/FindInvalidDataProcess.h b/code/PostProcessing/FindInvalidDataProcess.h index 50a2fe04c..d03778b28 100644 --- a/code/PostProcessing/FindInvalidDataProcess.h +++ b/code/PostProcessing/FindInvalidDataProcess.h @@ -4,7 +4,6 @@ Open Asset Import Library (assimp) Copyright (c) 2006-2020, assimp team - All rights reserved. Redistribution and use of this software in source and binary forms, @@ -48,14 +47,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "Common/BaseProcess.h" -#include #include +#include struct aiMesh; class FindInvalidDataProcessTest; -namespace Assimp { +namespace Assimp { // --------------------------------------------------------------------------- /** The FindInvalidData post-processing step. It searches the mesh data @@ -70,31 +69,31 @@ public: // ------------------------------------------------------------------- // - bool IsActive( unsigned int pFlags) const; + bool IsActive(unsigned int pFlags) const; // ------------------------------------------------------------------- // Setup import settings - void SetupProperties(const Importer* pImp); + void SetupProperties(const Importer *pImp); // ------------------------------------------------------------------- // Run the step - void Execute( aiScene* pScene); + void Execute(aiScene *pScene); // ------------------------------------------------------------------- /** Executes the post-processing step on the given mesh * @param pMesh The mesh to process. * @return 0 - nothing, 1 - removed sth, 2 - please delete me */ - int ProcessMesh( aiMesh* pMesh); + int ProcessMesh(aiMesh *pMesh); // ------------------------------------------------------------------- /** Executes the post-processing step on the given animation * @param anim The animation to process. */ - void ProcessAnimation (aiAnimation* anim); + void ProcessAnimation(aiAnimation *anim); // ------------------------------------------------------------------- /** Executes the post-processing step on the given anim channel * @param anim The animation channel to process.*/ - void ProcessAnimationChannel (aiNodeAnim* anim); + void ProcessAnimationChannel(aiNodeAnim *anim); private: ai_real configEpsilon; diff --git a/include/assimp/types.h b/include/assimp/types.h index c0b490814..f43520fe3 100644 --- a/include/assimp/types.h +++ b/include/assimp/types.h @@ -44,44 +44,44 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #pragma once #ifndef AI_TYPES_H_INC -#define AI_TYPES_H_INC +# define AI_TYPES_H_INC -#ifdef __GNUC__ -# pragma GCC system_header -#endif +# ifdef __GNUC__ +# pragma GCC system_header +# endif // Some runtime headers -#include -#include -#include -#include -#include +# include +# include +# include +# include +# include // Our compile configuration -#include +# include // Some types moved to separate header due to size of operators -#include -#include -#include -#include -#include -#include +# include +# include +# include +# include +# include +# include -typedef int32_t ai_int32; +typedef int32_t ai_int32; typedef uint32_t ai_uint32; -#ifdef __cplusplus +# ifdef __cplusplus -#include -#include // for std::nothrow_t -#include // for aiString::Set(const std::string&) +# include +# include // for std::nothrow_t +# include // for aiString::Set(const std::string&) -namespace Assimp { +namespace Assimp { //! @cond never -namespace Intern { - // -------------------------------------------------------------------- - /** @brief Internal helper class to utilize our internal new/delete +namespace Intern { +// -------------------------------------------------------------------- +/** @brief Internal helper class to utilize our internal new/delete * routines for allocating object of this and derived classes. * * By doing this you can safely share class objects between Assimp @@ -92,66 +92,68 @@ namespace Intern { * If it lies on a different heap than Assimp is working with, * the application is determined to crash. */ - // -------------------------------------------------------------------- -#ifndef SWIG - struct ASSIMP_API AllocateFromAssimpHeap { - // http://www.gotw.ca/publications/mill15.htm +// -------------------------------------------------------------------- +# ifndef SWIG +struct ASSIMP_API AllocateFromAssimpHeap { + // http://www.gotw.ca/publications/mill15.htm - // new/delete overload - void *operator new ( size_t num_bytes) /* throw( std::bad_alloc ) */; - void *operator new ( size_t num_bytes, const std::nothrow_t& ) throw(); - void operator delete ( void* data); + // new/delete overload + void *operator new(size_t num_bytes) /* throw( std::bad_alloc ) */; + void *operator new(size_t num_bytes, const std::nothrow_t &) throw(); + void operator delete(void *data); - // array new/delete overload - void *operator new[] ( size_t num_bytes) /* throw( std::bad_alloc ) */; - void *operator new[] ( size_t num_bytes, const std::nothrow_t& ) throw(); - void operator delete[] ( void* data); + // array new/delete overload + void *operator new[](size_t num_bytes) /* throw( std::bad_alloc ) */; + void *operator new[](size_t num_bytes, const std::nothrow_t &) throw(); + void operator delete[](void *data); - }; // struct AllocateFromAssimpHeap -#endif +}; // struct AllocateFromAssimpHeap +# endif } // namespace Intern - //! @endcond +//! @endcond } // namespace Assimp extern "C" { -#endif +# endif /** Maximum dimension for strings, ASSIMP strings are zero terminated. */ -#ifdef __cplusplus - static const size_t MAXLEN = 1024; -#else -# define MAXLEN 1024 -#endif +# ifdef __cplusplus +static const size_t MAXLEN = 1024; +# else +# define MAXLEN 1024 +# endif // ---------------------------------------------------------------------------------- /** Represents a plane in a three-dimensional, euclidean space */ struct aiPlane { -#ifdef __cplusplus - aiPlane () AI_NO_EXCEPT : a(0.f), b(0.f), c(0.f), d(0.f) {} - aiPlane (ai_real _a, ai_real _b, ai_real _c, ai_real _d) - : a(_a), b(_b), c(_c), d(_d) {} +# ifdef __cplusplus + aiPlane() AI_NO_EXCEPT : a(0.f), b(0.f), c(0.f), d(0.f) {} + aiPlane(ai_real _a, ai_real _b, ai_real _c, ai_real _d) : + a(_a), b(_b), c(_c), d(_d) {} - aiPlane (const aiPlane& o) : a(o.a), b(o.b), c(o.c), d(o.d) {} + aiPlane(const aiPlane &o) : + a(o.a), b(o.b), c(o.c), d(o.d) {} -#endif // !__cplusplus +# endif // !__cplusplus //! Plane equation - ai_real a,b,c,d; + ai_real a, b, c, d; }; // !struct aiPlane // ---------------------------------------------------------------------------------- /** Represents a ray */ struct aiRay { -#ifdef __cplusplus - aiRay () AI_NO_EXCEPT {} - aiRay (const aiVector3D& _pos, const aiVector3D& _dir) - : pos(_pos), dir(_dir) {} +# ifdef __cplusplus + aiRay() AI_NO_EXCEPT {} + aiRay(const aiVector3D &_pos, const aiVector3D &_dir) : + pos(_pos), dir(_dir) {} - aiRay (const aiRay& o) : pos (o.pos), dir (o.dir) {} + aiRay(const aiRay &o) : + pos(o.pos), dir(o.dir) {} -#endif // !__cplusplus +# endif // !__cplusplus //! Position and direction of the ray C_STRUCT aiVector3D pos, dir; @@ -160,55 +162,55 @@ struct aiRay { // ---------------------------------------------------------------------------------- /** Represents a color in Red-Green-Blue space. */ -struct aiColor3D -{ -#ifdef __cplusplus - aiColor3D () AI_NO_EXCEPT : r(0.0f), g(0.0f), b(0.0f) {} - aiColor3D (ai_real _r, ai_real _g, ai_real _b) : r(_r), g(_g), b(_b) {} - explicit aiColor3D (ai_real _r) : r(_r), g(_r), b(_r) {} - aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {} +struct aiColor3D { +# ifdef __cplusplus + aiColor3D() AI_NO_EXCEPT : r(0.0f), g(0.0f), b(0.0f) {} + aiColor3D(ai_real _r, ai_real _g, ai_real _b) : + r(_r), g(_g), b(_b) {} + explicit aiColor3D(ai_real _r) : + r(_r), g(_r), b(_r) {} + aiColor3D(const aiColor3D &o) : + r(o.r), g(o.g), b(o.b) {} - aiColor3D &operator=(const aiColor3D &o) { - r = o.r; - g = o.g; - b = o.b; - return *this; - } - - /** Component-wise comparison */ - // TODO: add epsilon? - bool operator == (const aiColor3D& other) const - {return r == other.r && g == other.g && b == other.b;} - - /** Component-wise inverse comparison */ - // TODO: add epsilon? - bool operator != (const aiColor3D& other) const - {return r != other.r || g != other.g || b != other.b;} + aiColor3D &operator=(const aiColor3D &o) { + r = o.r; + g = o.g; + b = o.b; + return *this; + } /** Component-wise comparison */ // TODO: add epsilon? - bool operator < (const aiColor3D& other) const { - return r < other.r || ( r == other.r && (g < other.g || (g == other.g && b < other.b ) ) ); + bool operator==(const aiColor3D &other) const { return r == other.r && g == other.g && b == other.b; } + + /** Component-wise inverse comparison */ + // TODO: add epsilon? + bool operator!=(const aiColor3D &other) const { return r != other.r || g != other.g || b != other.b; } + + /** Component-wise comparison */ + // TODO: add epsilon? + bool operator<(const aiColor3D &other) const { + return r < other.r || (r == other.r && (g < other.g || (g == other.g && b < other.b))); } /** Component-wise addition */ - aiColor3D operator+(const aiColor3D& c) const { - return aiColor3D(r+c.r,g+c.g,b+c.b); + aiColor3D operator+(const aiColor3D &c) const { + return aiColor3D(r + c.r, g + c.g, b + c.b); } /** Component-wise subtraction */ - aiColor3D operator-(const aiColor3D& c) const { - return aiColor3D(r-c.r,g-c.g,b-c.b); + aiColor3D operator-(const aiColor3D &c) const { + return aiColor3D(r - c.r, g - c.g, b - c.b); } /** Component-wise multiplication */ - aiColor3D operator*(const aiColor3D& c) const { - return aiColor3D(r*c.r,g*c.g,b*c.b); + aiColor3D operator*(const aiColor3D &c) const { + return aiColor3D(r * c.r, g * c.g, b * c.b); } /** Multiply with a scalar */ aiColor3D operator*(ai_real f) const { - return aiColor3D(r*f,g*f,b*f); + return aiColor3D(r * f, g * f, b * f); } /** Access a specific color component */ @@ -217,12 +219,12 @@ struct aiColor3D } /** Access a specific color component */ - ai_real& operator[](unsigned int i) { - if ( 0 == i ) { + ai_real &operator[](unsigned int i) { + if (0 == i) { return r; - } else if ( 1 == i ) { + } else if (1 == i) { return g; - } else if ( 2 == i ) { + } else if (2 == i) { return b; } return r; @@ -231,14 +233,14 @@ struct aiColor3D /** Check whether a color is black */ bool IsBlack() const { static const ai_real epsilon = ai_real(10e-3); - return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon; + return std::fabs(r) < epsilon && std::fabs(g) < epsilon && std::fabs(b) < epsilon; } -#endif // !__cplusplus +# endif // !__cplusplus //! Red, green and blue color values ai_real r, g, b; -}; // !struct aiColor3D +}; // !struct aiColor3D // ---------------------------------------------------------------------------------- /** Represents an UTF-8 string, zero byte terminated. @@ -261,99 +263,95 @@ struct aiColor3D * (binary) length of such a string is limited to MAXLEN characters (including the * the terminating zero). */ -struct aiString -{ -#ifdef __cplusplus +struct aiString { +# ifdef __cplusplus /** Default constructor, the string is set to have zero length */ aiString() AI_NO_EXCEPT - : length( 0 ) { + : length(0) { data[0] = '\0'; -#ifdef ASSIMP_BUILD_DEBUG +# ifdef ASSIMP_BUILD_DEBUG // Debug build: overwrite the string on its full length with ESC (27) - memset(data+1,27,MAXLEN-1); -#endif + memset(data + 1, 27, MAXLEN - 1); +# endif } /** Copy constructor */ - aiString(const aiString& rOther) - : length(rOther.length) - { + aiString(const aiString &rOther) : + length(rOther.length) { // Crop the string to the maximum length - length = length>=MAXLEN?MAXLEN-1:length; - memcpy( data, rOther.data, length); + length = length >= MAXLEN ? MAXLEN - 1 : length; + memcpy(data, rOther.data, length); data[length] = '\0'; } /** Constructor from std::string */ - explicit aiString(const std::string& pString) : - length( (ai_uint32) pString.length()) - { - length = length>=MAXLEN?MAXLEN-1:length; - memcpy( data, pString.c_str(), length); + explicit aiString(const std::string &pString) : + length((ai_uint32)pString.length()) { + length = length >= MAXLEN ? MAXLEN - 1 : length; + memcpy(data, pString.c_str(), length); data[length] = '\0'; } /** Copy a std::string to the aiString */ - void Set( const std::string& pString) { - if( pString.length() > MAXLEN - 1) { + void Set(const std::string &pString) { + if (pString.length() > MAXLEN - 1) { return; } length = (ai_uint32)pString.length(); - memcpy( data, pString.c_str(), length); + memcpy(data, pString.c_str(), length); data[length] = 0; } /** Copy a const char* to the aiString */ - void Set( const char* sz) { - const ai_int32 len = (ai_uint32) ::strlen(sz); - if( len > (ai_int32)MAXLEN - 1) { + void Set(const char *sz) { + const ai_int32 len = (ai_uint32)::strlen(sz); + if (len > (ai_int32)MAXLEN - 1) { return; } length = len; - memcpy( data, sz, len); + memcpy(data, sz, len); data[len] = 0; } - /** Assignment operator */ - aiString& operator = (const aiString &rOther) { + aiString &operator=(const aiString &rOther) { if (this == &rOther) { return *this; } - length = rOther.length;; - memcpy( data, rOther.data, length); + length = rOther.length; + ; + memcpy(data, rOther.data, length); data[length] = '\0'; return *this; } - /** Assign a const char* to the string */ - aiString& operator = (const char* sz) { + aiString &operator=(const char *sz) { Set(sz); return *this; } /** Assign a cstd::string to the string */ - aiString& operator = ( const std::string& pString) { + aiString &operator=(const std::string &pString) { Set(pString); return *this; } /** Comparison operator */ - bool operator==(const aiString& other) const { - return (length == other.length && 0 == memcmp(data,other.data,length)); + bool operator==(const aiString &other) const { + return (length == other.length && 0 == memcmp(data, other.data, length)); } /** Inverse comparison operator */ - bool operator!=(const aiString& other) const { - return (length != other.length || 0 != memcmp(data,other.data,length)); + bool operator!=(const aiString &other) const { + return (length != other.length || 0 != memcmp(data, other.data, length)); } /** Append a string to the string */ - void Append (const char* app) { - const ai_uint32 len = (ai_uint32) ::strlen(app); + void Append(const char *app) { + const ai_uint32 len = (ai_uint32)::strlen(app); if (!len) { return; } @@ -361,27 +359,27 @@ struct aiString return; } - memcpy(&data[length],app,len+1); + memcpy(&data[length], app, len + 1); length += len; } /** Clear the string - reset its length to zero */ - void Clear () { - length = 0; + void Clear() { + length = 0; data[0] = '\0'; -#ifdef ASSIMP_BUILD_DEBUG +# ifdef ASSIMP_BUILD_DEBUG // Debug build: overwrite the string on its full length with ESC (27) - memset(data+1,27,MAXLEN-1); -#endif + memset(data + 1, 27, MAXLEN - 1); +# endif } /** Returns a pointer to the underlying zero-terminated array of characters */ - const char* C_Str() const { + const char *C_Str() const { return data; } -#endif // !__cplusplus +# endif // !__cplusplus /** Binary length of the string excluding the terminal 0. This is NOT the * logical length of strings containing UTF-8 multi-byte sequences! It's @@ -390,15 +388,13 @@ struct aiString /** String buffer. Size limit is MAXLEN */ char data[MAXLEN]; -} ; // !struct aiString - +}; // !struct aiString // ---------------------------------------------------------------------------------- /** Standard return type for some library functions. * Rarely used, and if, mostly in the C API. */ -typedef enum aiReturn -{ +typedef enum aiReturn { /** Indicates that a function was successful */ aiReturn_SUCCESS = 0x0, @@ -416,19 +412,18 @@ typedef enum aiReturn _AI_ENFORCE_ENUM_SIZE = 0x7fffffff /// @endcond -} aiReturn; // !enum aiReturn +} aiReturn; // !enum aiReturn // just for backwards compatibility, don't use these constants anymore -#define AI_SUCCESS aiReturn_SUCCESS -#define AI_FAILURE aiReturn_FAILURE -#define AI_OUTOFMEMORY aiReturn_OUTOFMEMORY +# define AI_SUCCESS aiReturn_SUCCESS +# define AI_FAILURE aiReturn_FAILURE +# define AI_OUTOFMEMORY aiReturn_OUTOFMEMORY // ---------------------------------------------------------------------------------- /** Seek origins (for the virtual file system API). * Much cooler than using SEEK_SET, SEEK_CUR or SEEK_END. */ -enum aiOrigin -{ +enum aiOrigin { /** Beginning of the file */ aiOrigin_SET = 0x0, @@ -451,8 +446,7 @@ enum aiOrigin * Logging to these streams can be enabled with a single call to * #LogStream::createDefaultStream. */ -enum aiDefaultLogStream -{ +enum aiDefaultLogStream { /** Stream the log to a file */ aiDefaultLogStream_FILE = 0x1, @@ -475,33 +469,31 @@ enum aiDefaultLogStream }; // !enum aiDefaultLogStream // just for backwards compatibility, don't use these constants anymore -#define DLS_FILE aiDefaultLogStream_FILE -#define DLS_STDOUT aiDefaultLogStream_STDOUT -#define DLS_STDERR aiDefaultLogStream_STDERR -#define DLS_DEBUGGER aiDefaultLogStream_DEBUGGER +# define DLS_FILE aiDefaultLogStream_FILE +# define DLS_STDOUT aiDefaultLogStream_STDOUT +# define DLS_STDERR aiDefaultLogStream_STDERR +# define DLS_DEBUGGER aiDefaultLogStream_DEBUGGER // ---------------------------------------------------------------------------------- /** Stores the memory requirements for different components (e.g. meshes, materials, * animations) of an import. All sizes are in bytes. * @see Importer::GetMemoryRequirements() */ -struct aiMemoryInfo -{ -#ifdef __cplusplus +struct aiMemoryInfo { +# ifdef __cplusplus /** Default constructor */ aiMemoryInfo() AI_NO_EXCEPT - : textures (0) - , materials (0) - , meshes (0) - , nodes (0) - , animations (0) - , cameras (0) - , lights (0) - , total (0) - {} + : textures(0), + materials(0), + meshes(0), + nodes(0), + animations(0), + cameras(0), + lights(0), + total(0) {} -#endif +# endif /** Storage allocated for texture data */ unsigned int textures; @@ -528,16 +520,16 @@ struct aiMemoryInfo unsigned int total; }; // !struct aiMemoryInfo -#ifdef __cplusplus +# ifdef __cplusplus } -#endif //! __cplusplus +# endif //! __cplusplus // Include implementation files -#include "vector2.inl" -#include "vector3.inl" -#include "color4.inl" -#include "quaternion.inl" -#include "matrix3x3.inl" -#include "matrix4x4.inl" +# include "color4.inl" +# include "matrix3x3.inl" +# include "matrix4x4.inl" +# include "quaternion.inl" +# include "vector2.inl" +# include "vector3.inl" #endif // AI_TYPES_H_INC