summaryrefslogtreecommitdiff
path: root/src/mesh/assimp-master/code/PostProcessing/FindInvalidDataProcess.cpp
diff options
context:
space:
mode:
authorsanine <sanine.not@pm.me>2022-03-04 10:47:15 -0600
committersanine <sanine.not@pm.me>2022-03-04 10:47:15 -0600
commit058f98a63658dc1a2579826ba167fd61bed1e21f (patch)
treebcba07a1615a14d943f3af3f815a42f3be86b2f3 /src/mesh/assimp-master/code/PostProcessing/FindInvalidDataProcess.cpp
parent2f8028ac9e0812cb6f3cbb08f0f419e4e717bd22 (diff)
add assimp submodule
Diffstat (limited to 'src/mesh/assimp-master/code/PostProcessing/FindInvalidDataProcess.cpp')
-rw-r--r--src/mesh/assimp-master/code/PostProcessing/FindInvalidDataProcess.cpp409
1 files changed, 409 insertions, 0 deletions
diff --git a/src/mesh/assimp-master/code/PostProcessing/FindInvalidDataProcess.cpp b/src/mesh/assimp-master/code/PostProcessing/FindInvalidDataProcess.cpp
new file mode 100644
index 0000000..b42cbe9
--- /dev/null
+++ b/src/mesh/assimp-master/code/PostProcessing/FindInvalidDataProcess.cpp
@@ -0,0 +1,409 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+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 <assimp/Exceptional.h>
+#include <assimp/qnan.h>
+
+using namespace Assimp;
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+FindInvalidDataProcess::FindInvalidDataProcess() :
+ configEpsilon(0.0), mIgnoreTexCoods(false) {
+ // nothing to do here
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+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 {
+ return 0 != (pFlags & aiProcess_FindInvalidData);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Setup import configuration
+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);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Update mesh references in the node graph
+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) {
+
+ unsigned int ref = node->mMeshes[a];
+ 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) {
+ delete[] node->mMeshes;
+ node->mMeshes = nullptr;
+ }
+ }
+ // recursively update all children
+ 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) {
+ ASSIMP_LOG_DEBUG("FindInvalidDataProcess begin");
+
+ bool out = false;
+ std::vector<unsigned int> meshMapping(pScene->mNumMeshes);
+ unsigned int real = 0;
+
+ // Process meshes
+ for (unsigned int a = 0; a < pScene->mNumMeshes; a++) {
+ int result = ProcessMesh(pScene->mMeshes[a]);
+ if (0 == result) {
+ out = true;
+ }
+ if (2 == result) {
+ // remove this mesh
+ delete pScene->mMeshes[a];
+ pScene->mMeshes[a] = nullptr;
+
+ meshMapping[a] = UINT_MAX;
+ out = true;
+ 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]);
+ }
+
+ if (out) {
+ if (real != pScene->mNumMeshes) {
+ if (!real) {
+ throw DeadlyImportError("No meshes remaining");
+ }
+
+ // we need to remove some meshes.
+ // therefore we'll also need to remove all references
+ // to them from the scenegraph
+ UpdateMeshReferences(pScene->mRootNode, meshMapping);
+ pScene->mNumMeshes = real;
+ }
+
+ ASSIMP_LOG_INFO("FindInvalidDataProcess finished. Found issues ...");
+ } else {
+ ASSIMP_LOG_DEBUG("FindInvalidDataProcess finished. Everything seems to be OK.");
+ }
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename T>
+inline const char *ValidateArrayContents(const T * /*arr*/, unsigned int /*size*/,
+ const std::vector<bool> & /*dirtyMask*/, bool /*mayBeIdentical = false*/, bool /*mayBeZero = true*/) {
+ return nullptr;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <>
+inline const char *ValidateArrayContents<aiVector3D>(const aiVector3D *arr, unsigned int size,
+ const std::vector<bool> &dirtyMask, bool mayBeIdentical, bool mayBeZero) {
+ bool b = false;
+ unsigned int cnt = 0;
+ 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)) {
+ return "INF/NAN was found in a vector component";
+ }
+ if (!mayBeZero && !v.x && !v.y && !v.z) {
+ return "Found zero-length vector";
+ }
+ if (i && v != arr[i - 1]) b = true;
+ }
+ if (cnt > 1 && !b && !mayBeIdentical) {
+ return "All vectors are identical";
+ }
+ 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) {
+ const char *err = ValidateArrayContents(in, num, dirtyMask, mayBeIdentical, mayBeZero);
+ if (err) {
+ ASSIMP_LOG_ERROR("FindInvalidDataProcess fails on mesh ", name, ": ", err);
+ delete[] in;
+ in = nullptr;
+ return true;
+ }
+ return false;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename T>
+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;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <>
+bool EpsilonCompare<aiVectorKey>(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<aiQuatKey>(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 <typename T>
+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)) {
+ return false;
+ }
+ }
+ } else {
+ for (unsigned int i = 0; i < num - 1; ++i) {
+ if (in[i] != in[i + 1]) {
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Search an animation for invalid content
+void FindInvalidDataProcess::ProcessAnimation(aiAnimation *anim) {
+ // Process all animation channels
+ for (unsigned int a = 0; a < anim->mNumChannels; ++a) {
+ ProcessAnimationChannel(anim->mChannels[a]);
+ }
+}
+
+// ------------------------------------------------------------------------------------------------
+void FindInvalidDataProcess::ProcessAnimationChannel(aiNodeAnim *anim) {
+ ai_assert(nullptr != anim);
+ if (anim->mNumPositionKeys == 0 && anim->mNumRotationKeys == 0 && anim->mNumScalingKeys == 0) {
+ ai_assert_entry();
+ return;
+ }
+
+ // Check whether all values in a tracks are identical - in this case
+ // we can remove al keys except one.
+ // POSITIONS
+ 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
+ delete[] anim->mPositionKeys;
+ anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys = 1];
+ anim->mPositionKeys[0] = v;
+ i = 1;
+ }
+
+ // ROTATIONS
+ 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
+ delete[] anim->mRotationKeys;
+ anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys = 1];
+ anim->mRotationKeys[0] = v;
+ i = 1;
+ }
+
+ // SCALINGS
+ 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
+ delete[] anim->mScalingKeys;
+ anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys = 1];
+ anim->mScalingKeys[0] = v;
+ i = 1;
+ }
+ if (1 == i) {
+ ASSIMP_LOG_WARN("Simplified dummy tracks with just one key");
+ }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Search a mesh for invalid contents
+int FindInvalidDataProcess::ProcessMesh(aiMesh *pMesh) {
+ bool ret = false;
+ std::vector<bool> 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];
+
+ for (unsigned int i = 0; i < f.mNumIndices; ++i) {
+ dirtyMask[f.mIndices[i]] = false;
+ }
+ }
+
+ // Process vertex positions
+ if (pMesh->mVertices && ProcessArray(pMesh->mVertices, pMesh->mNumVertices, "positions", dirtyMask)) {
+ ASSIMP_LOG_ERROR("Deleting mesh: Unable to continue without vertex positions");
+
+ return 2;
+ }
+
+ // process texture coordinates
+ 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;
+
+ // delete all subsequent texture coordinate sets.
+ for (unsigned int a = i + 1; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+ delete[] pMesh->mTextureCoords[a];
+ pMesh->mTextureCoords[a] = nullptr;
+ pMesh->mNumUVComponents[a] = 0;
+ }
+
+ ret = true;
+ }
+ }
+ }
+
+ // -- we don't validate vertex colors, it's difficult to say whether
+ // they are invalid or not.
+
+ // Normals and tangents are undefined for point and line faces.
+ if (pMesh->mNormals || pMesh->mTangents) {
+
+ if (aiPrimitiveType_POINT & pMesh->mPrimitiveTypes ||
+ aiPrimitiveType_LINE & pMesh->mPrimitiveTypes) {
+ if (aiPrimitiveType_TRIANGLE & 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];
+
+ if (f.mNumIndices < 3) {
+ dirtyMask[f.mIndices[0]] = true;
+ if (f.mNumIndices == 2) {
+ dirtyMask[f.mIndices[1]] = true;
+ }
+ }
+ }
+ }
+ // Normals, tangents and bitangents are undefined for
+ // the whole mesh (and should not even be there)
+ else {
+ return ret;
+ }
+ }
+
+ // Process mesh normals
+ 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 = nullptr;
+ ret = true;
+ }
+
+ // Process mesh bitangents
+ if (pMesh->mBitangents && ProcessArray(pMesh->mBitangents, pMesh->mNumVertices, "bitangents", dirtyMask)) {
+ delete[] pMesh->mTangents;
+ pMesh->mTangents = nullptr;
+ ret = true;
+ }
+ }
+ return ret ? 1 : 0;
+}
+
+#endif // !! ASSIMP_BUILD_NO_FINDINVALIDDATA_PROCESS