v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update FindInvalidDataProcess.cpp 

-Fix some review findings.
pull/2310/head
Kim Kulling 2019-01-28 10:50:36 +01:00 committed by GitHub
parent 4c2898c82b
commit b35331b92a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 33 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
code/FindInvalidDataProcess.cpp
View File

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