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

small changes 

- removed static definition
- use emplace_back instead of push_back
- changed the c++ deprecated headers
- removed some redundant std containers initialization in the destructor
- removed redundant .clear call for the std containers in the destructor
- added some const reference for some std container parameters
- other small changes in different places
pull/3042/head
iamAdrianIusca 2020-03-01 11:12:37 +02:00
parent 4e414eb4ef
commit aca6aaf35d
23 changed files with 99 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
code/Common/BaseImporter.cpp
View File

@ -60,6 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <memory> #include <memory>
#include <sstream> #include <sstream>
#include <cctype> #include <cctype>
#include <utility>
using namespace Assimp; using namespace Assimp;
@ -484,11 +485,11 @@ void BaseImporter::TextFileToBuffer(IOStream* stream,
namespace Assimp { namespace Assimp {
// Represents an import request // Represents an import request
struct LoadRequest { struct LoadRequest {
LoadRequest(const std::string& _file, unsigned int _flags,const BatchLoader::PropertyMap* _map, unsigned int _id) LoadRequest(std::string _file, unsigned int _flags,const BatchLoader::PropertyMap* _map, unsigned int _id)
: file(_file) : file(std::move(_file))
, flags(_flags) , flags(_flags)
, refCnt(1) , refCnt(1)
, scene(NULL) , scene(nullptr)
, loaded(false) , loaded(false)
, id(_id) { , id(_id) {
if ( _map ) { if ( _map ) {

6
code/Common/Importer.h
View File

@ -129,14 +129,8 @@ ImporterPimpl::ImporterPimpl() AI_NO_EXCEPT
, mIsDefaultHandler( false ) , mIsDefaultHandler( false )
, mProgressHandler( nullptr ) , mProgressHandler( nullptr )
, mIsDefaultProgressHandler( false ) , mIsDefaultProgressHandler( false )
, mImporter()
, mPostProcessingSteps() , mPostProcessingSteps()
, mScene( nullptr ) , mScene( nullptr )
, mErrorString()
, mIntProperties()
, mFloatProperties()
, mStringProperties()
, mMatrixProperties()
, bExtraVerbose( false ) , bExtraVerbose( false )
, mPPShared( nullptr ) { , mPPShared( nullptr ) {
// empty // empty

16
code/Common/SceneCombiner.cpp
View File

@ -503,7 +503,7 @@ void SceneCombiner::MergeScenes(aiScene** _dest, aiScene* master, std::vector<At
OffsetNodeMeshIndices(node,offset[n]); OffsetNodeMeshIndices(node,offset[n]);
} }
if (n) // src[0] is the master node if (n) // src[0] is the master node
nodes.push_back(NodeAttachmentInfo( node,srcList[n-1].attachToNode,n )); nodes.emplace_back( node,srcList[n-1].attachToNode,n );
// add name prefixes? // add name prefixes?
if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) { if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) {
@ -662,7 +662,7 @@ void SceneCombiner::MergeScenes(aiScene** _dest, aiScene* master, std::vector<At
// Build a list of unique bones // Build a list of unique bones
void SceneCombiner::BuildUniqueBoneList(std::list<BoneWithHash>& asBones, void SceneCombiner::BuildUniqueBoneList(std::list<BoneWithHash>& asBones,
std::vector<aiMesh*>::const_iterator it, std::vector<aiMesh*>::const_iterator it,
std::vector<aiMesh*>::const_iterator end) const std::vector<aiMesh*>::const_iterator& end)
{ {
unsigned int iOffset = 0; unsigned int iOffset = 0;
for (; it != end;++it) { for (; it != end;++it) {
@ -670,24 +670,24 @@ void SceneCombiner::BuildUniqueBoneList(std::list<BoneWithHash>& asBones,
aiBone* p = (*it)->mBones[l]; aiBone* p = (*it)->mBones[l];
uint32_t itml = SuperFastHash(p->mName.data,(unsigned int)p->mName.length); uint32_t itml = SuperFastHash(p->mName.data,(unsigned int)p->mName.length);
std::list<BoneWithHash>::iterator it2 = asBones.begin(); auto it2 = asBones.begin();
std::list<BoneWithHash>::iterator end2 = asBones.end(); auto end2 = asBones.end();
for (;it2 != end2;++it2) { for (;it2 != end2;++it2) {
if ((*it2).first == itml) { if ((*it2).first == itml) {
(*it2).pSrcBones.push_back(BoneSrcIndex(p,iOffset)); (*it2).pSrcBones.emplace_back(p,iOffset);
break; break;
} }
} }
if (end2 == it2) { if (end2 == it2) {
// need to begin a new bone entry // need to begin a new bone entry
asBones.push_back(BoneWithHash()); asBones.emplace_back();
BoneWithHash& btz = asBones.back(); BoneWithHash& btz = asBones.back();
// setup members // setup members
btz.first = itml; btz.first = itml;
btz.second = &p->mName; btz.second = &p->mName;
btz.pSrcBones.push_back(BoneSrcIndex(p,iOffset)); btz.pSrcBones.emplace_back(p,iOffset);
} }
} }
iOffset += (*it)->mNumVertices; iOffset += (*it)->mNumVertices;
@ -697,7 +697,7 @@ void SceneCombiner::BuildUniqueBoneList(std::list<BoneWithHash>& asBones,
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Merge a list of bones // Merge a list of bones
void SceneCombiner::MergeBones(aiMesh* out,std::vector<aiMesh*>::const_iterator it, void SceneCombiner::MergeBones(aiMesh* out,std::vector<aiMesh*>::const_iterator it,
std::vector<aiMesh*>::const_iterator end) const std::vector<aiMesh*>::const_iterator& end)
{ {
if ( nullptr == out || out->mNumBones == 0 ) { if ( nullptr == out || out->mNumBones == 0 ) {
return; return;

74
code/Common/SkeletonMeshBuilder.cpp
View File

@ -124,10 +124,10 @@ void SkeletonMeshBuilder::CreateGeometry( const aiNode* pNode)
mVertices.push_back( childpos); mVertices.push_back( childpos);
mVertices.push_back( -front * distanceToChild * (ai_real)0.1); mVertices.push_back( -front * distanceToChild * (ai_real)0.1);
mFaces.push_back( Face( localVertexStart + 0, localVertexStart + 1, localVertexStart + 2)); mFaces.emplace_back( localVertexStart + 0, localVertexStart + 1, localVertexStart + 2);
mFaces.push_back( Face( localVertexStart + 3, localVertexStart + 4, localVertexStart + 5)); mFaces.emplace_back( localVertexStart + 3, localVertexStart + 4, localVertexStart + 5);
mFaces.push_back( Face( localVertexStart + 6, localVertexStart + 7, localVertexStart + 8)); mFaces.emplace_back( localVertexStart + 6, localVertexStart + 7, localVertexStart + 8);
mFaces.push_back( Face( localVertexStart + 9, localVertexStart + 10, localVertexStart + 11)); mFaces.emplace_back( localVertexStart + 9, localVertexStart + 10, localVertexStart + 11);
} }
} }
else else
@ -136,40 +136,40 @@ void SkeletonMeshBuilder::CreateGeometry( const aiNode* pNode)
aiVector3D ownpos( pNode->mTransformation.a4, pNode->mTransformation.b4, pNode->mTransformation.c4); aiVector3D ownpos( pNode->mTransformation.a4, pNode->mTransformation.b4, pNode->mTransformation.c4);
ai_real sizeEstimate = ownpos.Length() * ai_real( 0.18 ); ai_real sizeEstimate = ownpos.Length() * ai_real( 0.18 );
mVertices.push_back( aiVector3D( -sizeEstimate, 0.0, 0.0)); mVertices.emplace_back( -sizeEstimate, 0.0, 0.0);
mVertices.push_back( aiVector3D( 0.0, sizeEstimate, 0.0)); mVertices.emplace_back( 0.0, sizeEstimate, 0.0);
mVertices.push_back( aiVector3D( 0.0, 0.0, -sizeEstimate)); mVertices.emplace_back( 0.0, 0.0, -sizeEstimate);
mVertices.push_back( aiVector3D( 0.0, sizeEstimate, 0.0)); mVertices.emplace_back( 0.0, sizeEstimate, 0.0);
mVertices.push_back( aiVector3D( sizeEstimate, 0.0, 0.0)); mVertices.emplace_back( sizeEstimate, 0.0, 0.0);
mVertices.push_back( aiVector3D( 0.0, 0.0, -sizeEstimate)); mVertices.emplace_back( 0.0, 0.0, -sizeEstimate);
mVertices.push_back( aiVector3D( sizeEstimate, 0.0, 0.0)); mVertices.emplace_back( sizeEstimate, 0.0, 0.0);
mVertices.push_back( aiVector3D( 0.0, -sizeEstimate, 0.0)); mVertices.emplace_back( 0.0, -sizeEstimate, 0.0);
mVertices.push_back( aiVector3D( 0.0, 0.0, -sizeEstimate)); mVertices.emplace_back( 0.0, 0.0, -sizeEstimate);
mVertices.push_back( aiVector3D( 0.0, -sizeEstimate, 0.0)); mVertices.emplace_back( 0.0, -sizeEstimate, 0.0);
mVertices.push_back( aiVector3D( -sizeEstimate, 0.0, 0.0)); mVertices.emplace_back( -sizeEstimate, 0.0, 0.0);
mVertices.push_back( aiVector3D( 0.0, 0.0, -sizeEstimate)); mVertices.emplace_back( 0.0, 0.0, -sizeEstimate);
mVertices.push_back( aiVector3D( -sizeEstimate, 0.0, 0.0)); mVertices.emplace_back( -sizeEstimate, 0.0, 0.0);
mVertices.push_back( aiVector3D( 0.0, 0.0, sizeEstimate)); mVertices.emplace_back( 0.0, 0.0, sizeEstimate);
mVertices.push_back( aiVector3D( 0.0, sizeEstimate, 0.0)); mVertices.emplace_back( 0.0, sizeEstimate, 0.0);
mVertices.push_back( aiVector3D( 0.0, sizeEstimate, 0.0)); mVertices.emplace_back( 0.0, sizeEstimate, 0.0);
mVertices.push_back( aiVector3D( 0.0, 0.0, sizeEstimate)); mVertices.emplace_back( 0.0, 0.0, sizeEstimate);
mVertices.push_back( aiVector3D( sizeEstimate, 0.0, 0.0)); mVertices.emplace_back( sizeEstimate, 0.0, 0.0);
mVertices.push_back( aiVector3D( sizeEstimate, 0.0, 0.0)); mVertices.emplace_back( sizeEstimate, 0.0, 0.0);
mVertices.push_back( aiVector3D( 0.0, 0.0, sizeEstimate)); mVertices.emplace_back( 0.0, 0.0, sizeEstimate);
mVertices.push_back( aiVector3D( 0.0, -sizeEstimate, 0.0)); mVertices.emplace_back( 0.0, -sizeEstimate, 0.0);
mVertices.push_back( aiVector3D( 0.0, -sizeEstimate, 0.0)); mVertices.emplace_back( 0.0, -sizeEstimate, 0.0);
mVertices.push_back( aiVector3D( 0.0, 0.0, sizeEstimate)); mVertices.emplace_back( 0.0, 0.0, sizeEstimate);
mVertices.push_back( aiVector3D( -sizeEstimate, 0.0, 0.0)); mVertices.emplace_back( -sizeEstimate, 0.0, 0.0);
mFaces.push_back( Face( vertexStartIndex + 0, vertexStartIndex + 1, vertexStartIndex + 2)); mFaces.emplace_back( vertexStartIndex + 0, vertexStartIndex + 1, vertexStartIndex + 2);
mFaces.push_back( Face( vertexStartIndex + 3, vertexStartIndex + 4, vertexStartIndex + 5)); mFaces.emplace_back( vertexStartIndex + 3, vertexStartIndex + 4, vertexStartIndex + 5);
mFaces.push_back( Face( vertexStartIndex + 6, vertexStartIndex + 7, vertexStartIndex + 8)); mFaces.emplace_back( vertexStartIndex + 6, vertexStartIndex + 7, vertexStartIndex + 8);
mFaces.push_back( Face( vertexStartIndex + 9, vertexStartIndex + 10, vertexStartIndex + 11)); mFaces.emplace_back( vertexStartIndex + 9, vertexStartIndex + 10, vertexStartIndex + 11);
mFaces.push_back( Face( vertexStartIndex + 12, vertexStartIndex + 13, vertexStartIndex + 14)); mFaces.emplace_back( vertexStartIndex + 12, vertexStartIndex + 13, vertexStartIndex + 14);
mFaces.push_back( Face( vertexStartIndex + 15, vertexStartIndex + 16, vertexStartIndex + 17)); mFaces.emplace_back( vertexStartIndex + 15, vertexStartIndex + 16, vertexStartIndex + 17);
mFaces.push_back( Face( vertexStartIndex + 18, vertexStartIndex + 19, vertexStartIndex + 20)); mFaces.emplace_back( vertexStartIndex + 18, vertexStartIndex + 19, vertexStartIndex + 20);
mFaces.push_back( Face( vertexStartIndex + 21, vertexStartIndex + 22, vertexStartIndex + 23)); mFaces.emplace_back( vertexStartIndex + 21, vertexStartIndex + 22, vertexStartIndex + 23);
} }
unsigned int numVertices = static_cast<unsigned int>(mVertices.size() - vertexStartIndex); unsigned int numVertices = static_cast<unsigned int>(mVertices.size() - vertexStartIndex);
@ -259,7 +259,7 @@ aiMaterial* SkeletonMeshBuilder::CreateMaterial()
aiMaterial* matHelper = new aiMaterial; aiMaterial* matHelper = new aiMaterial;
// Name // Name
aiString matName( std::string( "SkeletonMaterial")); aiString matName("SkeletonMaterial");
matHelper->AddProperty( &matName, AI_MATKEY_NAME); matHelper->AddProperty( &matName, AI_MATKEY_NAME);
// Prevent backface culling // Prevent backface culling

4
code/Common/SpatialSort.cpp
View File

@ -110,7 +110,7 @@ void SpatialSort::Append( const aiVector3D* pPositions, unsigned int pNumPositio
// store position by index and distance // store position by index and distance
ai_real distance = *vec * mPlaneNormal; ai_real distance = *vec * mPlaneNormal;
mPositions.push_back( Entry( static_cast<unsigned int>(a+initial), *vec, distance)); mPositions.emplace_back( static_cast<unsigned int>(a+initial), *vec, distance);
} }
if (pFinalize) { if (pFinalize) {
@ -131,7 +131,7 @@ void SpatialSort::FindPositions( const aiVector3D& pPosition,
poResults.clear(); poResults.clear();
// quick check for positions outside the range // quick check for positions outside the range
if( mPositions.size() == 0) if( mPositions.empty())
return; return;
if( maxDist < mPositions.front().mDistance) if( maxDist < mPositions.front().mDistance)
return; return;

4
code/Common/SplitByBoneCountProcess.cpp
View File

@ -74,7 +74,7 @@ SplitByBoneCountProcess::~SplitByBoneCountProcess()
// Returns whether the processing step is present in the given flag. // Returns whether the processing step is present in the given flag.
bool SplitByBoneCountProcess::IsActive( unsigned int pFlags) const bool SplitByBoneCountProcess::IsActive( unsigned int pFlags) const
{ {
return !!(pFlags & aiProcess_SplitByBoneCount); return (pFlags & aiProcess_SplitByBoneCount) != 0;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -165,7 +165,7 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
{ {
const aiBone* bone = pMesh->mBones[a]; const aiBone* bone = pMesh->mBones[a];
for( unsigned int b = 0; b < bone->mNumWeights; ++b) for( unsigned int b = 0; b < bone->mNumWeights; ++b)
vertexBones[ bone->mWeights[b].mVertexId ].push_back( BoneWeight( a, bone->mWeights[b].mWeight)); vertexBones[ bone->mWeights[b].mVertexId ].emplace_back( a, bone->mWeights[b].mWeight);
} }
unsigned int numFacesHandled = 0; unsigned int numFacesHandled = 0;

24
code/Common/StandardShapes.cpp
View File

@ -445,20 +445,19 @@ void StandardShapes::MakeCone(ai_real height,ai_real radius1,
if (!bOpen) if (!bOpen)
{ {
// generate the end 'cap' // generate the end 'cap'
positions.push_back(aiVector3D(s * radius2, halfHeight, t * radius2 )); positions.emplace_back(s * radius2, halfHeight, t * radius2 );
positions.push_back(aiVector3D(s2 * radius2, halfHeight, t2 * radius2 )); positions.emplace_back(s2 * radius2, halfHeight, t2 * radius2 );
positions.push_back(aiVector3D(0.0, halfHeight, 0.0)); positions.emplace_back(0.0, halfHeight, 0.0);
if (radius1) if (radius1)
{ {
// generate the other end 'cap' // generate the other end 'cap'
positions.push_back(aiVector3D(s * radius1, -halfHeight, t * radius1 )); positions.emplace_back(s * radius1, -halfHeight, t * radius1 );
positions.push_back(aiVector3D(s2 * radius1, -halfHeight, t2 * radius1 )); positions.emplace_back(s2 * radius1, -halfHeight, t2 * radius1 );
positions.push_back(aiVector3D(0.0, -halfHeight, 0.0)); positions.emplace_back(0.0, -halfHeight, 0.0);
}
}
}
}
s = s2; s = s2;
t = t2; t = t2;
angle = next; angle = next;
@ -494,13 +493,14 @@ void StandardShapes::MakeCircle(ai_real radius, unsigned int tess,
for (ai_real angle = 0.0; angle < angle_max; ) for (ai_real angle = 0.0; angle < angle_max; )
{ {
positions.push_back(aiVector3D(s * radius,0.0,t * radius)); positions.emplace_back(s * radius,0.0,t * radius);
angle += angle_delta; angle += angle_delta;
s = std::cos(angle); s = std::cos(angle);
t = std::sin(angle); t = std::sin(angle);
positions.push_back(aiVector3D(s * radius,0.0,t * radius));
positions.push_back(aiVector3D(0.0,0.0,0.0)); positions.emplace_back(s * radius,0.0,t * radius);
positions.emplace_back(0.0,0.0,0.0);
} }
} }

2
code/Common/TargetAnimation.cpp
View File

@ -242,7 +242,7 @@ void TargetAnimationHelper::Process(std::vector<aiVectorKey>* distanceTrack)
// diff is now the vector in which our camera is pointing // diff is now the vector in which our camera is pointing
} }
if (real.size()) { if (!real.empty()) {
*distanceTrack = real; *distanceTrack = real;
} }
} }

26
code/Obj/ObjFileData.h
View File

@ -75,19 +75,14 @@ struct Face {
Material *m_pMaterial; Material *m_pMaterial;
//! \brief Default constructor //! \brief Default constructor
Face( aiPrimitiveType pt = aiPrimitiveType_POLYGON) explicit Face( aiPrimitiveType pt = aiPrimitiveType_POLYGON)
: m_PrimitiveType( pt ) : m_PrimitiveType( pt )
, m_vertices() , m_pMaterial( nullptr ) {
, m_normals()
, m_texturCoords()
, m_pMaterial( 0L ) {
// empty // empty
} }
//! \brief Destructor //! \brief Destructor
~Face() { ~Face() = default;
// empty
}
}; };
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -285,14 +280,12 @@ struct Model {
//! \brief The default class constructor //! \brief The default class constructor
Model() : Model() :
m_ModelName(""), m_pCurrent(nullptr),
m_pCurrent(NULL), m_pCurrentMaterial(nullptr),
m_pCurrentMaterial(NULL), m_pDefaultMaterial(nullptr),
m_pDefaultMaterial(NULL), m_pGroupFaceIDs(nullptr),
m_pGroupFaceIDs(NULL),
m_strActiveGroup(""),
m_TextureCoordDim(0), m_TextureCoordDim(0),
m_pCurrentMesh(NULL) m_pCurrentMesh(nullptr)
{ {
// empty // empty
} }
@ -304,19 +297,16 @@ struct Model {
it != m_Objects.end(); ++it) { it != m_Objects.end(); ++it) {
delete *it; delete *it;
} }
m_Objects.clear();
// Clear all stored mesh instances // Clear all stored mesh instances
for (std::vector<Mesh*>::iterator it = m_Meshes.begin(); for (std::vector<Mesh*>::iterator it = m_Meshes.begin();
it != m_Meshes.end(); ++it) { it != m_Meshes.end(); ++it) {
delete *it; delete *it;
} }
m_Meshes.clear();
for(GroupMapIt it = m_Groups.begin(); it != m_Groups.end(); ++it) { for(GroupMapIt it = m_Groups.begin(); it != m_Groups.end(); ++it) {
delete it->second; delete it->second;
} }
m_Groups.clear();
for ( std::map<std::string, Material*>::iterator it = m_MaterialMap.begin(); it != m_MaterialMap.end(); ++it ) { for ( std::map<std::string, Material*>::iterator it = m_MaterialMap.begin(); it != m_MaterialMap.end(); ++it ) {
delete it->second; delete it->second;

2
code/Obj/ObjFileImporter.cpp
View File

@ -112,7 +112,7 @@ void ObjFileImporter::InternReadFile( const std::string &file, aiScene* pScene,
// Read file into memory // Read file into memory
static const std::string mode = "rb"; static const std::string mode = "rb";
std::unique_ptr<IOStream> fileStream( pIOHandler->Open( file, mode)); std::unique_ptr<IOStream> fileStream( pIOHandler->Open( file, mode));
if( !fileStream.get() ) { if(!fileStream) {
throw DeadlyImportError( "Failed to open file " + file + "." ); throw DeadlyImportError( "Failed to open file " + file + "." );
} }

7
code/Obj/ObjFileParser.cpp
View File

@ -66,8 +66,7 @@ ObjFileParser::ObjFileParser()
, m_pModel( nullptr ) , m_pModel( nullptr )
, m_uiLine( 0 ) , m_uiLine( 0 )
, m_pIO( nullptr ) , m_pIO( nullptr )
, m_progress( nullptr ) , m_progress( nullptr ) {
, m_originalObjFileName() {
// empty // empty
} }
@ -567,7 +566,7 @@ void ObjFileParser::getMaterialDesc() {
if (!skip) { if (!skip) {
// Search for material // Search for material
std::map<std::string, ObjFile::Material*>::iterator it = m_pModel->m_MaterialMap.find(strName); auto it = m_pModel->m_MaterialMap.find(strName);
if (it == m_pModel->m_MaterialMap.end()) { if (it == m_pModel->m_MaterialMap.end()) {
// Not found, so we don't know anything about the material except for its name. // Not found, so we don't know anything about the material except for its name.
// This may be the case if the material library is missing. We don't want to lose all // This may be the case if the material library is missing. We don't want to lose all
@ -674,7 +673,7 @@ void ObjFileParser::getNewMaterial() {
while( m_DataIt != m_DataItEnd && IsSpaceOrNewLine( *m_DataIt ) ) { while( m_DataIt != m_DataItEnd && IsSpaceOrNewLine( *m_DataIt ) ) {
++m_DataIt; ++m_DataIt;
} }
std::map<std::string, ObjFile::Material*>::iterator it = m_pModel->m_MaterialMap.find( strMat ); auto it = m_pModel->m_MaterialMap.find( strMat );
if ( it == m_pModel->m_MaterialMap.end() ) { if ( it == m_pModel->m_MaterialMap.end() ) {
// Show a warning, if material was not found // Show a warning, if material was not found
ASSIMP_LOG_WARN("OBJ: Unsupported material requested: " + strMat); ASSIMP_LOG_WARN("OBJ: Unsupported material requested: " + strMat);

8
code/PostProcessing/ComputeUVMappingProcess.cpp
View File

@ -51,10 +51,10 @@ using namespace Assimp;
namespace { namespace {
const static aiVector3D base_axis_y(0.0,1.0,0.0); const aiVector3D base_axis_y(0.0,1.0,0.0);
const static aiVector3D base_axis_x(1.0,0.0,0.0); const aiVector3D base_axis_x(1.0,0.0,0.0);
const static aiVector3D base_axis_z(0.0,0.0,1.0); const aiVector3D base_axis_z(0.0,0.0,1.0);
const static ai_real angle_epsilon = ai_real( 0.95 ); const ai_real angle_epsilon = ai_real( 0.95 );
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------

8
code/PostProcessing/DeboneProcess.cpp
View File

@ -48,7 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// internal headers of the post-processing framework // internal headers of the post-processing framework
#include "ProcessHelper.h" #include "ProcessHelper.h"
#include "DeboneProcess.h" #include "DeboneProcess.h"
#include <stdio.h> #include <cstdio>
using namespace Assimp; using namespace Assimp;
@ -83,7 +83,7 @@ bool DeboneProcess::IsActive( unsigned int pFlags) const
void DeboneProcess::SetupProperties(const Importer* pImp) void DeboneProcess::SetupProperties(const Importer* pImp)
{ {
// get the current value of the property // get the current value of the property
mAllOrNone = pImp->GetPropertyInteger(AI_CONFIG_PP_DB_ALL_OR_NONE,0)?true:false; mAllOrNone = pImp->GetPropertyInteger(AI_CONFIG_PP_DB_ALL_OR_NONE, 0) != 0;
mThreshold = pImp->GetPropertyFloat(AI_CONFIG_PP_DB_THRESHOLD,AI_DEBONE_THRESHOLD); mThreshold = pImp->GetPropertyFloat(AI_CONFIG_PP_DB_THRESHOLD,AI_DEBONE_THRESHOLD);
} }
@ -104,7 +104,7 @@ void DeboneProcess::Execute( aiScene* pScene)
int numSplits = 0; int numSplits = 0;
if(!!mNumBonesCanDoWithout && (!mAllOrNone||mNumBonesCanDoWithout==mNumBones)) { if(mNumBonesCanDoWithout != 0 && (!mAllOrNone || mNumBonesCanDoWithout == mNumBones)) {
for(unsigned int a = 0; a < pScene->mNumMeshes; a++) { for(unsigned int a = 0; a < pScene->mNumMeshes; a++) {
if(splitList[a]) { if(splitList[a]) {
numSplits++; numSplits++;
@ -156,7 +156,7 @@ void DeboneProcess::Execute( aiScene* pScene)
} }
else { else {
// Mesh is kept unchanged - store it's new place in the mesh array // Mesh is kept unchanged - store it's new place in the mesh array
mSubMeshIndices[a].push_back(std::pair<unsigned int,aiNode*>(static_cast<unsigned int>(meshes.size()),(aiNode*)0)); mSubMeshIndices[a].emplace_back(static_cast<unsigned int>(meshes.size()),(aiNode*)0);
meshes.push_back(srcMesh); meshes.push_back(srcMesh);
} }
} }

2
code/PostProcessing/FindInvalidDataProcess.cpp
View File

@ -183,7 +183,7 @@ const char* ValidateArrayContents<aiVector3D>(const aiVector3D* arr, unsigned in
unsigned int cnt = 0; 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]) { if (!dirtyMask.empty() && dirtyMask[i]) {
continue; continue;
} }
++cnt; ++cnt;

4
code/PostProcessing/GenVertexNormalsProcess.cpp
View File

@ -158,9 +158,9 @@ bool GenVertexNormalsProcess::GenMeshVertexNormals (aiMesh* pMesh, unsigned int
// Set up a SpatialSort to quickly find all vertices close to a given position // Set up a SpatialSort to quickly find all vertices close to a given position
// check whether we can reuse the SpatialSort of a previous step. // check whether we can reuse the SpatialSort of a previous step.
SpatialSort* vertexFinder = NULL; SpatialSort* vertexFinder = nullptr;
SpatialSort _vertexFinder; SpatialSort _vertexFinder;
ai_real posEpsilon = ai_real( 1e-5 ); ai_real posEpsilon;
if (shared) { if (shared) {
std::vector<std::pair<SpatialSort,ai_real> >* avf; std::vector<std::pair<SpatialSort,ai_real> >* avf;
shared->GetProperty(AI_SPP_SPATIAL_SORT,avf); shared->GetProperty(AI_SPP_SPATIAL_SORT,avf);

2
code/PostProcessing/JoinVerticesProcess.cpp
View File

@ -423,7 +423,7 @@ int JoinVerticesProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
ASSIMP_LOG_ERROR( "X-Export: aiBone shall contain weights, but pointer to them is NULL." ); ASSIMP_LOG_ERROR( "X-Export: aiBone shall contain weights, but pointer to them is NULL." );
} }
if (newWeights.size() > 0) { if (!newWeights.empty()) {
// kill the old and replace them with the translated weights // kill the old and replace them with the translated weights
delete [] bone->mWeights; delete [] bone->mWeights;
bone->mNumWeights = (unsigned int)newWeights.size(); bone->mNumWeights = (unsigned int)newWeights.size();

4
code/PostProcessing/LimitBoneWeightsProcess.cpp
View File

@ -111,7 +111,7 @@ void LimitBoneWeightsProcess::ProcessMesh( aiMesh* pMesh)
for( unsigned int b = 0; b < bone->mNumWeights; b++) for( unsigned int b = 0; b < bone->mNumWeights; b++)
{ {
const aiVertexWeight& w = bone->mWeights[b]; const aiVertexWeight& w = bone->mWeights[b];
vertexWeights[w.mVertexId].push_back( Weight( a, w.mWeight)); vertexWeights[w.mVertexId].emplace_back( a, w.mWeight);
} }
} }
@ -156,7 +156,7 @@ void LimitBoneWeightsProcess::ProcessMesh( aiMesh* pMesh)
{ {
const std::vector<Weight>& vw = vertexWeights[a]; const std::vector<Weight>& vw = vertexWeights[a];
for( std::vector<Weight>::const_iterator it = vw.begin(); it != vw.end(); ++it) for( std::vector<Weight>::const_iterator it = vw.begin(); it != vw.end(); ++it)
boneWeights[it->mBone].push_back( aiVertexWeight( a, it->mWeight)); boneWeights[it->mBone].emplace_back( a, it->mWeight);
} }
// and finally copy the vertex weight list over to the mesh's bones // and finally copy the vertex weight list over to the mesh's bones

2
code/PostProcessing/OptimizeMeshes.cpp
View File

@ -140,7 +140,7 @@ void OptimizeMeshesProcess::Execute( aiScene* pScene)
// and process all nodes in the scenegraph recursively // and process all nodes in the scenegraph recursively
ProcessNode(pScene->mRootNode); ProcessNode(pScene->mRootNode);
if (!output.size()) { if (output.empty()) {
throw DeadlyImportError("OptimizeMeshes: No meshes remaining; there's definitely something wrong"); throw DeadlyImportError("OptimizeMeshes: No meshes remaining; there's definitely something wrong");
} }

2
code/PostProcessing/ProcessHelper.cpp
View File

@ -66,7 +66,7 @@ void ConvertListToStrings(const std::string& in, std::list<std::string>& out)
return; return;
} }
} }
out.push_back(std::string(base,(size_t)(s-base))); out.emplace_back(base,(size_t)(s-base));
++s; ++s;
} }
else { else {

2
code/PostProcessing/SortByPTypeProcess.cpp
View File

@ -293,7 +293,7 @@ void SortByPTypeProcess::Execute( aiScene* pScene) {
for (VertexWeightTable::const_iterator it = tbl.begin(), end = tbl.end(); for (VertexWeightTable::const_iterator it = tbl.begin(), end = tbl.end();
it != end; ++it) it != end; ++it)
{ {
tempBones[ (*it).first ].push_back( aiVertexWeight(outIdx, (*it).second) ); tempBones[ (*it).first ].emplace_back(outIdx, (*it).second );
} }
} }

4
code/PostProcessing/SplitLargeMeshes.cpp
View File

@ -316,13 +316,13 @@ void SplitLargeMeshesProcess_Triangle::SplitMesh(
} }
// add the newly created mesh to the list // add the newly created mesh to the list
avList.push_back(std::pair<aiMesh*, unsigned int>(pcMesh,a)); avList.emplace_back(pcMesh,a);
} }
// now delete the old mesh data // now delete the old mesh data
delete pMesh; delete pMesh;
} else { } else {
avList.push_back(std::pair<aiMesh*, unsigned int>(pMesh,a)); avList.emplace_back(pMesh,a);
} }
} }

2
code/PostProcessing/TriangulateProcess.cpp
View File

@ -200,7 +200,7 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
aiFace& face = pMesh->mFaces[a]; aiFace& face = pMesh->mFaces[a];
unsigned int* idx = face.mIndices; unsigned int* idx = face.mIndices;
int num = (int)face.mNumIndices, ear = 0, tmp, prev = num-1, next = 0, max = num; int num = (int)face.mNumIndices, ear, tmp, prev = num - 1, next = 0, max = num;
// Apply vertex colors to represent the face winding? // Apply vertex colors to represent the face winding?
#ifdef AI_BUILD_TRIANGULATE_COLOR_FACE_WINDING #ifdef AI_BUILD_TRIANGULATE_COLOR_FACE_WINDING

4
include/assimp/SceneCombiner.h
View File

@ -274,7 +274,7 @@ public:
* @param end Points to the mesh after the last mesh to be processed * @param end Points to the mesh after the last mesh to be processed
*/ */
static void MergeBones(aiMesh* out,std::vector<aiMesh*>::const_iterator it, static void MergeBones(aiMesh* out,std::vector<aiMesh*>::const_iterator it,
std::vector<aiMesh*>::const_iterator end); const std::vector<aiMesh*>::const_iterator& end);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Merges two or more materials /** Merges two or more materials
@ -300,7 +300,7 @@ public:
*/ */
static void BuildUniqueBoneList(std::list<BoneWithHash>& asBones, static void BuildUniqueBoneList(std::list<BoneWithHash>& asBones,
std::vector<aiMesh*>::const_iterator it, std::vector<aiMesh*>::const_iterator it,
std::vector<aiMesh*>::const_iterator end); const std::vector<aiMesh*>::const_iterator& end);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Add a name prefix to all nodes in a scene. /** Add a name prefix to all nodes in a scene.