bugfix: handling possible nullptr access.

update: replace clear be resize( 0 ) at some places to avoid double allocations ( only a micro optimization ).

Signed-off-by: Kim Kulling <kim.kulling@googlemail.com>
pull/309/head
Kim Kulling 2014-07-04 00:22:13 +02:00
parent b3b732c12b
commit c6b516b68b
4 changed files with 79 additions and 37 deletions

View File

@ -271,7 +271,7 @@ bool CalcTangentsProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
const aiVector3D& origNorm = pMesh->mNormals[a]; const aiVector3D& origNorm = pMesh->mNormals[a];
const aiVector3D& origTang = pMesh->mTangents[a]; const aiVector3D& origTang = pMesh->mTangents[a];
const aiVector3D& origBitang = pMesh->mBitangents[a]; const aiVector3D& origBitang = pMesh->mBitangents[a];
closeVertices.clear(); closeVertices.resize( 0 );
// find all vertices close to that position // find all vertices close to that position
vertexFinder->FindPositions( origPos, posEpsilon, verticesFound); vertexFinder->FindPositions( origPos, posEpsilon, verticesFound);

View File

@ -57,12 +57,15 @@ using namespace Assimp;
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer // Constructor to be privately used by Importer
MakeLeftHandedProcess::MakeLeftHandedProcess() MakeLeftHandedProcess::MakeLeftHandedProcess()
{} : BaseProcess() {
// empty
}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Destructor, private as well // Destructor, private as well
MakeLeftHandedProcess::~MakeLeftHandedProcess() MakeLeftHandedProcess::~MakeLeftHandedProcess() {
{} // empty
}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Returns whether the processing step is present in the given flag field. // Returns whether the processing step is present in the given flag field.
@ -121,9 +124,10 @@ void MakeLeftHandedProcess::ProcessNode( aiNode* pNode, const aiMatrix4x4& pPare
pNode->mTransformation.d3 = -pNode->mTransformation.d3; // useless, but anyways... pNode->mTransformation.d3 = -pNode->mTransformation.d3; // useless, but anyways...
// continue for all children // continue for all children
for( size_t a = 0; a < pNode->mNumChildren; ++a) for( size_t a = 0; a < pNode->mNumChildren; ++a ) {
ProcessNode( pNode->mChildren[ a ], pParentGlobalRotation * pNode->mTransformation ); ProcessNode( pNode->mChildren[ a ], pParentGlobalRotation * pNode->mTransformation );
} }
}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Converts a single mesh to left handed coordinates. // Converts a single mesh to left handed coordinates.
@ -244,6 +248,10 @@ void FlipUVsProcess::ProcessMaterial (aiMaterial* _mat)
aiMaterial* mat = (aiMaterial*)_mat; aiMaterial* mat = (aiMaterial*)_mat;
for (unsigned int a = 0; a < mat->mNumProperties;++a) { for (unsigned int a = 0; a < mat->mNumProperties;++a) {
aiMaterialProperty* prop = mat->mProperties[a]; aiMaterialProperty* prop = mat->mProperties[a];
if( !prop ) {
DefaultLogger::get()->debug( "Property is null" );
continue;
}
// UV transformation key? // UV transformation key?
if (!::strcmp( prop->mKey.data, "$tex.uvtrafo")) { if (!::strcmp( prop->mKey.data, "$tex.uvtrafo")) {
@ -263,13 +271,15 @@ void FlipUVsProcess::ProcessMesh( aiMesh* pMesh)
{ {
// mirror texture y coordinate // mirror texture y coordinate
for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) { for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) {
if( !pMesh->HasTextureCoords( a)) if( !pMesh->HasTextureCoords( a ) ) {
break; break;
}
for( unsigned int b = 0; b < pMesh->mNumVertices; b++) for( unsigned int b = 0; b < pMesh->mNumVertices; b++ ) {
pMesh->mTextureCoords[ a ][ b ].y = 1.0f - pMesh->mTextureCoords[ a ][ b ].y; pMesh->mTextureCoords[ a ][ b ].y = 1.0f - pMesh->mTextureCoords[ a ][ b ].y;
} }
} }
}
#endif // !ASSIMP_BUILD_NO_FLIPUVS_PROCESS #endif // !ASSIMP_BUILD_NO_FLIPUVS_PROCESS
#ifndef ASSIMP_BUILD_NO_FLIPWINDING_PROCESS #ifndef ASSIMP_BUILD_NO_FLIPWINDING_PROCESS

View File

@ -111,7 +111,7 @@ void DeboneProcess::Execute( aiScene* pScene)
if(numSplits) { if(numSplits) {
// we need to do something. Let's go. // we need to do something. Let's go.
mSubMeshIndices.clear(); //mSubMeshIndices.clear(); really needed?
mSubMeshIndices.resize(pScene->mNumMeshes); mSubMeshIndices.resize(pScene->mNumMeshes);
// build a new array of meshes for the scene // build a new array of meshes for the scene

View File

@ -56,7 +56,9 @@ namespace Assimp {
// The functions below accept any character type, but know only // The functions below accept any character type, but know only
// about ASCII. However, UTF-32 is the only safe ASCII superset to // about ASCII. However, UTF-32 is the only safe ASCII superset to
// use since it doesn't have multibyte sequences. // use since it doesn't have multi-byte sequences.
static const unsigned int BufferSize = 4096;
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
template <class char_t> template <class char_t>
@ -64,118 +66,145 @@ AI_FORCE_INLINE char_t ToLower( char_t in)
{ {
return (in >= (char_t)'A' && in <= (char_t)'Z') ? (char_t)(in+0x20) : in; return (in >= (char_t)'A' && in <= (char_t)'Z') ? (char_t)(in+0x20) : in;
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
template <class char_t> template <class char_t>
AI_FORCE_INLINE char_t ToUpper( char_t in) AI_FORCE_INLINE char_t ToUpper( char_t in) {
{
return (in >= (char_t)'a' && in <= (char_t)'z') ? (char_t)(in-0x20) : in; return (in >= (char_t)'a' && in <= (char_t)'z') ? (char_t)(in-0x20) : in;
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
template <class char_t> template <class char_t>
AI_FORCE_INLINE bool IsUpper( char_t in) AI_FORCE_INLINE bool IsUpper( char_t in)
{ {
return (in >= (char_t)'A' && in <= (char_t)'Z'); return (in >= (char_t)'A' && in <= (char_t)'Z');
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
template <class char_t> template <class char_t>
AI_FORCE_INLINE bool IsLower( char_t in) AI_FORCE_INLINE bool IsLower( char_t in)
{ {
return (in >= (char_t)'a' && in <= (char_t)'z'); return (in >= (char_t)'a' && in <= (char_t)'z');
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
template <class char_t> template <class char_t>
AI_FORCE_INLINE bool IsSpace( char_t in) AI_FORCE_INLINE bool IsSpace( char_t in)
{ {
return (in == (char_t)' ' || in == (char_t)'\t'); return (in == (char_t)' ' || in == (char_t)'\t');
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
template <class char_t> template <class char_t>
AI_FORCE_INLINE bool IsLineEnd( char_t in) AI_FORCE_INLINE bool IsLineEnd( char_t in)
{ {
return (in == (char_t)'\r' || in == (char_t)'\n' || in == (char_t)'\0'); return (in == (char_t)'\r' || in == (char_t)'\n' || in == (char_t)'\0');
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
template <class char_t> template <class char_t>
AI_FORCE_INLINE bool IsSpaceOrNewLine( char_t in) AI_FORCE_INLINE bool IsSpaceOrNewLine( char_t in)
{ {
return IsSpace<char_t>(in) || IsLineEnd<char_t>(in); return IsSpace<char_t>(in) || IsLineEnd<char_t>(in);
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
template <class char_t> template <class char_t>
AI_FORCE_INLINE bool SkipSpaces( const char_t* in, const char_t** out) AI_FORCE_INLINE bool SkipSpaces( const char_t* in, const char_t** out)
{ {
while (*in == (char_t)' ' || *in == (char_t)'\t')in++; while( *in == ( char_t )' ' || *in == ( char_t )'\t' ) {
++in;
}
*out = in; *out = in;
return !IsLineEnd<char_t>(*in); return !IsLineEnd<char_t>(*in);
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
template <class char_t> template <class char_t>
AI_FORCE_INLINE bool SkipSpaces( const char_t** inout) AI_FORCE_INLINE bool SkipSpaces( const char_t** inout)
{ {
return SkipSpaces<char_t>(*inout,inout); return SkipSpaces<char_t>(*inout,inout);
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
template <class char_t> template <class char_t>
AI_FORCE_INLINE bool SkipLine( const char_t* in, const char_t** out) AI_FORCE_INLINE bool SkipLine( const char_t* in, const char_t** out)
{ {
while (*in != (char_t)'\r' && *in != (char_t)'\n' && *in != (char_t)'\0')in++; while( *in != ( char_t )'\r' && *in != ( char_t )'\n' && *in != ( char_t )'\0' ) {
++in;
}
// files are opened in binary mode. Ergo there are both NL and CR // files are opened in binary mode. Ergo there are both NL and CR
while (*in == (char_t)'\r' || *in == (char_t)'\n')in++; while( *in == ( char_t )'\r' || *in == ( char_t )'\n' ) {
++in;
}
*out = in; *out = in;
return *in != (char_t)'\0'; return *in != (char_t)'\0';
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
template <class char_t> template <class char_t>
AI_FORCE_INLINE bool SkipLine( const char_t** inout) AI_FORCE_INLINE bool SkipLine( const char_t** inout)
{ {
return SkipLine<char_t>(*inout,inout); return SkipLine<char_t>(*inout,inout);
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
template <class char_t> template <class char_t>
AI_FORCE_INLINE bool SkipSpacesAndLineEnd( const char_t* in, const char_t** out) AI_FORCE_INLINE bool SkipSpacesAndLineEnd( const char_t* in, const char_t** out)
{ {
while (*in == (char_t)' ' || *in == (char_t)'\t' || while( *in == ( char_t )' ' || *in == ( char_t )'\t' || *in == ( char_t )'\r' || *in == ( char_t )'\n' ) {
*in == (char_t)'\r' || *in == (char_t)'\n')in++; ++in;
}
*out = in; *out = in;
return *in != '\0'; return *in != '\0';
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
template <class char_t> template <class char_t>
AI_FORCE_INLINE bool SkipSpacesAndLineEnd( const char_t** inout) AI_FORCE_INLINE bool SkipSpacesAndLineEnd( const char_t** inout)
{ {
return SkipSpacesAndLineEnd<char_t>(*inout,inout); return SkipSpacesAndLineEnd<char_t>(*inout,inout);
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
template <class char_t> template <class char_t>
AI_FORCE_INLINE bool GetNextLine(const char_t*& buffer, char_t out[4096]) AI_FORCE_INLINE bool GetNextLine( const char_t*& buffer, char_t out[ BufferSize ] )
{ {
if ((char_t)'\0' == *buffer)return false; if( ( char_t )'\0' == *buffer ) {
return false;
}
char* _out = out; char* _out = out;
char* const end = _out+4096; char* const end = _out + BufferSize;
while (!IsLineEnd( *buffer ) && _out < end) while( !IsLineEnd( *buffer ) && _out < end ) {
*_out++ = *buffer++; *_out++ = *buffer++;
}
*_out = (char_t)'\0'; *_out = (char_t)'\0';
while (IsLineEnd( *buffer ) && '\0' != *buffer)++buffer; while( IsLineEnd( *buffer ) && '\0' != *buffer ) {
++buffer;
}
return true; return true;
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
template <class char_t> template <class char_t>
AI_FORCE_INLINE bool IsNumeric( char_t in) AI_FORCE_INLINE bool IsNumeric( char_t in)
{ {
return ( in >= '0' && in <= '9' ) || '-' == in || '+' == in; return ( in >= '0' && in <= '9' ) || '-' == in || '+' == in;
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
template <class char_t> template <class char_t>
AI_FORCE_INLINE bool TokenMatch(char_t*& in, const char* token, unsigned int len) AI_FORCE_INLINE bool TokenMatch(char_t*& in, const char* token, unsigned int len)
{ {
if (!::strncmp(token,in,len) && IsSpaceOrNewLine(in[len])) if (!::strncmp(token,in,len) && IsSpaceOrNewLine(in[len])) {
{
in += len+1; in += len+1;
return true; return true;
} }
return false; return false;
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
@ -186,8 +215,7 @@ AI_FORCE_INLINE bool TokenMatch(char_t*& in, const char* token, unsigned int len
*/ */
AI_FORCE_INLINE bool TokenMatchI(const char*& in, const char* token, unsigned int len) AI_FORCE_INLINE bool TokenMatchI(const char*& in, const char* token, unsigned int len)
{ {
if (!ASSIMP_strincmp(token,in,len) && IsSpaceOrNewLine(in[len])) if (!ASSIMP_strincmp(token,in,len) && IsSpaceOrNewLine(in[len])) {
{
in += len+1; in += len+1;
return true; return true;
} }
@ -207,5 +235,9 @@ AI_FORCE_INLINE std::string GetNextToken(const char*& in)
while (!IsSpaceOrNewLine(*in))++in; while (!IsSpaceOrNewLine(*in))++in;
return std::string(cur,(size_t)(in-cur)); return std::string(cur,(size_t)(in-cur));
} }
// ---------------------------------------------------------------------------------
} // ! namespace Assimp } // ! namespace Assimp
#endif // ! AI_PARSING_UTILS_H_INC #endif // ! AI_PARSING_UTILS_H_INC