259 lines
9.5 KiB
C++
259 lines
9.5 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 FindDegenerates.cpp
|
|
* @brief Implementation of the FindDegenerates post-process step.
|
|
*/
|
|
|
|
|
|
|
|
// internal headers
|
|
#include "ProcessHelper.h"
|
|
#include "FindDegenerates.h"
|
|
#include "Exceptional.h"
|
|
|
|
using namespace Assimp;
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Constructor to be privately used by Importer
|
|
FindDegeneratesProcess::FindDegeneratesProcess()
|
|
: mConfigRemoveDegenerates( false )
|
|
, mConfigCheckAreaOfTriangle( false ){
|
|
// empty
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Destructor, private as well
|
|
FindDegeneratesProcess::~FindDegeneratesProcess() {
|
|
// nothing to do here
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Returns whether the processing step is present in the given flag field.
|
|
bool FindDegeneratesProcess::IsActive( unsigned int pFlags) const {
|
|
return 0 != (pFlags & aiProcess_FindDegenerates);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Setup import configuration
|
|
void FindDegeneratesProcess::SetupProperties(const Importer* pImp) {
|
|
// Get the current value of AI_CONFIG_PP_FD_REMOVE
|
|
mConfigRemoveDegenerates = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_FD_REMOVE,0));
|
|
mConfigCheckAreaOfTriangle = ( 0 != pImp->GetPropertyInteger(AI_CONFIG_PP_FD_CHECKAREA) );
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Executes the post processing step on the given imported data.
|
|
void FindDegeneratesProcess::Execute( aiScene* pScene) {
|
|
DefaultLogger::get()->debug("FindDegeneratesProcess begin");
|
|
for (unsigned int i = 0; i < pScene->mNumMeshes;++i){
|
|
ExecuteOnMesh( pScene->mMeshes[ i ] );
|
|
}
|
|
DefaultLogger::get()->debug("FindDegeneratesProcess finished");
|
|
}
|
|
|
|
static ai_real heron( ai_real a, ai_real b, ai_real c ) {
|
|
ai_real s = (a + b + c) / 2;
|
|
ai_real area = pow((s * ( s - a ) * ( s - b ) * ( s - c ) ), (ai_real)0.5 );
|
|
return area;
|
|
}
|
|
|
|
static ai_real distance3D( const aiVector3D &vA, aiVector3D &vB ) {
|
|
const ai_real lx = ( vB.x - vA.x );
|
|
const ai_real ly = ( vB.y - vA.y );
|
|
const ai_real lz = ( vB.z - vA.z );
|
|
ai_real a = lx*lx + ly*ly + lz*lz;
|
|
ai_real d = pow( a, (ai_real)0.5 );
|
|
|
|
return d;
|
|
}
|
|
|
|
static ai_real calculateAreaOfTriangle( const aiFace& face, aiMesh* mesh ) {
|
|
ai_real area = 0;
|
|
|
|
aiVector3D vA( mesh->mVertices[ face.mIndices[ 0 ] ] );
|
|
aiVector3D vB( mesh->mVertices[ face.mIndices[ 1 ] ] );
|
|
aiVector3D vC( mesh->mVertices[ face.mIndices[ 2 ] ] );
|
|
|
|
ai_real a( distance3D( vA, vB ) );
|
|
ai_real b( distance3D( vB, vC ) );
|
|
ai_real c( distance3D( vC, vA ) );
|
|
area = heron( a, b, c );
|
|
|
|
return area;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Executes the post processing step on the given imported mesh
|
|
void FindDegeneratesProcess::ExecuteOnMesh( aiMesh* mesh) {
|
|
mesh->mPrimitiveTypes = 0;
|
|
|
|
std::vector<bool> remove_me;
|
|
if (mConfigRemoveDegenerates) {
|
|
remove_me.resize( mesh->mNumFaces, false );
|
|
}
|
|
|
|
unsigned int deg = 0, limit;
|
|
for ( unsigned int a = 0; a < mesh->mNumFaces; ++a ) {
|
|
aiFace& face = mesh->mFaces[a];
|
|
bool first = true;
|
|
|
|
// check whether the face contains degenerated entries
|
|
for (unsigned int i = 0; i < face.mNumIndices; ++i) {
|
|
// Polygons with more than 4 points are allowed to have double points, that is
|
|
// simulating polygons with holes just with concave polygons. However,
|
|
// double points may not come directly after another.
|
|
limit = face.mNumIndices;
|
|
if (face.mNumIndices > 4) {
|
|
limit = std::min( limit, i+2 );
|
|
}
|
|
|
|
for (unsigned int t = i+1; t < limit; ++t) {
|
|
if (mesh->mVertices[face.mIndices[ i ] ] == mesh->mVertices[ face.mIndices[ t ] ]) {
|
|
// we have found a matching vertex position
|
|
// remove the corresponding index from the array
|
|
--face.mNumIndices;
|
|
--limit;
|
|
for (unsigned int m = t; m < face.mNumIndices; ++m) {
|
|
face.mIndices[ m ] = face.mIndices[ m+1 ];
|
|
}
|
|
--t;
|
|
|
|
// NOTE: we set the removed vertex index to an unique value
|
|
// to make sure the developer gets notified when his
|
|
// application attemps to access this data.
|
|
face.mIndices[ face.mNumIndices ] = 0xdeadbeef;
|
|
|
|
if(first) {
|
|
++deg;
|
|
first = false;
|
|
}
|
|
|
|
if ( mConfigRemoveDegenerates ) {
|
|
remove_me[ a ] = true;
|
|
goto evil_jump_outside; // hrhrhrh ... yeah, this rocks baby!
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( mConfigCheckAreaOfTriangle ) {
|
|
if ( face.mNumIndices == 3 ) {
|
|
ai_real area = calculateAreaOfTriangle( face, mesh );
|
|
if ( area < 1e-6 ) {
|
|
if ( mConfigRemoveDegenerates ) {
|
|
remove_me[ a ] = true;
|
|
goto evil_jump_outside;
|
|
}
|
|
|
|
// todo: check for index which is corrupt.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// We need to update the primitive flags array of the mesh.
|
|
switch (face.mNumIndices)
|
|
{
|
|
case 1u:
|
|
mesh->mPrimitiveTypes |= aiPrimitiveType_POINT;
|
|
break;
|
|
case 2u:
|
|
mesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
|
|
break;
|
|
case 3u:
|
|
mesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
|
|
break;
|
|
default:
|
|
mesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
|
|
break;
|
|
};
|
|
evil_jump_outside:
|
|
continue;
|
|
}
|
|
|
|
// If AI_CONFIG_PP_FD_REMOVE is true, remove degenerated faces from the import
|
|
if (mConfigRemoveDegenerates && deg) {
|
|
unsigned int n = 0;
|
|
for (unsigned int a = 0; a < mesh->mNumFaces; ++a)
|
|
{
|
|
aiFace& face_src = mesh->mFaces[a];
|
|
if (!remove_me[a]) {
|
|
aiFace& face_dest = mesh->mFaces[n++];
|
|
|
|
// Do a manual copy, keep the index array
|
|
face_dest.mNumIndices = face_src.mNumIndices;
|
|
face_dest.mIndices = face_src.mIndices;
|
|
|
|
if (&face_src != &face_dest) {
|
|
// clear source
|
|
face_src.mNumIndices = 0;
|
|
face_src.mIndices = NULL;
|
|
}
|
|
}
|
|
else {
|
|
// Otherwise delete it if we don't need this face
|
|
delete[] face_src.mIndices;
|
|
face_src.mIndices = NULL;
|
|
face_src.mNumIndices = 0;
|
|
}
|
|
}
|
|
// Just leave the rest of the array unreferenced, we don't care for now
|
|
mesh->mNumFaces = n;
|
|
if (!mesh->mNumFaces) {
|
|
// WTF!?
|
|
// OK ... for completeness and because I'm not yet tired,
|
|
// let's write code that willl hopefully never be called
|
|
// (famous last words)
|
|
|
|
// OK ... bad idea.
|
|
throw DeadlyImportError("Mesh is empty after removal of degenerated primitives ... WTF!?");
|
|
}
|
|
}
|
|
|
|
if (deg && !DefaultLogger::isNullLogger())
|
|
{
|
|
char s[64];
|
|
ASSIMP_itoa10(s,deg);
|
|
DefaultLogger::get()->warn(std::string("Found ") + s + " degenerated primitives");
|
|
}
|
|
}
|