diff --git a/code/AssetLib/Collada/ColladaExporter.cpp b/code/AssetLib/Collada/ColladaExporter.cpp index 567f7c8e7..251cbee3e 100644 --- a/code/AssetLib/Collada/ColladaExporter.cpp +++ b/code/AssetLib/Collada/ColladaExporter.cpp @@ -573,7 +573,7 @@ bool ColladaExporter::ReadMaterialSurface(Surface &poSurface, const aiMaterial & index_str = index_str.substr(1, std::string::npos); try { - index = (unsigned int)strtoul10_64(index_str.c_str()); + index = (unsigned int)strtoul10_64(index_str.c_str()); } catch (std::exception &error) { throw DeadlyExportError(error.what()); } diff --git a/code/AssetLib/FBX/FBXImporter.cpp b/code/AssetLib/FBX/FBXImporter.cpp index f80b65cd4..4c473510e 100644 --- a/code/AssetLib/FBX/FBXImporter.cpp +++ b/code/AssetLib/FBX/FBXImporter.cpp @@ -187,6 +187,11 @@ void FBXImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy // size relative to cm float size_relative_to_cm = doc.GlobalSettings().UnitScaleFactor(); + if (size_relative_to_cm == 0.0) + { + // BaseImporter later asserts that fileScale is non-zero. + ThrowException("The UnitScaleFactor must be non-zero"); + } // Set FBX file scale is relative to CM must be converted to M for // assimp universal format (M) diff --git a/include/assimp/fast_atof.h b/include/assimp/fast_atof.h index 6e9a1bba7..9ea49c85c 100644 --- a/include/assimp/fast_atof.h +++ b/include/assimp/fast_atof.h @@ -24,11 +24,11 @@ #include #include #include -#include #include #include "StringComparison.h" #include +#include #ifdef _MSC_VER # include @@ -185,13 +185,15 @@ unsigned int strtoul_cppstyle( const char* in, const char** out=0) { // Special version of the function, providing higher accuracy and safety // It is mainly used by fast_atof to prevent ugly and unwanted integer overflows. // ------------------------------------------------------------------------------------ +template inline uint64_t strtoul10_64( const char* in, const char** out=0, unsigned int* max_inout=0) { unsigned int cur = 0; uint64_t value = 0; if ( *in < '0' || *in > '9' ) { - throw std::invalid_argument( std::string( "The string \"" ) + in + "\" cannot be converted into a value." ); + // The string is known to be bad, so don't risk printing the whole thing. + throw ExceptionType("The string \"", std::string(in).substr(0, 100), "\" cannot be converted into a value." ); } for ( ;; ) { @@ -237,6 +239,7 @@ uint64_t strtoul10_64( const char* in, const char** out=0, unsigned int* max_ino // ------------------------------------------------------------------------------------ // signed variant of strtoul10_64 // ------------------------------------------------------------------------------------ +template inline int64_t strtol10_64(const char* in, const char** out = 0, unsigned int* max_inout = 0) { bool inv = (*in == '-'); @@ -244,7 +247,7 @@ int64_t strtol10_64(const char* in, const char** out = 0, unsigned int* max_inou ++in; } - int64_t value = strtoul10_64(in, out, max_inout); + int64_t value = strtoul10_64(in, out, max_inout); if (inv) { value = -value; } @@ -259,7 +262,7 @@ int64_t strtol10_64(const char* in, const char** out = 0, unsigned int* max_inou //! about 6 times faster than atof in win32. // If you find any bugs, please send them to me, niko (at) irrlicht3d.org. // ------------------------------------------------------------------------------------ -template +template inline const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true) { Real f = 0; @@ -289,13 +292,14 @@ const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true) if (!(c[0] >= '0' && c[0] <= '9') && !((c[0] == '.' || (check_comma && c[0] == ',')) && c[1] >= '0' && c[1] <= '9')) { - throw std::invalid_argument("Cannot parse string " - "as real number: does not start with digit " + // The string is known to be bad, so don't risk printing the whole thing. + throw ExceptionType("Cannot parse string \"", std::string(c).substr(0, 100), + "\" as a real number: does not start with digit " "or decimal point followed by digit."); } if (*c != '.' && (! check_comma || c[0] != ',')) { - f = static_cast( strtoul10_64 ( c, &c) ); + f = static_cast( strtoul10_64 ( c, &c) ); } if ((*c == '.' || (check_comma && c[0] == ',')) && c[1] >= '0' && c[1] <= '9') { @@ -310,7 +314,7 @@ const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true) // number of digits to be read. AI_FAST_ATOF_RELAVANT_DECIMALS can be a value between // 1 and 15. unsigned int diff = AI_FAST_ATOF_RELAVANT_DECIMALS; - double pl = static_cast( strtoul10_64 ( c, &c, &diff )); + double pl = static_cast( strtoul10_64 ( c, &c, &diff )); pl *= fast_atof_table[diff]; f += static_cast( pl ); @@ -332,7 +336,7 @@ const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true) // The reason float constants are used here is that we've seen cases where compilers // would perform such casts on compile-time constants at runtime, which would be // bad considering how frequently fast_atoreal_move is called in Assimp. - Real exp = static_cast( strtoul10_64(c, &c) ); + Real exp = static_cast( strtoul10_64(c, &c) ); if (einv) { exp = -exp; } @@ -348,26 +352,29 @@ const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true) // ------------------------------------------------------------------------------------ // The same but more human. +template inline ai_real fast_atof(const char* c) { ai_real ret(0.0); - fast_atoreal_move(c, ret); + fast_atoreal_move(c, ret); return ret; } +template inline ai_real fast_atof( const char* c, const char** cout) { ai_real ret(0.0); - *cout = fast_atoreal_move(c, ret); + *cout = fast_atoreal_move(c, ret); return ret; } +template inline ai_real fast_atof( const char** inout) { ai_real ret(0.0); - *inout = fast_atoreal_move(*inout, ret); + *inout = fast_atoreal_move(*inout, ret); return ret; }