430 lines
15 KiB
C++
430 lines
15 KiB
C++
/*
|
|
---------------------------------------------------------------------------
|
|
Open Asset Import Library (assimp)
|
|
---------------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2017, 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 "Macros.h"
|
|
#include "Exceptional.h"
|
|
#include "qnan.h"
|
|
|
|
using namespace Assimp;
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Constructor to be privately used by Importer
|
|
FindInvalidDataProcess::FindInvalidDataProcess()
|
|
: configEpsilon(0.0)
|
|
{
|
|
// 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));
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// 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 ...
|
|
if(!(node->mNumMeshes = 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);
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Executes the post processing step on the given imported data.
|
|
void FindInvalidDataProcess::Execute( aiScene* pScene)
|
|
{
|
|
DefaultLogger::get()->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;
|
|
if ((result = ProcessMesh( pScene->mMeshes[a]))) {
|
|
out = true;
|
|
|
|
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 a = 0; a < pScene->mNumAnimations;++a) {
|
|
ProcessAnimation( pScene->mAnimations[a]);
|
|
}
|
|
|
|
|
|
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;
|
|
}
|
|
|
|
DefaultLogger::get()->info("FindInvalidDataProcess finished. Found issues ...");
|
|
}
|
|
else DefaultLogger::get()->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 NULL;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
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 NULL;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
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) {
|
|
DefaultLogger::get()->error(std::string("FindInvalidDataProcess fails on mesh ") + name + ": " + err);
|
|
|
|
delete[] in;
|
|
in = NULL;
|
|
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 (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)
|
|
{
|
|
int i = 0;
|
|
|
|
// 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
|
|
// we can remove al keys except one.
|
|
// POSITIONS
|
|
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)
|
|
DefaultLogger::get()->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)) {
|
|
DefaultLogger::get()->error("Deleting mesh: Unable to continue without vertex positions");
|
|
|
|
return 2;
|
|
}
|
|
|
|
// process texture coordinates
|
|
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] = NULL;
|
|
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 = NULL;
|
|
ret = true;
|
|
}
|
|
|
|
// Process mesh bitangents
|
|
if (pMesh->mBitangents && ProcessArray(pMesh->mBitangents,pMesh->mNumVertices,"bitangents",dirtyMask)) {
|
|
delete[] pMesh->mTangents; pMesh->mTangents = NULL;
|
|
ret = true;
|
|
}
|
|
}
|
|
return ret ? 1 : 0;
|
|
}
|
|
|
|
|
|
#endif // !! ASSIMP_BUILD_NO_FINDINVALIDDATA_PROCESS
|