Merge branch 'master' into coverity_scan

appveyor.yml

@@ -10,7 +10,9 @@ branches:
   only:
     - master
 
-platform: x64
+platform:
+    - x86
+    - x64
 configuration: Release
 
 build:

cmake-modules/FindPkgMacros.cmake

@@ -127,6 +127,7 @@ MACRO(findpkg_framework fwk)
       /System/Library/Frameworks
       /Network/Library/Frameworks
       /Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS3.0.sdk/System/Library/Frameworks/
+      /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS3.0.sdk/System/Library/Frameworks/
     )
     FOREACH(dir ${${fwk}_FRAMEWORK_PATH})
       SET(fwkpath ${dir}/${fwk}.framework)

code/ASEParser.cpp

@@ -825,7 +825,7 @@ bool Parser::ParseString(std::string& out,const char* szName)
     if (!SkipSpaces(&filePtr))
     {
 
-        ai_snprintf(szBuffer, 1023, "Unable to parse %s block: Unexpected EOL",szName);
+        ai_snprintf(szBuffer, 1024, "Unable to parse %s block: Unexpected EOL",szName);
         LogWarning(szBuffer);
         return false;
     }
@@ -833,7 +833,7 @@ bool Parser::ParseString(std::string& out,const char* szName)
     if ('\"' != *filePtr)
     {
 
-        ai_snprintf(szBuffer, 1023, "Unable to parse %s block: Strings are expected "
+        ai_snprintf(szBuffer, 1024, "Unable to parse %s block: Strings are expected "
             "to be enclosed in double quotation marks",szName);
         LogWarning(szBuffer);
         return false;

code/ColladaLoader.cpp

@@ -55,6 +55,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "Defines.h"
 
 #include "time.h"
+#include "math.h"
 #include <boost/foreach.hpp>
 #include "../include/assimp/DefaultLogger.hpp"
 #include "../include/assimp/Importer.hpp"
@@ -77,13 +78,21 @@ static const aiImporterDesc desc = {
     "dae"
 };
 
-
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 ColladaLoader::ColladaLoader()
-    : noSkeletonMesh()
+    : mFileName()
+	, mMeshIndexByID()
+	, mMaterialIndexByName()
+	, mMeshes()
+	, newMats()
+	, mCameras()
+	, mLights()
+	, mTextures()
+	, mAnims()
+	, noSkeletonMesh( false )
     , ignoreUpDirection(false)
-    , mNodeNameCounter()
+    , mNodeNameCounter( 0 )
 {}
 
 // ------------------------------------------------------------------------------------------------
@@ -1161,6 +1170,25 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
                       }
                       ++pos;
                   }
+				  
+				  // https://github.com/assimp/assimp/issues/458
+			  	  // Sub-sample axis-angle channels if the delta between two consecutive
+                  // key-frame angles is >= 180 degrees.
+				  if (transforms[e.mTransformIndex].mType == Collada::TF_ROTATE && e.mSubElement == 3 && pos > 0 && pos < e.mTimeAccessor->mCount) {
+					  float cur_key_angle = ReadFloat(*e.mValueAccessor, *e.mValueData, pos, 0);
+					  float last_key_angle = ReadFloat(*e.mValueAccessor, *e.mValueData, pos - 1, 0);
+					  float cur_key_time = ReadFloat(*e.mTimeAccessor, *e.mTimeData, pos, 0);
+					  float last_key_time = ReadFloat(*e.mTimeAccessor, *e.mTimeData, pos - 1, 0);
+					  float last_eval_angle = last_key_angle + (cur_key_angle - last_key_angle) * (time - last_key_time) / (cur_key_time - last_key_time); 
+					  float delta = std::fabs(cur_key_angle - last_eval_angle);
+				      if (delta >= 180.0f) {
+						int subSampleCount = static_cast<int>(floorf(delta / 90.0f));
+						if (cur_key_time != time) {
+							float nextSampleTime = time + (cur_key_time - time) / subSampleCount;
+							nextTime = std::min(nextTime, nextSampleTime);
+						  }
+					  }
+				  }
               }
 
               // no more keys on any channel after the current time -> we're done
@@ -1357,7 +1385,7 @@ void ColladaLoader::FillMaterials( const ColladaParser& pParser, aiScene* /*pSce
                 effect.mTransparency *= (
                     0.212671f * effect.mTransparent.r +
                     0.715160f * effect.mTransparent.g +
-                    0.072169 * effect.mTransparent.b
+                    0.072169f * effect.mTransparent.b
                 );
 
                 effect.mTransparent.a = 1.f;

code/FBXDeformer.cpp

@@ -131,7 +131,7 @@ Cluster::~Cluster()
 // ------------------------------------------------------------------------------------------------
 Skin::Skin(uint64_t id, const Element& element, const Document& doc, const std::string& name)
 : Deformer(id,element,doc,name)
-{
+, accuracy( 0.0f ) {
     const Scope& sc = GetRequiredScope(element);
 
     const Element* const Link_DeformAcuracy = sc["Link_DeformAcuracy"];

code/GenVertexNormalsProcess.cpp

@@ -56,14 +56,13 @@ using namespace Assimp;
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 GenVertexNormalsProcess::GenVertexNormalsProcess()
-{
+: configMaxAngle( AI_DEG_TO_RAD( 175.f ) ) {
-    this->configMaxAngle = AI_DEG_TO_RAD(175.f);
+    // empty
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-GenVertexNormalsProcess::~GenVertexNormalsProcess()
+GenVertexNormalsProcess::~GenVertexNormalsProcess() {
-{
     // nothing to do here
 }
 

code/Importer.cpp

@@ -140,7 +140,7 @@ void AllocateFromAssimpHeap::operator delete[] ( void* data)    {
 // ------------------------------------------------------------------------------------------------
 // Importer constructor.
 Importer::Importer()
-{
+ : pimpl( NULL ) {
     // allocate the pimpl first
     pimpl = new ImporterPimpl();
 
@@ -197,7 +197,7 @@ Importer::~Importer()
 // ------------------------------------------------------------------------------------------------
 // Copy constructor - copies the config of another Importer, not the scene
 Importer::Importer(const Importer &other)
-{
+	: pimpl(NULL) {
     new(this) Importer();
 
     pimpl->mIntProperties    = other.pimpl->mIntProperties;

code/MakeVerboseFormat.cpp

@@ -174,7 +174,8 @@ bool MakeVerboseFormatProcess::MakeVerboseFormat(aiMesh* pcMesh)
         delete pcMesh->mBones[i]->mWeights;
         if (!newWeights[i].empty()) {
             pcMesh->mBones[i]->mWeights = new aiVertexWeight[newWeights[i].size()];
-            memcpy(pcMesh->mBones[i]->mWeights, &newWeights[i][0],
+            aiVertexWeight *weightToCopy = &( newWeights[i][0] );
+            memcpy(pcMesh->mBones[i]->mWeights, weightToCopy,
                 sizeof(aiVertexWeight) * newWeights[i].size());
             delete[] newWeights;
         } else {

code/ObjFileImporter.cpp

@@ -145,6 +145,13 @@ void ObjFileImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
         modelName = pFile;
     }
 
+    // This next stage takes ~ 1/3th of the total readFile task
+    // so should amount for 1/3th of the progress
+    // only update every 100KB or it'll be too slow
+    unsigned int progress = 0;
+    unsigned int progressCounter = 0;
+    const unsigned int updateProgressEveryBytes = 100 * 1024;
+    const unsigned int progressTotal = (3*m_Buffer.size()/updateProgressEveryBytes);
     // process all '\'
     std::vector<char> ::iterator iter = m_Buffer.begin();
     while (iter != m_Buffer.end())
@@ -159,10 +166,19 @@ void ObjFileImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
         }
         else
             ++iter;
+
+        if (++progressCounter >= updateProgressEveryBytes)
+        {
+            m_progress->UpdateFileRead(++progress, progressTotal);
+            progressCounter = 0;
+        }
     }
 
+    // 1/3rd progress
+    m_progress->UpdateFileRead(1, 3);
+
     // parse the file into a temporary representation
-    ObjFileParser parser(m_Buffer, modelName, pIOHandler);
+    ObjFileParser parser(m_Buffer, modelName, pIOHandler, m_progress);
 
     // And create the proper return structures out of it
     CreateDataFromImport(parser.GetModel(), pScene);

code/ObjFileParser.cpp

@@ -61,12 +61,13 @@ const std::string ObjFileParser::DEFAULT_MATERIAL = AI_DEFAULT_MATERIAL_NAME;
 
 // -------------------------------------------------------------------
 //  Constructor with loaded data and directories.
-ObjFileParser::ObjFileParser(std::vector<char> &data,const std::string &modelName, IOSystem *io ) :
+ObjFileParser::ObjFileParser(std::vector<char> &data,const std::string &modelName, IOSystem *io, ProgressHandler* progress ) :
     m_DataIt(data.begin()),
     m_DataItEnd(data.end()),
     m_pModel(NULL),
     m_uiLine(0),
-    m_pIO( io )
+    m_pIO( io ),
+    m_progress(progress)
 {
     std::fill_n(m_buffer,Buffersize,0);
 
@@ -106,8 +107,28 @@ void ObjFileParser::parseFile()
     if (m_DataIt == m_DataItEnd)
         return;
 
+    // only update every 100KB or it'll be too slow
+    const unsigned int updateProgressEveryBytes = 100 * 1024;
+    unsigned int progressCounter = 0;
+    const unsigned int bytesToProcess = std::distance(m_DataIt, m_DataItEnd);
+    const unsigned int progressTotal = 3 * bytesToProcess;
+    const unsigned int progressOffset = bytesToProcess;
+    unsigned int processed = 0;
+
+    DataArrayIt lastDataIt = m_DataIt;
+
     while (m_DataIt != m_DataItEnd)
     {
+        // Handle progress reporting
+        processed += std::distance(lastDataIt, m_DataIt);
+        lastDataIt = m_DataIt;
+        if (processed > (progressCounter * updateProgressEveryBytes))
+        {
+            progressCounter++;
+            m_progress->UpdateFileRead(progressOffset + processed*2, progressTotal);
+        }
+
+        // parse line
         switch (*m_DataIt)
         {
         case 'v': // Parse a vertex texture coordinate

code/ObjFileParser.h

@@ -59,6 +59,7 @@ namespace ObjFile {
 
 class ObjFileImporter;
 class IOSystem;
+class ProgressHandler;
 
 /// \class  ObjFileParser
 /// \brief  Parser for a obj waveform file
@@ -71,7 +72,7 @@ public:
 
 public:
     /// \brief  Constructor with data array.
-    ObjFileParser(std::vector<char> &Data,const std::string &strModelName, IOSystem* io);
+    ObjFileParser(std::vector<char> &Data,const std::string &strModelName, IOSystem* io, ProgressHandler* progress);
     /// \brief  Destructor
     ~ObjFileParser();
     /// \brief  Model getter.
@@ -139,6 +140,8 @@ private:
     char m_buffer[Buffersize];
     /// Pointer to IO system instance.
     IOSystem *m_pIO;
+    //! Pointer to progress handler
+    ProgressHandler* m_progress;
     /// Path to the current model
 };
 

contrib/openddlparser/code/OpenDDLCommon.cpp

@@ -151,6 +151,16 @@ DataArrayList::~DataArrayList() {
     // empty
 }
 
+size_t DataArrayList::size() {
+    size_t result=1;
+    DataArrayList *n=m_next;
+    while( n!=ddl_nullptr ) {
+        result++;
+        n=n->m_next;
+    }
+    return result;
+}
+
 Context::Context()
 : m_root( ddl_nullptr ) {
     // empty

contrib/openddlparser/code/OpenDDLExport.cpp

@@ -29,12 +29,30 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 BEGIN_ODDLPARSER_NS
 
-IOStreamBase::IOStreamBase()
+StreamFormatterBase::StreamFormatterBase() {
-: m_file( ddl_nullptr ) {
+
-    // empty
 }
+
+StreamFormatterBase::~StreamFormatterBase() {
+
+}
+
+std::string StreamFormatterBase::format( const std::string &statement ) {
+    std::string tmp( statement );
+    return tmp;
+}
+
+IOStreamBase::IOStreamBase( StreamFormatterBase *formatter )
+: m_formatter( formatter )
+, m_file( ddl_nullptr ) {
+    if (ddl_nullptr == m_formatter) {
+        m_formatter = new StreamFormatterBase;
+    }
+}
+
 IOStreamBase::~IOStreamBase() {
-    // empty
+    delete m_formatter;
+    m_formatter = ddl_nullptr;
 }
 
 bool IOStreamBase::open( const std::string &name ) {
@@ -57,12 +75,12 @@ bool IOStreamBase::close() {
     return true;
 }
 
-void IOStreamBase::write( const std::string &statement ) {
+size_t IOStreamBase::write( const std::string &statement ) {
     if (ddl_nullptr == m_file) {
-        return;
+        return 0;
     }
-
+    std::string formatStatement = m_formatter->format( statement );
-    ::fwrite( statement.c_str(), sizeof( char ), statement.size(), m_file );
+    return ::fwrite( formatStatement.c_str(), sizeof( char ), formatStatement.size(), m_file );
 }
 
 struct DDLNodeIterator {
@@ -88,6 +106,10 @@ struct DDLNodeIterator {
 
         return false;
     }
+
+private:
+    DDLNodeIterator() ddl_no_copy;
+    DDLNodeIterator &operator = ( const DDLNodeIterator & ) ddl_no_copy;
 };
 
 static void writeLineEnd( std::string &statement ) {
@@ -410,3 +432,4 @@ bool OpenDDLExport::writeValueArray( DataArrayList *al, std::string &statement )
 }
 
 END_ODDLPARSER_NS
+

contrib/openddlparser/code/OpenDDLParser.cpp

@@ -33,7 +33,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #  include <windows.h>
 #endif // _WIN32
 
-#define DEBUG_HEADER_NAME 
 
 BEGIN_ODDLPARSER_NS
 
@@ -74,7 +73,10 @@ const char *getTypeToken( Value::ValueType  type ) {
 
 static void logInvalidTokenError( char *in, const std::string &exp, OpenDDLParser::logCallback callback ) {
     std::stringstream stream;
-    stream << "Invalid token " << *in << ", " << exp << " expected." << std::endl;
+    stream << "Invalid token \"" << *in << "\"" << " expected \"" << exp << "\"" << std::endl;
+    std::string full(in);
+    std::string part(full.substr(0,50));
+    stream << part;
     callback( ddl_error_msg, stream.str() );
 }
 
@@ -83,6 +85,14 @@ static bool isIntegerType( Value::ValueType integerType ) {
             integerType != Value::ddl_int32 && integerType != Value::ddl_int64 ) {
         return false;
     }
+    return true;
+}
+
+static bool isUnsignedIntegerType( Value::ValueType integerType ) {
+    if( integerType != Value::ddl_unsigned_int8 && integerType != Value::ddl_unsigned_int16 &&
+            integerType != Value::ddl_unsigned_int32 && integerType != Value::ddl_unsigned_int64 ) {
+        return false;
+    }
 
     return true;
 }
@@ -206,6 +216,9 @@ bool OpenDDLParser::parse() {
     size_t pos( current - &m_buffer[ 0 ] );
     while( pos < m_buffer.size() ) {
         current = parseNextNode( current, end );
+        if(current==ddl_nullptr) {
+            return false;
+        }
         pos = current - &m_buffer[ 0 ];
     }
     return true;
@@ -218,8 +231,6 @@ bool OpenDDLParser::exportContext( Context *ctx, const std::string &filename ) {
 
     OpenDDLExport myExporter;
     return myExporter.exportContext( ctx, filename );
-
-    return false;
 }
 
 char *OpenDDLParser::parseNextNode( char *in, char *end ) {
@@ -229,12 +240,15 @@ char *OpenDDLParser::parseNextNode( char *in, char *end ) {
     return in;
 }
 
+#ifdef DEBUG_HEADER_NAME
 static void dumpId( Identifier *id ) {
     if( ddl_nullptr != id ) {
-        if ( ddl_nullptr != id->m_text.m_buffer ) { }
+        if ( ddl_nullptr != id->m_text.m_buffer ) {
             std::cout << id->m_text.m_buffer << std::endl;
+	}
     }
 }
+#endif
 
 char *OpenDDLParser::parseHeader( char *in, char *end ) {
     if( ddl_nullptr == in || in == end ) {
@@ -260,7 +274,7 @@ char *OpenDDLParser::parseHeader( char *in, char *end ) {
 
                 if( *in != Grammar::CommaSeparator[ 0 ] && *in != Grammar::ClosePropertyToken[ 0 ] ) {
                     logInvalidTokenError( in, Grammar::ClosePropertyToken, m_logCallback );
-                    return in;
+                    return ddl_nullptr;
                 }
 
                 if( ddl_nullptr != prop && *in != Grammar::CommaSeparator[ 0 ] ) {
@@ -285,13 +299,13 @@ char *OpenDDLParser::parseHeader( char *in, char *end ) {
         }
 
         // set the properties
-        if( ddl_nullptr != first ) {
+        if( ddl_nullptr != first && ddl_nullptr != node ) {
             node->setProperties( first );
         }
 
         Name *name( ddl_nullptr );
         in = OpenDDLParser::parseName( in, end, &name );
-        if( ddl_nullptr != name ) {
+        if( ddl_nullptr != name && ddl_nullptr != node ) {
             const std::string nodeName( name->m_id->m_text.m_buffer );
             node->setName( nodeName );
         }
@@ -311,13 +325,16 @@ char *OpenDDLParser::parseStructure( char *in, char *end ) {
         // loop over all children ( data and nodes )
         do {
             in = parseStructureBody( in, end, error );
+            if(in == ddl_nullptr){
+                return ddl_nullptr;
+            }
         } while ( *in != '}' );
         in++;
     } else {
         in++;
         logInvalidTokenError( in, std::string( Grammar::OpenBracketToken ), m_logCallback );
         error = true;
-        return in;
+        return ddl_nullptr;
     }
     in = lookForNextToken( in, end );
 
@@ -375,7 +392,7 @@ char *OpenDDLParser::parseStructureBody( char *in, char *end, bool &error ) {
                 setNodeValues( top(), values );
                 setNodeReferences( top(), refs );
             } else if( arrayLen > 1 ) {
-                in = parseDataArrayList( in, end, &dtArrayList );
+                in = parseDataArrayList( in, end, type, &dtArrayList );
                 setNodeDataArrayList( top(), dtArrayList );
             } else {
                 std::cerr << "0 for array is invalid." << std::endl;
@@ -386,6 +403,7 @@ char *OpenDDLParser::parseStructureBody( char *in, char *end, bool &error ) {
         in = lookForNextToken( in, end );
         if( *in != '}' ) {
             logInvalidTokenError( in, std::string( Grammar::CloseBracketToken ), m_logCallback );
+            return ddl_nullptr;
         } else {
             //in++;
         }
@@ -479,7 +497,7 @@ char *OpenDDLParser::parseName( char *in, char *end, Name **name ) {
     if( *in == '%' ) {
         ntype = LocalName;
     }
-
+    in++;
     Name *currentName( ddl_nullptr );
     Identifier *id( ddl_nullptr );
     in = parseIdentifier( in, end, &id );
@@ -510,7 +528,7 @@ char *OpenDDLParser::parseIdentifier( char *in, char *end, Identifier **id ) {
     // get size of id
     size_t idLen( 0 );
     char *start( in );
-    while( !isSeparator( *in ) && !isNewLine( *in ) && ( in != end ) && *in != Grammar::OpenPropertyToken[ 0 ] && *in != Grammar::ClosePropertyToken[ 0 ] ) {
+    while( !isSeparator( *in ) && !isNewLine( *in ) && ( in != end ) && *in != Grammar::OpenPropertyToken[ 0 ] && *in != Grammar::ClosePropertyToken[ 0 ] && *in != '$' ) {
         ++in;
         ++idLen;
     }
@@ -631,7 +649,7 @@ char *OpenDDLParser::parseIntegerLiteral( char *in, char *end, Value **integer,
         return in;
     }
 
-    if( !isIntegerType( integerType ) ) {
+    if( !(isIntegerType( integerType ) || isUnsignedIntegerType(integerType)) ) {
         return in;
     }
 
@@ -642,7 +660,13 @@ char *OpenDDLParser::parseIntegerLiteral( char *in, char *end, Value **integer,
     }
 
     if( isNumeric( *start ) ) {
-        const int value( atoi( start ) );
+#ifdef OPENDDL_NO_USE_CPP11
+        const int64 value( atol( start ) ); // maybe not really 64bit as atoll is but exists without c++11
+        const uint64 uvalue( strtoul( start,ddl_nullptr,10 ) );
+#else
+        const int64 value( atoll( start ) );
+        const uint64 uvalue( strtoull( start,ddl_nullptr,10 ) );
+#endif
         *integer = ValueAllocator::allocPrimData( integerType );
         switch( integerType ) {
             case Value::ddl_int8:
@@ -657,6 +681,18 @@ char *OpenDDLParser::parseIntegerLiteral( char *in, char *end, Value **integer,
             case Value::ddl_int64:
                     ( *integer )->setInt64( ( int64 ) value );
                     break;
+            case Value::ddl_unsigned_int8:
+                    ( *integer )->setUnsignedInt8( (uint8) uvalue );
+                    break;
+            case Value::ddl_unsigned_int16:
+                    ( *integer )->setUnsignedInt16( ( uint16 ) uvalue );
+                    break;
+            case Value::ddl_unsigned_int32:
+                    ( *integer )->setUnsignedInt32( ( uint32 ) uvalue );
+                    break;
+            case Value::ddl_unsigned_int64:
+                    ( *integer )->setUnsignedInt64( ( uint64 ) uvalue );
+                    break;
             default:
                 break;
         }
@@ -665,7 +701,7 @@ char *OpenDDLParser::parseIntegerLiteral( char *in, char *end, Value **integer,
     return in;
 }
 
-char *OpenDDLParser::parseFloatingLiteral( char *in, char *end, Value **floating ) {
+char *OpenDDLParser::parseFloatingLiteral( char *in, char *end, Value **floating, Value::ValueType floatType) {
     *floating = ddl_nullptr;
     if( ddl_nullptr == in || in == end ) {
         return in;
@@ -690,9 +726,16 @@ char *OpenDDLParser::parseFloatingLiteral( char *in, char *end, Value **floating
     }
 
     if( ok ) {
-        const float value( ( float ) atof( start ) );
+        if(floatType == Value::ddl_double)
-        *floating = ValueAllocator::allocPrimData( Value::ddl_float );
+        {
-        ( *floating )->setFloat( value );
+            const double value( atof( start ) );
+            *floating = ValueAllocator::allocPrimData( Value::ddl_double );
+            ( *floating )->setDouble( value );
+        } else {
+            const float value( ( float ) atof( start ) );
+            *floating = ValueAllocator::allocPrimData( Value::ddl_float );
+            ( *floating )->setFloat( value );
+        }
     }
 
     return in;
@@ -856,12 +899,27 @@ char *OpenDDLParser::parseDataList( char *in, char *end, Value::ValueType type,
                     }
                 }
             } else {
-                if (Value::ddl_int32 == type) {
+                switch(type){
-                    in = parseIntegerLiteral( in, end, &current );
+                    case Value::ddl_int8:
-                } else if (Value::ddl_float == type) {
+                    case Value::ddl_int16:
-                    in = parseFloatingLiteral( in, end, &current );
+                    case Value::ddl_int32:
-                } else if (Value::ddl_string == type) {
+                    case Value::ddl_int64:
-                    in = parseStringLiteral( in, end, &current );
+                    case Value::ddl_unsigned_int8:
+                    case Value::ddl_unsigned_int16:
+                    case Value::ddl_unsigned_int32:
+                    case Value::ddl_unsigned_int64:
+                        in = parseIntegerLiteral( in, end, &current, type);
+                        break;
+                    case Value::ddl_half:
+                    case Value::ddl_float:
+                    case Value::ddl_double:
+                        in = parseFloatingLiteral( in, end, &current, type);
+                        break;
+                    case Value::ddl_string:
+                        in = parseStringLiteral( in, end, &current );
+                        break;
+                    default:
+                        break;
                 }
             }
 
@@ -895,7 +953,7 @@ static DataArrayList *createDataArrayList( Value *currentValue, size_t numValues
     return dataList;
 
 }
-char *OpenDDLParser::parseDataArrayList( char *in, char *end, DataArrayList **dataList ) {
+char *OpenDDLParser::parseDataArrayList( char *in, char *end,Value::ValueType type, DataArrayList **dataList ) {
     *dataList = ddl_nullptr;
     if( ddl_nullptr == in || in == end ) {
         return in;
@@ -910,7 +968,7 @@ char *OpenDDLParser::parseDataArrayList( char *in, char *end, DataArrayList **da
         do {
             size_t numRefs( 0 ), numValues( 0 );
             currentValue = ddl_nullptr;
-            Value::ValueType type( Value::ddl_none );
+
             in = parseDataList( in, end, type, &currentValue, numValues, &refs, numRefs );
             if( ddl_nullptr != currentValue ) {
                 if( ddl_nullptr == prev ) {

contrib/openddlparser/code/Value.cpp

@@ -316,6 +316,16 @@ Value *Value::getNext() const {
     return m_next;
 }
 
+size_t Value::size(){
+    size_t result=1;
+    Value *n=m_next;
+    while( n!=ddl_nullptr) {
+        result++;
+        n=n->m_next;
+    }
+    return result;
+}
+
 Value *ValueAllocator::allocPrimData( Value::ValueType type, size_t len ) {
     if( type == Value::ddl_none || Value::ddl_types_max == type ) {
         return ddl_nullptr;

contrib/openddlparser/include/openddlparser/OpenDDLCommon.h

@@ -56,9 +56,15 @@ BEGIN_ODDLPARSER_NS
 #ifndef OPENDDL_NO_USE_CPP11
     // All C++11 constructs
 #   define ddl_nullptr nullptr
+#   define ddl_override override
+#   define ddl_final final
+#   define ddl_no_copy = delete
 #else
     // Fall-back for older compilers
 #   define ddl_nullptr NULL
+#   define ddl_override
+#   define ddl_final
+#   define ddl_no_copy
 #endif // OPENDDL_NO_USE_CPP11
 
 // Forward declarations
@@ -122,8 +128,8 @@ struct DLL_ODDLPARSER_EXPORT Text {
     bool operator == ( const Text &rhs ) const;
 
 private:
-    Text( const Text & );
+    Text( const Text & ) ddl_no_copy;
-    Text &operator = ( const Text & );
+    Text &operator = ( const Text & ) ddl_no_copy;
 };
 
 ///	@brief  Stores an OpenDDL-specific identifier type.
@@ -147,8 +153,8 @@ struct DLL_ODDLPARSER_EXPORT Identifier {
     bool operator == ( const Identifier &rhs ) const;
 
 private:
-    Identifier( const Identifier & );
+    Identifier( const Identifier & ) ddl_no_copy;
-    Identifier &operator = ( const Identifier & );
+    Identifier &operator = ( const Identifier & ) ddl_no_copy;
 };
 
 ///	@brief  Description of the type of a name.
@@ -171,8 +177,8 @@ struct DLL_ODDLPARSER_EXPORT Name {
     ~Name();
 
 private:
-    Name( const Name & );
+    Name( const Name & ) ddl_no_copy;
-    Name &operator = ( const Name& );
+    Name &operator = ( const Name& ) ddl_no_copy;
 };
 
 ///	@brief  Stores a bundle of references.
@@ -192,8 +198,8 @@ struct DLL_ODDLPARSER_EXPORT Reference {
     ~Reference();
 
 private:
-    Reference( const Reference & );
+    Reference( const Reference & ) ddl_no_copy;
-    Reference &operator = ( const Reference & );
+    Reference &operator = ( const Reference & ) ddl_no_copy;
 };
 
 ///	@brief  Stores a property list.
@@ -214,8 +220,8 @@ struct DLL_ODDLPARSER_EXPORT Property {
     ~Property();
 
 private:
-    Property( const Property & );
+    Property( const Property & ) ddl_no_copy;
-    Property &operator = ( const Property & );
+    Property &operator = ( const Property & ) ddl_no_copy;
 };
 
 ///	@brief  Stores a data array list.
@@ -230,9 +236,12 @@ struct DLL_ODDLPARSER_EXPORT DataArrayList {
     ///	@brief  The destructor.
     ~DataArrayList();
 
+    /// @brief  Gets the length of the array
+    size_t size();
+
 private:
-    DataArrayList( const DataArrayList & ); 
+    DataArrayList( const DataArrayList & ) ddl_no_copy;
-    DataArrayList &operator = ( const DataArrayList & );
+    DataArrayList &operator = ( const DataArrayList & ) ddl_no_copy;
 };
 
 ///	@brief  Stores the context of a parsed OpenDDL declaration.
@@ -249,8 +258,8 @@ struct DLL_ODDLPARSER_EXPORT Context {
     void clear();
 
 private:
-    Context( const Context & );
+    Context( const Context & ) ddl_no_copy;
-    Context &operator = ( const Context & );
+    Context &operator = ( const Context & ) ddl_no_copy;
 };
 
 END_ODDLPARSER_NS

contrib/openddlparser/include/openddlparser/OpenDDLExport.h

@@ -27,19 +27,31 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 BEGIN_ODDLPARSER_NS
 
+//-------------------------------------------------------------------------------------------------
+/// @ingroup    IOStreamBase
+///	@brief      This class represents the stream to write out.
+//-------------------------------------------------------------------------------------------------
+class DLL_ODDLPARSER_EXPORT StreamFormatterBase {
+public:
+    StreamFormatterBase();
+    virtual ~StreamFormatterBase();
+    virtual std::string format( const std::string &statement );
+};
+
 //-------------------------------------------------------------------------------------------------
 /// @ingroup    IOStreamBase
 ///	@brief      This class represents the stream to write out.
 //-------------------------------------------------------------------------------------------------
 class DLL_ODDLPARSER_EXPORT IOStreamBase {
 public:
-    IOStreamBase();
+    IOStreamBase( StreamFormatterBase *formatter = ddl_nullptr );
     virtual ~IOStreamBase();
     virtual bool open( const std::string &anme );
     virtual bool close();
-    virtual void write( const std::string &statement );
+    virtual size_t write( const std::string &statement );
 
 private:
+    StreamFormatterBase *m_formatter;
     FILE *m_file;
 };
 

contrib/openddlparser/include/openddlparser/OpenDDLParser.h

@@ -166,12 +166,12 @@ public: // parser helpers
     static char *parseReference( char *in, char *end, std::vector<Name*> &names );
     static char *parseBooleanLiteral( char *in, char *end, Value **boolean );
     static char *parseIntegerLiteral( char *in, char *end, Value **integer, Value::ValueType integerType = Value::ddl_int32 );
-    static char *parseFloatingLiteral( char *in, char *end, Value **floating );
+    static char *parseFloatingLiteral( char *in, char *end, Value **floating, Value::ValueType floatType= Value::ddl_float );
     static char *parseStringLiteral( char *in, char *end, Value **stringData );
     static char *parseHexaLiteral( char *in, char *end, Value **data );
     static char *parseProperty( char *in, char *end, Property **prop );
     static char *parseDataList( char *in, char *end, Value::ValueType type, Value **data, size_t &numValues, Reference **refs, size_t &numRefs );
-    static char *parseDataArrayList( char *in, char *end, DataArrayList **dataList );
+    static char *parseDataArrayList( char *in, char *end, Value::ValueType type, DataArrayList **dataList );
     static const char *getVersion();
 
 private:

contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h

@@ -26,19 +26,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 BEGIN_ODDLPARSER_NS
 
-template<class T>
-inline
-bool isComment( T *in, T *end ) {
-    if( *in == '/' ) {
-        if( in + 1 != end ) {
-            if( *( in + 1 ) == '/' ) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-
 template<class T>
 inline
 bool isUpperCase( T in ) {
@@ -66,7 +53,7 @@ bool isNewLine( const T in ) {
 template<class T>
 inline
 bool isSeparator( T in ) {
-    if( isSpace( in ) || ',' == in || '{' == in || '}' == in || '[' == in ) {
+    if( isSpace( in ) || ',' == in || '{' == in || '}' == in || '[' == in || '(' == in || ')' == in ) {
         return true;
     }
     return false;
@@ -98,7 +85,7 @@ template<class T>
 inline
 bool isNumeric( const T in ) {
     return ( in >= '0' && in <= '9' );
-    //return ( chartype_table[in] );
+	//return ( chartype_table[in] );
     /*if (in >= '0' &&  in <= '9' )
     return true;
 
@@ -108,7 +95,7 @@ bool isNumeric( const T in ) {
 template<class T>
 inline
 bool isNotEndOfToken( T *in, T *end ) {
-    return ( '}' != *in && ',' != *in && !isSpace( *in ) && in != end );
+    return ( '}' != *in && ',' != *in && !isSpace( *in ) && ')' != *in && in != end );
 }
 
 template<class T>
@@ -249,4 +236,24 @@ int hex2Decimal( char in ) {
     return ErrorHex2Decimal;
 }
 
+template<class T>
+inline
+bool isComment( T *in, T *end ) {
+    if ( *in=='/' ) {
+        if ( in+1!=end ) {
+            if ( *( in+1 )=='/' ) {
+                char *drive( ( in+2 ) );
+                if ( isUpperCase<T>( *drive )||isLowerCase<T>( *drive )&&*( drive+1 )=='/' )  {
+                    return false;
+                } else {
+                    return true;
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
 END_ODDLPARSER_NS
+

contrib/openddlparser/include/openddlparser/Value.h

@@ -109,44 +109,132 @@ public:
         ddl_unsigned_int16,     ///< Unsigned integer type, 16 bytes
         ddl_unsigned_int32,     ///< Unsigned integer type, 32 bytes
         ddl_unsigned_int64,     ///< Unsigned integer type, 64 bytes
-        ddl_half,               
+        ddl_half,               ///< Half data type.
-        ddl_float,
+        ddl_float,              ///< float data type
-        ddl_double,
+        ddl_double,             ///< Double data type.
-        ddl_string,
+        ddl_string,             ///< String data type.
-        ddl_ref,
+        ddl_ref,                ///< Reference, used to define references to other data definitions.
-        ddl_types_max
+        ddl_types_max           ///< Upper limit.
     };
 
+    ///	@brief  The class constructor.
+    /// @param  type        [in] The value type.
     Value( ValueType type );
+
+    ///	@brief  The class destructor.
     ~Value();
+
+    ///	@brief  Assigns a boolean to the value.
+    /// @param  value       [in9 The value.
     void setBool( bool value );
+
+    ///	@brief  Returns the boolean value.
+    /// @return The boolean value.
     bool getBool();
+
+    ///	@brief  Assigns a int8 to the value.
+    /// @param  value       [in] The value.
     void setInt8( int8 value );
+
+    ///	@brief  Returns the int8 value.
+    /// @return The int8 value.
     int8 getInt8();
+
+    ///	@brief  Assigns a int16 to the value.
+    /// @param  value       [in] The value.
     void setInt16( int16 value );
+
+    ///	@brief  Returns the int16 value.
+    /// @return The int16 value.
     int16 getInt16();
+
+    ///	@brief  Assigns a int32 to the value.
+    /// @param  value       [in] The value.
     void setInt32( int32 value );
+
+    ///	@brief  Returns the int16 value.
+    /// @return The int32 value.
     int32 getInt32();
+
+    ///	@brief  Assigns a int64 to the value.
+    /// @param  value       [in] The value.
     void setInt64( int64 value );
+
+    ///	@brief  Returns the int16 value.
+    /// @return The int64 value.
     int64 getInt64();
+
+    ///	@brief  Assigns a unsigned int8 to the value.
+    /// @param  value       [in] The value.
     void setUnsignedInt8( uint8 value );
+
+    ///	@brief  Returns the unsigned int8 value.
+    /// @return The unsigned int8 value.
     uint8 getUnsignedInt8() const;
+
+    ///	@brief  Assigns a unsigned int16 to the value.
+    /// @param  value       [in] The value.
     void setUnsignedInt16( uint16 value );
+
+    ///	@brief  Returns the unsigned int16 value.
+    /// @return The unsigned int16 value.
     uint16 getUnsignedInt16() const;
+
+    ///	@brief  Assigns a unsigned int32 to the value.
+    /// @param  value       [in] The value.
     void setUnsignedInt32( uint32 value );
+
+    ///	@brief  Returns the unsigned int8 value.
+    /// @return The unsigned int32 value.
     uint32 getUnsignedInt32() const;
+
+    ///	@brief  Assigns a unsigned int64 to the value.
+    /// @param  value       [in] The value.
     void setUnsignedInt64( uint64 value );
+
+    ///	@brief  Returns the unsigned int64 value.
+    /// @return The unsigned int64 value.
     uint64 getUnsignedInt64() const;
+
+    ///	@brief  Assigns a float to the value.
+    /// @param  value       [in] The value.
     void setFloat( float value );
+
+    ///	@brief  Returns the float value.
+    /// @return The float value.
     float getFloat() const;
+
+    ///	@brief  Assigns a double to the value.
+    /// @param  value       [in] The value.
     void setDouble( double value );
+
+    ///	@brief  Returns the double value.
+    /// @return The double value.
     double getDouble() const;
+
+    ///	@brief  Assigns a std::string to the value.
+    /// @param  value       [in] The value.
     void setString( const std::string &str );
+
+    ///	@brief  Returns the std::string value.
+    /// @return The std::string value.
     const char *getString() const;
+
+    ///	@brief  Dumps the value.
     void dump();
+
+    ///	@brief  Assigns the next value.
+    ///	@param  next        [n] The next value.
     void setNext( Value *next );
+
+    ///	@brief  Returns the next value.
+    /// @return The next value.s
     Value *getNext() const;
 
+    /// @brief  Gets the length of the array.
+    /// @return The number of items in the array.
+    size_t size();
+
     ValueType m_type;
     size_t m_size;
     unsigned char *m_data;

include/assimp/ai_assert.h

@@ -1,5 +1,43 @@
-/** @file ai_assert.h
+/*
- */
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2016, 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.
+---------------------------------------------------------------------------
+*/
 #ifndef AI_DEBUG_H_INC
 #define AI_DEBUG_H_INC
 

include/assimp/mesh.h

@@ -249,7 +249,8 @@ struct aiBone
 
     //! Default constructor
     aiBone()
-      : mNumWeights( 0 )
+        : mName()
+        , mNumWeights( 0 )
       , mWeights( NULL )
     {
     }