Refactor: Expand tabs to 4 spaces

include/assimp/DefaultLogger.hpp

@@ -48,7 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "NullLogger.hpp"
 #include <vector>
 
-namespace Assimp	{
+namespace Assimp    {
 // ------------------------------------------------------------------------------------
 class IOStream;
 struct LogStreamInfo;
@@ -70,118 +70,118 @@ struct LogStreamInfo;
  *  implementation of #Logger to #set().
  *  @note The whole logging stuff causes a small extra overhead for all imports. */
 class ASSIMP_API DefaultLogger :
-	public Logger	{
+    public Logger   {
 
 public:
 
-	// ----------------------------------------------------------------------
-	/** @brief Creates a logging instance.
-	 *  @param name Name for log file. Only valid in combination
-	 *    with the aiDefaultLogStream_FILE flag.
-	 *  @param severity	Log severity, VERBOSE turns on debug messages
-	 *  @param defStreams  Default log streams to be attached. Any bitwise
-	 *    combination of the aiDefaultLogStream enumerated values.
-	 *    If #aiDefaultLogStream_FILE is specified but an empty string is
-	 *    passed for 'name', no log file is created at all.
-	 *  @param  io IOSystem to be used to open external files (such as the
-	 *   log file). Pass NULL to rely on the default implementation.
-	 *  This replaces the default #NullLogger with a #DefaultLogger instance. */
-	static Logger *create(const char* name = ASSIMP_DEFAULT_LOG_NAME,
-		LogSeverity severity    = NORMAL,
-		unsigned int defStreams = aiDefaultLogStream_DEBUGGER | aiDefaultLogStream_FILE,
-		IOSystem* io		    = NULL);
-
-	// ----------------------------------------------------------------------
-	/** @brief Setup a custom #Logger implementation.
-	 *
-	 *  Use this if the provided #DefaultLogger class doesn't fit into
-	 *  your needs. If the provided message formatting is OK for you,
-	 *  it's much easier to use #create() and to attach your own custom
-	 *  output streams to it.
-	 *  @param logger Pass NULL to setup a default NullLogger*/
-	static void set (Logger *logger);
-
-	// ----------------------------------------------------------------------
-	/** @brief	Getter for singleton instance
-	 *	 @return Only instance. This is never null, but it could be a
-	 *  NullLogger. Use isNullLogger to check this.*/
-	static Logger *get();
-
-	// ----------------------------------------------------------------------
-	/** @brief  Return whether a #NullLogger is currently active
-	 *  @return true if the current logger is a #NullLogger.
-	 *  Use create() or set() to setup a logger that does actually do
-	 *  something else than just rejecting all log messages. */
-	static bool isNullLogger();
-
-	// ----------------------------------------------------------------------
-	/** @brief	Kills the current singleton logger and replaces it with a
-	 *  #NullLogger instance. */
-	static void kill();
-
-	// ----------------------------------------------------------------------
-	/**	@copydoc Logger::attachStream   */
-	bool attachStream(LogStream *pStream,
-		unsigned int severity);
-
-	// ----------------------------------------------------------------------
-	/**	@copydoc Logger::detatchStream */
-	bool detatchStream(LogStream *pStream,
-		unsigned int severity);
+    // ----------------------------------------------------------------------
+    /** @brief Creates a logging instance.
+     *  @param name Name for log file. Only valid in combination
+     *    with the aiDefaultLogStream_FILE flag.
+     *  @param severity Log severity, VERBOSE turns on debug messages
+     *  @param defStreams  Default log streams to be attached. Any bitwise
+     *    combination of the aiDefaultLogStream enumerated values.
+     *    If #aiDefaultLogStream_FILE is specified but an empty string is
+     *    passed for 'name', no log file is created at all.
+     *  @param  io IOSystem to be used to open external files (such as the
+     *   log file). Pass NULL to rely on the default implementation.
+     *  This replaces the default #NullLogger with a #DefaultLogger instance. */
+    static Logger *create(const char* name = ASSIMP_DEFAULT_LOG_NAME,
+        LogSeverity severity    = NORMAL,
+        unsigned int defStreams = aiDefaultLogStream_DEBUGGER | aiDefaultLogStream_FILE,
+        IOSystem* io            = NULL);
+
+    // ----------------------------------------------------------------------
+    /** @brief Setup a custom #Logger implementation.
+     *
+     *  Use this if the provided #DefaultLogger class doesn't fit into
+     *  your needs. If the provided message formatting is OK for you,
+     *  it's much easier to use #create() and to attach your own custom
+     *  output streams to it.
+     *  @param logger Pass NULL to setup a default NullLogger*/
+    static void set (Logger *logger);
+
+    // ----------------------------------------------------------------------
+    /** @brief  Getter for singleton instance
+     *   @return Only instance. This is never null, but it could be a
+     *  NullLogger. Use isNullLogger to check this.*/
+    static Logger *get();
+
+    // ----------------------------------------------------------------------
+    /** @brief  Return whether a #NullLogger is currently active
+     *  @return true if the current logger is a #NullLogger.
+     *  Use create() or set() to setup a logger that does actually do
+     *  something else than just rejecting all log messages. */
+    static bool isNullLogger();
+
+    // ----------------------------------------------------------------------
+    /** @brief  Kills the current singleton logger and replaces it with a
+     *  #NullLogger instance. */
+    static void kill();
+
+    // ----------------------------------------------------------------------
+    /** @copydoc Logger::attachStream   */
+    bool attachStream(LogStream *pStream,
+        unsigned int severity);
+
+    // ----------------------------------------------------------------------
+    /** @copydoc Logger::detatchStream */
+    bool detatchStream(LogStream *pStream,
+        unsigned int severity);
 
 
 private:
 
-	// ----------------------------------------------------------------------
-	/** @briefPrivate construction for internal use by create().
-	 *  @param severity Logging granularity  */
-	DefaultLogger(LogSeverity severity);
+    // ----------------------------------------------------------------------
+    /** @briefPrivate construction for internal use by create().
+     *  @param severity Logging granularity  */
+    DefaultLogger(LogSeverity severity);
 
-	// ----------------------------------------------------------------------
-	/**	@briefDestructor	*/
-	~DefaultLogger();
+    // ----------------------------------------------------------------------
+    /** @briefDestructor    */
+    ~DefaultLogger();
 
 private:
 
-	/**	@brief	Logs debug infos, only been written when severity level VERBOSE is set */
-	void OnDebug(const char* message);
+    /** @brief  Logs debug infos, only been written when severity level VERBOSE is set */
+    void OnDebug(const char* message);
 
-	/**	@brief	Logs an info message */
-	void OnInfo(const char*  message);
+    /** @brief  Logs an info message */
+    void OnInfo(const char*  message);
 
-	/**	@brief	Logs a warning message */
-	void OnWarn(const char*  message);
+    /** @brief  Logs a warning message */
+    void OnWarn(const char*  message);
 
-	/**	@brief	Logs an error message */
-	void OnError(const char* message);
+    /** @brief  Logs an error message */
+    void OnError(const char* message);
 
-	// ----------------------------------------------------------------------
-	/**	@brief Writes a message to all streams */
-	void WriteToStreams(const char* message, ErrorSeverity ErrorSev );
+    // ----------------------------------------------------------------------
+    /** @brief Writes a message to all streams */
+    void WriteToStreams(const char* message, ErrorSeverity ErrorSev );
 
-	// ----------------------------------------------------------------------
-	/** @brief Returns the thread id.
-	 *	@note This is an OS specific feature, if not supported, a
-	 *    zero will be returned.
-	 */
-	unsigned int GetThreadID();
+    // ----------------------------------------------------------------------
+    /** @brief Returns the thread id.
+     *  @note This is an OS specific feature, if not supported, a
+     *    zero will be returned.
+     */
+    unsigned int GetThreadID();
 
 private:
-	//	Aliases for stream container
-	typedef std::vector<LogStreamInfo*>	StreamArray;
-	typedef std::vector<LogStreamInfo*>::iterator StreamIt;
-	typedef std::vector<LogStreamInfo*>::const_iterator ConstStreamIt;
+    //  Aliases for stream container
+    typedef std::vector<LogStreamInfo*> StreamArray;
+    typedef std::vector<LogStreamInfo*>::iterator StreamIt;
+    typedef std::vector<LogStreamInfo*>::const_iterator ConstStreamIt;
 
-	//!	only logging instance
-	static Logger *m_pLogger;
-	static NullLogger s_pNullLogger;
+    //! only logging instance
+    static Logger *m_pLogger;
+    static NullLogger s_pNullLogger;
 
-	//!	Attached streams
-	StreamArray	m_StreamArray;
+    //! Attached streams
+    StreamArray m_StreamArray;
 
-	bool noRepeatMsg;
-	char lastMsg[MAX_LOG_MESSAGE_LENGTH*2];
-	size_t lastLen;
+    bool noRepeatMsg;
+    char lastMsg[MAX_LOG_MESSAGE_LENGTH*2];
+    size_t lastLen;
 };
 // ------------------------------------------------------------------------------------
 

include/assimp/Exporter.hpp

@@ -50,9 +50,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "cexport.h"
 #include <map>
 
-namespace Assimp	{
-	class ExporterPimpl;
-	class IOSystem;
+namespace Assimp    {
+    class ExporterPimpl;
+    class IOSystem;
 
 
 // ----------------------------------------------------------------------------------
@@ -77,426 +77,426 @@ namespace Assimp	{
 class ASSIMP_API ExportProperties;
 
 class ASSIMP_API Exporter
-	// TODO: causes good ol' base class has no dll interface warning
+    // TODO: causes good ol' base class has no dll interface warning
 //#ifdef __cplusplus
-//	: public boost::noncopyable
+//  : public boost::noncopyable
 //#endif // __cplusplus
 {
 public:
 
-	/** Function pointer type of a Export worker function */
-	typedef void (*fpExportFunc)(const char*, IOSystem*, const aiScene*, const ExportProperties*);
-
-	/** Internal description of an Assimp export format option */
-	struct ExportFormatEntry
-	{
-		/// Public description structure to be returned by aiGetExportFormatDescription()
-		aiExportFormatDesc mDescription;
-
-		// Worker function to do the actual exporting
-		fpExportFunc mExportFunction;
-
-		// Postprocessing steps to be executed PRIOR to invoking mExportFunction
-		unsigned int mEnforcePP;
-
-		// Constructor to fill all entries
-		ExportFormatEntry( const char* pId, const char* pDesc, const char* pExtension, fpExportFunc pFunction, unsigned int pEnforcePP = 0u)
-		{
-			mDescription.id = pId;
-			mDescription.description = pDesc;
-			mDescription.fileExtension = pExtension;
-			mExportFunction = pFunction;
-			mEnforcePP = pEnforcePP;
-		}
-
-		ExportFormatEntry() :
-		    mExportFunction()
-		  , mEnforcePP()
-		{
-			mDescription.id = NULL;
-			mDescription.description = NULL;
-			mDescription.fileExtension = NULL;
-		}
-	};
+    /** Function pointer type of a Export worker function */
+    typedef void (*fpExportFunc)(const char*, IOSystem*, const aiScene*, const ExportProperties*);
+
+    /** Internal description of an Assimp export format option */
+    struct ExportFormatEntry
+    {
+        /// Public description structure to be returned by aiGetExportFormatDescription()
+        aiExportFormatDesc mDescription;
+
+        // Worker function to do the actual exporting
+        fpExportFunc mExportFunction;
+
+        // Postprocessing steps to be executed PRIOR to invoking mExportFunction
+        unsigned int mEnforcePP;
+
+        // Constructor to fill all entries
+        ExportFormatEntry( const char* pId, const char* pDesc, const char* pExtension, fpExportFunc pFunction, unsigned int pEnforcePP = 0u)
+        {
+            mDescription.id = pId;
+            mDescription.description = pDesc;
+            mDescription.fileExtension = pExtension;
+            mExportFunction = pFunction;
+            mEnforcePP = pEnforcePP;
+        }
+
+        ExportFormatEntry() :
+            mExportFunction()
+          , mEnforcePP()
+        {
+            mDescription.id = NULL;
+            mDescription.description = NULL;
+            mDescription.fileExtension = NULL;
+        }
+    };
 
 
 public:
 
 
-	Exporter();
-	~Exporter();
+    Exporter();
+    ~Exporter();
 
 public:
 
 
-	// -------------------------------------------------------------------
-	/** Supplies a custom IO handler to the exporter to use to open and
-	 * access files.
-	 *
-	 * If you need #Export to use custom IO logic to access the files,
-	 * you need to supply a custom implementation of IOSystem and
-	 * IOFile to the exporter.
-	 *
-	 * #Exporter takes ownership of the object and will destroy it
-	 * afterwards. The previously assigned handler will be deleted.
-	 * Pass NULL to take again ownership of your IOSystem and reset Assimp
-	 * to use its default implementation, which uses plain file IO.
-	 *
-	 * @param pIOHandler The IO handler to be used in all file accesses
-	 *   of the Importer. */
-	void SetIOHandler( IOSystem* pIOHandler);
-
-	// -------------------------------------------------------------------
-	/** Retrieves the IO handler that is currently set.
-	 * You can use #IsDefaultIOHandler() to check whether the returned
-	 * interface is the default IO handler provided by ASSIMP. The default
-	 * handler is active as long the application doesn't supply its own
-	 * custom IO handler via #SetIOHandler().
-	 * @return A valid IOSystem interface, never NULL. */
-	IOSystem* GetIOHandler() const;
-
-	// -------------------------------------------------------------------
-	/** Checks whether a default IO handler is active
-	 * A default handler is active as long the application doesn't
-	 * supply its own custom IO handler via #SetIOHandler().
-	 * @return true by default */
-	bool IsDefaultIOHandler() const;
-
-
-
-	// -------------------------------------------------------------------
-	/** Exports the given scene to a chosen file format. Returns the exported
-	* data as a binary blob which you can write into a file or something.
-	* When you're done with the data, simply let the #Exporter instance go
-	* out of scope to have it released automatically.
-	* @param pScene The scene to export. Stays in possession of the caller,
-	*   is not changed by the function.
-	* @param pFormatId ID string to specify to which format you want to
-	*   export to. Use
-	* #GetExportFormatCount / #GetExportFormatDescription to learn which
-	*   export formats are available.
-	* @param pPreprocessing See the documentation for #Export
-	* @return the exported data or NULL in case of error.
-	* @note If the Exporter instance did already hold a blob from
-	*   a previous call to #ExportToBlob, it will be disposed.
-	*   Any IO handlers set via #SetIOHandler are ignored here.
-	* @note Use aiCopyScene() to get a modifiable copy of a previously
-	*   imported scene. */
-	const aiExportDataBlob* ExportToBlob(  const aiScene* pScene, const char* pFormatId, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
-	inline const aiExportDataBlob* ExportToBlob(  const aiScene* pScene, const std::string& pFormatId, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
-
-
-	// -------------------------------------------------------------------
-	/** Convenience function to export directly to a file. Use
-	 *  #SetIOSystem to supply a custom IOSystem to gain fine-grained control
-	 *  about the output data flow of the export process.
-	 * @param pBlob A data blob obtained from a previous call to #aiExportScene. Must not be NULL.
-	 * @param pPath Full target file name. Target must be accessible.
-	 * @param pPreprocessing Accepts any choice of the #aiPostProcessSteps enumerated
-	 *   flags, but in reality only a subset of them makes sense here. Specifying
-	 *   'preprocessing' flags is useful if the input scene does not conform to
-	 *   Assimp's default conventions as specified in the @link data Data Structures Page @endlink.
-	 *   In short, this means the geometry data should use a right-handed coordinate systems, face
-	 *   winding should be counter-clockwise and the UV coordinate origin is assumed to be in
-	 *   the upper left. The #aiProcess_MakeLeftHanded, #aiProcess_FlipUVs and
-	 *   #aiProcess_FlipWindingOrder flags are used in the import side to allow users
-	 *   to have those defaults automatically adapted to their conventions. Specifying those flags
-	 *   for exporting has the opposite effect, respectively. Some other of the
-	 *   #aiPostProcessSteps enumerated values may be useful as well, but you'll need
-	 *   to try out what their effect on the exported file is. Many formats impose
-	 *   their own restrictions on the structure of the geometry stored therein,
-	 *   so some preprocessing may have little or no effect at all, or may be
-	 *   redundant as exporters would apply them anyhow. A good example
-	 *   is triangulation - whilst you can enforce it by specifying
-	 *   the #aiProcess_Triangulate flag, most export formats support only
-	 *   triangulate data so they would run the step even if it wasn't requested.
-	 *
-	 *   If assimp detects that the input scene was directly taken from the importer side of
+    // -------------------------------------------------------------------
+    /** Supplies a custom IO handler to the exporter to use to open and
+     * access files.
+     *
+     * If you need #Export to use custom IO logic to access the files,
+     * you need to supply a custom implementation of IOSystem and
+     * IOFile to the exporter.
+     *
+     * #Exporter takes ownership of the object and will destroy it
+     * afterwards. The previously assigned handler will be deleted.
+     * Pass NULL to take again ownership of your IOSystem and reset Assimp
+     * to use its default implementation, which uses plain file IO.
+     *
+     * @param pIOHandler The IO handler to be used in all file accesses
+     *   of the Importer. */
+    void SetIOHandler( IOSystem* pIOHandler);
+
+    // -------------------------------------------------------------------
+    /** Retrieves the IO handler that is currently set.
+     * You can use #IsDefaultIOHandler() to check whether the returned
+     * interface is the default IO handler provided by ASSIMP. The default
+     * handler is active as long the application doesn't supply its own
+     * custom IO handler via #SetIOHandler().
+     * @return A valid IOSystem interface, never NULL. */
+    IOSystem* GetIOHandler() const;
+
+    // -------------------------------------------------------------------
+    /** Checks whether a default IO handler is active
+     * A default handler is active as long the application doesn't
+     * supply its own custom IO handler via #SetIOHandler().
+     * @return true by default */
+    bool IsDefaultIOHandler() const;
+
+
+
+    // -------------------------------------------------------------------
+    /** Exports the given scene to a chosen file format. Returns the exported
+    * data as a binary blob which you can write into a file or something.
+    * When you're done with the data, simply let the #Exporter instance go
+    * out of scope to have it released automatically.
+    * @param pScene The scene to export. Stays in possession of the caller,
+    *   is not changed by the function.
+    * @param pFormatId ID string to specify to which format you want to
+    *   export to. Use
+    * #GetExportFormatCount / #GetExportFormatDescription to learn which
+    *   export formats are available.
+    * @param pPreprocessing See the documentation for #Export
+    * @return the exported data or NULL in case of error.
+    * @note If the Exporter instance did already hold a blob from
+    *   a previous call to #ExportToBlob, it will be disposed.
+    *   Any IO handlers set via #SetIOHandler are ignored here.
+    * @note Use aiCopyScene() to get a modifiable copy of a previously
+    *   imported scene. */
+    const aiExportDataBlob* ExportToBlob(  const aiScene* pScene, const char* pFormatId, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
+    inline const aiExportDataBlob* ExportToBlob(  const aiScene* pScene, const std::string& pFormatId, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
+
+
+    // -------------------------------------------------------------------
+    /** Convenience function to export directly to a file. Use
+     *  #SetIOSystem to supply a custom IOSystem to gain fine-grained control
+     *  about the output data flow of the export process.
+     * @param pBlob A data blob obtained from a previous call to #aiExportScene. Must not be NULL.
+     * @param pPath Full target file name. Target must be accessible.
+     * @param pPreprocessing Accepts any choice of the #aiPostProcessSteps enumerated
+     *   flags, but in reality only a subset of them makes sense here. Specifying
+     *   'preprocessing' flags is useful if the input scene does not conform to
+     *   Assimp's default conventions as specified in the @link data Data Structures Page @endlink.
+     *   In short, this means the geometry data should use a right-handed coordinate systems, face
+     *   winding should be counter-clockwise and the UV coordinate origin is assumed to be in
+     *   the upper left. The #aiProcess_MakeLeftHanded, #aiProcess_FlipUVs and
+     *   #aiProcess_FlipWindingOrder flags are used in the import side to allow users
+     *   to have those defaults automatically adapted to their conventions. Specifying those flags
+     *   for exporting has the opposite effect, respectively. Some other of the
+     *   #aiPostProcessSteps enumerated values may be useful as well, but you'll need
+     *   to try out what their effect on the exported file is. Many formats impose
+     *   their own restrictions on the structure of the geometry stored therein,
+     *   so some preprocessing may have little or no effect at all, or may be
+     *   redundant as exporters would apply them anyhow. A good example
+     *   is triangulation - whilst you can enforce it by specifying
+     *   the #aiProcess_Triangulate flag, most export formats support only
+     *   triangulate data so they would run the step even if it wasn't requested.
+     *
+     *   If assimp detects that the input scene was directly taken from the importer side of
      *   the library (i.e. not copied using aiCopyScene and potetially modified afterwards),
      *   any postprocessing steps already applied to the scene will not be applied again, unless
      *   they show non-idempotent behaviour (#aiProcess_MakeLeftHanded, #aiProcess_FlipUVs and
      *   #aiProcess_FlipWindingOrder).
-	 * @return AI_SUCCESS if everything was fine.
-	 * @note Use aiCopyScene() to get a modifiable copy of a previously
-	 *   imported scene.*/
-	aiReturn Export( const aiScene* pScene, const char* pFormatId, const char* pPath, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
-	inline aiReturn Export( const aiScene* pScene, const std::string& pFormatId, const std::string& pPath,  unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
-
-
-	// -------------------------------------------------------------------
-	/** Returns an error description of an error that occurred in #Export
-	 *    or #ExportToBlob
-	 *
-	 * Returns an empty string if no error occurred.
-	 * @return A description of the last error, an empty string if no
-	 *   error occurred. The string is never NULL.
-	 *
-	 * @note The returned function remains valid until one of the
-	 * following methods is called: #Export, #ExportToBlob, #FreeBlob */
-	const char* GetErrorString() const;
-
-
-	// -------------------------------------------------------------------
-	/** Return the blob obtained from the last call to #ExportToBlob */
-	const aiExportDataBlob* GetBlob() const;
-
-
-	// -------------------------------------------------------------------
-	/** Orphan the blob from the last call to #ExportToBlob. This means
-	 *  the caller takes ownership and is thus responsible for calling
-	 *  the C API function #aiReleaseExportBlob to release it. */
-	const aiExportDataBlob* GetOrphanedBlob() const;
-
-
-	// -------------------------------------------------------------------
-	/** Frees the current blob.
-	 *
-	 *  The function does nothing if no blob has previously been
-	 *  previously produced via #ExportToBlob. #FreeBlob is called
-	 *  automatically by the destructor. The only reason to call
-	 *  it manually would be to reclain as much storage as possible
-	 *  without giving up the #Exporter instance yet. */
-	void FreeBlob( );
-
-
-	// -------------------------------------------------------------------
-	/** Returns the number of export file formats available in the current
-	 *  Assimp build. Use #Exporter::GetExportFormatDescription to
-	 *  retrieve infos of a specific export format.
-	 *
-	 *  This includes built-in exporters as well as exporters registered
-	 *  using #RegisterExporter.
-	 **/
-	size_t GetExportFormatCount() const;
-
-
-	// -------------------------------------------------------------------
-	/** Returns a description of the nth export file format. Use #
-	 *  #Exporter::GetExportFormatCount to learn how many export
-	 *  formats are supported.
-	 *
-	 * The returned pointer is of static storage duration iff the
-	 * pIndex pertains to a built-in exporter (i.e. one not registered
-	 * via #RegistrerExporter). It is restricted to the life-time of the
-	 * #Exporter instance otherwise.
-	 *
-	 * @param pIndex Index of the export format to retrieve information
-	 *  for. Valid range is 0 to #Exporter::GetExportFormatCount
-	 * @return A description of that specific export format.
-	 *  NULL if pIndex is out of range. */
-	const aiExportFormatDesc* GetExportFormatDescription( size_t pIndex ) const;
-
-
-	// -------------------------------------------------------------------
-	/** Register a custom exporter. Custom export formats are limited to
-	 *    to the current #Exporter instance and do not affect the
-	 *    library globally. The indexes under which the format's
-	 *    export format description can be queried are assigned
-	 *    monotonously.
-	 *  @param desc Exporter description.
-	 *  @return aiReturn_SUCCESS if the export format was successfully
-	 *    registered. A common cause that would prevent an exporter
-	 *    from being registered is that its format id is already
-	 *    occupied by another format. */
-	aiReturn RegisterExporter(const ExportFormatEntry& desc);
-
-
-	// -------------------------------------------------------------------
-	/** Remove an export format previously registered with #RegisterExporter
-	 *  from the #Exporter instance (this can also be used to drop
-	 *  builtin exporters because those are implicitly registered
-	 *  using #RegisterExporter).
-	 *  @param id Format id to be unregistered, this refers to the
-	 *    'id' field of #aiExportFormatDesc.
-	 *  @note Calling this method on a format description not yet registered
-	 *    has no effect.*/
-	void UnregisterExporter(const char* id);
+     * @return AI_SUCCESS if everything was fine.
+     * @note Use aiCopyScene() to get a modifiable copy of a previously
+     *   imported scene.*/
+    aiReturn Export( const aiScene* pScene, const char* pFormatId, const char* pPath, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
+    inline aiReturn Export( const aiScene* pScene, const std::string& pFormatId, const std::string& pPath,  unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
+
+
+    // -------------------------------------------------------------------
+    /** Returns an error description of an error that occurred in #Export
+     *    or #ExportToBlob
+     *
+     * Returns an empty string if no error occurred.
+     * @return A description of the last error, an empty string if no
+     *   error occurred. The string is never NULL.
+     *
+     * @note The returned function remains valid until one of the
+     * following methods is called: #Export, #ExportToBlob, #FreeBlob */
+    const char* GetErrorString() const;
+
+
+    // -------------------------------------------------------------------
+    /** Return the blob obtained from the last call to #ExportToBlob */
+    const aiExportDataBlob* GetBlob() const;
+
+
+    // -------------------------------------------------------------------
+    /** Orphan the blob from the last call to #ExportToBlob. This means
+     *  the caller takes ownership and is thus responsible for calling
+     *  the C API function #aiReleaseExportBlob to release it. */
+    const aiExportDataBlob* GetOrphanedBlob() const;
+
+
+    // -------------------------------------------------------------------
+    /** Frees the current blob.
+     *
+     *  The function does nothing if no blob has previously been
+     *  previously produced via #ExportToBlob. #FreeBlob is called
+     *  automatically by the destructor. The only reason to call
+     *  it manually would be to reclain as much storage as possible
+     *  without giving up the #Exporter instance yet. */
+    void FreeBlob( );
+
+
+    // -------------------------------------------------------------------
+    /** Returns the number of export file formats available in the current
+     *  Assimp build. Use #Exporter::GetExportFormatDescription to
+     *  retrieve infos of a specific export format.
+     *
+     *  This includes built-in exporters as well as exporters registered
+     *  using #RegisterExporter.
+     **/
+    size_t GetExportFormatCount() const;
+
+
+    // -------------------------------------------------------------------
+    /** Returns a description of the nth export file format. Use #
+     *  #Exporter::GetExportFormatCount to learn how many export
+     *  formats are supported.
+     *
+     * The returned pointer is of static storage duration iff the
+     * pIndex pertains to a built-in exporter (i.e. one not registered
+     * via #RegistrerExporter). It is restricted to the life-time of the
+     * #Exporter instance otherwise.
+     *
+     * @param pIndex Index of the export format to retrieve information
+     *  for. Valid range is 0 to #Exporter::GetExportFormatCount
+     * @return A description of that specific export format.
+     *  NULL if pIndex is out of range. */
+    const aiExportFormatDesc* GetExportFormatDescription( size_t pIndex ) const;
+
+
+    // -------------------------------------------------------------------
+    /** Register a custom exporter. Custom export formats are limited to
+     *    to the current #Exporter instance and do not affect the
+     *    library globally. The indexes under which the format's
+     *    export format description can be queried are assigned
+     *    monotonously.
+     *  @param desc Exporter description.
+     *  @return aiReturn_SUCCESS if the export format was successfully
+     *    registered. A common cause that would prevent an exporter
+     *    from being registered is that its format id is already
+     *    occupied by another format. */
+    aiReturn RegisterExporter(const ExportFormatEntry& desc);
+
+
+    // -------------------------------------------------------------------
+    /** Remove an export format previously registered with #RegisterExporter
+     *  from the #Exporter instance (this can also be used to drop
+     *  builtin exporters because those are implicitly registered
+     *  using #RegisterExporter).
+     *  @param id Format id to be unregistered, this refers to the
+     *    'id' field of #aiExportFormatDesc.
+     *  @note Calling this method on a format description not yet registered
+     *    has no effect.*/
+    void UnregisterExporter(const char* id);
 
 
 protected:
 
-	// Just because we don't want you to know how we're hacking around.
-	ExporterPimpl* pimpl;
+    // Just because we don't want you to know how we're hacking around.
+    ExporterPimpl* pimpl;
 };
 
 
 class ASSIMP_API ExportProperties
 {
 public:
-	// Data type to store the key hash
-	typedef unsigned int KeyType;
+    // Data type to store the key hash
+    typedef unsigned int KeyType;
 
-	// typedefs for our four configuration maps.
-	// We don't need more, so there is no need for a generic solution
-	typedef std::map<KeyType, int> IntPropertyMap;
-	typedef std::map<KeyType, float> FloatPropertyMap;
-	typedef std::map<KeyType, std::string> StringPropertyMap;
-	typedef std::map<KeyType, aiMatrix4x4> MatrixPropertyMap;
+    // typedefs for our four configuration maps.
+    // We don't need more, so there is no need for a generic solution
+    typedef std::map<KeyType, int> IntPropertyMap;
+    typedef std::map<KeyType, float> FloatPropertyMap;
+    typedef std::map<KeyType, std::string> StringPropertyMap;
+    typedef std::map<KeyType, aiMatrix4x4> MatrixPropertyMap;
 
 public:
 
-	/** Standard constructor
-	* @see ExportProperties()
-	*/
-
-	ExportProperties();
-
-	// -------------------------------------------------------------------
-	/** Copy constructor.
-	 *
-	 * This copies the configuration properties of another ExportProperties.
-	 * @see ExportProperties(const ExportProperties& other)
-	 */
-	ExportProperties(const ExportProperties& other);
-
-	// -------------------------------------------------------------------
-	/** Set an integer configuration property.
-	 * @param szName Name of the property. All supported properties
-	 *   are defined in the aiConfig.g header (all constants share the
-	 *   prefix AI_CONFIG_XXX and are simple strings).
-	 * @param iValue New value of the property
-	 * @return true if the property was set before. The new value replaces
-	 *   the previous value in this case.
-	 * @note Property of different types (float, int, string ..) are kept
-	 *   on different stacks, so calling SetPropertyInteger() for a
-	 *   floating-point property has no effect - the loader will call
-	 *   GetPropertyFloat() to read the property, but it won't be there.
-	 */
-	bool SetPropertyInteger(const char* szName, int iValue);
-
-	// -------------------------------------------------------------------
-	/** Set a boolean configuration property. Boolean properties
-	 *  are stored on the integer stack internally so it's possible
-	 *  to set them via #SetPropertyBool and query them with
-	 *  #GetPropertyBool and vice versa.
-	 * @see SetPropertyInteger()
-	 */
-	bool SetPropertyBool(const char* szName, bool value)	{
-		return SetPropertyInteger(szName,value);
-	}
-
-	// -------------------------------------------------------------------
-	/** Set a floating-point configuration property.
-	 * @see SetPropertyInteger()
-	 */
-	bool SetPropertyFloat(const char* szName, float fValue);
-
-	// -------------------------------------------------------------------
-	/** Set a string configuration property.
-	 * @see SetPropertyInteger()
-	 */
-	bool SetPropertyString(const char* szName, const std::string& sValue);
-
-	// -------------------------------------------------------------------
-	/** Set a matrix configuration property.
-	 * @see SetPropertyInteger()
-	 */
-	bool SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue);
-
-	// -------------------------------------------------------------------
-	/** Get a configuration property.
-	 * @param szName Name of the property. All supported properties
-	 *   are defined in the aiConfig.g header (all constants share the
-	 *   prefix AI_CONFIG_XXX).
-	 * @param iErrorReturn Value that is returned if the property
-	 *   is not found.
-	 * @return Current value of the property
-	 * @note Property of different types (float, int, string ..) are kept
-	 *   on different lists, so calling SetPropertyInteger() for a
-	 *   floating-point property has no effect - the loader will call
-	 *   GetPropertyFloat() to read the property, but it won't be there.
-	 */
-	int GetPropertyInteger(const char* szName,
-		int iErrorReturn = 0xffffffff) const;
-
-	// -------------------------------------------------------------------
-	/** Get a boolean configuration property. Boolean properties
-	 *  are stored on the integer stack internally so it's possible
-	 *  to set them via #SetPropertyBool and query them with
-	 *  #GetPropertyBool and vice versa.
-	 * @see GetPropertyInteger()
-	 */
-	bool GetPropertyBool(const char* szName, bool bErrorReturn = false) const {
-		return GetPropertyInteger(szName,bErrorReturn)!=0;
-	}
-
-	// -------------------------------------------------------------------
-	/** Get a floating-point configuration property
-	 * @see GetPropertyInteger()
-	 */
-	float GetPropertyFloat(const char* szName,
-		float fErrorReturn = 10e10f) const;
-
-	// -------------------------------------------------------------------
-	/** Get a string configuration property
-	 *
-	 *  The return value remains valid until the property is modified.
-	 * @see GetPropertyInteger()
-	 */
-	const std::string GetPropertyString(const char* szName,
-		const std::string& sErrorReturn = "") const;
-
-	// -------------------------------------------------------------------
-	/** Get a matrix configuration property
-	 *
-	 *  The return value remains valid until the property is modified.
-	 * @see GetPropertyInteger()
-	 */
-	const aiMatrix4x4 GetPropertyMatrix(const char* szName,
-		const aiMatrix4x4& sErrorReturn = aiMatrix4x4()) const;
-
-	// -------------------------------------------------------------------
-	/** Determine a integer configuration property has been set.
-	* @see HasPropertyInteger()
-	 */
-	bool HasPropertyInteger(const char* szName) const;
-
-	/** Determine a boolean configuration property has been set.
-	* @see HasPropertyBool()
-	 */
-	bool HasPropertyBool(const char* szName) const;
-
-	/** Determine a boolean configuration property has been set.
-	* @see HasPropertyFloat()
-	 */
-	bool HasPropertyFloat(const char* szName) const;
-
-	/** Determine a String configuration property has been set.
-	* @see HasPropertyString()
-	 */
-	bool HasPropertyString(const char* szName) const;
-
-	/** Determine a Matrix configuration property has been set.
-	* @see HasPropertyMatrix()
-	 */
-	bool HasPropertyMatrix(const char* szName) const;
+    /** Standard constructor
+    * @see ExportProperties()
+    */
+
+    ExportProperties();
+
+    // -------------------------------------------------------------------
+    /** Copy constructor.
+     *
+     * This copies the configuration properties of another ExportProperties.
+     * @see ExportProperties(const ExportProperties& other)
+     */
+    ExportProperties(const ExportProperties& other);
+
+    // -------------------------------------------------------------------
+    /** Set an integer configuration property.
+     * @param szName Name of the property. All supported properties
+     *   are defined in the aiConfig.g header (all constants share the
+     *   prefix AI_CONFIG_XXX and are simple strings).
+     * @param iValue New value of the property
+     * @return true if the property was set before. The new value replaces
+     *   the previous value in this case.
+     * @note Property of different types (float, int, string ..) are kept
+     *   on different stacks, so calling SetPropertyInteger() for a
+     *   floating-point property has no effect - the loader will call
+     *   GetPropertyFloat() to read the property, but it won't be there.
+     */
+    bool SetPropertyInteger(const char* szName, int iValue);
+
+    // -------------------------------------------------------------------
+    /** Set a boolean configuration property. Boolean properties
+     *  are stored on the integer stack internally so it's possible
+     *  to set them via #SetPropertyBool and query them with
+     *  #GetPropertyBool and vice versa.
+     * @see SetPropertyInteger()
+     */
+    bool SetPropertyBool(const char* szName, bool value)    {
+        return SetPropertyInteger(szName,value);
+    }
+
+    // -------------------------------------------------------------------
+    /** Set a floating-point configuration property.
+     * @see SetPropertyInteger()
+     */
+    bool SetPropertyFloat(const char* szName, float fValue);
+
+    // -------------------------------------------------------------------
+    /** Set a string configuration property.
+     * @see SetPropertyInteger()
+     */
+    bool SetPropertyString(const char* szName, const std::string& sValue);
+
+    // -------------------------------------------------------------------
+    /** Set a matrix configuration property.
+     * @see SetPropertyInteger()
+     */
+    bool SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue);
+
+    // -------------------------------------------------------------------
+    /** Get a configuration property.
+     * @param szName Name of the property. All supported properties
+     *   are defined in the aiConfig.g header (all constants share the
+     *   prefix AI_CONFIG_XXX).
+     * @param iErrorReturn Value that is returned if the property
+     *   is not found.
+     * @return Current value of the property
+     * @note Property of different types (float, int, string ..) are kept
+     *   on different lists, so calling SetPropertyInteger() for a
+     *   floating-point property has no effect - the loader will call
+     *   GetPropertyFloat() to read the property, but it won't be there.
+     */
+    int GetPropertyInteger(const char* szName,
+        int iErrorReturn = 0xffffffff) const;
+
+    // -------------------------------------------------------------------
+    /** Get a boolean configuration property. Boolean properties
+     *  are stored on the integer stack internally so it's possible
+     *  to set them via #SetPropertyBool and query them with
+     *  #GetPropertyBool and vice versa.
+     * @see GetPropertyInteger()
+     */
+    bool GetPropertyBool(const char* szName, bool bErrorReturn = false) const {
+        return GetPropertyInteger(szName,bErrorReturn)!=0;
+    }
+
+    // -------------------------------------------------------------------
+    /** Get a floating-point configuration property
+     * @see GetPropertyInteger()
+     */
+    float GetPropertyFloat(const char* szName,
+        float fErrorReturn = 10e10f) const;
+
+    // -------------------------------------------------------------------
+    /** Get a string configuration property
+     *
+     *  The return value remains valid until the property is modified.
+     * @see GetPropertyInteger()
+     */
+    const std::string GetPropertyString(const char* szName,
+        const std::string& sErrorReturn = "") const;
+
+    // -------------------------------------------------------------------
+    /** Get a matrix configuration property
+     *
+     *  The return value remains valid until the property is modified.
+     * @see GetPropertyInteger()
+     */
+    const aiMatrix4x4 GetPropertyMatrix(const char* szName,
+        const aiMatrix4x4& sErrorReturn = aiMatrix4x4()) const;
+
+    // -------------------------------------------------------------------
+    /** Determine a integer configuration property has been set.
+    * @see HasPropertyInteger()
+     */
+    bool HasPropertyInteger(const char* szName) const;
+
+    /** Determine a boolean configuration property has been set.
+    * @see HasPropertyBool()
+     */
+    bool HasPropertyBool(const char* szName) const;
+
+    /** Determine a boolean configuration property has been set.
+    * @see HasPropertyFloat()
+     */
+    bool HasPropertyFloat(const char* szName) const;
+
+    /** Determine a String configuration property has been set.
+    * @see HasPropertyString()
+     */
+    bool HasPropertyString(const char* szName) const;
+
+    /** Determine a Matrix configuration property has been set.
+    * @see HasPropertyMatrix()
+     */
+    bool HasPropertyMatrix(const char* szName) const;
 
 protected:
 
-	/** List of integer properties */
-	IntPropertyMap mIntProperties;
+    /** List of integer properties */
+    IntPropertyMap mIntProperties;
 
-	/** List of floating-point properties */
-	FloatPropertyMap mFloatProperties;
+    /** List of floating-point properties */
+    FloatPropertyMap mFloatProperties;
 
-	/** List of string properties */
-	StringPropertyMap mStringProperties;
+    /** List of string properties */
+    StringPropertyMap mStringProperties;
 
-	/** List of Matrix properties */
-	MatrixPropertyMap mMatrixProperties;
+    /** List of Matrix properties */
+    MatrixPropertyMap mMatrixProperties;
 };
 
 
 // ----------------------------------------------------------------------------------
 inline const aiExportDataBlob* Exporter :: ExportToBlob(  const aiScene* pScene, const std::string& pFormatId,unsigned int pPreprocessing, const ExportProperties* pProperties)
 {
-	return ExportToBlob(pScene,pFormatId.c_str(),pPreprocessing, pProperties);
+    return ExportToBlob(pScene,pFormatId.c_str(),pPreprocessing, pProperties);
 }
 
 // ----------------------------------------------------------------------------------
 inline aiReturn Exporter :: Export( const aiScene* pScene, const std::string& pFormatId, const std::string& pPath, unsigned int pPreprocessing, const ExportProperties* pProperties)
 {
-	return Export(pScene,pFormatId.c_str(),pPath.c_str(),pPreprocessing, pProperties);
+    return Export(pScene,pFormatId.c_str(),pPath.c_str(),pPreprocessing, pProperties);
 }
 
 } // namespace Assimp

include/assimp/IOStream.hpp

@@ -48,11 +48,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "types.h"
 
 #ifndef __cplusplus
-#	error This header requires C++ to be used. aiFileIO.h is the \
-	corresponding C interface.
+#   error This header requires C++ to be used. aiFileIO.h is the \
+    corresponding C interface.
 #endif
 
-namespace Assimp	{
+namespace Assimp    {
 
 // ----------------------------------------------------------------------------------
 /** @brief CPP-API: Class to handle file I/O for C++
@@ -63,74 +63,74 @@ namespace Assimp	{
 */
 class ASSIMP_API IOStream
 #ifndef SWIG
-	: public Intern::AllocateFromAssimpHeap
+    : public Intern::AllocateFromAssimpHeap
 #endif
 {
 protected:
-	/** Constructor protected, use IOSystem::Open() to create an instance. */
-	IOStream(void);
+    /** Constructor protected, use IOSystem::Open() to create an instance. */
+    IOStream(void);
 
 public:
-	// -------------------------------------------------------------------
-	/** @brief Destructor. Deleting the object closes the underlying file,
-	 * alternatively you may use IOSystem::Close() to release the file.
-	 */
-	virtual ~IOStream();
-
-	// -------------------------------------------------------------------
-	/** @brief Read from the file
-	 *
-	 * See fread() for more details
-	 * This fails for write-only files */
+    // -------------------------------------------------------------------
+    /** @brief Destructor. Deleting the object closes the underlying file,
+     * alternatively you may use IOSystem::Close() to release the file.
+     */
+    virtual ~IOStream();
+
+    // -------------------------------------------------------------------
+    /** @brief Read from the file
+     *
+     * See fread() for more details
+     * This fails for write-only files */
     virtual size_t Read(void* pvBuffer,
-		size_t pSize,
-		size_t pCount) = 0;
-
-	// -------------------------------------------------------------------
-	/** @brief Write to the file
-	*
-	* See fwrite() for more details
-	* This fails for read-only files */
+        size_t pSize,
+        size_t pCount) = 0;
+
+    // -------------------------------------------------------------------
+    /** @brief Write to the file
+    *
+    * See fwrite() for more details
+    * This fails for read-only files */
     virtual size_t Write(const void* pvBuffer,
-		size_t pSize,
-		size_t pCount) = 0;
-
-	// -------------------------------------------------------------------
-	/** @brief Set the read/write cursor of the file
-	 *
-	 * Note that the offset is _negative_ for aiOrigin_END.
-	 * See fseek() for more details */
-	virtual aiReturn Seek(size_t pOffset,
-		aiOrigin pOrigin) = 0;
-
-	// -------------------------------------------------------------------
-	/** @brief Get the current position of the read/write cursor
-	 *
-	 * See ftell() for more details */
+        size_t pSize,
+        size_t pCount) = 0;
+
+    // -------------------------------------------------------------------
+    /** @brief Set the read/write cursor of the file
+     *
+     * Note that the offset is _negative_ for aiOrigin_END.
+     * See fseek() for more details */
+    virtual aiReturn Seek(size_t pOffset,
+        aiOrigin pOrigin) = 0;
+
+    // -------------------------------------------------------------------
+    /** @brief Get the current position of the read/write cursor
+     *
+     * See ftell() for more details */
     virtual size_t Tell() const = 0;
 
-	// -------------------------------------------------------------------
-	/**	@brief Returns filesize
-	 *	Returns the filesize. */
-	virtual size_t FileSize() const = 0;
+    // -------------------------------------------------------------------
+    /** @brief Returns filesize
+     *  Returns the filesize. */
+    virtual size_t FileSize() const = 0;
 
-	// -------------------------------------------------------------------
-	/**	@brief Flush the contents of the file buffer (for writers)
-	 *	See fflush() for more details.
-	 */
-	virtual void Flush() = 0;
+    // -------------------------------------------------------------------
+    /** @brief Flush the contents of the file buffer (for writers)
+     *  See fflush() for more details.
+     */
+    virtual void Flush() = 0;
 }; //! class IOStream
 
 // ----------------------------------------------------------------------------------
 inline IOStream::IOStream()
 {
-	// empty
+    // empty
 }
 
 // ----------------------------------------------------------------------------------
 inline IOStream::~IOStream()
 {
-	// empty
+    // empty
 }
 // ----------------------------------------------------------------------------------
 } //!namespace Assimp

include/assimp/IOSystem.hpp

@@ -48,12 +48,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_IOSYSTEM_H_INC
 
 #ifndef __cplusplus
-#	error This header requires C++ to be used. aiFileIO.h is the \
-	corresponding C interface.
+#   error This header requires C++ to be used. aiFileIO.h is the \
+    corresponding C interface.
 #endif
 
 #include "types.h"
-namespace Assimp	{
+namespace Assimp    {
 class IOStream;
 
 // ---------------------------------------------------------------------------
@@ -66,122 +66,122 @@ class IOStream;
  *  @see Importer::SetIOHandler() */
 class ASSIMP_API IOSystem
 #ifndef SWIG
-	: public Intern::AllocateFromAssimpHeap
+    : public Intern::AllocateFromAssimpHeap
 #endif
 {
 public:
 
-	// -------------------------------------------------------------------
-	/** @brief Default constructor.
-	 *
-	 *  Create an instance of your derived class and assign it to an
-	 *  #Assimp::Importer instance by calling Importer::SetIOHandler().
-	 */
-	IOSystem();
+    // -------------------------------------------------------------------
+    /** @brief Default constructor.
+     *
+     *  Create an instance of your derived class and assign it to an
+     *  #Assimp::Importer instance by calling Importer::SetIOHandler().
+     */
+    IOSystem();
 
-	// -------------------------------------------------------------------
-	/** @brief Virtual destructor.
-	 *
-	 *  It is safe to be called from within DLL Assimp, we're constructed
-	 *  on Assimp's heap.
-	 */
-	virtual ~IOSystem();
+    // -------------------------------------------------------------------
+    /** @brief Virtual destructor.
+     *
+     *  It is safe to be called from within DLL Assimp, we're constructed
+     *  on Assimp's heap.
+     */
+    virtual ~IOSystem();
 
 
 public:
 
-	// -------------------------------------------------------------------
-	/** @brief For backward compatibility
-	 *  @see Exists(const char*)
-	 */
-	AI_FORCE_INLINE bool Exists( const std::string& pFile) const;
-
-	// -------------------------------------------------------------------
-	/** @brief Tests for the existence of a file at the given path.
-	 *
-	 * @param pFile Path to the file
-	 * @return true if there is a file with this path, else false.
-	 */
-
-	virtual bool Exists( const char* pFile) const = 0;
-
-
-
-	// -------------------------------------------------------------------
-	/**	@brief Returns the system specific directory separator
-	 *	@return	System specific directory separator
-	 */
-	virtual char getOsSeparator() const = 0;
-
-
-	// -------------------------------------------------------------------
-	/** @brief Open a new file with a given path.
-	 *
-	 *  When the access to the file is finished, call Close() to release
-	 *  all associated resources (or the virtual dtor of the IOStream).
-	 *
-	 *  @param pFile Path to the file
-	 *  @param pMode Desired file I/O mode. Required are: "wb", "w", "wt",
-	 *         "rb", "r", "rt".
-	 *
-	 *  @return New IOStream interface allowing the lib to access
-	 *         the underlying file.
-	 *  @note When implementing this class to provide custom IO handling,
-	 *  you probably have to supply an own implementation of IOStream as well.
-	 */
-	virtual IOStream* Open(const char* pFile,
-		const char* pMode = "rb") = 0;
-
-	// -------------------------------------------------------------------
-	/** @brief For backward compatibility
-	 *  @see Open(const char*, const char*)
-	 */
-	inline IOStream* Open(const std::string& pFile,
-		const std::string& pMode = std::string("rb"));
-
-
-
-	// -------------------------------------------------------------------
-	/** @brief Closes the given file and releases all resources
-	 *    associated with it.
-	 *  @param pFile The file instance previously created by Open().
-	 */
-	virtual void Close( IOStream* pFile) = 0;
-
-	// -------------------------------------------------------------------
-	/** @brief Compares two paths and check whether the point to
-	 *         identical files.
-	 *
-	 * The dummy implementation of this virtual member performs a
-	 * case-insensitive comparison of the given strings. The default IO
-	 * system implementation uses OS mechanisms to convert relative into
-	 * absolute paths, so the result can be trusted.
-	 * @param one First file
-	 * @param second Second file
-	 * @return true if the paths point to the same file. The file needn't
-	 *   be existing, however.
-	 */
-	virtual bool ComparePaths (const char* one,
-		const char* second) const;
-
-	// -------------------------------------------------------------------
-	/** @brief For backward compatibility
-	 *  @see ComparePaths(const char*, const char*)
-	 */
-	inline bool ComparePaths (const std::string& one,
-		const std::string& second) const;
+    // -------------------------------------------------------------------
+    /** @brief For backward compatibility
+     *  @see Exists(const char*)
+     */
+    AI_FORCE_INLINE bool Exists( const std::string& pFile) const;
+
+    // -------------------------------------------------------------------
+    /** @brief Tests for the existence of a file at the given path.
+     *
+     * @param pFile Path to the file
+     * @return true if there is a file with this path, else false.
+     */
+
+    virtual bool Exists( const char* pFile) const = 0;
+
+
+
+    // -------------------------------------------------------------------
+    /** @brief Returns the system specific directory separator
+     *  @return System specific directory separator
+     */
+    virtual char getOsSeparator() const = 0;
+
+
+    // -------------------------------------------------------------------
+    /** @brief Open a new file with a given path.
+     *
+     *  When the access to the file is finished, call Close() to release
+     *  all associated resources (or the virtual dtor of the IOStream).
+     *
+     *  @param pFile Path to the file
+     *  @param pMode Desired file I/O mode. Required are: "wb", "w", "wt",
+     *         "rb", "r", "rt".
+     *
+     *  @return New IOStream interface allowing the lib to access
+     *         the underlying file.
+     *  @note When implementing this class to provide custom IO handling,
+     *  you probably have to supply an own implementation of IOStream as well.
+     */
+    virtual IOStream* Open(const char* pFile,
+        const char* pMode = "rb") = 0;
+
+    // -------------------------------------------------------------------
+    /** @brief For backward compatibility
+     *  @see Open(const char*, const char*)
+     */
+    inline IOStream* Open(const std::string& pFile,
+        const std::string& pMode = std::string("rb"));
+
+
+
+    // -------------------------------------------------------------------
+    /** @brief Closes the given file and releases all resources
+     *    associated with it.
+     *  @param pFile The file instance previously created by Open().
+     */
+    virtual void Close( IOStream* pFile) = 0;
+
+    // -------------------------------------------------------------------
+    /** @brief Compares two paths and check whether the point to
+     *         identical files.
+     *
+     * The dummy implementation of this virtual member performs a
+     * case-insensitive comparison of the given strings. The default IO
+     * system implementation uses OS mechanisms to convert relative into
+     * absolute paths, so the result can be trusted.
+     * @param one First file
+     * @param second Second file
+     * @return true if the paths point to the same file. The file needn't
+     *   be existing, however.
+     */
+    virtual bool ComparePaths (const char* one,
+        const char* second) const;
+
+    // -------------------------------------------------------------------
+    /** @brief For backward compatibility
+     *  @see ComparePaths(const char*, const char*)
+     */
+    inline bool ComparePaths (const std::string& one,
+        const std::string& second) const;
 };
 
 // ----------------------------------------------------------------------------
 AI_FORCE_INLINE IOSystem::IOSystem()
 {
-	// empty
+    // empty
 }
 
 // ----------------------------------------------------------------------------
 AI_FORCE_INLINE IOSystem::~IOSystem()
 {
-	// empty
+    // empty
 }
 
 // ----------------------------------------------------------------------------
@@ -192,31 +192,31 @@ AI_FORCE_INLINE IOSystem::~IOSystem()
 
 // ----------------------------------------------------------------------------
 AI_FORCE_INLINE IOStream* IOSystem::Open(const std::string& pFile,
-	const std::string& pMode)
+    const std::string& pMode)
 {
-	// NOTE:
-	// For compatibility, interface was changed to const char* to
-	// avoid crashes between binary incompatible STL versions
-	return Open(pFile.c_str(),pMode.c_str());
+    // NOTE:
+    // For compatibility, interface was changed to const char* to
+    // avoid crashes between binary incompatible STL versions
+    return Open(pFile.c_str(),pMode.c_str());
 }
 
 // ----------------------------------------------------------------------------
 AI_FORCE_INLINE bool IOSystem::Exists( const std::string& pFile) const
 {
-	// NOTE:
-	// For compatibility, interface was changed to const char* to
-	// avoid crashes between binary incompatible STL versions
-	return Exists(pFile.c_str());
+    // NOTE:
+    // For compatibility, interface was changed to const char* to
+    // avoid crashes between binary incompatible STL versions
+    return Exists(pFile.c_str());
 }
 
 // ----------------------------------------------------------------------------
 inline bool IOSystem::ComparePaths (const std::string& one,
-	const std::string& second) const
+    const std::string& second) const
 {
-	// NOTE:
-	// For compatibility, interface was changed to const char* to
-	// avoid crashes between binary incompatible STL versions
-	return ComparePaths(one.c_str(),second.c_str());
+    // NOTE:
+    // For compatibility, interface was changed to const char* to
+    // avoid crashes between binary incompatible STL versions
+    return ComparePaths(one.c_str(),second.c_str());
 }
 
 // ----------------------------------------------------------------------------

include/assimp/LogStream.hpp

@@ -44,7 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_LOGSTREAM_H
 #define INCLUDED_AI_LOGSTREAM_H
 #include "types.h"
-namespace Assimp	{
+namespace Assimp    {
 class IOSystem;
 
 // ------------------------------------------------------------------------------------
@@ -55,39 +55,39 @@ class IOSystem;
  *  are not enough for your purpose. */
 class ASSIMP_API LogStream
 #ifndef SWIG
-	: public Intern::AllocateFromAssimpHeap
+    : public Intern::AllocateFromAssimpHeap
 #endif
 {
 protected:
-	/** @brief	Default constructor	*/
-	LogStream() {
-	}
+    /** @brief  Default constructor */
+    LogStream() {
+    }
 public:
-	/** @brief	Virtual destructor	*/
-	virtual ~LogStream() {
-	}
+    /** @brief  Virtual destructor  */
+    virtual ~LogStream() {
+    }
 
-	// -------------------------------------------------------------------
-	/** @brief	Overwrite this for your own output methods
-	 *
-	 *  Log messages *may* consist of multiple lines and you shouldn't
-	 *  expect a consistent formatting. If you want custom formatting
-	 *  (e.g. generate HTML), supply a custom instance of Logger to
-	 *  #DefaultLogger:set(). Usually you can *expect* that a log message
-	 *  is exactly one line and terminated with a single \n character.
-	 *  @param message Message to be written */
-	virtual void write(const char* message) = 0;
+    // -------------------------------------------------------------------
+    /** @brief  Overwrite this for your own output methods
+     *
+     *  Log messages *may* consist of multiple lines and you shouldn't
+     *  expect a consistent formatting. If you want custom formatting
+     *  (e.g. generate HTML), supply a custom instance of Logger to
+     *  #DefaultLogger:set(). Usually you can *expect* that a log message
+     *  is exactly one line and terminated with a single \n character.
+     *  @param message Message to be written */
+    virtual void write(const char* message) = 0;
 
-	// -------------------------------------------------------------------
-	/** @brief Creates a default log stream
-	 *  @param streams Type of the default stream
-	 *  @param name For aiDefaultLogStream_FILE: name of the output file
-	 *  @param io For aiDefaultLogStream_FILE: IOSystem to be used to open the output
-	 *   file. Pass NULL for the default implementation.
-	 *  @return New LogStream instance.  */
-	static LogStream* createDefaultStream(aiDefaultLogStream stream,
-		const char* name = "AssimpLog.txt",
-		IOSystem* io = NULL);
+    // -------------------------------------------------------------------
+    /** @brief Creates a default log stream
+     *  @param streams Type of the default stream
+     *  @param name For aiDefaultLogStream_FILE: name of the output file
+     *  @param io For aiDefaultLogStream_FILE: IOSystem to be used to open the output
+     *   file. Pass NULL for the default implementation.
+     *  @return New LogStream instance.  */
+    static LogStream* createDefaultStream(aiDefaultLogStream stream,
+        const char* name = "AssimpLog.txt",
+        IOSystem* io = NULL);
 
 }; // !class LogStream
 // ------------------------------------------------------------------------------------

include/assimp/Logger.hpp

@@ -45,217 +45,217 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INCLUDED_AI_LOGGER_H
 
 #include "types.h"
-namespace Assimp	{
+namespace Assimp    {
 class LogStream;
 
 // Maximum length of a log message. Longer messages are rejected.
 #define MAX_LOG_MESSAGE_LENGTH 1024u
 
 // ----------------------------------------------------------------------------------
-/**	@brief CPP-API: Abstract interface for logger implementations.
+/** @brief CPP-API: Abstract interface for logger implementations.
  *  Assimp provides a default implementation and uses it for almost all
  *  logging stuff ('DefaultLogger'). This class defines just basic logging
  *  behaviour and is not of interest for you. Instead, take a look at #DefaultLogger. */
 class ASSIMP_API Logger
 #ifndef SWIG
-	: public Intern::AllocateFromAssimpHeap
+    : public Intern::AllocateFromAssimpHeap
 #endif
 {
 public:
 
-	// ----------------------------------------------------------------------
-	/**	@enum	LogSeverity
-	 *	@brief	Log severity to describe the granularity of logging.
-	 */
-	enum LogSeverity
-	{
-		NORMAL,		//!< Normal granularity of logging
-		VERBOSE		//!< Debug infos will be logged, too
-	};
-
-	// ----------------------------------------------------------------------
-	/**	@enum	ErrorSeverity
-	 *	@brief	Description for severity of a log message.
-	 *
-	 *  Every LogStream has a bitwise combination of these flags.
-	 *  A LogStream doesn't receive any messages of a specific type
-	 *  if it doesn't specify the corresponding ErrorSeverity flag.
-	 */
-	enum ErrorSeverity
-	{
-		Debugging	= 1,	//!< Debug log message
-		Info		= 2, 	//!< Info log message
-		Warn		= 4,	//!< Warn log message
-		Err			= 8		//!< Error log message
-	};
+    // ----------------------------------------------------------------------
+    /** @enum   LogSeverity
+     *  @brief  Log severity to describe the granularity of logging.
+     */
+    enum LogSeverity
+    {
+        NORMAL,     //!< Normal granularity of logging
+        VERBOSE     //!< Debug infos will be logged, too
+    };
+
+    // ----------------------------------------------------------------------
+    /** @enum   ErrorSeverity
+     *  @brief  Description for severity of a log message.
+     *
+     *  Every LogStream has a bitwise combination of these flags.
+     *  A LogStream doesn't receive any messages of a specific type
+     *  if it doesn't specify the corresponding ErrorSeverity flag.
+     */
+    enum ErrorSeverity
+    {
+        Debugging   = 1,    //!< Debug log message
+        Info        = 2,    //!< Info log message
+        Warn        = 4,    //!< Warn log message
+        Err         = 8     //!< Error log message
+    };
 
 public:
 
-	/** @brief	Virtual destructor */
-	virtual ~Logger();
-
-	// ----------------------------------------------------------------------
-	/** @brief	Writes a debug message
-	 *	 @param	message	Debug message*/
-	void debug(const char* message);
-	inline void debug(const std::string &message);
-
-	// ----------------------------------------------------------------------
-	/** @brief	Writes a info message
-	 *	@param	message Info message*/
-	void info(const char* message);
-	inline void info(const std::string &message);
-
-	// ----------------------------------------------------------------------
-	/** @brief	Writes a warning message
-	 *	@param	message Warn message*/
-	void warn(const char* message);
-	inline void warn(const std::string &message);
-
-	// ----------------------------------------------------------------------
-	/** @brief	Writes an error message
-	 *	@param	message	Error message*/
-	void error(const char* message);
-	inline void error(const std::string &message);
-
-	// ----------------------------------------------------------------------
-	/** @brief	Set a new log severity.
-	 *	@param	log_severity New severity for logging*/
-	void setLogSeverity(LogSeverity log_severity);
-
-	// ----------------------------------------------------------------------
-	/** @brief Get the current log severity*/
-	LogSeverity getLogSeverity() const;
-
-	// ----------------------------------------------------------------------
-	/** @brief	Attach a new log-stream
-	 *
-	 *  The logger takes ownership of the stream and is responsible
-	 *  for its destruction (which is done using ::delete when the logger
-	 *  itself is destroyed). Call detachStream to detach a stream and to
-	 *  gain ownership of it again.
-	 *	 @param	pStream	 Log-stream to attach
-	 *  @param severity  Message filter, specified which types of log
-	 *    messages are dispatched to the stream. Provide a bitwise
-	 *    combination of the ErrorSeverity flags.
-	 *  @return true if the stream has been attached, false otherwise.*/
-	virtual bool attachStream(LogStream *pStream,
-		unsigned int severity = Debugging | Err | Warn | Info) = 0;
-
-	// ----------------------------------------------------------------------
-	/** @brief	Detach a still attached stream from the logger (or
-	 *          modify the filter flags bits)
-	 *	 @param	pStream	Log-stream instance for detaching
-	 *  @param severity Provide a bitwise combination of the ErrorSeverity
-	 *    flags. This value is &~ed with the current flags of the stream,
-	 *    if the result is 0 the stream is detached from the Logger and
-	 *    the caller retakes the possession of the stream.
-	 *  @return true if the stream has been detached, false otherwise.*/
-	virtual bool detatchStream(LogStream *pStream,
-		unsigned int severity = Debugging | Err | Warn | Info) = 0;
+    /** @brief  Virtual destructor */
+    virtual ~Logger();
+
+    // ----------------------------------------------------------------------
+    /** @brief  Writes a debug message
+     *   @param message Debug message*/
+    void debug(const char* message);
+    inline void debug(const std::string &message);
+
+    // ----------------------------------------------------------------------
+    /** @brief  Writes a info message
+     *  @param  message Info message*/
+    void info(const char* message);
+    inline void info(const std::string &message);
+
+    // ----------------------------------------------------------------------
+    /** @brief  Writes a warning message
+     *  @param  message Warn message*/
+    void warn(const char* message);
+    inline void warn(const std::string &message);
+
+    // ----------------------------------------------------------------------
+    /** @brief  Writes an error message
+     *  @param  message Error message*/
+    void error(const char* message);
+    inline void error(const std::string &message);
+
+    // ----------------------------------------------------------------------
+    /** @brief  Set a new log severity.
+     *  @param  log_severity New severity for logging*/
+    void setLogSeverity(LogSeverity log_severity);
+
+    // ----------------------------------------------------------------------
+    /** @brief Get the current log severity*/
+    LogSeverity getLogSeverity() const;
+
+    // ----------------------------------------------------------------------
+    /** @brief  Attach a new log-stream
+     *
+     *  The logger takes ownership of the stream and is responsible
+     *  for its destruction (which is done using ::delete when the logger
+     *  itself is destroyed). Call detachStream to detach a stream and to
+     *  gain ownership of it again.
+     *   @param pStream  Log-stream to attach
+     *  @param severity  Message filter, specified which types of log
+     *    messages are dispatched to the stream. Provide a bitwise
+     *    combination of the ErrorSeverity flags.
+     *  @return true if the stream has been attached, false otherwise.*/
+    virtual bool attachStream(LogStream *pStream,
+        unsigned int severity = Debugging | Err | Warn | Info) = 0;
+
+    // ----------------------------------------------------------------------
+    /** @brief  Detach a still attached stream from the logger (or
+     *          modify the filter flags bits)
+     *   @param pStream Log-stream instance for detaching
+     *  @param severity Provide a bitwise combination of the ErrorSeverity
+     *    flags. This value is &~ed with the current flags of the stream,
+     *    if the result is 0 the stream is detached from the Logger and
+     *    the caller retakes the possession of the stream.
+     *  @return true if the stream has been detached, false otherwise.*/
+    virtual bool detatchStream(LogStream *pStream,
+        unsigned int severity = Debugging | Err | Warn | Info) = 0;
 
 protected:
 
-	/** Default constructor */
-	Logger();
-
-	/** Construction with a given log severity */
-	Logger(LogSeverity severity);
-
-	// ----------------------------------------------------------------------
-	/** @brief Called as a request to write a specific debug message
-	 *	@param	message	Debug message. Never longer than
-	 *    MAX_LOG_MESSAGE_LENGTH characters (excluding the '0').
-	 *  @note  The message string is only valid until the scope of
-	 *    the function is left.
-	 */
-	virtual void OnDebug(const char* message)= 0;
-
-	// ----------------------------------------------------------------------
-	/** @brief Called as a request to write a specific info message
-	 *	@param	message	Info message. Never longer than
-	 *    MAX_LOG_MESSAGE_LENGTH characters (ecxluding the '0').
-	 *  @note  The message string is only valid until the scope of
-	 *    the function is left.
-	 */
-	virtual void OnInfo(const char* message) = 0;
-
-	// ----------------------------------------------------------------------
-	/** @brief Called as a request to write a specific warn message
-	 *	@param	message	Warn message. Never longer than
-	 *    MAX_LOG_MESSAGE_LENGTH characters (exluding the '0').
-	 *  @note  The message string is only valid until the scope of
-	 *    the function is left.
-	 */
-	virtual void OnWarn(const char* essage) = 0;
-
-	// ----------------------------------------------------------------------
-	/** @brief Called as a request to write a specific error message
-	 *	@param	message Error message. Never longer than
-	 *    MAX_LOG_MESSAGE_LENGTH characters (exluding the '0').
-	 *  @note  The message string is only valid until the scope of
-	 *    the function is left.
-	 */
-	virtual void OnError(const char* message) = 0;
+    /** Default constructor */
+    Logger();
+
+    /** Construction with a given log severity */
+    Logger(LogSeverity severity);
+
+    // ----------------------------------------------------------------------
+    /** @brief Called as a request to write a specific debug message
+     *  @param  message Debug message. Never longer than
+     *    MAX_LOG_MESSAGE_LENGTH characters (excluding the '0').
+     *  @note  The message string is only valid until the scope of
+     *    the function is left.
+     */
+    virtual void OnDebug(const char* message)= 0;
+
+    // ----------------------------------------------------------------------
+    /** @brief Called as a request to write a specific info message
+     *  @param  message Info message. Never longer than
+     *    MAX_LOG_MESSAGE_LENGTH characters (ecxluding the '0').
+     *  @note  The message string is only valid until the scope of
+     *    the function is left.
+     */
+    virtual void OnInfo(const char* message) = 0;
+
+    // ----------------------------------------------------------------------
+    /** @brief Called as a request to write a specific warn message
+     *  @param  message Warn message. Never longer than
+     *    MAX_LOG_MESSAGE_LENGTH characters (exluding the '0').
+     *  @note  The message string is only valid until the scope of
+     *    the function is left.
+     */
+    virtual void OnWarn(const char* essage) = 0;
+
+    // ----------------------------------------------------------------------
+    /** @brief Called as a request to write a specific error message
+     *  @param  message Error message. Never longer than
+     *    MAX_LOG_MESSAGE_LENGTH characters (exluding the '0').
+     *  @note  The message string is only valid until the scope of
+     *    the function is left.
+     */
+    virtual void OnError(const char* message) = 0;
 
 protected:
 
-	//!	Logger severity
-	LogSeverity m_Severity;
+    //! Logger severity
+    LogSeverity m_Severity;
 };
 
 // ----------------------------------------------------------------------------------
-//	Default constructor
-inline Logger::Logger()	{
-	setLogSeverity(NORMAL);
+//  Default constructor
+inline Logger::Logger() {
+    setLogSeverity(NORMAL);
 }
 
 // ----------------------------------------------------------------------------------
-//	Virtual destructor
+//  Virtual destructor
 inline  Logger::~Logger()
 {
 }
 
 // ----------------------------------------------------------------------------------
 // Construction with given logging severity
-inline Logger::Logger(LogSeverity severity)	{
-	setLogSeverity(severity);
+inline Logger::Logger(LogSeverity severity) {
+    setLogSeverity(severity);
 }
 
 // ----------------------------------------------------------------------------------
 // Log severity setter
 inline void Logger::setLogSeverity(LogSeverity log_severity){
-	m_Severity = log_severity;
+    m_Severity = log_severity;
 }
 
 // ----------------------------------------------------------------------------------
 // Log severity getter
 inline Logger::LogSeverity Logger::getLogSeverity() const {
-	return m_Severity;
+    return m_Severity;
 }
 
 // ----------------------------------------------------------------------------------
 inline void Logger::debug(const std::string &message)
 {
-	return debug(message.c_str());
+    return debug(message.c_str());
 }
 
 // ----------------------------------------------------------------------------------
 inline void Logger::error(const std::string &message)
 {
-	return error(message.c_str());
+    return error(message.c_str());
 }
 
 // ----------------------------------------------------------------------------------
 inline void Logger::warn(const std::string &message)
 {
-	return warn(message.c_str());
+    return warn(message.c_str());
 }
 
 // ----------------------------------------------------------------------------------
 inline void Logger::info(const std::string &message)
 {
-	return info(message.c_str());
+    return info(message.c_str());
 }
 
 // ----------------------------------------------------------------------------------

include/assimp/NullLogger.hpp

@@ -46,48 +46,48 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INCLUDED_AI_NULLLOGGER_H
 
 #include "Logger.hpp"
-namespace Assimp	{
+namespace Assimp    {
 // ---------------------------------------------------------------------------
 /** @brief CPP-API: Empty logging implementation.
  *
  * Does nothing! Used by default if the application hasn't requested a
  * custom logger via #DefaultLogger::set() or #DefaultLogger::create(); */
 class ASSIMP_API NullLogger
-	: public Logger	{
+    : public Logger {
 
 public:
 
-	/**	@brief	Logs a debug message */
-	void OnDebug(const char* message) {
-		(void)message; //this avoids compiler warnings
-	}
-
-	/**	@brief	Logs an info message */
-	void OnInfo(const char* message) {
-		(void)message; //this avoids compiler warnings
-	}
-
-	/**	@brief	Logs a warning message */
-	void OnWarn(const char* message) {
-		(void)message; //this avoids compiler warnings
-	}
-
-	/**	@brief	Logs an error message */
-	void OnError(const char* message) {
-		(void)message; //this avoids compiler warnings
-	}
-
-	/**	@brief	Detach a still attached stream from logger */
-	bool attachStream(LogStream *pStream, unsigned int severity) {
-		(void)pStream; (void)severity; //this avoids compiler warnings
-		return false;
-	}
-
-	/**	@brief	Detach a still attached stream from logger */
-	bool detatchStream(LogStream *pStream, unsigned int severity) {
-		(void)pStream; (void)severity; //this avoids compiler warnings
-		return false;
-	}
+    /** @brief  Logs a debug message */
+    void OnDebug(const char* message) {
+        (void)message; //this avoids compiler warnings
+    }
+
+    /** @brief  Logs an info message */
+    void OnInfo(const char* message) {
+        (void)message; //this avoids compiler warnings
+    }
+
+    /** @brief  Logs a warning message */
+    void OnWarn(const char* message) {
+        (void)message; //this avoids compiler warnings
+    }
+
+    /** @brief  Logs an error message */
+    void OnError(const char* message) {
+        (void)message; //this avoids compiler warnings
+    }
+
+    /** @brief  Detach a still attached stream from logger */
+    bool attachStream(LogStream *pStream, unsigned int severity) {
+        (void)pStream; (void)severity; //this avoids compiler warnings
+        return false;
+    }
+
+    /** @brief  Detach a still attached stream from logger */
+    bool detatchStream(LogStream *pStream, unsigned int severity) {
+        (void)pStream; (void)severity; //this avoids compiler warnings
+        return false;
+    }
 
 private:
 };

include/assimp/ProgressHandler.hpp

@@ -44,7 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_PROGRESSHANDLER_H
 #define INCLUDED_AI_PROGRESSHANDLER_H
 #include "types.h"
-namespace Assimp	{
+namespace Assimp    {
 
 // ------------------------------------------------------------------------------------
 /** @brief CPP-API: Abstract interface for custom progress report receivers.
@@ -53,67 +53,67 @@ namespace Assimp	{
  *  implementation provided by Assimp doesn't do anything at all. */
 class ASSIMP_API ProgressHandler
 #ifndef SWIG
-	: public Intern::AllocateFromAssimpHeap
+    : public Intern::AllocateFromAssimpHeap
 #endif
 {
 protected:
-	/** @brief	Default constructor	*/
-	ProgressHandler () {
-	}
+    /** @brief  Default constructor */
+    ProgressHandler () {
+    }
 public:
-	/** @brief	Virtual destructor	*/
-	virtual ~ProgressHandler () {
-	}
+    /** @brief  Virtual destructor  */
+    virtual ~ProgressHandler () {
+    }
 
-	// -------------------------------------------------------------------
-	/** @brief Progress callback.
-	 *  @param percentage An estimate of the current loading progress,
-	 *    in percent. Or -1.f if such an estimate is not available.
-	 *
-	 *  There are restriction on what you may do from within your
-	 *  implementation of this method: no exceptions may be thrown and no
-	 *  non-const #Importer methods may be called. It is
-	 *  not generally possible to predict the number of callbacks
-	 *  fired during a single import.
-	 *
-	 *  @return Return false to abort loading at the next possible
-	 *   occasion (loaders and Assimp are generally allowed to perform
-	 *   all needed cleanup tasks prior to returning control to the
-	 *   caller). If the loading is aborted, #Importer::ReadFile()
-	 *   returns always NULL.
-	 *   */
-	virtual bool Update(float percentage = -1.f) = 0;
+    // -------------------------------------------------------------------
+    /** @brief Progress callback.
+     *  @param percentage An estimate of the current loading progress,
+     *    in percent. Or -1.f if such an estimate is not available.
+     *
+     *  There are restriction on what you may do from within your
+     *  implementation of this method: no exceptions may be thrown and no
+     *  non-const #Importer methods may be called. It is
+     *  not generally possible to predict the number of callbacks
+     *  fired during a single import.
+     *
+     *  @return Return false to abort loading at the next possible
+     *   occasion (loaders and Assimp are generally allowed to perform
+     *   all needed cleanup tasks prior to returning control to the
+     *   caller). If the loading is aborted, #Importer::ReadFile()
+     *   returns always NULL.
+     *   */
+    virtual bool Update(float percentage = -1.f) = 0;
 
-	// -------------------------------------------------------------------
-	/** @brief Progress callback for file loading steps
-	 *  @param numberOfSteps The number of total post-processing
-	 *   steps
-	 *  @param currentStep The index of the current post-processing
-	 *   step that will run, or equal to numberOfSteps if all of
-	 *   them has finished. This number is always strictly monotone
-	 *   increasing, although not necessarily linearly.
-	 *
-	 *  @note This is currently only used at the start and the end
-	 *   of the file parsing.
-	 *   */
-	virtual void UpdateFileRead(int currentStep /*= 0*/, int numberOfSteps /*= 0*/) {
-		float f = numberOfSteps ? currentStep / (float)numberOfSteps : 1.0f;
-		Update( f * 0.5f );
-	}
+    // -------------------------------------------------------------------
+    /** @brief Progress callback for file loading steps
+     *  @param numberOfSteps The number of total post-processing
+     *   steps
+     *  @param currentStep The index of the current post-processing
+     *   step that will run, or equal to numberOfSteps if all of
+     *   them has finished. This number is always strictly monotone
+     *   increasing, although not necessarily linearly.
+     *
+     *  @note This is currently only used at the start and the end
+     *   of the file parsing.
+     *   */
+    virtual void UpdateFileRead(int currentStep /*= 0*/, int numberOfSteps /*= 0*/) {
+        float f = numberOfSteps ? currentStep / (float)numberOfSteps : 1.0f;
+        Update( f * 0.5f );
+    }
 
-	// -------------------------------------------------------------------
-	/** @brief Progress callback for post-processing steps
-	 *  @param numberOfSteps The number of total post-processing
-	 *   steps
-	 *  @param currentStep The index of the current post-processing
-	 *   step that will run, or equal to numberOfSteps if all of
-	 *   them has finished. This number is always strictly monotone
-	 *   increasing, although not necessarily linearly.
-	 *   */
-	virtual void UpdatePostProcess(int currentStep /*= 0*/, int numberOfSteps /*= 0*/) {
-		float f = numberOfSteps ? currentStep / (float)numberOfSteps : 1.0f;
-		Update( f * 0.5f + 0.5f );
-	}
+    // -------------------------------------------------------------------
+    /** @brief Progress callback for post-processing steps
+     *  @param numberOfSteps The number of total post-processing
+     *   steps
+     *  @param currentStep The index of the current post-processing
+     *   step that will run, or equal to numberOfSteps if all of
+     *   them has finished. This number is always strictly monotone
+     *   increasing, although not necessarily linearly.
+     *   */
+    virtual void UpdatePostProcess(int currentStep /*= 0*/, int numberOfSteps /*= 0*/) {
+        float f = numberOfSteps ? currentStep / (float)numberOfSteps : 1.0f;
+        Update( f * 0.5f + 0.5f );
+    }
 
 }; // !class ProgressHandler
 // ------------------------------------------------------------------------------------

include/assimp/ai_assert.h

@@ -4,10 +4,10 @@
 #define AI_DEBUG_H_INC
 
 #ifdef ASSIMP_BUILD_DEBUG
-#	include <assert.h>
-#	define	ai_assert(expression) assert(expression)
+#   include <assert.h>
+#   define  ai_assert(expression) assert(expression)
 #else
-#	define	ai_assert(expression)
+#   define  ai_assert(expression)
 #endif
 
 

include/assimp/anim.h

@@ -57,41 +57,41 @@ extern "C" {
 /** A time-value pair specifying a certain 3D vector for the given time. */
 struct aiVectorKey
 {
-	/** The time of this key */
-	double mTime;
+    /** The time of this key */
+    double mTime;
 
-	/** The value of this key */
-	C_STRUCT aiVector3D mValue;
+    /** The value of this key */
+    C_STRUCT aiVector3D mValue;
 
 #ifdef __cplusplus
 
-	//! Default constructor
-	aiVectorKey(){}
-
-	//! Construction from a given time and key value
-	aiVectorKey(double time, const aiVector3D& value)
-		:	mTime	(time)
-		,	mValue	(value)
-	{}
-
-
-	typedef aiVector3D elem_type;
-
-	// Comparison operators. For use with std::find();
-	bool operator == (const aiVectorKey& o) const {
-		return o.mValue == this->mValue;
-	}
-	bool operator != (const aiVectorKey& o) const {
-		return o.mValue != this->mValue;
-	}
-
-	// Relational operators. For use with std::sort();
-	bool operator < (const aiVectorKey& o) const {
-		return mTime < o.mTime;
-	}
-	bool operator > (const aiVectorKey& o) const {
-		return mTime > o.mTime;
-	}
+    //! Default constructor
+    aiVectorKey(){}
+
+    //! Construction from a given time and key value
+    aiVectorKey(double time, const aiVector3D& value)
+        :   mTime   (time)
+        ,   mValue  (value)
+    {}
+
+
+    typedef aiVector3D elem_type;
+
+    // Comparison operators. For use with std::find();
+    bool operator == (const aiVectorKey& o) const {
+        return o.mValue == this->mValue;
+    }
+    bool operator != (const aiVectorKey& o) const {
+        return o.mValue != this->mValue;
+    }
+
+    // Relational operators. For use with std::sort();
+    bool operator < (const aiVectorKey& o) const {
+        return mTime < o.mTime;
+    }
+    bool operator > (const aiVectorKey& o) const {
+        return mTime > o.mTime;
+    }
 #endif
 };
 
@@ -100,39 +100,39 @@ struct aiVectorKey
  *  Rotations are expressed with quaternions. */
 struct aiQuatKey
 {
-	/** The time of this key */
-	double mTime;
+    /** The time of this key */
+    double mTime;
 
-	/** The value of this key */
-	C_STRUCT aiQuaternion mValue;
+    /** The value of this key */
+    C_STRUCT aiQuaternion mValue;
 
 #ifdef __cplusplus
-	aiQuatKey(){
-	}
-
-	/** Construction from a given time and key value */
-	aiQuatKey(double time, const aiQuaternion& value)
-		:	mTime	(time)
-		,	mValue	(value)
-	{}
-
-	typedef aiQuaternion elem_type;
-
-	// Comparison operators. For use with std::find();
-	bool operator == (const aiQuatKey& o) const {
-		return o.mValue == this->mValue;
-	}
-	bool operator != (const aiQuatKey& o) const {
-		return o.mValue != this->mValue;
-	}
-
-	// Relational operators. For use with std::sort();
-	bool operator < (const aiQuatKey& o) const {
-		return mTime < o.mTime;
-	}
-	bool operator > (const aiQuatKey& o) const {
-		return mTime > o.mTime;
-	}
+    aiQuatKey(){
+    }
+
+    /** Construction from a given time and key value */
+    aiQuatKey(double time, const aiQuaternion& value)
+        :   mTime   (time)
+        ,   mValue  (value)
+    {}
+
+    typedef aiQuaternion elem_type;
+
+    // Comparison operators. For use with std::find();
+    bool operator == (const aiQuatKey& o) const {
+        return o.mValue == this->mValue;
+    }
+    bool operator != (const aiQuatKey& o) const {
+        return o.mValue != this->mValue;
+    }
+
+    // Relational operators. For use with std::sort();
+    bool operator < (const aiQuatKey& o) const {
+        return mTime < o.mTime;
+    }
+    bool operator > (const aiQuatKey& o) const {
+        return mTime > o.mTime;
+    }
 #endif
 };
 
@@ -140,43 +140,43 @@ struct aiQuatKey
 /** Binds a anim mesh to a specific point in time. */
 struct aiMeshKey
 {
-	/** The time of this key */
-	double mTime;
+    /** The time of this key */
+    double mTime;
 
-	/** Index into the aiMesh::mAnimMeshes array of the
-	 *  mesh coresponding to the #aiMeshAnim hosting this
-	 *  key frame. The referenced anim mesh is evaluated
-	 *  according to the rules defined in the docs for #aiAnimMesh.*/
-	unsigned int mValue;
+    /** Index into the aiMesh::mAnimMeshes array of the
+     *  mesh coresponding to the #aiMeshAnim hosting this
+     *  key frame. The referenced anim mesh is evaluated
+     *  according to the rules defined in the docs for #aiAnimMesh.*/
+    unsigned int mValue;
 
 #ifdef __cplusplus
 
-	aiMeshKey() {
-	}
-
-	/** Construction from a given time and key value */
-	aiMeshKey(double time, const unsigned int value)
-		:	mTime	(time)
-		,	mValue	(value)
-	{}
-
-	typedef unsigned int elem_type;
-
-	// Comparison operators. For use with std::find();
-	bool operator == (const aiMeshKey& o) const {
-		return o.mValue == this->mValue;
-	}
-	bool operator != (const aiMeshKey& o) const {
-		return o.mValue != this->mValue;
-	}
-
-	// Relational operators. For use with std::sort();
-	bool operator < (const aiMeshKey& o) const {
-		return mTime < o.mTime;
-	}
-	bool operator > (const aiMeshKey& o) const {
-		return mTime > o.mTime;
-	}
+    aiMeshKey() {
+    }
+
+    /** Construction from a given time and key value */
+    aiMeshKey(double time, const unsigned int value)
+        :   mTime   (time)
+        ,   mValue  (value)
+    {}
+
+    typedef unsigned int elem_type;
+
+    // Comparison operators. For use with std::find();
+    bool operator == (const aiMeshKey& o) const {
+        return o.mValue == this->mValue;
+    }
+    bool operator != (const aiMeshKey& o) const {
+        return o.mValue != this->mValue;
+    }
+
+    // Relational operators. For use with std::sort();
+    bool operator < (const aiMeshKey& o) const {
+        return mTime < o.mTime;
+    }
+    bool operator > (const aiMeshKey& o) const {
+        return mTime > o.mTime;
+    }
 
 #endif
 };
@@ -187,28 +187,28 @@ struct aiMeshKey
  *  aiNodeAnim::mPostState.*/
 enum aiAnimBehaviour
 {
-	/** The value from the default node transformation is taken*/
-	aiAnimBehaviour_DEFAULT  = 0x0,
+    /** The value from the default node transformation is taken*/
+    aiAnimBehaviour_DEFAULT  = 0x0,
 
-	/** The nearest key value is used without interpolation */
-	aiAnimBehaviour_CONSTANT = 0x1,
+    /** The nearest key value is used without interpolation */
+    aiAnimBehaviour_CONSTANT = 0x1,
 
-	/** The value of the nearest two keys is linearly
-	 *  extrapolated for the current time value.*/
-	aiAnimBehaviour_LINEAR   = 0x2,
+    /** The value of the nearest two keys is linearly
+     *  extrapolated for the current time value.*/
+    aiAnimBehaviour_LINEAR   = 0x2,
 
-	/** The animation is repeated.
-	 *
-	 *  If the animation key go from n to m and the current
-	 *  time is t, use the value at (t-n) % (|m-n|).*/
-	aiAnimBehaviour_REPEAT   = 0x3,
+    /** The animation is repeated.
+     *
+     *  If the animation key go from n to m and the current
+     *  time is t, use the value at (t-n) % (|m-n|).*/
+    aiAnimBehaviour_REPEAT   = 0x3,
 
 
 
-	/** This value is not used, it is just here to force the
-	 *  the compiler to map this enum to a 32 Bit integer  */
+    /** This value is not used, it is just here to force the
+     *  the compiler to map this enum to a 32 Bit integer  */
 #ifndef SWIG
-	_aiAnimBehaviour_Force32Bit = INT_MAX
+    _aiAnimBehaviour_Force32Bit = INT_MAX
 #endif
 };
 
@@ -229,73 +229,73 @@ enum aiAnimBehaviour
  *  implementations need to cope with them! ) */
 struct aiNodeAnim
 {
-	/** The name of the node affected by this animation. The node
-	 *  must exist and it must be unique.*/
-	C_STRUCT aiString mNodeName;
-
-	/** The number of position keys */
-	unsigned int mNumPositionKeys;
-
-	/** The position keys of this animation channel. Positions are
-	 * specified as 3D vector. The array is mNumPositionKeys in size.
-	 *
-	 * If there are position keys, there will also be at least one
-	 * scaling and one rotation key.*/
-	C_STRUCT aiVectorKey* mPositionKeys;
-
-	/** The number of rotation keys */
-	unsigned int mNumRotationKeys;
-
-	/** The rotation keys of this animation channel. Rotations are
-	 *  given as quaternions,  which are 4D vectors. The array is
-	 *  mNumRotationKeys in size.
-	 *
-	 * If there are rotation keys, there will also be at least one
-	 * scaling and one position key. */
-	C_STRUCT aiQuatKey* mRotationKeys;
-
-
-	/** The number of scaling keys */
-	unsigned int mNumScalingKeys;
-
-	/** The scaling keys of this animation channel. Scalings are
-	 *  specified as 3D vector. The array is mNumScalingKeys in size.
-	 *
-	 * If there are scaling keys, there will also be at least one
-	 * position and one rotation key.*/
-	C_STRUCT aiVectorKey* mScalingKeys;
-
-
-	/** Defines how the animation behaves before the first
-	 *  key is encountered.
-	 *
-	 *  The default value is aiAnimBehaviour_DEFAULT (the original
-	 *  transformation matrix of the affected node is used).*/
-	C_ENUM aiAnimBehaviour mPreState;
-
-	/** Defines how the animation behaves after the last
-	 *  key was processed.
-	 *
-	 *  The default value is aiAnimBehaviour_DEFAULT (the original
-	 *  transformation matrix of the affected node is taken).*/
-	C_ENUM aiAnimBehaviour mPostState;
+    /** The name of the node affected by this animation. The node
+     *  must exist and it must be unique.*/
+    C_STRUCT aiString mNodeName;
+
+    /** The number of position keys */
+    unsigned int mNumPositionKeys;
+
+    /** The position keys of this animation channel. Positions are
+     * specified as 3D vector. The array is mNumPositionKeys in size.
+     *
+     * If there are position keys, there will also be at least one
+     * scaling and one rotation key.*/
+    C_STRUCT aiVectorKey* mPositionKeys;
+
+    /** The number of rotation keys */
+    unsigned int mNumRotationKeys;
+
+    /** The rotation keys of this animation channel. Rotations are
+     *  given as quaternions,  which are 4D vectors. The array is
+     *  mNumRotationKeys in size.
+     *
+     * If there are rotation keys, there will also be at least one
+     * scaling and one position key. */
+    C_STRUCT aiQuatKey* mRotationKeys;
+
+
+    /** The number of scaling keys */
+    unsigned int mNumScalingKeys;
+
+    /** The scaling keys of this animation channel. Scalings are
+     *  specified as 3D vector. The array is mNumScalingKeys in size.
+     *
+     * If there are scaling keys, there will also be at least one
+     * position and one rotation key.*/
+    C_STRUCT aiVectorKey* mScalingKeys;
+
+
+    /** Defines how the animation behaves before the first
+     *  key is encountered.
+     *
+     *  The default value is aiAnimBehaviour_DEFAULT (the original
+     *  transformation matrix of the affected node is used).*/
+    C_ENUM aiAnimBehaviour mPreState;
+
+    /** Defines how the animation behaves after the last
+     *  key was processed.
+     *
+     *  The default value is aiAnimBehaviour_DEFAULT (the original
+     *  transformation matrix of the affected node is taken).*/
+    C_ENUM aiAnimBehaviour mPostState;
 
 #ifdef __cplusplus
-	aiNodeAnim()
-	{
-		mNumPositionKeys = 0; mPositionKeys = NULL;
-		mNumRotationKeys = 0; mRotationKeys = NULL;
-		mNumScalingKeys  = 0; mScalingKeys  = NULL;
-
-		mPreState = mPostState = aiAnimBehaviour_DEFAULT;
-	}
-
-	~aiNodeAnim()
-	{
-		delete [] mPositionKeys;
-		delete [] mRotationKeys;
-		delete [] mScalingKeys;
-	}
+    aiNodeAnim()
+    {
+        mNumPositionKeys = 0; mPositionKeys = NULL;
+        mNumRotationKeys = 0; mRotationKeys = NULL;
+        mNumScalingKeys  = 0; mScalingKeys  = NULL;
+
+        mPreState = mPostState = aiAnimBehaviour_DEFAULT;
+    }
+
+    ~aiNodeAnim()
+    {
+        delete [] mPositionKeys;
+        delete [] mRotationKeys;
+        delete [] mScalingKeys;
+    }
 #endif // __cplusplus
 };
 
@@ -307,29 +307,29 @@ struct aiNodeAnim
  *  point in time. */
 struct aiMeshAnim
 {
-	/** Name of the mesh to be animated. An empty string is not allowed,
-	 *  animated meshes need to be named (not necessarily uniquely,
-	 *  the name can basically serve as wildcard to select a group
-	 *  of meshes with similar animation setup)*/
-	C_STRUCT aiString mName;
+    /** Name of the mesh to be animated. An empty string is not allowed,
+     *  animated meshes need to be named (not necessarily uniquely,
+     *  the name can basically serve as wildcard to select a group
+     *  of meshes with similar animation setup)*/
+    C_STRUCT aiString mName;
 
-	/** Size of the #mKeys array. Must be 1, at least. */
-	unsigned int mNumKeys;
+    /** Size of the #mKeys array. Must be 1, at least. */
+    unsigned int mNumKeys;
 
-	/** Key frames of the animation. May not be NULL. */
-	C_STRUCT aiMeshKey* mKeys;
+    /** Key frames of the animation. May not be NULL. */
+    C_STRUCT aiMeshKey* mKeys;
 
 #ifdef __cplusplus
 
-	aiMeshAnim()
-		: mNumKeys()
-		, mKeys()
-	{}
+    aiMeshAnim()
+        : mNumKeys()
+        , mKeys()
+    {}
 
-	~aiMeshAnim()
-	{
-		delete[] mKeys;
-	}
+    ~aiMeshAnim()
+    {
+        delete[] mKeys;
+    }
 
 #endif
 };
@@ -339,63 +339,63 @@ struct aiMeshAnim
  *  each node affected by the animation a separate series of data is given.*/
 struct aiAnimation
 {
-	/** The name of the animation. If the modeling package this data was
-	 *  exported from does support only a single animation channel, this
-	 *  name is usually empty (length is zero). */
-	C_STRUCT aiString mName;
+    /** The name of the animation. If the modeling package this data was
+     *  exported from does support only a single animation channel, this
+     *  name is usually empty (length is zero). */
+    C_STRUCT aiString mName;
 
-	/** Duration of the animation in ticks.  */
-	double mDuration;
+    /** Duration of the animation in ticks.  */
+    double mDuration;
 
-	/** Ticks per second. 0 if not specified in the imported file */
-	double mTicksPerSecond;
+    /** Ticks per second. 0 if not specified in the imported file */
+    double mTicksPerSecond;
 
-	/** The number of bone animation channels. Each channel affects
-	 *  a single node. */
-	unsigned int mNumChannels;
+    /** The number of bone animation channels. Each channel affects
+     *  a single node. */
+    unsigned int mNumChannels;
 
-	/** The node animation channels. Each channel affects a single node.
-	 *  The array is mNumChannels in size. */
-	C_STRUCT aiNodeAnim** mChannels;
+    /** The node animation channels. Each channel affects a single node.
+     *  The array is mNumChannels in size. */
+    C_STRUCT aiNodeAnim** mChannels;
 
 
-	/** The number of mesh animation channels. Each channel affects
-	 *  a single mesh and defines vertex-based animation. */
-	unsigned int mNumMeshChannels;
+    /** The number of mesh animation channels. Each channel affects
+     *  a single mesh and defines vertex-based animation. */
+    unsigned int mNumMeshChannels;
 
-	/** The mesh animation channels. Each channel affects a single mesh.
-	 *  The array is mNumMeshChannels in size. */
-	C_STRUCT aiMeshAnim** mMeshChannels;
+    /** The mesh animation channels. Each channel affects a single mesh.
+     *  The array is mNumMeshChannels in size. */
+    C_STRUCT aiMeshAnim** mMeshChannels;
 
 #ifdef __cplusplus
-	aiAnimation()
-		: mDuration(-1.)
-		, mTicksPerSecond()
-		, mNumChannels()
-		, mChannels()
-		, mNumMeshChannels()
-		, mMeshChannels()
-	{
-	}
-
-	~aiAnimation()
-	{
-		// DO NOT REMOVE THIS ADDITIONAL CHECK
-		if (mNumChannels && mChannels)	{
-			for( unsigned int a = 0; a < mNumChannels; a++) {
-				delete mChannels[a];
-			}
-
-		delete [] mChannels;
-		}
-		if (mNumMeshChannels && mMeshChannels)	{
-			for( unsigned int a = 0; a < mNumMeshChannels; a++) {
-				delete mMeshChannels[a];
-			}
-
-		delete [] mMeshChannels;
-		}
-	}
+    aiAnimation()
+        : mDuration(-1.)
+        , mTicksPerSecond()
+        , mNumChannels()
+        , mChannels()
+        , mNumMeshChannels()
+        , mMeshChannels()
+    {
+    }
+
+    ~aiAnimation()
+    {
+        // DO NOT REMOVE THIS ADDITIONAL CHECK
+        if (mNumChannels && mChannels)  {
+            for( unsigned int a = 0; a < mNumChannels; a++) {
+                delete mChannels[a];
+            }
+
+        delete [] mChannels;
+        }
+        if (mNumMeshChannels && mMeshChannels)  {
+            for( unsigned int a = 0; a < mNumMeshChannels; a++) {
+                delete mMeshChannels[a];
+            }
+
+        delete [] mMeshChannels;
+        }
+    }
 #endif // __cplusplus
 };
 
@@ -414,65 +414,65 @@ namespace Assimp {
 template <typename T>
 struct Interpolator
 {
-	// ------------------------------------------------------------------
-	/** @brief Get the result of the interpolation between a,b.
-	 *
-	 *  The interpolation algorithm depends on the type of the operands.
-	 *  aiQuaternion's and aiQuatKey's SLERP, the rest does a simple
-	 *  linear interpolation. */
-	void operator () (T& out,const T& a, const T& b, float d) const {
-		out = a + (b-a)*d;
-	}
+    // ------------------------------------------------------------------
+    /** @brief Get the result of the interpolation between a,b.
+     *
+     *  The interpolation algorithm depends on the type of the operands.
+     *  aiQuaternion's and aiQuatKey's SLERP, the rest does a simple
+     *  linear interpolation. */
+    void operator () (T& out,const T& a, const T& b, float d) const {
+        out = a + (b-a)*d;
+    }
 }; // ! Interpolator <T>
 
 //! @cond Never
 
 template <>
-struct Interpolator	<aiQuaternion>	{
-	void operator () (aiQuaternion& out,const aiQuaternion& a,
-		const aiQuaternion& b, float d) const
-	{
-		aiQuaternion::Interpolate(out,a,b,d);
-	}
+struct Interpolator <aiQuaternion>  {
+    void operator () (aiQuaternion& out,const aiQuaternion& a,
+        const aiQuaternion& b, float d) const
+    {
+        aiQuaternion::Interpolate(out,a,b,d);
+    }
 }; // ! Interpolator <aiQuaternion>
 
 template <>
-struct Interpolator	<unsigned int>	{
-	void operator () (unsigned int& out,unsigned int a,
-		unsigned int b, float d) const
-	{
-		out = d>0.5f ? b : a;
-	}
+struct Interpolator <unsigned int>  {
+    void operator () (unsigned int& out,unsigned int a,
+        unsigned int b, float d) const
+    {
+        out = d>0.5f ? b : a;
+    }
 }; // ! Interpolator <aiQuaternion>
 
 template <>
-struct Interpolator	 <aiVectorKey>	{
-	void operator () (aiVector3D& out,const aiVectorKey& a,
-		const aiVectorKey& b, float d) const
-	{
-		Interpolator<aiVector3D> ipl;
-		ipl(out,a.mValue,b.mValue,d);
-	}
+struct Interpolator  <aiVectorKey>  {
+    void operator () (aiVector3D& out,const aiVectorKey& a,
+        const aiVectorKey& b, float d) const
+    {
+        Interpolator<aiVector3D> ipl;
+        ipl(out,a.mValue,b.mValue,d);
+    }
 }; // ! Interpolator <aiVectorKey>
 
 template <>
-struct Interpolator <aiQuatKey>		{
-	void operator () (aiQuaternion& out, const aiQuatKey& a,
-		const aiQuatKey& b, float d) const
-	{
-		Interpolator<aiQuaternion> ipl;
-		ipl(out,a.mValue,b.mValue,d);
-	}
+struct Interpolator <aiQuatKey>     {
+    void operator () (aiQuaternion& out, const aiQuatKey& a,
+        const aiQuatKey& b, float d) const
+    {
+        Interpolator<aiQuaternion> ipl;
+        ipl(out,a.mValue,b.mValue,d);
+    }
 }; // ! Interpolator <aiQuatKey>
 
 template <>
-struct Interpolator <aiMeshKey>		{
-	void operator () (unsigned int& out, const aiMeshKey& a,
-		const aiMeshKey& b, float d) const
-	{
-		Interpolator<unsigned int> ipl;
-		ipl(out,a.mValue,b.mValue,d);
-	}
+struct Interpolator <aiMeshKey>     {
+    void operator () (unsigned int& out, const aiMeshKey& a,
+        const aiMeshKey& b, float d) const
+    {
+        Interpolator<unsigned int> ipl;
+        ipl(out,a.mValue,b.mValue,d);
+    }
 }; // ! Interpolator <aiQuatKey>
 
 //! @endcond

include/assimp/camera.h

@@ -97,120 +97,120 @@ extern "C" {
 */
 struct aiCamera
 {
-	/** The name of the camera.
-	 *
-	 *  There must be a node in the scenegraph with the same name.
-	 *  This node specifies the position of the camera in the scene
-	 *  hierarchy and can be animated.
-	 */
-	C_STRUCT aiString mName;
-
-	/** Position of the camera relative to the coordinate space
-	 *  defined by the corresponding node.
-	 *
-	 *  The default value is 0|0|0.
-	 */
-	C_STRUCT aiVector3D mPosition;
-
-
-	/** 'Up' - vector of the camera coordinate system relative to
-	 *  the coordinate space defined by the corresponding node.
-	 *
-	 *  The 'right' vector of the camera coordinate system is
-	 *  the cross product of  the up and lookAt vectors.
-	 *  The default value is 0|1|0. The vector
-	 *  may be normalized, but it needn't.
-	 */
-	C_STRUCT aiVector3D mUp;
-
-
-	/** 'LookAt' - vector of the camera coordinate system relative to
-	 *  the coordinate space defined by the corresponding node.
-	 *
-	 *  This is the viewing direction of the user.
-	 *  The default value is 0|0|1. The vector
-	 *  may be normalized, but it needn't.
-	 */
-	C_STRUCT aiVector3D mLookAt;
-
-
-	/** Half horizontal field of view angle, in radians.
-	 *
-	 *  The field of view angle is the angle between the center
-	 *  line of the screen and the left or right border.
-	 *  The default value is 1/4PI.
-	 */
-	float mHorizontalFOV;
-
-	/** Distance of the near clipping plane from the camera.
-	 *
-	 * The value may not be 0.f (for arithmetic reasons to prevent
-	 * a division through zero). The default value is 0.1f.
-	 */
-	float mClipPlaneNear;
-
-	/** Distance of the far clipping plane from the camera.
-	 *
-	 * The far clipping plane must, of course, be further away than the
-	 * near clipping plane. The default value is 1000.f. The ratio
-	 * between the near and the far plane should not be too
-	 * large (between 1000-10000 should be ok) to avoid floating-point
-	 * inaccuracies which could lead to z-fighting.
-	 */
-	float mClipPlaneFar;
-
-
-	/** Screen aspect ratio.
-	 *
-	 * This is the ration between the width and the height of the
-	 * screen. Typical values are 4/3, 1/2 or 1/1. This value is
-	 * 0 if the aspect ratio is not defined in the source file.
-	 * 0 is also the default value.
-	 */
-	float mAspect;
+    /** The name of the camera.
+     *
+     *  There must be a node in the scenegraph with the same name.
+     *  This node specifies the position of the camera in the scene
+     *  hierarchy and can be animated.
+     */
+    C_STRUCT aiString mName;
+
+    /** Position of the camera relative to the coordinate space
+     *  defined by the corresponding node.
+     *
+     *  The default value is 0|0|0.
+     */
+    C_STRUCT aiVector3D mPosition;
+
+
+    /** 'Up' - vector of the camera coordinate system relative to
+     *  the coordinate space defined by the corresponding node.
+     *
+     *  The 'right' vector of the camera coordinate system is
+     *  the cross product of  the up and lookAt vectors.
+     *  The default value is 0|1|0. The vector
+     *  may be normalized, but it needn't.
+     */
+    C_STRUCT aiVector3D mUp;
+
+
+    /** 'LookAt' - vector of the camera coordinate system relative to
+     *  the coordinate space defined by the corresponding node.
+     *
+     *  This is the viewing direction of the user.
+     *  The default value is 0|0|1. The vector
+     *  may be normalized, but it needn't.
+     */
+    C_STRUCT aiVector3D mLookAt;
+
+
+    /** Half horizontal field of view angle, in radians.
+     *
+     *  The field of view angle is the angle between the center
+     *  line of the screen and the left or right border.
+     *  The default value is 1/4PI.
+     */
+    float mHorizontalFOV;
+
+    /** Distance of the near clipping plane from the camera.
+     *
+     * The value may not be 0.f (for arithmetic reasons to prevent
+     * a division through zero). The default value is 0.1f.
+     */
+    float mClipPlaneNear;
+
+    /** Distance of the far clipping plane from the camera.
+     *
+     * The far clipping plane must, of course, be further away than the
+     * near clipping plane. The default value is 1000.f. The ratio
+     * between the near and the far plane should not be too
+     * large (between 1000-10000 should be ok) to avoid floating-point
+     * inaccuracies which could lead to z-fighting.
+     */
+    float mClipPlaneFar;
+
+
+    /** Screen aspect ratio.
+     *
+     * This is the ration between the width and the height of the
+     * screen. Typical values are 4/3, 1/2 or 1/1. This value is
+     * 0 if the aspect ratio is not defined in the source file.
+     * 0 is also the default value.
+     */
+    float mAspect;
 
 #ifdef __cplusplus
 
-	aiCamera()
-		: mUp				(0.f,1.f,0.f)
-		, mLookAt			(0.f,0.f,1.f)
-		, mHorizontalFOV	(0.25f * (float)AI_MATH_PI)
-		, mClipPlaneNear	(0.1f)
-		, mClipPlaneFar		(1000.f)
-		, mAspect			(0.f)
-	{}
-
-	/** @brief Get a *right-handed* camera matrix from me
-	 *  @param out Camera matrix to be filled
-	 */
-	void GetCameraMatrix (aiMatrix4x4& out) const
-	{
-		/** todo: test ... should work, but i'm not absolutely sure */
-
-		/** We don't know whether these vectors are already normalized ...*/
-		aiVector3D zaxis = mLookAt;     zaxis.Normalize();
-		aiVector3D yaxis = mUp;         yaxis.Normalize();
-		aiVector3D xaxis = mUp^mLookAt; xaxis.Normalize();
-
-		out.a4 = -(xaxis * mPosition);
-		out.b4 = -(yaxis * mPosition);
-		out.c4 = -(zaxis * mPosition);
-
-		out.a1 = xaxis.x;
-		out.a2 = xaxis.y;
-		out.a3 = xaxis.z;
-
-		out.b1 = yaxis.x;
-		out.b2 = yaxis.y;
-		out.b3 = yaxis.z;
-
-		out.c1 = zaxis.x;
-		out.c2 = zaxis.y;
-		out.c3 = zaxis.z;
-
-		out.d1 = out.d2 = out.d3 = 0.f;
-		out.d4 = 1.f;
-	}
+    aiCamera()
+        : mUp               (0.f,1.f,0.f)
+        , mLookAt           (0.f,0.f,1.f)
+        , mHorizontalFOV    (0.25f * (float)AI_MATH_PI)
+        , mClipPlaneNear    (0.1f)
+        , mClipPlaneFar     (1000.f)
+        , mAspect           (0.f)
+    {}
+
+    /** @brief Get a *right-handed* camera matrix from me
+     *  @param out Camera matrix to be filled
+     */
+    void GetCameraMatrix (aiMatrix4x4& out) const
+    {
+        /** todo: test ... should work, but i'm not absolutely sure */
+
+        /** We don't know whether these vectors are already normalized ...*/
+        aiVector3D zaxis = mLookAt;     zaxis.Normalize();
+        aiVector3D yaxis = mUp;         yaxis.Normalize();
+        aiVector3D xaxis = mUp^mLookAt; xaxis.Normalize();
+
+        out.a4 = -(xaxis * mPosition);
+        out.b4 = -(yaxis * mPosition);
+        out.c4 = -(zaxis * mPosition);
+
+        out.a1 = xaxis.x;
+        out.a2 = xaxis.y;
+        out.a3 = xaxis.z;
+
+        out.b1 = yaxis.x;
+        out.b2 = yaxis.y;
+        out.b3 = yaxis.z;
+
+        out.c1 = zaxis.x;
+        out.c2 = zaxis.y;
+        out.c3 = zaxis.z;
+
+        out.d1 = out.d2 = out.d3 = 0.f;
+        out.d4 = 1.f;
+    }
 
 #endif
 };

include/assimp/cexport.h

@@ -63,17 +63,17 @@ struct aiFileIO; // aiFileIO.h
 */
 struct aiExportFormatDesc
 {
-	/// a short string ID to uniquely identify the export format. Use this ID string to
-	/// specify which file format you want to export to when calling #aiExportScene().
-	/// Example: "dae" or "obj"
-	const char* id;
+    /// a short string ID to uniquely identify the export format. Use this ID string to
+    /// specify which file format you want to export to when calling #aiExportScene().
+    /// Example: "dae" or "obj"
+    const char* id;
 
-	/// A short description of the file format to present to users. Useful if you want
-	/// to allow the user to select an export format.
-	const char* description;
+    /// A short description of the file format to present to users. Useful if you want
+    /// to allow the user to select an export format.
+    const char* description;
 
-	/// Recommended file extension for the exported file in lower case.
-	const char* fileExtension;
+    /// Recommended file extension for the exported file in lower case.
+    const char* fileExtension;
 };
 
 
@@ -104,7 +104,7 @@ ASSIMP_API const C_STRUCT aiExportFormatDesc* aiGetExportFormatDescription( size
  *    delete it again.
  */
 ASSIMP_API void aiCopyScene(const C_STRUCT aiScene* pIn,
-	C_STRUCT aiScene** pOut);
+    C_STRUCT aiScene** pOut);
 
 
 // --------------------------------------------------------------------------------
@@ -151,9 +151,9 @@ ASSIMP_API void aiFreeScene(const C_STRUCT aiScene* pIn);
 *   imported scene.
 */
 ASSIMP_API aiReturn aiExportScene( const C_STRUCT aiScene* pScene,
-	const char* pFormatId,
-	const char* pFileName,
-	unsigned int pPreprocessing);
+    const char* pFormatId,
+    const char* pFileName,
+    unsigned int pPreprocessing);
 
 
 // --------------------------------------------------------------------------------
@@ -172,10 +172,10 @@ ASSIMP_API aiReturn aiExportScene( const C_STRUCT aiScene* pScene,
 *   imported scene.
 */
 ASSIMP_API aiReturn aiExportSceneEx( const C_STRUCT aiScene* pScene,
-	const char* pFormatId,
-	const char* pFileName,
-	C_STRUCT aiFileIO* pIO,
-	unsigned int pPreprocessing );
+    const char* pFormatId,
+    const char* pFileName,
+    C_STRUCT aiFileIO* pIO,
+    unsigned int pPreprocessing );
 
 
 // --------------------------------------------------------------------------------
@@ -190,39 +190,39 @@ ASSIMP_API aiReturn aiExportSceneEx( const C_STRUCT aiScene* pScene,
 */
 struct aiExportDataBlob
 {
-	/// Size of the data in bytes
-	size_t size;
+    /// Size of the data in bytes
+    size_t size;
 
-	/// The data.
-	void* data;
+    /// The data.
+    void* data;
 
-	/** Name of the blob. An empty string always
-	    indicates the first (and primary) blob,
-	    which contains the actual file data.
+    /** Name of the blob. An empty string always
+        indicates the first (and primary) blob,
+        which contains the actual file data.
         Any other blobs are auxiliary files produced
-	    by exporters (i.e. material files). Existence
-	    of such files depends on the file format. Most
-	    formats don't split assets across multiple files.
-
-		If used, blob names usually contain the file
-		extension that should be used when writing
-		the data to disc.
-	 */
+        by exporters (i.e. material files). Existence
+        of such files depends on the file format. Most
+        formats don't split assets across multiple files.
+
+        If used, blob names usually contain the file
+        extension that should be used when writing
+        the data to disc.
+     */
     C_STRUCT aiString name;
 
-	/** Pointer to the next blob in the chain or NULL if there is none. */
-	C_STRUCT aiExportDataBlob * next;
+    /** Pointer to the next blob in the chain or NULL if there is none. */
+    C_STRUCT aiExportDataBlob * next;
 
 #ifdef __cplusplus
-	/// Default constructor
-	aiExportDataBlob() { size = 0; data = next = NULL; }
-	/// Releases the data
-	~aiExportDataBlob() { delete [] static_cast<unsigned char*>( data ); delete next; }
+    /// Default constructor
+    aiExportDataBlob() { size = 0; data = next = NULL; }
+    /// Releases the data
+    ~aiExportDataBlob() { delete [] static_cast<unsigned char*>( data ); delete next; }
 
 private:
-	// no copying
-	aiExportDataBlob(const aiExportDataBlob& );
-	aiExportDataBlob& operator= (const aiExportDataBlob& );
+    // no copying
+    aiExportDataBlob(const aiExportDataBlob& );
+    aiExportDataBlob& operator= (const aiExportDataBlob& );
 #endif // __cplusplus
 };
 

include/assimp/cfileio.h

@@ -75,16 +75,16 @@ typedef char* aiUserData;
  *  or memory locations. */
 struct aiFileIO
 {
-	/** Function used to open a new file
-	 */
-	aiFileOpenProc OpenProc;
+    /** Function used to open a new file
+     */
+    aiFileOpenProc OpenProc;
 
-	/** Function used to close an existing file
-	 */
-	aiFileCloseProc CloseProc;
+    /** Function used to close an existing file
+     */
+    aiFileCloseProc CloseProc;
 
-	/** User-defined, opaque data */
-	aiUserData UserData;
+    /** User-defined, opaque data */
+    aiUserData UserData;
 };
 
 // ----------------------------------------------------------------------------------
@@ -99,34 +99,34 @@ struct aiFileIO
  *  such as ZIP archives or memory locations. */
 struct aiFile
 {
-	/** Callback to read from a file */
-	aiFileReadProc ReadProc;
-
-	/** Callback to write to a file */
-	aiFileWriteProc WriteProc;
-
-	/** Callback to retrieve the current position of
-	 *  the file cursor (ftell())
-	 */
-	aiFileTellProc TellProc;
-
-	/** Callback to retrieve the size of the file,
-	 *  in bytes
-	 */
-	aiFileTellProc FileSizeProc;
-
-	/** Callback to set the current position
-	 * of the file cursor (fseek())
-	 */
-	aiFileSeek SeekProc;
-
-	/** Callback to flush the file contents
-	 */
-	aiFileFlushProc FlushProc;
-
-	/** User-defined, opaque data
-	 */
-	aiUserData UserData;
+    /** Callback to read from a file */
+    aiFileReadProc ReadProc;
+
+    /** Callback to write to a file */
+    aiFileWriteProc WriteProc;
+
+    /** Callback to retrieve the current position of
+     *  the file cursor (ftell())
+     */
+    aiFileTellProc TellProc;
+
+    /** Callback to retrieve the size of the file,
+     *  in bytes
+     */
+    aiFileTellProc FileSizeProc;
+
+    /** Callback to set the current position
+     * of the file cursor (fseek())
+     */
+    aiFileSeek SeekProc;
+
+    /** Callback to flush the file contents
+     */
+    aiFileFlushProc FlushProc;
+
+    /** User-defined, opaque data
+     */
+    aiUserData UserData;
 };
 
 #ifdef __cplusplus

include/assimp/cimport.h

@@ -64,11 +64,11 @@ typedef void (*aiLogStreamCallback)(const char* /* message */, char* /* user */)
 // --------------------------------------------------------------------------------
 struct aiLogStream
 {
-	/** callback to be called */
-	aiLogStreamCallback callback;
+    /** callback to be called */
+    aiLogStreamCallback callback;
 
-	/** user data to be passed to the callback */
-	char* user;
+    /** user data to be passed to the callback */
+    char* user;
 };
 
 
@@ -108,8 +108,8 @@ typedef int aiBool;
  * @return Pointer to the imported data or NULL if the import failed.
  */
 ASSIMP_API const C_STRUCT aiScene* aiImportFile(
-	const char* pFile,
-	unsigned int pFlags);
+    const char* pFile,
+    unsigned int pFlags);
 
 // --------------------------------------------------------------------------------
 /** Reads the given file using user-defined I/O functions and returns
@@ -133,9 +133,9 @@ ASSIMP_API const C_STRUCT aiScene* aiImportFile(
  * @note Include <aiFileIO.h> for the definition of #aiFileIO.
  */
 ASSIMP_API const C_STRUCT aiScene* aiImportFileEx(
-	const char* pFile,
-	unsigned int pFlags,
-	C_STRUCT aiFileIO* pFS);
+    const char* pFile,
+    unsigned int pFlags,
+    C_STRUCT aiFileIO* pFS);
 
 // --------------------------------------------------------------------------------
 /** Same as #aiImportFileEx, but adds an extra parameter containing importer settings.
@@ -154,10 +154,10 @@ ASSIMP_API const C_STRUCT aiScene* aiImportFileEx(
  * @see aiImportFileEx
  */
 ASSIMP_API const C_STRUCT aiScene* aiImportFileExWithProperties(
-	const char* pFile,
-	unsigned int pFlags,
-	C_STRUCT aiFileIO* pFS,
-	const C_STRUCT aiPropertyStore* pProps);
+    const char* pFile,
+    unsigned int pFlags,
+    C_STRUCT aiFileIO* pFS,
+    const C_STRUCT aiPropertyStore* pProps);
 
 // --------------------------------------------------------------------------------
 /** Reads the given file from a given memory buffer,
@@ -191,10 +191,10 @@ ASSIMP_API const C_STRUCT aiScene* aiImportFileExWithProperties(
  * the regular aiImportFileEx()/aiImportFileExWithProperties() API.
  */
 ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemory(
-	const char* pBuffer,
-	unsigned int pLength,
-	unsigned int pFlags,
-	const char* pHint);
+    const char* pBuffer,
+    unsigned int pLength,
+    unsigned int pFlags,
+    const char* pHint);
 
 // --------------------------------------------------------------------------------
 /** Same as #aiImportFileFromMemory, but adds an extra parameter containing importer settings.
@@ -225,11 +225,11 @@ ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemory(
  * @see aiImportFileFromMemory
  */
 ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemoryWithProperties(
-	const char* pBuffer,
-	unsigned int pLength,
-	unsigned int pFlags,
-	const char* pHint,
-	const C_STRUCT aiPropertyStore* pProps);
+    const char* pBuffer,
+    unsigned int pLength,
+    unsigned int pFlags,
+    const char* pHint,
+    const C_STRUCT aiPropertyStore* pProps);
 
 // --------------------------------------------------------------------------------
 /** Apply post-processing to an already-imported scene.
@@ -247,8 +247,8 @@ ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemoryWithProperties(
  *   which can actually cause the scene to be reset to NULL.
  */
 ASSIMP_API const C_STRUCT aiScene* aiApplyPostProcessing(
-	const C_STRUCT aiScene* pScene,
-	unsigned int pFlags);
+    const C_STRUCT aiScene* pScene,
+    unsigned int pFlags);
 
 // --------------------------------------------------------------------------------
 /** Get one of the predefine log streams. This is the quick'n'easy solution to
@@ -271,8 +271,8 @@ ASSIMP_API const C_STRUCT aiScene* aiApplyPostProcessing(
  *  @return The log stream. callback is set to NULL if something went wrong.
  */
 ASSIMP_API C_STRUCT aiLogStream aiGetPredefinedLogStream(
-	C_ENUM aiDefaultLogStream pStreams,
-	const char* file);
+    C_ENUM aiDefaultLogStream pStreams,
+    const char* file);
 
 // --------------------------------------------------------------------------------
 /** Attach a custom log stream to the libraries' logging system.
@@ -285,7 +285,7 @@ ASSIMP_API C_STRUCT aiLogStream aiGetPredefinedLogStream(
  *    Alternatively (for the lazy folks) #aiDetachAllLogStreams is provided.
  */
 ASSIMP_API void aiAttachLogStream(
-	const C_STRUCT aiLogStream* stream);
+    const C_STRUCT aiLogStream* stream);
 
 // --------------------------------------------------------------------------------
 /** Enable verbose logging. Verbose logging includes debug-related stuff and
@@ -306,7 +306,7 @@ ASSIMP_API void aiEnableVerboseLogging(aiBool d);
  *  @see aiDetachAllLogStreams
  */
 ASSIMP_API C_ENUM aiReturn aiDetachLogStream(
-	const C_STRUCT aiLogStream* stream);
+    const C_STRUCT aiLogStream* stream);
 
 // --------------------------------------------------------------------------------
 /** Detach all active log streams from the libraries' logging system.
@@ -325,7 +325,7 @@ ASSIMP_API void aiDetachAllLogStreams(void);
  * @param pScene The imported data to release. NULL is a valid value.
  */
 ASSIMP_API void aiReleaseImport(
-	const C_STRUCT aiScene* pScene);
+    const C_STRUCT aiScene* pScene);
 
 // --------------------------------------------------------------------------------
 /** Returns the error text of the last failed import process.
@@ -344,7 +344,7 @@ ASSIMP_API const char* aiGetErrorString();
  * @return AI_TRUE if the file extension is supported.
  */
 ASSIMP_API aiBool aiIsExtensionSupported(
-	const char* szExtension);
+    const char* szExtension);
 
 // --------------------------------------------------------------------------------
 /** Get a list of all file extensions supported by ASSIMP.
@@ -355,7 +355,7 @@ ASSIMP_API aiBool aiIsExtensionSupported(
  * Format of the list: "*.3ds;*.obj;*.dae". NULL is not a valid parameter.
  */
 ASSIMP_API void aiGetExtensionList(
-	C_STRUCT aiString* szOut);
+    C_STRUCT aiString* szOut);
 
 // --------------------------------------------------------------------------------
 /** Get the approximated storage required by an imported asset
@@ -363,8 +363,8 @@ ASSIMP_API void aiGetExtensionList(
  * @param in Data structure to be filled.
  */
 ASSIMP_API void aiGetMemoryRequirements(
-	const C_STRUCT aiScene* pIn,
-	C_STRUCT aiMemoryInfo* in);
+    const C_STRUCT aiScene* pIn,
+    C_STRUCT aiMemoryInfo* in);
 
 
 
@@ -395,9 +395,9 @@ ASSIMP_API void aiReleasePropertyStore(C_STRUCT aiPropertyStore* p);
  * @param value New value for the property
  */
 ASSIMP_API void aiSetImportPropertyInteger(
-	C_STRUCT aiPropertyStore* store,
-	const char* szName,
-	int value);
+    C_STRUCT aiPropertyStore* store,
+    const char* szName,
+    int value);
 
 // --------------------------------------------------------------------------------
 /** Set a floating-point property.
@@ -412,9 +412,9 @@ ASSIMP_API void aiSetImportPropertyInteger(
  * @param value New value for the property
  */
 ASSIMP_API void aiSetImportPropertyFloat(
-	C_STRUCT aiPropertyStore* store,
-	const char* szName,
-	float value);
+    C_STRUCT aiPropertyStore* store,
+    const char* szName,
+    float value);
 
 // --------------------------------------------------------------------------------
 /** Set a string property.
@@ -429,9 +429,9 @@ ASSIMP_API void aiSetImportPropertyFloat(
  * @param st New value for the property
  */
 ASSIMP_API void aiSetImportPropertyString(
-	C_STRUCT aiPropertyStore* store,
-	const char* szName,
-	const C_STRUCT aiString* st);
+    C_STRUCT aiPropertyStore* store,
+    const char* szName,
+    const C_STRUCT aiString* st);
 
 // --------------------------------------------------------------------------------
 /** Set a matrix property.
@@ -446,9 +446,9 @@ ASSIMP_API void aiSetImportPropertyString(
  * @param mat New value for the property
  */
 ASSIMP_API void aiSetImportPropertyMatrix(
-	C_STRUCT aiPropertyStore* store,
-	const char* szName,
-	const C_STRUCT aiMatrix4x4* mat);
+    C_STRUCT aiPropertyStore* store,
+    const char* szName,
+    const C_STRUCT aiMatrix4x4* mat);
 
 // --------------------------------------------------------------------------------
 /** Construct a quaternion from a 3x3 rotation matrix.
@@ -457,8 +457,8 @@ ASSIMP_API void aiSetImportPropertyMatrix(
  *  @see aiQuaternion(const aiMatrix3x3& pRotMatrix)
  */
 ASSIMP_API void aiCreateQuaternionFromMatrix(
-	C_STRUCT aiQuaternion* quat,
-	const C_STRUCT aiMatrix3x3* mat);
+    C_STRUCT aiQuaternion* quat,
+    const C_STRUCT aiMatrix3x3* mat);
 
 // --------------------------------------------------------------------------------
 /** Decompose a transformation matrix into its rotational, translational and
@@ -471,24 +471,24 @@ ASSIMP_API void aiCreateQuaternionFromMatrix(
  * @see aiMatrix4x4::Decompose (aiVector3D&, aiQuaternion&, aiVector3D&) const;
  */
 ASSIMP_API void aiDecomposeMatrix(
-	const C_STRUCT aiMatrix4x4* mat,
-	C_STRUCT aiVector3D* scaling,
-	C_STRUCT aiQuaternion* rotation,
-	C_STRUCT aiVector3D* position);
+    const C_STRUCT aiMatrix4x4* mat,
+    C_STRUCT aiVector3D* scaling,
+    C_STRUCT aiQuaternion* rotation,
+    C_STRUCT aiVector3D* position);
 
 // --------------------------------------------------------------------------------
 /** Transpose a 4x4 matrix.
  *  @param mat Pointer to the matrix to be transposed
  */
 ASSIMP_API void aiTransposeMatrix4(
-	C_STRUCT aiMatrix4x4* mat);
+    C_STRUCT aiMatrix4x4* mat);
 
 // --------------------------------------------------------------------------------
 /** Transpose a 3x3 matrix.
  *  @param mat Pointer to the matrix to be transposed
  */
 ASSIMP_API void aiTransposeMatrix3(
-	C_STRUCT aiMatrix3x3* mat);
+    C_STRUCT aiMatrix3x3* mat);
 
 // --------------------------------------------------------------------------------
 /** Transform a vector by a 3x3 matrix
@@ -496,8 +496,8 @@ ASSIMP_API void aiTransposeMatrix3(
  *  @param mat Matrix to transform the vector with.
  */
 ASSIMP_API void aiTransformVecByMatrix3(
-	C_STRUCT aiVector3D* vec,
-	const C_STRUCT aiMatrix3x3* mat);
+    C_STRUCT aiVector3D* vec,
+    const C_STRUCT aiMatrix3x3* mat);
 
 // --------------------------------------------------------------------------------
 /** Transform a vector by a 4x4 matrix
@@ -505,8 +505,8 @@ ASSIMP_API void aiTransformVecByMatrix3(
  *  @param mat Matrix to transform the vector with.
  */
 ASSIMP_API void aiTransformVecByMatrix4(
-	C_STRUCT aiVector3D* vec,
-	const C_STRUCT aiMatrix4x4* mat);
+    C_STRUCT aiVector3D* vec,
+    const C_STRUCT aiMatrix4x4* mat);
 
 // --------------------------------------------------------------------------------
 /** Multiply two 4x4 matrices.
@@ -514,8 +514,8 @@ ASSIMP_API void aiTransformVecByMatrix4(
  *  @param src Matrix to be multiplied with 'dst'.
  */
 ASSIMP_API void aiMultiplyMatrix4(
-	C_STRUCT aiMatrix4x4* dst,
-	const C_STRUCT aiMatrix4x4* src);
+    C_STRUCT aiMatrix4x4* dst,
+    const C_STRUCT aiMatrix4x4* src);
 
 // --------------------------------------------------------------------------------
 /** Multiply two 3x3 matrices.
@@ -523,22 +523,22 @@ ASSIMP_API void aiMultiplyMatrix4(
  *  @param src Matrix to be multiplied with 'dst'.
  */
 ASSIMP_API void aiMultiplyMatrix3(
-	C_STRUCT aiMatrix3x3* dst,
-	const C_STRUCT aiMatrix3x3* src);
+    C_STRUCT aiMatrix3x3* dst,
+    const C_STRUCT aiMatrix3x3* src);
 
 // --------------------------------------------------------------------------------
 /** Get a 3x3 identity matrix.
  *  @param mat Matrix to receive its personal identity
  */
 ASSIMP_API void aiIdentityMatrix3(
-	C_STRUCT aiMatrix3x3* mat);
+    C_STRUCT aiMatrix3x3* mat);
 
 // --------------------------------------------------------------------------------
 /** Get a 4x4 identity matrix.
  *  @param mat Matrix to receive its personal identity
  */
 ASSIMP_API void aiIdentityMatrix4(
-	C_STRUCT aiMatrix4x4* mat);
+    C_STRUCT aiMatrix4x4* mat);
 
 // --------------------------------------------------------------------------------
 /** Returns the number of import file formats available in the current Assimp build.

include/assimp/color4.h

@@ -56,37 +56,37 @@ template <typename TReal>
 class aiColor4t
 {
 public:
-	aiColor4t () : r(), g(), b(), a() {}
-	aiColor4t (TReal _r, TReal _g, TReal _b, TReal _a)
-		: r(_r), g(_g), b(_b), a(_a) {}
-	aiColor4t (TReal _r) : r(_r), g(_r), b(_r), a(_r) {}
-	aiColor4t (const aiColor4t& o)
-		: r(o.r), g(o.g), b(o.b), a(o.a) {}
+    aiColor4t () : r(), g(), b(), a() {}
+    aiColor4t (TReal _r, TReal _g, TReal _b, TReal _a)
+        : r(_r), g(_g), b(_b), a(_a) {}
+    aiColor4t (TReal _r) : r(_r), g(_r), b(_r), a(_r) {}
+    aiColor4t (const aiColor4t& o)
+        : r(o.r), g(o.g), b(o.b), a(o.a) {}
 
 public:
-	// combined operators
-	const aiColor4t& operator += (const aiColor4t& o);
-	const aiColor4t& operator -= (const aiColor4t& o);
-	const aiColor4t& operator *= (TReal f);
-	const aiColor4t& operator /= (TReal f);
+    // combined operators
+    const aiColor4t& operator += (const aiColor4t& o);
+    const aiColor4t& operator -= (const aiColor4t& o);
+    const aiColor4t& operator *= (TReal f);
+    const aiColor4t& operator /= (TReal f);
 
 public:
-	// comparison
-	bool operator == (const aiColor4t& other) const;
-	bool operator != (const aiColor4t& other) const;
-	bool operator <  (const aiColor4t& other) const;
+    // comparison
+    bool operator == (const aiColor4t& other) const;
+    bool operator != (const aiColor4t& other) const;
+    bool operator <  (const aiColor4t& other) const;
 
-	// color tuple access, rgba order
-	inline TReal operator[](unsigned int i) const;
-	inline TReal& operator[](unsigned int i);
+    // color tuple access, rgba order
+    inline TReal operator[](unsigned int i) const;
+    inline TReal& operator[](unsigned int i);
 
-	/** check whether a color is (close to) black */
-	inline bool IsBlack() const;
+    /** check whether a color is (close to) black */
+    inline bool IsBlack() const;
 
 public:
 
-	// Red, green, blue and alpha color values
-	TReal r, g, b, a;
+    // Red, green, blue and alpha color values
+    TReal r, g, b, a;
 } PACK_STRUCT;  // !struct aiColor4D
 
 typedef aiColor4t<float> aiColor4D;
@@ -94,7 +94,7 @@ typedef aiColor4t<float> aiColor4D;
 #else
 
 struct aiColor4D {
-	float r, g, b, a;
+    float r, g, b, a;
 } PACK_STRUCT;
 
 #endif // __cplusplus

include/assimp/color4.inl

@@ -51,131 +51,131 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator += (const aiColor4t<TReal>& o) {
-	r += o.r; g += o.g; b += o.b; a += o.a;
-	return *this;
+    r += o.r; g += o.g; b += o.b; a += o.a;
+    return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator -= (const aiColor4t<TReal>& o) {
-	r -= o.r; g -= o.g; b -= o.b; a -= o.a;
-	return *this;
+    r -= o.r; g -= o.g; b -= o.b; a -= o.a;
+    return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator *= (TReal f) {
-	r *= f; g *= f; b *= f; a *= f;
-	return *this;
+    r *= f; g *= f; b *= f; a *= f;
+    return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator /= (TReal f) {
-	r /= f; g /= f; b /= f; a /= f;
-	return *this;
+    r /= f; g /= f; b /= f; a /= f;
+    return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE TReal aiColor4t<TReal>::operator[](unsigned int i) const {
-	return *(&r + i);
+    return *(&r + i);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE TReal& aiColor4t<TReal>::operator[](unsigned int i) {
-	return *(&r + i);
+    return *(&r + i);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE bool aiColor4t<TReal>::operator== (const aiColor4t<TReal>& other) const {
-	return r == other.r && g == other.g && b == other.b && a == other.a;
+    return r == other.r && g == other.g && b == other.b && a == other.a;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE bool aiColor4t<TReal>::operator!= (const aiColor4t<TReal>& other) const {
-	return r != other.r || g != other.g || b != other.b || a != other.a;
+    return r != other.r || g != other.g || b != other.b || a != other.a;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE bool aiColor4t<TReal>::operator< (const aiColor4t<TReal>& other) const {
-	return r < other.r || (
-		r == other.r && (
-			g < other.g || (
-				g == other.g && (
-					b < other.b || (
-						b == other.b && (
-							a < other.a
-						)
-					)
-				)
-			)
-		)
-	);
+    return r < other.r || (
+        r == other.r && (
+            g < other.g || (
+                g == other.g && (
+                    b < other.b || (
+                        b == other.b && (
+                            a < other.a
+                        )
+                    )
+                )
+            )
+        )
+    );
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE aiColor4t<TReal> operator + (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)	{
-	return aiColor4t<TReal>( v1.r + v2.r, v1.g + v2.g, v1.b + v2.b, v1.a + v2.a);
+AI_FORCE_INLINE aiColor4t<TReal> operator + (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
+    return aiColor4t<TReal>( v1.r + v2.r, v1.g + v2.g, v1.b + v2.b, v1.a + v2.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE aiColor4t<TReal> operator - (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)	{
-	return aiColor4t<TReal>( v1.r - v2.r, v1.g - v2.g, v1.b - v2.b, v1.a - v2.a);
+AI_FORCE_INLINE aiColor4t<TReal> operator - (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
+    return aiColor4t<TReal>( v1.r - v2.r, v1.g - v2.g, v1.b - v2.b, v1.a - v2.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE aiColor4t<TReal> operator * (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)	{
-	return aiColor4t<TReal>( v1.r * v2.r, v1.g * v2.g, v1.b * v2.b, v1.a * v2.a);
+AI_FORCE_INLINE aiColor4t<TReal> operator * (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
+    return aiColor4t<TReal>( v1.r * v2.r, v1.g * v2.g, v1.b * v2.b, v1.a * v2.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE aiColor4t<TReal> operator / (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)	{
-	return aiColor4t<TReal>( v1.r / v2.r, v1.g / v2.g, v1.b / v2.b, v1.a / v2.a);
+AI_FORCE_INLINE aiColor4t<TReal> operator / (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2)    {
+    return aiColor4t<TReal>( v1.r / v2.r, v1.g / v2.g, v1.b / v2.b, v1.a / v2.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE aiColor4t<TReal> operator * ( TReal f, const aiColor4t<TReal>& v)	{
-	return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a);
+AI_FORCE_INLINE aiColor4t<TReal> operator * ( TReal f, const aiColor4t<TReal>& v)   {
+    return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE  aiColor4t<TReal> operator * ( const aiColor4t<TReal>& v, TReal f)	{
-	return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a);
+AI_FORCE_INLINE  aiColor4t<TReal> operator * ( const aiColor4t<TReal>& v, TReal f)  {
+    return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE  aiColor4t<TReal> operator / ( const aiColor4t<TReal>& v, TReal f)	{
-	return v * (1/f);
+AI_FORCE_INLINE  aiColor4t<TReal> operator / ( const aiColor4t<TReal>& v, TReal f)  {
+    return v * (1/f);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE  aiColor4t<TReal> operator / ( TReal f,const aiColor4t<TReal>& v)	{
-	return aiColor4t<TReal>(f,f,f,f)/v;
+AI_FORCE_INLINE  aiColor4t<TReal> operator / ( TReal f,const aiColor4t<TReal>& v)   {
+    return aiColor4t<TReal>(f,f,f,f)/v;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE  aiColor4t<TReal> operator + ( const aiColor4t<TReal>& v, TReal f)	{
-	return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a);
+AI_FORCE_INLINE  aiColor4t<TReal> operator + ( const aiColor4t<TReal>& v, TReal f)  {
+    return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE  aiColor4t<TReal> operator - ( const aiColor4t<TReal>& v, TReal f)	{
-	return aiColor4t<TReal>( v.r-f, v.g-f, v.b-f, v.a-f);
+AI_FORCE_INLINE  aiColor4t<TReal> operator - ( const aiColor4t<TReal>& v, TReal f)  {
+    return aiColor4t<TReal>( v.r-f, v.g-f, v.b-f, v.a-f);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE  aiColor4t<TReal> operator + ( TReal f, const aiColor4t<TReal>& v)	{
-	return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a);
+AI_FORCE_INLINE  aiColor4t<TReal> operator + ( TReal f, const aiColor4t<TReal>& v)  {
+    return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-AI_FORCE_INLINE  aiColor4t<TReal> operator - ( TReal f, const aiColor4t<TReal>& v)	{
-	return aiColor4t<TReal>( f-v.r, f-v.g, f-v.b, f-v.a);
+AI_FORCE_INLINE  aiColor4t<TReal> operator - ( TReal f, const aiColor4t<TReal>& v)  {
+    return aiColor4t<TReal>( f-v.r, f-v.g, f-v.b, f-v.a);
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-inline bool aiColor4t<TReal> :: IsBlack() const	{
-	// The alpha component doesn't care here. black is black.
-	static const TReal epsilon = 10e-3f;
-	return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon;
+inline bool aiColor4t<TReal> :: IsBlack() const {
+    // The alpha component doesn't care here. black is black.
+    static const TReal epsilon = 10e-3f;
+    return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon;
 }
 
 #endif // __cplusplus

include/assimp/config.h

@@ -75,7 +75,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * Property type: bool. Default value: false.
  */
 #define AI_CONFIG_GLOB_MEASURE_TIME  \
-	"GLOB_MEASURE_TIME"
+    "GLOB_MEASURE_TIME"
 
 
 // ---------------------------------------------------------------------------
@@ -87,7 +87,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 // ---------------------------------------------------------------------------
 #define AI_CONFIG_IMPORT_NO_SKELETON_MESHES \
-	"IMPORT_NO_SKELETON_MESHES"
+    "IMPORT_NO_SKELETON_MESHES"
 
 
 
@@ -108,7 +108,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * Property type: int, default value: -1.
  */
 #define AI_CONFIG_GLOB_MULTITHREADING  \
-	"GLOB_MULTITHREADING"
+    "GLOB_MULTITHREADING"
 #endif
 
 // ###########################################################################
@@ -127,12 +127,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 // ---------------------------------------------------------------------------
 #define AI_CONFIG_PP_SBBC_MAX_BONES \
-	"PP_SBBC_MAX_BONES"
+    "PP_SBBC_MAX_BONES"
 
 
 // default limit for bone count
 #if (!defined AI_SBBC_DEFAULT_MAX_BONES)
-#	define AI_SBBC_DEFAULT_MAX_BONES		60
+#   define AI_SBBC_DEFAULT_MAX_BONES        60
 #endif
 
 
@@ -145,7 +145,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * Property type: float. Default value: 45 degrees
  */
 #define AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE \
-	"PP_CT_MAX_SMOOTHING_ANGLE"
+    "PP_CT_MAX_SMOOTHING_ANGLE"
 
 // ---------------------------------------------------------------------------
 /** @brief Source UV channel for tangent space computation.
@@ -155,7 +155,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 // ---------------------------------------------------------------------------
 #define AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX \
-	"PP_CT_TEXTURE_CHANNEL_INDEX"
+    "PP_CT_TEXTURE_CHANNEL_INDEX"
 
 // ---------------------------------------------------------------------------
 /** @brief  Specifies the maximum angle that may be between two face normals
@@ -170,7 +170,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * the output quality may be reduced.
  */
 #define AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE \
-	"PP_GSN_MAX_SMOOTHING_ANGLE"
+    "PP_GSN_MAX_SMOOTHING_ANGLE"
 
 
 // ---------------------------------------------------------------------------
@@ -183,8 +183,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * a default palette (from Quake 1) is used.
  * Property type: string.
  */
-#define AI_CONFIG_IMPORT_MDL_COLORMAP		\
-	"IMPORT_MDL_COLORMAP"
+#define AI_CONFIG_IMPORT_MDL_COLORMAP       \
+    "IMPORT_MDL_COLORMAP"
 
 // ---------------------------------------------------------------------------
 /** @brief Configures the #aiProcess_RemoveRedundantMaterials step to
@@ -205,8 +205,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * @note Linefeeds, tabs or carriage returns are treated as whitespace.
  *   Material names are case sensitive.
  */
-#define AI_CONFIG_PP_RRM_EXCLUDE_LIST	\
-	"PP_RRM_EXCLUDE_LIST"
+#define AI_CONFIG_PP_RRM_EXCLUDE_LIST   \
+    "PP_RRM_EXCLUDE_LIST"
 
 // ---------------------------------------------------------------------------
 /** @brief Configures the #aiProcess_PreTransformVertices step to
@@ -220,8 +220,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * any transformations.
  * Property type: bool. Default value: false.
  */
-#define AI_CONFIG_PP_PTV_KEEP_HIERARCHY		\
-	"PP_PTV_KEEP_HIERARCHY"
+#define AI_CONFIG_PP_PTV_KEEP_HIERARCHY     \
+    "PP_PTV_KEEP_HIERARCHY"
 
 // ---------------------------------------------------------------------------
 /** @brief Configures the #aiProcess_PreTransformVertices step to normalize
@@ -230,8 +230,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  meshes are scaled appropriately (uniformly of course!).
  *  This might be useful if you don't know the spatial dimension of the input
  *  data*/
-#define AI_CONFIG_PP_PTV_NORMALIZE	\
-	"PP_PTV_NORMALIZE"
+#define AI_CONFIG_PP_PTV_NORMALIZE  \
+    "PP_PTV_NORMALIZE"
 
 // ---------------------------------------------------------------------------
 /** @brief Configures the #aiProcess_PreTransformVertices step to use
@@ -239,8 +239,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  transforming vertices.
  *  Property type: bool. Default value: false.
  */
-#define AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION	\
-	"PP_PTV_ADD_ROOT_TRANSFORMATION"
+#define AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION    \
+    "PP_PTV_ADD_ROOT_TRANSFORMATION"
 
 // ---------------------------------------------------------------------------
 /** @brief Configures the #aiProcess_PreTransformVertices step to use
@@ -249,8 +249,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  of the transformation matrix.
  *  Property type: aiMatrix4x4.
  */
-#define AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION	\
-	"PP_PTV_ROOT_TRANSFORMATION"
+#define AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION    \
+    "PP_PTV_ROOT_TRANSFORMATION"
 
 // ---------------------------------------------------------------------------
 /** @brief Configures the #aiProcess_FindDegenerates step to
@@ -263,7 +263,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * Property type: bool. Default value: false.
  */
 #define AI_CONFIG_PP_FD_REMOVE \
-	"PP_FD_REMOVE"
+    "PP_FD_REMOVE"
 
 // ---------------------------------------------------------------------------
 /** @brief Configures the #aiProcess_OptimizeGraph step to preserve nodes
@@ -283,8 +283,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * @note Linefeeds, tabs or carriage returns are treated as whitespace.
  *   Node names are case sensitive.
  */
-#define AI_CONFIG_PP_OG_EXCLUDE_LIST	\
-	"PP_OG_EXCLUDE_LIST"
+#define AI_CONFIG_PP_OG_EXCLUDE_LIST    \
+    "PP_OG_EXCLUDE_LIST"
 
 // ---------------------------------------------------------------------------
 /** @brief  Set the maximum number of triangles in a mesh.
@@ -294,12 +294,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * @note The default value is AI_SLM_DEFAULT_MAX_TRIANGLES
  * Property type: integer.
  */
-#define AI_CONFIG_PP_SLM_TRIANGLE_LIMIT	\
-	"PP_SLM_TRIANGLE_LIMIT"
+#define AI_CONFIG_PP_SLM_TRIANGLE_LIMIT \
+    "PP_SLM_TRIANGLE_LIMIT"
 
 // default value for AI_CONFIG_PP_SLM_TRIANGLE_LIMIT
 #if (!defined AI_SLM_DEFAULT_MAX_TRIANGLES)
-#	define AI_SLM_DEFAULT_MAX_TRIANGLES		1000000
+#   define AI_SLM_DEFAULT_MAX_TRIANGLES     1000000
 #endif
 
 // ---------------------------------------------------------------------------
@@ -311,11 +311,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * Property type: integer.
  */
 #define AI_CONFIG_PP_SLM_VERTEX_LIMIT \
-	"PP_SLM_VERTEX_LIMIT"
+    "PP_SLM_VERTEX_LIMIT"
 
 // default value for AI_CONFIG_PP_SLM_VERTEX_LIMIT
 #if (!defined AI_SLM_DEFAULT_MAX_VERTICES)
-#	define AI_SLM_DEFAULT_MAX_VERTICES		1000000
+#   define AI_SLM_DEFAULT_MAX_VERTICES      1000000
 #endif
 
 // ---------------------------------------------------------------------------
@@ -324,12 +324,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * This is used by the #aiProcess_LimitBoneWeights PostProcess-Step.
  * @note The default value is AI_LBW_MAX_WEIGHTS
  * Property type: integer.*/
-#define AI_CONFIG_PP_LBW_MAX_WEIGHTS	\
-	"PP_LBW_MAX_WEIGHTS"
+#define AI_CONFIG_PP_LBW_MAX_WEIGHTS    \
+    "PP_LBW_MAX_WEIGHTS"
 
 // default value for AI_CONFIG_PP_LBW_MAX_WEIGHTS
 #if (!defined AI_LMW_MAX_WEIGHTS)
-#	define AI_LMW_MAX_WEIGHTS	0x4
+#   define AI_LMW_MAX_WEIGHTS   0x4
 #endif // !! AI_LMW_MAX_WEIGHTS
 
 // ---------------------------------------------------------------------------
@@ -339,11 +339,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * @note The default value is AI_DEBONE_THRESHOLD
  * Property type: float.*/
 #define AI_CONFIG_PP_DB_THRESHOLD \
-	"PP_DB_THRESHOLD"
+    "PP_DB_THRESHOLD"
 
 // default value for AI_CONFIG_PP_LBW_MAX_WEIGHTS
 #if (!defined AI_DEBONE_THRESHOLD)
-#	define AI_DEBONE_THRESHOLD	1.0f
+#   define AI_DEBONE_THRESHOLD  1.0f
 #endif // !! AI_DEBONE_THRESHOLD
 
 // ---------------------------------------------------------------------------
@@ -353,12 +353,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * @note The default value is 0
  * Property type: bool.*/
 #define AI_CONFIG_PP_DB_ALL_OR_NONE \
-	"PP_DB_ALL_OR_NONE"
+    "PP_DB_ALL_OR_NONE"
 
 /** @brief Default value for the #AI_CONFIG_PP_ICL_PTCACHE_SIZE property
  */
 #ifndef PP_ICL_PTCACHE_SIZE
-#	define PP_ICL_PTCACHE_SIZE 12
+#   define PP_ICL_PTCACHE_SIZE 12
 #endif
 
 // ---------------------------------------------------------------------------
@@ -372,7 +372,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * performance improvements for most nVidia/AMD cards since 2002.
  * Property type: integer.
  */
-#define AI_CONFIG_PP_ICL_PTCACHE_SIZE	"PP_ICL_PTCACHE_SIZE"
+#define AI_CONFIG_PP_ICL_PTCACHE_SIZE   "PP_ICL_PTCACHE_SIZE"
 
 // ---------------------------------------------------------------------------
 /** @brief Enumerates components of the aiScene and aiMesh data structures
@@ -382,63 +382,63 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 enum aiComponent
 {
-	/** Normal vectors */
+    /** Normal vectors */
 #ifdef SWIG
-	aiComponent_NORMALS = 0x2,
+    aiComponent_NORMALS = 0x2,
 #else
-	aiComponent_NORMALS = 0x2u,
+    aiComponent_NORMALS = 0x2u,
 #endif
 
-	/** Tangents and bitangents go always together ... */
+    /** Tangents and bitangents go always together ... */
 #ifdef SWIG
-	aiComponent_TANGENTS_AND_BITANGENTS = 0x4,
+    aiComponent_TANGENTS_AND_BITANGENTS = 0x4,
 #else
-	aiComponent_TANGENTS_AND_BITANGENTS = 0x4u,
+    aiComponent_TANGENTS_AND_BITANGENTS = 0x4u,
 #endif
 
-	/** ALL color sets
-	 * Use aiComponent_COLORn(N) to specify the N'th set */
-	aiComponent_COLORS = 0x8,
+    /** ALL color sets
+     * Use aiComponent_COLORn(N) to specify the N'th set */
+    aiComponent_COLORS = 0x8,
 
-	/** ALL texture UV sets
-	 * aiComponent_TEXCOORDn(N) to specify the N'th set  */
-	aiComponent_TEXCOORDS = 0x10,
+    /** ALL texture UV sets
+     * aiComponent_TEXCOORDn(N) to specify the N'th set  */
+    aiComponent_TEXCOORDS = 0x10,
 
-	/** Removes all bone weights from all meshes.
-	 * The scenegraph nodes corresponding to the bones are NOT removed.
-	 * use the #aiProcess_OptimizeGraph step to do this */
-	aiComponent_BONEWEIGHTS = 0x20,
+    /** Removes all bone weights from all meshes.
+     * The scenegraph nodes corresponding to the bones are NOT removed.
+     * use the #aiProcess_OptimizeGraph step to do this */
+    aiComponent_BONEWEIGHTS = 0x20,
 
-	/** Removes all node animations (aiScene::mAnimations).
-	 * The corresponding scenegraph nodes are NOT removed.
-	 * use the #aiProcess_OptimizeGraph step to do this */
-	aiComponent_ANIMATIONS = 0x40,
+    /** Removes all node animations (aiScene::mAnimations).
+     * The corresponding scenegraph nodes are NOT removed.
+     * use the #aiProcess_OptimizeGraph step to do this */
+    aiComponent_ANIMATIONS = 0x40,
 
-	/** Removes all embedded textures (aiScene::mTextures) */
-	aiComponent_TEXTURES = 0x80,
+    /** Removes all embedded textures (aiScene::mTextures) */
+    aiComponent_TEXTURES = 0x80,
 
-	/** Removes all light sources (aiScene::mLights).
-	 * The corresponding scenegraph nodes are NOT removed.
-	 * use the #aiProcess_OptimizeGraph step to do this */
-	aiComponent_LIGHTS = 0x100,
+    /** Removes all light sources (aiScene::mLights).
+     * The corresponding scenegraph nodes are NOT removed.
+     * use the #aiProcess_OptimizeGraph step to do this */
+    aiComponent_LIGHTS = 0x100,
 
-	/** Removes all cameras (aiScene::mCameras).
-	 * The corresponding scenegraph nodes are NOT removed.
-	 * use the #aiProcess_OptimizeGraph step to do this */
-	aiComponent_CAMERAS = 0x200,
+    /** Removes all cameras (aiScene::mCameras).
+     * The corresponding scenegraph nodes are NOT removed.
+     * use the #aiProcess_OptimizeGraph step to do this */
+    aiComponent_CAMERAS = 0x200,
 
-	/** Removes all meshes (aiScene::mMeshes). */
-	aiComponent_MESHES = 0x400,
+    /** Removes all meshes (aiScene::mMeshes). */
+    aiComponent_MESHES = 0x400,
 
-	/** Removes all materials. One default material will
-	 * be generated, so aiScene::mNumMaterials will be 1. */
-	aiComponent_MATERIALS = 0x800,
+    /** Removes all materials. One default material will
+     * be generated, so aiScene::mNumMaterials will be 1. */
+    aiComponent_MATERIALS = 0x800,
 
 
-	/** This value is not used. It is just there to force the
-	 *  compiler to map this enum to a 32 Bit integer. */
+    /** This value is not used. It is just there to force the
+     *  compiler to map this enum to a 32 Bit integer. */
 #ifndef SWIG
-	_aiComponent_Force32Bit = 0x9fffffff
+    _aiComponent_Force32Bit = 0x9fffffff
 #endif
 };
 
@@ -460,8 +460,8 @@ enum aiComponent
  * of the flags defined above) the import FAILS. Mainly because there is
  * no data to work on anymore ...
  */
-#define AI_CONFIG_PP_RVC_FLAGS				\
-	"PP_RVC_FLAGS"
+#define AI_CONFIG_PP_RVC_FLAGS              \
+    "PP_RVC_FLAGS"
 
 // ---------------------------------------------------------------------------
 /** @brief Input parameter to the #aiProcess_SortByPType step:
@@ -472,8 +472,8 @@ enum aiComponent
  *  be to exclude all line and point meshes from the import. This
  *  is an integer property, its default value is 0.
  */
-#define AI_CONFIG_PP_SBP_REMOVE				\
-	"PP_SBP_REMOVE"
+#define AI_CONFIG_PP_SBP_REMOVE             \
+    "PP_SBP_REMOVE"
 
 // ---------------------------------------------------------------------------
 /** @brief Input parameter to the #aiProcess_FindInvalidData step:
@@ -484,8 +484,8 @@ enum aiComponent
  *  abs(n0-n1)>epsilon holds true for all vector respectively quaternion
  *  components. The default value is 0.f - comparisons are exact then.
  */
-#define AI_CONFIG_PP_FID_ANIM_ACCURACY				\
-	"PP_FID_ANIM_ACCURACY"
+#define AI_CONFIG_PP_FID_ANIM_ACCURACY              \
+    "PP_FID_ANIM_ACCURACY"
 
 
 // TransformUVCoords evaluates UV scalings
@@ -508,8 +508,8 @@ enum aiComponent
  *  property, of course). By default all transformations are enabled
  * (AI_UVTRAFO_ALL).
  */
-#define AI_CONFIG_PP_TUV_EVALUATE				\
-	"PP_TUV_EVALUATE"
+#define AI_CONFIG_PP_TUV_EVALUATE               \
+    "PP_TUV_EVALUATE"
 
 // ---------------------------------------------------------------------------
 /** @brief A hint to assimp to favour speed against import quality.
@@ -520,7 +520,7 @@ enum aiComponent
  * This property is expected to be an integer, != 0 stands for true.
  * The default value is 0.
  */
-#define AI_CONFIG_FAVOUR_SPEED				\
+#define AI_CONFIG_FAVOUR_SPEED              \
  "FAVOUR_SPEED"
 
 
@@ -538,7 +538,7 @@ enum aiComponent
  * Property type: bool
  */
 #define AI_CONFIG_IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS \
-	"IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS"
+    "IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS"
 
 // ---------------------------------------------------------------------------
 /** @brief Set whether the fbx importer will read all materials present in the
@@ -550,7 +550,7 @@ enum aiComponent
  * Property type: bool
  */
 #define AI_CONFIG_IMPORT_FBX_READ_ALL_MATERIALS \
-	"IMPORT_FBX_READ_ALL_MATERIALS"
+    "IMPORT_FBX_READ_ALL_MATERIALS"
 
 // ---------------------------------------------------------------------------
 /** @brief Set whether the fbx importer will read materials.
@@ -559,7 +559,7 @@ enum aiComponent
  * Property type: bool
  */
 #define AI_CONFIG_IMPORT_FBX_READ_MATERIALS \
-	"IMPORT_FBX_READ_MATERIALS"
+    "IMPORT_FBX_READ_MATERIALS"
 
 // ---------------------------------------------------------------------------
 /** @brief Set whether the fbx importer will read cameras.
@@ -568,7 +568,7 @@ enum aiComponent
  * Property type: bool
  */
 #define AI_CONFIG_IMPORT_FBX_READ_CAMERAS \
-	"IMPORT_FBX_READ_CAMERAS"
+    "IMPORT_FBX_READ_CAMERAS"
 
 // ---------------------------------------------------------------------------
 /** @brief Set whether the fbx importer will read light sources.
@@ -577,7 +577,7 @@ enum aiComponent
  * Property type: bool
  */
 #define AI_CONFIG_IMPORT_FBX_READ_LIGHTS \
-	"IMPORT_FBX_READ_LIGHTS"
+    "IMPORT_FBX_READ_LIGHTS"
 
 // ---------------------------------------------------------------------------
 /** @brief Set whether the fbx importer will read animations.
@@ -586,7 +586,7 @@ enum aiComponent
  * Property type: bool
  */
 #define AI_CONFIG_IMPORT_FBX_READ_ANIMATIONS \
-	"IMPORT_FBX_READ_ANIMATIONS"
+    "IMPORT_FBX_READ_ANIMATIONS"
 
 // ---------------------------------------------------------------------------
 /** @brief Set whether the fbx importer will act in strict mode in which only
@@ -598,7 +598,7 @@ enum aiComponent
  * Property type: bool
  */
 #define AI_CONFIG_IMPORT_FBX_STRICT_MODE \
-	"IMPORT_FBX_STRICT_MODE"
+    "IMPORT_FBX_STRICT_MODE"
 
 // ---------------------------------------------------------------------------
 /** @brief Set whether the fbx importer will preserve pivot points for
@@ -609,7 +609,7 @@ enum aiComponent
  * Property type: bool
  */
 #define AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS \
-	"IMPORT_FBX_PRESERVE_PIVOTS"
+    "IMPORT_FBX_PRESERVE_PIVOTS"
 
 // ---------------------------------------------------------------------------
 /** @brief Specifies whether the importer will drop empty animation curves or
@@ -620,7 +620,7 @@ enum aiComponent
  * Property type: bool
  */
 #define AI_CONFIG_IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES \
-	"IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES"
+    "IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES"
 
 
 
@@ -637,14 +637,14 @@ enum aiComponent
  *   want to override the global setting).
  * Property type: integer.
  */
-#define AI_CONFIG_IMPORT_GLOBAL_KEYFRAME	"IMPORT_GLOBAL_KEYFRAME"
+#define AI_CONFIG_IMPORT_GLOBAL_KEYFRAME    "IMPORT_GLOBAL_KEYFRAME"
 
-#define AI_CONFIG_IMPORT_MD3_KEYFRAME		"IMPORT_MD3_KEYFRAME"
-#define AI_CONFIG_IMPORT_MD2_KEYFRAME		"IMPORT_MD2_KEYFRAME"
-#define AI_CONFIG_IMPORT_MDL_KEYFRAME		"IMPORT_MDL_KEYFRAME"
-#define AI_CONFIG_IMPORT_MDC_KEYFRAME		"IMPORT_MDC_KEYFRAME"
-#define AI_CONFIG_IMPORT_SMD_KEYFRAME		"IMPORT_SMD_KEYFRAME"
-#define AI_CONFIG_IMPORT_UNREAL_KEYFRAME	"IMPORT_UNREAL_KEYFRAME"
+#define AI_CONFIG_IMPORT_MD3_KEYFRAME       "IMPORT_MD3_KEYFRAME"
+#define AI_CONFIG_IMPORT_MD2_KEYFRAME       "IMPORT_MD2_KEYFRAME"
+#define AI_CONFIG_IMPORT_MDL_KEYFRAME       "IMPORT_MDL_KEYFRAME"
+#define AI_CONFIG_IMPORT_MDC_KEYFRAME       "IMPORT_MDC_KEYFRAME"
+#define AI_CONFIG_IMPORT_SMD_KEYFRAME       "IMPORT_SMD_KEYFRAME"
+#define AI_CONFIG_IMPORT_UNREAL_KEYFRAME    "IMPORT_UNREAL_KEYFRAME"
 
 
 // ---------------------------------------------------------------------------
@@ -653,8 +653,8 @@ enum aiComponent
  *
  *  Property type: bool. Default value: true.
  */
-#define AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL	\
-	"IMPORT_AC_SEPARATE_BFCULL"
+#define AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL \
+    "IMPORT_AC_SEPARATE_BFCULL"
 
 // ---------------------------------------------------------------------------
 /** @brief  Configures whether the AC loader evaluates subdivision surfaces (
@@ -664,8 +664,8 @@ enum aiComponent
  *
  * * Property type: bool. Default value: true.
  */
-#define AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION	\
-	"IMPORT_AC_EVAL_SUBDIVISION"
+#define AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION    \
+    "IMPORT_AC_EVAL_SUBDIVISION"
 
 // ---------------------------------------------------------------------------
 /** @brief  Configures the UNREAL 3D loader to separate faces with different
@@ -674,7 +674,7 @@ enum aiComponent
  * * Property type: bool. Default value: true.
  */
 #define AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS \
-	"UNREAL_HANDLE_FLAGS"
+    "UNREAL_HANDLE_FLAGS"
 
 // ---------------------------------------------------------------------------
 /** @brief Configures the terragen import plugin to compute uv's for
@@ -687,17 +687,17 @@ enum aiComponent
  * * Property type: bool. Default value: false.
  */
 #define AI_CONFIG_IMPORT_TER_MAKE_UVS \
-	"IMPORT_TER_MAKE_UVS"
+    "IMPORT_TER_MAKE_UVS"
 
 // ---------------------------------------------------------------------------
 /** @brief  Configures the ASE loader to always reconstruct normal vectors
- *	basing on the smoothing groups loaded from the file.
+ *  basing on the smoothing groups loaded from the file.
  *
  * Some ASE files have carry invalid normals, other don't.
  * * Property type: bool. Default value: true.
  */
-#define AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS	\
-	"IMPORT_ASE_RECONSTRUCT_NORMALS"
+#define AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS    \
+    "IMPORT_ASE_RECONSTRUCT_NORMALS"
 
 // ---------------------------------------------------------------------------
 /** @brief  Configures the M3D loader to detect and process multi-part
@@ -709,7 +709,7 @@ enum aiComponent
  * Property type: bool. Default value: true.
  */
 #define AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART \
-	"IMPORT_MD3_HANDLE_MULTIPART"
+    "IMPORT_MD3_HANDLE_MULTIPART"
 
 // ---------------------------------------------------------------------------
 /** @brief  Tells the MD3 loader which skin files to load.
@@ -721,7 +721,7 @@ enum aiComponent
  * Property type: String. Default value: "default".
  */
 #define AI_CONFIG_IMPORT_MD3_SKIN_NAME \
-	"IMPORT_MD3_SKIN_NAME"
+    "IMPORT_MD3_SKIN_NAME"
 
 // ---------------------------------------------------------------------------
 /** @brief  Specify the Quake 3 shader file to be used for a particular
@@ -739,7 +739,7 @@ enum aiComponent
  * Property type: String. Default value: n/a.
  */
 #define AI_CONFIG_IMPORT_MD3_SHADER_SRC \
-	"IMPORT_MD3_SHADER_SRC"
+    "IMPORT_MD3_SHADER_SRC"
 
 // ---------------------------------------------------------------------------
 /** @brief  Configures the LWO loader to load just one layer from the model.
@@ -752,8 +752,8 @@ enum aiComponent
  * layer name may not be empty.<br>
  * Property type: Integer. Default value: all layers are loaded.
  */
-#define AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY			\
-	"IMPORT_LWO_ONE_LAYER_ONLY"
+#define AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY         \
+    "IMPORT_LWO_ONE_LAYER_ONLY"
 
 // ---------------------------------------------------------------------------
 /** @brief  Configures the MD5 loader to not load the MD5ANIM file for
@@ -766,8 +766,8 @@ enum aiComponent
  *
  * * Property type: bool. Default value: false.
  */
-#define AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD			\
-	"IMPORT_MD5_NO_ANIM_AUTOLOAD"
+#define AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD           \
+    "IMPORT_MD5_NO_ANIM_AUTOLOAD"
 
 // ---------------------------------------------------------------------------
 /** @brief Defines the begin of the time range for which the LWS loader
@@ -785,10 +785,10 @@ enum aiComponent
  *
  * @see AI_CONFIG_IMPORT_LWS_ANIM_END - end of the imported time range
  */
-#define AI_CONFIG_IMPORT_LWS_ANIM_START			\
-	"IMPORT_LWS_ANIM_START"
-#define AI_CONFIG_IMPORT_LWS_ANIM_END			\
-	"IMPORT_LWS_ANIM_END"
+#define AI_CONFIG_IMPORT_LWS_ANIM_START         \
+    "IMPORT_LWS_ANIM_START"
+#define AI_CONFIG_IMPORT_LWS_ANIM_END           \
+    "IMPORT_LWS_ANIM_END"
 
 // ---------------------------------------------------------------------------
 /** @brief Defines the output frame rate of the IRR loader.
@@ -798,8 +798,8 @@ enum aiComponent
  * are returned by the converter.<br>
  * Property type: integer. Default value: 100
  */
-#define AI_CONFIG_IMPORT_IRR_ANIM_FPS				\
-	"IMPORT_IRR_ANIM_FPS"
+#define AI_CONFIG_IMPORT_IRR_ANIM_FPS               \
+    "IMPORT_IRR_ANIM_FPS"
 
 // ---------------------------------------------------------------------------
 /** @brief Ogre Importer will try to find referenced materials from this file.
@@ -811,8 +811,8 @@ enum aiComponent
  * <br>
  * Property type: String. Default value: Scene.material.
  */
-#define AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE	\
-	"IMPORT_OGRE_MATERIAL_FILE"
+#define AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE \
+    "IMPORT_OGRE_MATERIAL_FILE"
 
 // ---------------------------------------------------------------------------
 /** @brief Ogre Importer detect the texture usage from its filename.
@@ -832,7 +832,7 @@ enum aiComponent
  * Property type: Bool. Default value: false.
  */
 #define AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME \
-	"IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME"
+    "IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME"
 
 /** @brief Specifies whether the IFC loader skips over IfcSpace elements.
  *

include/assimp/defs.h

@@ -47,163 +47,163 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_DEFINES_H
 #define INCLUDED_AI_DEFINES_H
 
-	//////////////////////////////////////////////////////////////////////////
-	/* Define ASSIMP_BUILD_NO_XX_IMPORTER to disable a specific
-	 * file format loader. The loader is be excluded from the
-	 * build in this case. 'XX' stands for the most common file
-	 * extension of the file format. E.g.:
-	 * ASSIMP_BUILD_NO_X_IMPORTER disables the X loader.
-	 *
-	 * If you're unsure about that, take a look at the implementation of the
-	 * import plugin you wish to disable. You'll find the right define in the
-	 * first lines of the corresponding unit.
-	 *
-	 * Other (mixed) configuration switches are listed here:
-	 *    ASSIMP_BUILD_NO_COMPRESSED_X
-	 *      - Disable support for compressed X files (zip)
-	 *    ASSIMP_BUILD_NO_COMPRESSED_BLEND
-	 *      - Disable support for compressed Blender files (zip)
-	 *    ASSIMP_BUILD_NO_COMPRESSED_IFC
-	 *      - Disable support for IFCZIP files (unzip)
-	 */
-	//////////////////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////////////////
+    /* Define ASSIMP_BUILD_NO_XX_IMPORTER to disable a specific
+     * file format loader. The loader is be excluded from the
+     * build in this case. 'XX' stands for the most common file
+     * extension of the file format. E.g.:
+     * ASSIMP_BUILD_NO_X_IMPORTER disables the X loader.
+     *
+     * If you're unsure about that, take a look at the implementation of the
+     * import plugin you wish to disable. You'll find the right define in the
+     * first lines of the corresponding unit.
+     *
+     * Other (mixed) configuration switches are listed here:
+     *    ASSIMP_BUILD_NO_COMPRESSED_X
+     *      - Disable support for compressed X files (zip)
+     *    ASSIMP_BUILD_NO_COMPRESSED_BLEND
+     *      - Disable support for compressed Blender files (zip)
+     *    ASSIMP_BUILD_NO_COMPRESSED_IFC
+     *      - Disable support for IFCZIP files (unzip)
+     */
+    //////////////////////////////////////////////////////////////////////////
 
 #ifndef ASSIMP_BUILD_NO_COMPRESSED_X
-#	define ASSIMP_BUILD_NEED_Z_INFLATE
+#   define ASSIMP_BUILD_NEED_Z_INFLATE
 #endif
 
 #ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND
-#	define ASSIMP_BUILD_NEED_Z_INFLATE
+#   define ASSIMP_BUILD_NEED_Z_INFLATE
 #endif
 
 #ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
-#	define ASSIMP_BUILD_NEED_Z_INFLATE
-#	define ASSIMP_BUILD_NEED_UNZIP
+#   define ASSIMP_BUILD_NEED_Z_INFLATE
+#   define ASSIMP_BUILD_NEED_UNZIP
 #endif
 
 #ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER
-#	define ASSIMP_BUILD_NEED_Z_INFLATE
-#	define ASSIMP_BUILD_NEED_UNZIP
+#   define ASSIMP_BUILD_NEED_Z_INFLATE
+#   define ASSIMP_BUILD_NEED_UNZIP
 #endif
 
-	//////////////////////////////////////////////////////////////////////////
-	/* Define ASSIMP_BUILD_NO_XX_PROCESS to disable a specific
-	 * post processing step. This is the current list of process names ('XX'):
-	 * CALCTANGENTS
-	 * JOINVERTICES
-	 * TRIANGULATE
-	 * GENFACENORMALS
-	 * GENVERTEXNORMALS
-	 * REMOVEVC
-	 * SPLITLARGEMESHES
-	 * PRETRANSFORMVERTICES
-	 * LIMITBONEWEIGHTS
-	 * VALIDATEDS
-	 * IMPROVECACHELOCALITY
-	 * FIXINFACINGNORMALS
-	 * REMOVE_REDUNDANTMATERIALS
-	 * OPTIMIZEGRAPH
-	 * SORTBYPTYPE
-	 * FINDINVALIDDATA
-	 * TRANSFORMTEXCOORDS
-	 * GENUVCOORDS
-	 * ENTITYMESHBUILDER
-	 * MAKELEFTHANDED
-	 * FLIPUVS
-	 * FLIPWINDINGORDER
-	 * OPTIMIZEMESHES
-	 * OPTIMIZEANIMS
-	 * OPTIMIZEGRAPH
-	 * GENENTITYMESHES
-	 * FIXTEXTUREPATHS */
-	//////////////////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////////////////
+    /* Define ASSIMP_BUILD_NO_XX_PROCESS to disable a specific
+     * post processing step. This is the current list of process names ('XX'):
+     * CALCTANGENTS
+     * JOINVERTICES
+     * TRIANGULATE
+     * GENFACENORMALS
+     * GENVERTEXNORMALS
+     * REMOVEVC
+     * SPLITLARGEMESHES
+     * PRETRANSFORMVERTICES
+     * LIMITBONEWEIGHTS
+     * VALIDATEDS
+     * IMPROVECACHELOCALITY
+     * FIXINFACINGNORMALS
+     * REMOVE_REDUNDANTMATERIALS
+     * OPTIMIZEGRAPH
+     * SORTBYPTYPE
+     * FINDINVALIDDATA
+     * TRANSFORMTEXCOORDS
+     * GENUVCOORDS
+     * ENTITYMESHBUILDER
+     * MAKELEFTHANDED
+     * FLIPUVS
+     * FLIPWINDINGORDER
+     * OPTIMIZEMESHES
+     * OPTIMIZEANIMS
+     * OPTIMIZEGRAPH
+     * GENENTITYMESHES
+     * FIXTEXTUREPATHS */
+    //////////////////////////////////////////////////////////////////////////
 
 #ifdef _MSC_VER
-#	undef ASSIMP_API
-
-	//////////////////////////////////////////////////////////////////////////
-	/* Define 'ASSIMP_BUILD_DLL_EXPORT' to build a DLL of the library */
-	//////////////////////////////////////////////////////////////////////////
-#	ifdef ASSIMP_BUILD_DLL_EXPORT
-#		define ASSIMP_API __declspec(dllexport)
-#		define ASSIMP_API_WINONLY __declspec(dllexport)
-#		pragma warning (disable : 4251)
-
-	//////////////////////////////////////////////////////////////////////////
-	/* Define 'ASSIMP_DLL' before including Assimp to link to ASSIMP in
-	 * an external DLL under Windows. Default is static linkage. */
-	//////////////////////////////////////////////////////////////////////////
-#	elif (defined ASSIMP_DLL)
-#		define ASSIMP_API __declspec(dllimport)
-#		define ASSIMP_API_WINONLY __declspec(dllimport)
-#	else
-#		define ASSIMP_API
-#		define ASSIMP_API_WINONLY
-#	endif
-
-	/* Force the compiler to inline a function, if possible
-	 */
-#	define AI_FORCE_INLINE __forceinline
-
-	/* Tells the compiler that a function never returns. Used in code analysis
-	 * to skip dead paths (e.g. after an assertion evaluated to false). */
-#	define AI_WONT_RETURN __declspec(noreturn)
+#   undef ASSIMP_API
+
+    //////////////////////////////////////////////////////////////////////////
+    /* Define 'ASSIMP_BUILD_DLL_EXPORT' to build a DLL of the library */
+    //////////////////////////////////////////////////////////////////////////
+#   ifdef ASSIMP_BUILD_DLL_EXPORT
+#       define ASSIMP_API __declspec(dllexport)
+#       define ASSIMP_API_WINONLY __declspec(dllexport)
+#       pragma warning (disable : 4251)
+
+    //////////////////////////////////////////////////////////////////////////
+    /* Define 'ASSIMP_DLL' before including Assimp to link to ASSIMP in
+     * an external DLL under Windows. Default is static linkage. */
+    //////////////////////////////////////////////////////////////////////////
+#   elif (defined ASSIMP_DLL)
+#       define ASSIMP_API __declspec(dllimport)
+#       define ASSIMP_API_WINONLY __declspec(dllimport)
+#   else
+#       define ASSIMP_API
+#       define ASSIMP_API_WINONLY
+#   endif
+
+    /* Force the compiler to inline a function, if possible
+     */
+#   define AI_FORCE_INLINE __forceinline
+
+    /* Tells the compiler that a function never returns. Used in code analysis
+     * to skip dead paths (e.g. after an assertion evaluated to false). */
+#   define AI_WONT_RETURN __declspec(noreturn)
 
 #elif defined(SWIG)
 
-	/* Do nothing, the relevant defines are all in AssimpSwigPort.i */
+    /* Do nothing, the relevant defines are all in AssimpSwigPort.i */
 
 #else
 
-#	define AI_WONT_RETURN
+#   define AI_WONT_RETURN
 
-#	define ASSIMP_API __attribute__ ((visibility("default")))
-#	define ASSIMP_API_WINONLY
-#	define AI_FORCE_INLINE inline
+#   define ASSIMP_API __attribute__ ((visibility("default")))
+#   define ASSIMP_API_WINONLY
+#   define AI_FORCE_INLINE inline
 #endif // (defined _MSC_VER)
 
 #ifdef __GNUC__
-#	define AI_WONT_RETURN_SUFFIX  __attribute__((noreturn))
+#   define AI_WONT_RETURN_SUFFIX  __attribute__((noreturn))
 #else
-#	define AI_WONT_RETURN_SUFFIX
+#   define AI_WONT_RETURN_SUFFIX
 #endif // (defined __clang__)
 
 #ifdef __cplusplus
-	/* No explicit 'struct' and 'enum' tags for C++, this keeps showing up
-	 * in doxydocs.
-	 */
-#	define C_STRUCT
-#	define C_ENUM
+    /* No explicit 'struct' and 'enum' tags for C++, this keeps showing up
+     * in doxydocs.
+     */
+#   define C_STRUCT
+#   define C_ENUM
 #else
-	//////////////////////////////////////////////////////////////////////////
-	/* To build the documentation, make sure ASSIMP_DOXYGEN_BUILD
-	 * is defined by Doxygen's preprocessor. The corresponding
-	 * entries in the DOXYFILE are: */
-	//////////////////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////////////////
+    /* To build the documentation, make sure ASSIMP_DOXYGEN_BUILD
+     * is defined by Doxygen's preprocessor. The corresponding
+     * entries in the DOXYFILE are: */
+    //////////////////////////////////////////////////////////////////////////
 #if 0
-	ENABLE_PREPROCESSING   = YES
-	MACRO_EXPANSION        = YES
-	EXPAND_ONLY_PREDEF     = YES
-	SEARCH_INCLUDES        = YES
-	INCLUDE_PATH           =
-	INCLUDE_FILE_PATTERNS  =
-	PREDEFINED             = ASSIMP_DOXYGEN_BUILD=1
-	EXPAND_AS_DEFINED      = C_STRUCT C_ENUM
-	SKIP_FUNCTION_MACROS   = YES
+    ENABLE_PREPROCESSING   = YES
+    MACRO_EXPANSION        = YES
+    EXPAND_ONLY_PREDEF     = YES
+    SEARCH_INCLUDES        = YES
+    INCLUDE_PATH           =
+    INCLUDE_FILE_PATTERNS  =
+    PREDEFINED             = ASSIMP_DOXYGEN_BUILD=1
+    EXPAND_AS_DEFINED      = C_STRUCT C_ENUM
+    SKIP_FUNCTION_MACROS   = YES
 #endif
-	//////////////////////////////////////////////////////////////////////////
-	/* Doxygen gets confused if we use c-struct typedefs to avoid
-	 * the explicit 'struct' notation. This trick here has the same
-	 * effect as the TYPEDEF_HIDES_STRUCT option, but we don't need
-	 * to typedef all structs/enums. */
-	 //////////////////////////////////////////////////////////////////////////
-#	if (defined ASSIMP_DOXYGEN_BUILD)
-#		define C_STRUCT
-#		define C_ENUM
-#	else
-#		define C_STRUCT struct
-#		define C_ENUM   enum
-#	endif
+    //////////////////////////////////////////////////////////////////////////
+    /* Doxygen gets confused if we use c-struct typedefs to avoid
+     * the explicit 'struct' notation. This trick here has the same
+     * effect as the TYPEDEF_HIDES_STRUCT option, but we don't need
+     * to typedef all structs/enums. */
+     //////////////////////////////////////////////////////////////////////////
+#   if (defined ASSIMP_DOXYGEN_BUILD)
+#       define C_STRUCT
+#       define C_ENUM
+#   else
+#       define C_STRUCT struct
+#       define C_ENUM   enum
+#   endif
 #endif
 
 #if (defined(__BORLANDC__) || defined (__BCPLUSPLUS__))
@@ -212,49 +212,49 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // "W8059 Packgr��e der Struktur ge�ndert"
 
 #endif
-	//////////////////////////////////////////////////////////////////////////
-	/* Define 'ASSIMP_BUILD_BOOST_WORKAROUND' to compile assimp
-	 * without boost. This is done by using a few workaround
-	 * classes and brings some limitations (e.g. some logging won't be done,
-	 * the library won't utilize threads or be threadsafe at all).
-	 * This implies the 'ASSIMP_BUILD_SINGLETHREADED' setting. */
-	 //////////////////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////////////////
+    /* Define 'ASSIMP_BUILD_BOOST_WORKAROUND' to compile assimp
+     * without boost. This is done by using a few workaround
+     * classes and brings some limitations (e.g. some logging won't be done,
+     * the library won't utilize threads or be threadsafe at all).
+     * This implies the 'ASSIMP_BUILD_SINGLETHREADED' setting. */
+     //////////////////////////////////////////////////////////////////////////
 #ifdef ASSIMP_BUILD_BOOST_WORKAROUND
 
-	// threading support requires boost
+    // threading support requires boost
 #ifndef ASSIMP_BUILD_SINGLETHREADED
-#	define ASSIMP_BUILD_SINGLETHREADED
+#   define ASSIMP_BUILD_SINGLETHREADED
 #endif
 
 #endif // !! ASSIMP_BUILD_BOOST_WORKAROUND
 
-	//////////////////////////////////////////////////////////////////////////
-	/* Define ASSIMP_BUILD_SINGLETHREADED to compile assimp
-	 * without threading support. The library doesn't utilize
-	 * threads then and is itself not threadsafe.
-	 * If this flag is specified boost::threads is *not* required. */
-	//////////////////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////////////////
+    /* Define ASSIMP_BUILD_SINGLETHREADED to compile assimp
+     * without threading support. The library doesn't utilize
+     * threads then and is itself not threadsafe.
+     * If this flag is specified boost::threads is *not* required. */
+    //////////////////////////////////////////////////////////////////////////
 #ifndef ASSIMP_BUILD_SINGLETHREADED
-#	define ASSIMP_BUILD_SINGLETHREADED
+#   define ASSIMP_BUILD_SINGLETHREADED
 #endif
 
 #if defined(_DEBUG) || ! defined(NDEBUG)
-#	define ASSIMP_BUILD_DEBUG
+#   define ASSIMP_BUILD_DEBUG
 #endif
 
-	//////////////////////////////////////////////////////////////////////////
-	/* Useful constants */
-	//////////////////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////////////////
+    /* Useful constants */
+    //////////////////////////////////////////////////////////////////////////
 
 /* This is PI. Hi PI. */
-#define AI_MATH_PI			(3.141592653589793238462643383279 )
-#define AI_MATH_TWO_PI		(AI_MATH_PI * 2.0)
-#define AI_MATH_HALF_PI		(AI_MATH_PI * 0.5)
+#define AI_MATH_PI          (3.141592653589793238462643383279 )
+#define AI_MATH_TWO_PI      (AI_MATH_PI * 2.0)
+#define AI_MATH_HALF_PI     (AI_MATH_PI * 0.5)
 
 /* And this is to avoid endless casts to float */
-#define AI_MATH_PI_F		(3.1415926538f)
-#define AI_MATH_TWO_PI_F	(AI_MATH_PI_F * 2.0f)
-#define AI_MATH_HALF_PI_F	(AI_MATH_PI_F * 0.5f)
+#define AI_MATH_PI_F        (3.1415926538f)
+#define AI_MATH_TWO_PI_F    (AI_MATH_PI_F * 2.0f)
+#define AI_MATH_HALF_PI_F   (AI_MATH_PI_F * 0.5f)
 
 /* Tiny macro to convert from radians to degrees and back */
 #define AI_DEG_TO_RAD(x) ((x)*0.0174532925f)
@@ -262,18 +262,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /* Support for big-endian builds */
 #if defined(__BYTE_ORDER__)
-#	if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-#		if !defined(__BIG_ENDIAN__)
-#			define __BIG_ENDIAN__
-#		endif
-#	else /* little endian */
-#		if defined (__BIG_ENDIAN__)
-#			undef __BIG_ENDIAN__
-#		endif
-#	endif
+#   if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#       if !defined(__BIG_ENDIAN__)
+#           define __BIG_ENDIAN__
+#       endif
+#   else /* little endian */
+#       if defined (__BIG_ENDIAN__)
+#           undef __BIG_ENDIAN__
+#       endif
+#   endif
 #endif
 #if defined(__BIG_ENDIAN__)
-#	define AI_BUILD_BIG_ENDIAN
+#   define AI_BUILD_BIG_ENDIAN
 #endif
 
 #endif // !! INCLUDED_AI_DEFINES_H

include/assimp/importerdesc.h

@@ -50,29 +50,29 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *  common to many importers*/
 enum aiImporterFlags
 {
-	/** Indicates that there is a textual encoding of the
-	 *  file format; and that it is supported.*/
-	aiImporterFlags_SupportTextFlavour = 0x1,
-
-	/** Indicates that there is a binary encoding of the
-	 *  file format; and that it is supported.*/
-	aiImporterFlags_SupportBinaryFlavour = 0x2,
-
-	/** Indicates that there is a compressed encoding of the
-	 *  file format; and that it is supported.*/
-	aiImporterFlags_SupportCompressedFlavour = 0x4,
-
-	/** Indicates that the importer reads only a very particular
-	  * subset of the file format. This happens commonly for
-	  * declarative or procedural formats which cannot easily
-	  * be mapped to #aiScene */
-	aiImporterFlags_LimitedSupport = 0x8,
-
-	/** Indicates that the importer is highly experimental and
-	  * should be used with care. This only happens for trunk
-	  * (i.e. SVN) versions, experimental code is not included
-	  * in releases. */
-	aiImporterFlags_Experimental = 0x10
+    /** Indicates that there is a textual encoding of the
+     *  file format; and that it is supported.*/
+    aiImporterFlags_SupportTextFlavour = 0x1,
+
+    /** Indicates that there is a binary encoding of the
+     *  file format; and that it is supported.*/
+    aiImporterFlags_SupportBinaryFlavour = 0x2,
+
+    /** Indicates that there is a compressed encoding of the
+     *  file format; and that it is supported.*/
+    aiImporterFlags_SupportCompressedFlavour = 0x4,
+
+    /** Indicates that the importer reads only a very particular
+      * subset of the file format. This happens commonly for
+      * declarative or procedural formats which cannot easily
+      * be mapped to #aiScene */
+    aiImporterFlags_LimitedSupport = 0x8,
+
+    /** Indicates that the importer is highly experimental and
+      * should be used with care. This only happens for trunk
+      * (i.e. SVN) versions, experimental code is not included
+      * in releases. */
+    aiImporterFlags_Experimental = 0x10
 };
 
 
@@ -86,50 +86,50 @@ enum aiImporterFlags
  *  characteristics. */
 struct aiImporterDesc
 {
-	/** Full name of the importer (i.e. Blender3D importer)*/
-	const char* mName;
-
-	/** Original author (left blank if unknown or whole assimp team) */
-	const char* mAuthor;
-
-	/** Current maintainer, left blank if the author maintains */
-	const char* mMaintainer;
-
-	/** Implementation comments, i.e. unimplemented features*/
-	const char* mComments;
-
-	/** These flags indicate some characteristics common to many
-		importers. */
-	unsigned int mFlags;
-
-	/** Minimum format version that can be loaded im major.minor format,
-	    both are set to 0 if there is either no version scheme
-		or if the loader doesn't care. */
-	unsigned int mMinMajor;
-	unsigned int mMinMinor;
-
-	/** Maximum format version that can be loaded im major.minor format,
-	    both are set to 0 if there is either no version scheme
-		or if the loader doesn't care. Loaders that expect to be
-		forward-compatible to potential future format versions should
-		indicate  zero, otherwise they should specify the current
-		maximum version.*/
-	unsigned int mMaxMajor;
-	unsigned int mMaxMinor;
-
-	/** List of file extensions this importer can handle.
-	    List entries are separated by space characters.
-		All entries are lower case without a leading dot (i.e.
-		"xml dae" would be a valid value. Note that multiple
-		importers may respond to the same file extension -
-		assimp calls all importers in the order in which they
-		are registered and each importer gets the opportunity
-		to load the file until one importer "claims" the file. Apart
-		from file extension checks, importers typically use
-		other methods to quickly reject files (i.e. magic
-		words) so this does not mean that common or generic
-		file extensions such as XML would be tediously slow. */
-	const char* mFileExtensions;
+    /** Full name of the importer (i.e. Blender3D importer)*/
+    const char* mName;
+
+    /** Original author (left blank if unknown or whole assimp team) */
+    const char* mAuthor;
+
+    /** Current maintainer, left blank if the author maintains */
+    const char* mMaintainer;
+
+    /** Implementation comments, i.e. unimplemented features*/
+    const char* mComments;
+
+    /** These flags indicate some characteristics common to many
+        importers. */
+    unsigned int mFlags;
+
+    /** Minimum format version that can be loaded im major.minor format,
+        both are set to 0 if there is either no version scheme
+        or if the loader doesn't care. */
+    unsigned int mMinMajor;
+    unsigned int mMinMinor;
+
+    /** Maximum format version that can be loaded im major.minor format,
+        both are set to 0 if there is either no version scheme
+        or if the loader doesn't care. Loaders that expect to be
+        forward-compatible to potential future format versions should
+        indicate  zero, otherwise they should specify the current
+        maximum version.*/
+    unsigned int mMaxMajor;
+    unsigned int mMaxMinor;
+
+    /** List of file extensions this importer can handle.
+        List entries are separated by space characters.
+        All entries are lower case without a leading dot (i.e.
+        "xml dae" would be a valid value. Note that multiple
+        importers may respond to the same file extension -
+        assimp calls all importers in the order in which they
+        are registered and each importer gets the opportunity
+        to load the file until one importer "claims" the file. Apart
+        from file extension checks, importers typically use
+        other methods to quickly reject files (i.e. magic
+        words) so this does not mean that common or generic
+        file extensions such as XML would be tediously slow. */
+    const char* mFileExtensions;
 };
 
 /** \brief  Returns the Importer description for a given extension.

include/assimp/light.h

@@ -57,37 +57,37 @@ extern "C" {
  */
 enum aiLightSourceType
 {
-	aiLightSource_UNDEFINED     = 0x0,
-
-	//! A directional light source has a well-defined direction
-	//! but is infinitely far away. That's quite a good
-	//! approximation for sun light.
-	aiLightSource_DIRECTIONAL   = 0x1,
-
-	//! A point light source has a well-defined position
-	//! in space but no direction - it emits light in all
-	//! directions. A normal bulb is a point light.
-	aiLightSource_POINT         = 0x2,
-
-	//! A spot light source emits light in a specific
-	//! angle. It has a position and a direction it is pointing to.
-	//! A good example for a spot light is a light spot in
-	//! sport arenas.
-	aiLightSource_SPOT          = 0x3,
-
-	//! The generic light level of the world, including the bounces
-	//! of all other lightsources.
-	//! Typically, there's at most one ambient light in a scene.
-	//! This light type doesn't have a valid position, direction, or
-	//! other properties, just a color.
-	aiLightSource_AMBIENT       = 0x4,
-
-
-	/** This value is not used. It is just there to force the
-	 *  compiler to map this enum to a 32 Bit integer.
-	 */
+    aiLightSource_UNDEFINED     = 0x0,
+
+    //! A directional light source has a well-defined direction
+    //! but is infinitely far away. That's quite a good
+    //! approximation for sun light.
+    aiLightSource_DIRECTIONAL   = 0x1,
+
+    //! A point light source has a well-defined position
+    //! in space but no direction - it emits light in all
+    //! directions. A normal bulb is a point light.
+    aiLightSource_POINT         = 0x2,
+
+    //! A spot light source emits light in a specific
+    //! angle. It has a position and a direction it is pointing to.
+    //! A good example for a spot light is a light spot in
+    //! sport arenas.
+    aiLightSource_SPOT          = 0x3,
+
+    //! The generic light level of the world, including the bounces
+    //! of all other lightsources.
+    //! Typically, there's at most one ambient light in a scene.
+    //! This light type doesn't have a valid position, direction, or
+    //! other properties, just a color.
+    aiLightSource_AMBIENT       = 0x4,
+
+
+    /** This value is not used. It is just there to force the
+     *  compiler to map this enum to a 32 Bit integer.
+     */
 #ifndef SWIG
-	_aiLightSource_Force32Bit = INT_MAX
+    _aiLightSource_Force32Bit = INT_MAX
 #endif
 };
 
@@ -106,128 +106,128 @@ enum aiLightSourceType
 */
 struct aiLight
 {
-	/** The name of the light source.
-	 *
-	 *  There must be a node in the scenegraph with the same name.
-	 *  This node specifies the position of the light in the scene
-	 *  hierarchy and can be animated.
-	 */
-	C_STRUCT aiString mName;
-
-	/** The type of the light source.
- 	 *
-	 * aiLightSource_UNDEFINED is not a valid value for this member.
-	 */
-	C_ENUM aiLightSourceType mType;
-
-	/** Position of the light source in space. Relative to the
-	 *  transformation of the node corresponding to the light.
-	 *
-	 *  The position is undefined for directional lights.
-	 */
-	C_STRUCT aiVector3D mPosition;
-
-	/** Direction of the light source in space. Relative to the
-	 *  transformation of the node corresponding to the light.
-	 *
-	 *  The direction is undefined for point lights. The vector
-	 *  may be normalized, but it needn't.
-	 */
-	C_STRUCT aiVector3D mDirection;
-
-	/** Constant light attenuation factor.
-	 *
-	 *  The intensity of the light source at a given distance 'd' from
-	 *  the light's position is
-	 *  @code
-	 *  Atten = 1/( att0 + att1 * d + att2 * d*d)
-	 *  @endcode
-	 *  This member corresponds to the att0 variable in the equation.
-	 *  Naturally undefined for directional lights.
-	 */
-	float mAttenuationConstant;
-
-	/** Linear light attenuation factor.
-	 *
-	 *  The intensity of the light source at a given distance 'd' from
-	 *  the light's position is
-	 *  @code
-	 *  Atten = 1/( att0 + att1 * d + att2 * d*d)
-	 *  @endcode
-	 *  This member corresponds to the att1 variable in the equation.
-	 *  Naturally undefined for directional lights.
-	 */
-	float mAttenuationLinear;
-
-	/** Quadratic light attenuation factor.
-	 *
-	 *  The intensity of the light source at a given distance 'd' from
-	 *  the light's position is
-	 *  @code
-	 *  Atten = 1/( att0 + att1 * d + att2 * d*d)
-	 *  @endcode
-	 *  This member corresponds to the att2 variable in the equation.
-	 *  Naturally undefined for directional lights.
-	 */
-	float mAttenuationQuadratic;
-
-	/** Diffuse color of the light source
-	 *
-	 *  The diffuse light color is multiplied with the diffuse
-	 *  material color to obtain the final color that contributes
-	 *  to the diffuse shading term.
-	 */
-	C_STRUCT aiColor3D mColorDiffuse;
-
-	/** Specular color of the light source
-	 *
-	 *  The specular light color is multiplied with the specular
-	 *  material color to obtain the final color that contributes
-	 *  to the specular shading term.
-	 */
-	C_STRUCT aiColor3D mColorSpecular;
-
-	/** Ambient color of the light source
-	 *
-	 *  The ambient light color is multiplied with the ambient
-	 *  material color to obtain the final color that contributes
-	 *  to the ambient shading term. Most renderers will ignore
-	 *  this value it, is just a remaining of the fixed-function pipeline
-	 *  that is still supported by quite many file formats.
-	 */
-	C_STRUCT aiColor3D mColorAmbient;
-
-	/** Inner angle of a spot light's light cone.
-	 *
-	 *  The spot light has maximum influence on objects inside this
-	 *  angle. The angle is given in radians. It is 2PI for point
-	 *  lights and undefined for directional lights.
-	 */
-	float mAngleInnerCone;
-
-	/** Outer angle of a spot light's light cone.
-	 *
-	 *  The spot light does not affect objects outside this angle.
-	 *  The angle is given in radians. It is 2PI for point lights and
-	 *  undefined for directional lights. The outer angle must be
-	 *  greater than or equal to the inner angle.
-	 *  It is assumed that the application uses a smooth
-	 *  interpolation between the inner and the outer cone of the
-	 *  spot light.
-	 */
-	float mAngleOuterCone;
+    /** The name of the light source.
+     *
+     *  There must be a node in the scenegraph with the same name.
+     *  This node specifies the position of the light in the scene
+     *  hierarchy and can be animated.
+     */
+    C_STRUCT aiString mName;
+
+    /** The type of the light source.
+     *
+     * aiLightSource_UNDEFINED is not a valid value for this member.
+     */
+    C_ENUM aiLightSourceType mType;
+
+    /** Position of the light source in space. Relative to the
+     *  transformation of the node corresponding to the light.
+     *
+     *  The position is undefined for directional lights.
+     */
+    C_STRUCT aiVector3D mPosition;
+
+    /** Direction of the light source in space. Relative to the
+     *  transformation of the node corresponding to the light.
+     *
+     *  The direction is undefined for point lights. The vector
+     *  may be normalized, but it needn't.
+     */
+    C_STRUCT aiVector3D mDirection;
+
+    /** Constant light attenuation factor.
+     *
+     *  The intensity of the light source at a given distance 'd' from
+     *  the light's position is
+     *  @code
+     *  Atten = 1/( att0 + att1 * d + att2 * d*d)
+     *  @endcode
+     *  This member corresponds to the att0 variable in the equation.
+     *  Naturally undefined for directional lights.
+     */
+    float mAttenuationConstant;
+
+    /** Linear light attenuation factor.
+     *
+     *  The intensity of the light source at a given distance 'd' from
+     *  the light's position is
+     *  @code
+     *  Atten = 1/( att0 + att1 * d + att2 * d*d)
+     *  @endcode
+     *  This member corresponds to the att1 variable in the equation.
+     *  Naturally undefined for directional lights.
+     */
+    float mAttenuationLinear;
+
+    /** Quadratic light attenuation factor.
+     *
+     *  The intensity of the light source at a given distance 'd' from
+     *  the light's position is
+     *  @code
+     *  Atten = 1/( att0 + att1 * d + att2 * d*d)
+     *  @endcode
+     *  This member corresponds to the att2 variable in the equation.
+     *  Naturally undefined for directional lights.
+     */
+    float mAttenuationQuadratic;
+
+    /** Diffuse color of the light source
+     *
+     *  The diffuse light color is multiplied with the diffuse
+     *  material color to obtain the final color that contributes
+     *  to the diffuse shading term.
+     */
+    C_STRUCT aiColor3D mColorDiffuse;
+
+    /** Specular color of the light source
+     *
+     *  The specular light color is multiplied with the specular
+     *  material color to obtain the final color that contributes
+     *  to the specular shading term.
+     */
+    C_STRUCT aiColor3D mColorSpecular;
+
+    /** Ambient color of the light source
+     *
+     *  The ambient light color is multiplied with the ambient
+     *  material color to obtain the final color that contributes
+     *  to the ambient shading term. Most renderers will ignore
+     *  this value it, is just a remaining of the fixed-function pipeline
+     *  that is still supported by quite many file formats.
+     */
+    C_STRUCT aiColor3D mColorAmbient;
+
+    /** Inner angle of a spot light's light cone.
+     *
+     *  The spot light has maximum influence on objects inside this
+     *  angle. The angle is given in radians. It is 2PI for point
+     *  lights and undefined for directional lights.
+     */
+    float mAngleInnerCone;
+
+    /** Outer angle of a spot light's light cone.
+     *
+     *  The spot light does not affect objects outside this angle.
+     *  The angle is given in radians. It is 2PI for point lights and
+     *  undefined for directional lights. The outer angle must be
+     *  greater than or equal to the inner angle.
+     *  It is assumed that the application uses a smooth
+     *  interpolation between the inner and the outer cone of the
+     *  spot light.
+     */
+    float mAngleOuterCone;
 
 #ifdef __cplusplus
 
-	aiLight()
-		:	mType                 (aiLightSource_UNDEFINED)
-		,	mAttenuationConstant  (0.f)
-		,   mAttenuationLinear    (1.f)
-		,   mAttenuationQuadratic (0.f)
-		,	mAngleInnerCone       ((float)AI_MATH_TWO_PI)
-		,	mAngleOuterCone       ((float)AI_MATH_TWO_PI)
-	{
-	}
+    aiLight()
+        :   mType                 (aiLightSource_UNDEFINED)
+        ,   mAttenuationConstant  (0.f)
+        ,   mAttenuationLinear    (1.f)
+        ,   mAttenuationQuadratic (0.f)
+        ,   mAngleInnerCone       ((float)AI_MATH_TWO_PI)
+        ,   mAngleOuterCone       ((float)AI_MATH_TWO_PI)
+    {
+    }
 
 #endif
 };

include/assimp/material.inl

@@ -52,212 +52,212 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 inline aiReturn aiMaterial::GetTexture( aiTextureType type,
    unsigned int  index,
    C_STRUCT aiString* path,
-   aiTextureMapping* mapping	/*= NULL*/,
-   unsigned int* uvindex		/*= NULL*/,
-   float* blend				   /*= NULL*/,
-   aiTextureOp* op				/*= NULL*/,
-   aiTextureMapMode* mapmode	/*= NULL*/) const
+   aiTextureMapping* mapping    /*= NULL*/,
+   unsigned int* uvindex        /*= NULL*/,
+   float* blend                /*= NULL*/,
+   aiTextureOp* op              /*= NULL*/,
+   aiTextureMapMode* mapmode    /*= NULL*/) const
 {
-	return ::aiGetMaterialTexture(this,type,index,path,mapping,uvindex,blend,op,mapmode);
+    return ::aiGetMaterialTexture(this,type,index,path,mapping,uvindex,blend,op,mapmode);
 }
 
 // ---------------------------------------------------------------------------
 inline unsigned int aiMaterial::GetTextureCount(aiTextureType type) const
 {
-	return ::aiGetMaterialTextureCount(this,type);
+    return ::aiGetMaterialTextureCount(this,type);
 }
 
 // ---------------------------------------------------------------------------
 template <typename Type>
 inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-	unsigned int idx, Type* pOut,
-	unsigned int* pMax) const
+    unsigned int idx, Type* pOut,
+    unsigned int* pMax) const
 {
-	unsigned int iNum = pMax ? *pMax : 1;
-
-	const aiMaterialProperty* prop;
-	const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx,
-		(const aiMaterialProperty**)&prop);
-	if ( AI_SUCCESS == ret )	{
-
-		if (prop->mDataLength < sizeof(Type)*iNum) {
-			return AI_FAILURE;
-		}
-
-		if (prop->mType != aiPTI_Buffer) {
-			return AI_FAILURE;
-		}
-
-		iNum = std::min((size_t)iNum,prop->mDataLength / sizeof(Type));
-		::memcpy(pOut,prop->mData,iNum * sizeof(Type));
-		if (pMax) {
-			*pMax = iNum;
-		}
-	}
-	return ret;
+    unsigned int iNum = pMax ? *pMax : 1;
+
+    const aiMaterialProperty* prop;
+    const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx,
+        (const aiMaterialProperty**)&prop);
+    if ( AI_SUCCESS == ret )    {
+
+        if (prop->mDataLength < sizeof(Type)*iNum) {
+            return AI_FAILURE;
+        }
+
+        if (prop->mType != aiPTI_Buffer) {
+            return AI_FAILURE;
+        }
+
+        iNum = std::min((size_t)iNum,prop->mDataLength / sizeof(Type));
+        ::memcpy(pOut,prop->mData,iNum * sizeof(Type));
+        if (pMax) {
+            *pMax = iNum;
+        }
+    }
+    return ret;
 }
 
 // ---------------------------------------------------------------------------
 template <typename Type>
 inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-	unsigned int idx,Type& pOut) const
+    unsigned int idx,Type& pOut) const
 {
-	const aiMaterialProperty* prop;
-	const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx,
-		(const aiMaterialProperty**)&prop);
-	if ( AI_SUCCESS == ret )	{
-
-		if (prop->mDataLength < sizeof(Type)) {
-			return AI_FAILURE;
-		}
-
-		if (prop->mType != aiPTI_Buffer) {
-			return AI_FAILURE;
-		}
-
-		::memcpy(&pOut,prop->mData,sizeof(Type));
-	}
-	return ret;
+    const aiMaterialProperty* prop;
+    const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx,
+        (const aiMaterialProperty**)&prop);
+    if ( AI_SUCCESS == ret )    {
+
+        if (prop->mDataLength < sizeof(Type)) {
+            return AI_FAILURE;
+        }
+
+        if (prop->mType != aiPTI_Buffer) {
+            return AI_FAILURE;
+        }
+
+        ::memcpy(&pOut,prop->mData,sizeof(Type));
+    }
+    return ret;
 }
 
 // ---------------------------------------------------------------------------
 inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-	unsigned int idx,float* pOut,
-	unsigned int* pMax) const
+    unsigned int idx,float* pOut,
+    unsigned int* pMax) const
 {
-	return ::aiGetMaterialFloatArray(this,pKey,type,idx,pOut,pMax);
+    return ::aiGetMaterialFloatArray(this,pKey,type,idx,pOut,pMax);
 }
 // ---------------------------------------------------------------------------
 inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-	unsigned int idx,int* pOut,
-	unsigned int* pMax) const
+    unsigned int idx,int* pOut,
+    unsigned int* pMax) const
 {
-	return ::aiGetMaterialIntegerArray(this,pKey,type,idx,pOut,pMax);
+    return ::aiGetMaterialIntegerArray(this,pKey,type,idx,pOut,pMax);
 }
 // ---------------------------------------------------------------------------
 inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-	unsigned int idx,float& pOut) const
+    unsigned int idx,float& pOut) const
 {
-	return aiGetMaterialFloat(this,pKey,type,idx,&pOut);
+    return aiGetMaterialFloat(this,pKey,type,idx,&pOut);
 }
 // ---------------------------------------------------------------------------
 inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-	unsigned int idx,int& pOut) const
+    unsigned int idx,int& pOut) const
 {
-	return aiGetMaterialInteger(this,pKey,type,idx,&pOut);
+    return aiGetMaterialInteger(this,pKey,type,idx,&pOut);
 }
 // ---------------------------------------------------------------------------
 inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-	unsigned int idx,aiColor4D& pOut) const
+    unsigned int idx,aiColor4D& pOut) const
 {
-	return aiGetMaterialColor(this,pKey,type,idx,&pOut);
+    return aiGetMaterialColor(this,pKey,type,idx,&pOut);
 }
 // ---------------------------------------------------------------------------
 inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-	unsigned int idx,aiColor3D& pOut) const
+    unsigned int idx,aiColor3D& pOut) const
 {
-	aiColor4D c;
-	const aiReturn ret = aiGetMaterialColor(this,pKey,type,idx,&c);
-	pOut = aiColor3D(c.r,c.g,c.b);
-	return ret;
+    aiColor4D c;
+    const aiReturn ret = aiGetMaterialColor(this,pKey,type,idx,&c);
+    pOut = aiColor3D(c.r,c.g,c.b);
+    return ret;
 }
 // ---------------------------------------------------------------------------
 inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-	unsigned int idx,aiString& pOut) const
+    unsigned int idx,aiString& pOut) const
 {
-	return aiGetMaterialString(this,pKey,type,idx,&pOut);
+    return aiGetMaterialString(this,pKey,type,idx,&pOut);
 }
 // ---------------------------------------------------------------------------
 inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
-	unsigned int idx,aiUVTransform& pOut) const
+    unsigned int idx,aiUVTransform& pOut) const
 {
-	return aiGetMaterialUVTransform(this,pKey,type,idx,&pOut);
+    return aiGetMaterialUVTransform(this,pKey,type,idx,&pOut);
 }
 
 
 // ---------------------------------------------------------------------------
 template<class TYPE>
 aiReturn aiMaterial::AddProperty (const TYPE* pInput,
-	const unsigned int pNumValues,
-	const char* pKey,
-	unsigned int type,
-	unsigned int index)
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
 {
-	return AddBinaryProperty((const void*)pInput,
-		pNumValues * sizeof(TYPE),
-		pKey,type,index,aiPTI_Buffer);
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(TYPE),
+        pKey,type,index,aiPTI_Buffer);
 }
 
 // ---------------------------------------------------------------------------
 inline aiReturn aiMaterial::AddProperty(const float* pInput,
-	const unsigned int pNumValues,
-	const char* pKey,
-	unsigned int type,
-	unsigned int index)
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
 {
-	return AddBinaryProperty((const void*)pInput,
-		pNumValues * sizeof(float),
-		pKey,type,index,aiPTI_Float);
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(float),
+        pKey,type,index,aiPTI_Float);
 }
 
 // ---------------------------------------------------------------------------
 inline aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput,
-	const unsigned int pNumValues,
-	const char* pKey,
-	unsigned int type,
-	unsigned int index)
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
 {
-	return AddBinaryProperty((const void*)pInput,
-		pNumValues * sizeof(aiUVTransform),
-		pKey,type,index,aiPTI_Float);
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(aiUVTransform),
+        pKey,type,index,aiPTI_Float);
 }
 
 // ---------------------------------------------------------------------------
 inline aiReturn aiMaterial::AddProperty(const aiColor4D* pInput,
-	const unsigned int pNumValues,
-	const char* pKey,
-	unsigned int type,
-	unsigned int index)
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
 {
-	return AddBinaryProperty((const void*)pInput,
-		pNumValues * sizeof(aiColor4D),
-		pKey,type,index,aiPTI_Float);
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(aiColor4D),
+        pKey,type,index,aiPTI_Float);
 }
 
 // ---------------------------------------------------------------------------
 inline aiReturn aiMaterial::AddProperty(const aiColor3D* pInput,
-	const unsigned int pNumValues,
-	const char* pKey,
-	unsigned int type,
-	unsigned int index)
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
 {
-	return AddBinaryProperty((const void*)pInput,
-		pNumValues * sizeof(aiColor3D),
-		pKey,type,index,aiPTI_Float);
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(aiColor3D),
+        pKey,type,index,aiPTI_Float);
 }
 
 // ---------------------------------------------------------------------------
 inline aiReturn aiMaterial::AddProperty(const aiVector3D* pInput,
-	const unsigned int pNumValues,
-	const char* pKey,
-	unsigned int type,
-	unsigned int index)
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
 {
-	return AddBinaryProperty((const void*)pInput,
-		pNumValues * sizeof(aiVector3D),
-		pKey,type,index,aiPTI_Float);
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(aiVector3D),
+        pKey,type,index,aiPTI_Float);
 }
 
 // ---------------------------------------------------------------------------
 inline aiReturn aiMaterial::AddProperty(const int* pInput,
-	const unsigned int pNumValues,
-	const char* pKey,
-	unsigned int type,
-	unsigned int index)
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
 {
-	return AddBinaryProperty((const void*)pInput,
-		pNumValues * sizeof(int),
-		pKey,type,index,aiPTI_Integer);
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(int),
+        pKey,type,index,aiPTI_Integer);
 }
 
 
@@ -270,79 +270,79 @@ inline aiReturn aiMaterial::AddProperty(const int* pInput,
 // ---------------------------------------------------------------------------
 template<>
 inline aiReturn aiMaterial::AddProperty<float>(const float* pInput,
-	const unsigned int pNumValues,
-	const char* pKey,
-	unsigned int type,
-	unsigned int index)
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
 {
-	return AddBinaryProperty((const void*)pInput,
-		pNumValues * sizeof(float),
-		pKey,type,index,aiPTI_Float);
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(float),
+        pKey,type,index,aiPTI_Float);
 }
 
 // ---------------------------------------------------------------------------
 template<>
 inline aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput,
-	const unsigned int pNumValues,
-	const char* pKey,
-	unsigned int type,
-	unsigned int index)
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
 {
-	return AddBinaryProperty((const void*)pInput,
-		pNumValues * sizeof(aiUVTransform),
-		pKey,type,index,aiPTI_Float);
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(aiUVTransform),
+        pKey,type,index,aiPTI_Float);
 }
 
 // ---------------------------------------------------------------------------
 template<>
 inline aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
-	const unsigned int pNumValues,
-	const char* pKey,
-	unsigned int type,
-	unsigned int index)
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
 {
-	return AddBinaryProperty((const void*)pInput,
-		pNumValues * sizeof(aiColor4D),
-		pKey,type,index,aiPTI_Float);
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(aiColor4D),
+        pKey,type,index,aiPTI_Float);
 }
 
 // ---------------------------------------------------------------------------
 template<>
 inline aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
-	const unsigned int pNumValues,
-	const char* pKey,
-	unsigned int type,
-	unsigned int index)
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
 {
-	return AddBinaryProperty((const void*)pInput,
-		pNumValues * sizeof(aiColor3D),
-		pKey,type,index,aiPTI_Float);
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(aiColor3D),
+        pKey,type,index,aiPTI_Float);
 }
 
 // ---------------------------------------------------------------------------
 template<>
 inline aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
-	const unsigned int pNumValues,
-	const char* pKey,
-	unsigned int type,
-	unsigned int index)
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
 {
-	return AddBinaryProperty((const void*)pInput,
-		pNumValues * sizeof(aiVector3D),
-		pKey,type,index,aiPTI_Float);
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(aiVector3D),
+        pKey,type,index,aiPTI_Float);
 }
 
 // ---------------------------------------------------------------------------
 template<>
 inline aiReturn aiMaterial::AddProperty<int>(const int* pInput,
-	const unsigned int pNumValues,
-	const char* pKey,
-	unsigned int type,
-	unsigned int index)
+    const unsigned int pNumValues,
+    const char* pKey,
+    unsigned int type,
+    unsigned int index)
 {
-	return AddBinaryProperty((const void*)pInput,
-		pNumValues * sizeof(int),
-		pKey,type,index,aiPTI_Integer);
+    return AddBinaryProperty((const void*)pInput,
+        pNumValues * sizeof(int),
+        pKey,type,index,aiPTI_Integer);
 }
 
 //! @endcond

include/assimp/matrix3x3.h

@@ -66,105 +66,105 @@ class aiMatrix3x3t
 {
 public:
 
-	aiMatrix3x3t () :
-		a1(static_cast<TReal>(1.0f)), a2(), a3(),
-		b1(), b2(static_cast<TReal>(1.0f)), b3(),
-		c1(), c2(), c3(static_cast<TReal>(1.0f)) {}
-
-	aiMatrix3x3t (	TReal _a1, TReal _a2, TReal _a3,
-					TReal _b1, TReal _b2, TReal _b3,
-					TReal _c1, TReal _c2, TReal _c3) :
-		a1(_a1), a2(_a2), a3(_a3),
-		b1(_b1), b2(_b2), b3(_b3),
-		c1(_c1), c2(_c2), c3(_c3)
-	{}
+    aiMatrix3x3t () :
+        a1(static_cast<TReal>(1.0f)), a2(), a3(),
+        b1(), b2(static_cast<TReal>(1.0f)), b3(),
+        c1(), c2(), c3(static_cast<TReal>(1.0f)) {}
+
+    aiMatrix3x3t (  TReal _a1, TReal _a2, TReal _a3,
+                    TReal _b1, TReal _b2, TReal _b3,
+                    TReal _c1, TReal _c2, TReal _c3) :
+        a1(_a1), a2(_a2), a3(_a3),
+        b1(_b1), b2(_b2), b3(_b3),
+        c1(_c1), c2(_c2), c3(_c3)
+    {}
 
 public:
 
-	// matrix multiplication.
-	aiMatrix3x3t& operator *= (const aiMatrix3x3t& m);
-	aiMatrix3x3t  operator  * (const aiMatrix3x3t& m) const;
+    // matrix multiplication.
+    aiMatrix3x3t& operator *= (const aiMatrix3x3t& m);
+    aiMatrix3x3t  operator  * (const aiMatrix3x3t& m) const;
 
-	// array access operators
-	TReal* operator[]       (unsigned int p_iIndex);
-	const TReal* operator[] (unsigned int p_iIndex) const;
+    // array access operators
+    TReal* operator[]       (unsigned int p_iIndex);
+    const TReal* operator[] (unsigned int p_iIndex) const;
 
-	// comparison operators
-	bool operator== (const aiMatrix4x4t<TReal>& m) const;
-	bool operator!= (const aiMatrix4x4t<TReal>& m) const;
+    // comparison operators
+    bool operator== (const aiMatrix4x4t<TReal>& m) const;
+    bool operator!= (const aiMatrix4x4t<TReal>& m) const;
 
-	bool Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon = 1e-6) const;
+    bool Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon = 1e-6) const;
 
-	template <typename TOther>
-	operator aiMatrix3x3t<TOther> () const;
+    template <typename TOther>
+    operator aiMatrix3x3t<TOther> () const;
 
 public:
 
-	// -------------------------------------------------------------------
-	/** @brief Construction from a 4x4 matrix. The remaining parts
-	 *  of the matrix are ignored.
-	 */
-	explicit aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix);
-
-	// -------------------------------------------------------------------
-	/** @brief Transpose the matrix
-	 */
-	aiMatrix3x3t& Transpose();
-
-	// -------------------------------------------------------------------
-	/** @brief Invert the matrix.
-	 *  If the matrix is not invertible all elements are set to qnan.
-	 *  Beware, use (f != f) to check whether a TReal f is qnan.
-	 */
-	aiMatrix3x3t& Inverse();
-	TReal Determinant() const;
+    // -------------------------------------------------------------------
+    /** @brief Construction from a 4x4 matrix. The remaining parts
+     *  of the matrix are ignored.
+     */
+    explicit aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix);
+
+    // -------------------------------------------------------------------
+    /** @brief Transpose the matrix
+     */
+    aiMatrix3x3t& Transpose();
+
+    // -------------------------------------------------------------------
+    /** @brief Invert the matrix.
+     *  If the matrix is not invertible all elements are set to qnan.
+     *  Beware, use (f != f) to check whether a TReal f is qnan.
+     */
+    aiMatrix3x3t& Inverse();
+    TReal Determinant() const;
 
 public:
-	// -------------------------------------------------------------------
-	/** @brief Returns a rotation matrix for a rotation around z
-	 *  @param a Rotation angle, in radians
-	 *  @param out Receives the output matrix
-	 *  @return Reference to the output matrix
-	 */
-	static aiMatrix3x3t& RotationZ(TReal a, aiMatrix3x3t& out);
-
-	// -------------------------------------------------------------------
-	/** @brief Returns a rotation matrix for a rotation around
-	 *    an arbitrary axis.
-	 *
-	 *  @param a Rotation angle, in radians
-	 *  @param axis Axis to rotate around
-	 *  @param out To be filled
-	 */
-	static aiMatrix3x3t& Rotation( TReal a,
-		const aiVector3t<TReal>& axis, aiMatrix3x3t& out);
-
-	// -------------------------------------------------------------------
-	/** @brief Returns a translation matrix
-	 *  @param v Translation vector
-	 *  @param out Receives the output matrix
-	 *  @return Reference to the output matrix
-	 */
-	static aiMatrix3x3t& Translation( const aiVector2t<TReal>& v, aiMatrix3x3t& out);
-
-	// -------------------------------------------------------------------
-	/** @brief A function for creating a rotation matrix that rotates a
-	 *  vector called "from" into another vector called "to".
-	 * Input : from[3], to[3] which both must be *normalized* non-zero vectors
-	 * Output: mtx[3][3] -- a 3x3 matrix in colum-major form
-	 * Authors: Tomas Möller, John Hughes
-	 *          "Efficiently Building a Matrix to Rotate One Vector to Another"
-	 *          Journal of Graphics Tools, 4(4):1-4, 1999
-	 */
-	static aiMatrix3x3t& FromToMatrix(const aiVector3t<TReal>& from,
-		const aiVector3t<TReal>& to, aiMatrix3x3t& out);
+    // -------------------------------------------------------------------
+    /** @brief Returns a rotation matrix for a rotation around z
+     *  @param a Rotation angle, in radians
+     *  @param out Receives the output matrix
+     *  @return Reference to the output matrix
+     */
+    static aiMatrix3x3t& RotationZ(TReal a, aiMatrix3x3t& out);
+
+    // -------------------------------------------------------------------
+    /** @brief Returns a rotation matrix for a rotation around
+     *    an arbitrary axis.
+     *
+     *  @param a Rotation angle, in radians
+     *  @param axis Axis to rotate around
+     *  @param out To be filled
+     */
+    static aiMatrix3x3t& Rotation( TReal a,
+        const aiVector3t<TReal>& axis, aiMatrix3x3t& out);
+
+    // -------------------------------------------------------------------
+    /** @brief Returns a translation matrix
+     *  @param v Translation vector
+     *  @param out Receives the output matrix
+     *  @return Reference to the output matrix
+     */
+    static aiMatrix3x3t& Translation( const aiVector2t<TReal>& v, aiMatrix3x3t& out);
+
+    // -------------------------------------------------------------------
+    /** @brief A function for creating a rotation matrix that rotates a
+     *  vector called "from" into another vector called "to".
+     * Input : from[3], to[3] which both must be *normalized* non-zero vectors
+     * Output: mtx[3][3] -- a 3x3 matrix in colum-major form
+     * Authors: Tomas Möller, John Hughes
+     *          "Efficiently Building a Matrix to Rotate One Vector to Another"
+     *          Journal of Graphics Tools, 4(4):1-4, 1999
+     */
+    static aiMatrix3x3t& FromToMatrix(const aiVector3t<TReal>& from,
+        const aiVector3t<TReal>& to, aiMatrix3x3t& out);
 
 public:
 
 
-	TReal a1, a2, a3;
-	TReal b1, b2, b3;
-	TReal c1, c2, c3;
+    TReal a1, a2, a3;
+    TReal b1, b2, b3;
+    TReal c1, c2, c3;
 } PACK_STRUCT;
 
 typedef aiMatrix3x3t<float> aiMatrix3x3;
@@ -173,9 +173,9 @@ typedef aiMatrix3x3t<float> aiMatrix3x3;
 
 struct aiMatrix3x3 {
 
-	float a1, a2, a3;
-	float b1, b2, b3;
-	float c1, c2, c3;
+    float a1, a2, a3;
+    float b1, b2, b3;
+    float c1, c2, c3;
 } PACK_STRUCT;
 
 #endif

include/assimp/matrix3x3.inl

@@ -58,25 +58,25 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 template <typename TReal>
 inline aiMatrix3x3t<TReal>::aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix)
 {
-	a1 = pMatrix.a1; a2 = pMatrix.a2; a3 = pMatrix.a3;
-	b1 = pMatrix.b1; b2 = pMatrix.b2; b3 = pMatrix.b3;
-	c1 = pMatrix.c1; c2 = pMatrix.c2; c3 = pMatrix.c3;
+    a1 = pMatrix.a1; a2 = pMatrix.a2; a3 = pMatrix.a3;
+    b1 = pMatrix.b1; b2 = pMatrix.b2; b3 = pMatrix.b3;
+    c1 = pMatrix.c1; c2 = pMatrix.c2; c3 = pMatrix.c3;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& m)
 {
-	*this = aiMatrix3x3t<TReal>(m.a1 * a1 + m.b1 * a2 + m.c1 * a3,
-		m.a2 * a1 + m.b2 * a2 + m.c2 * a3,
-		m.a3 * a1 + m.b3 * a2 + m.c3 * a3,
-		m.a1 * b1 + m.b1 * b2 + m.c1 * b3,
-		m.a2 * b1 + m.b2 * b2 + m.c2 * b3,
-		m.a3 * b1 + m.b3 * b2 + m.c3 * b3,
-		m.a1 * c1 + m.b1 * c2 + m.c1 * c3,
-		m.a2 * c1 + m.b2 * c2 + m.c2 * c3,
-		m.a3 * c1 + m.b3 * c2 + m.c3 * c3);
-	return *this;
+    *this = aiMatrix3x3t<TReal>(m.a1 * a1 + m.b1 * a2 + m.c1 * a3,
+        m.a2 * a1 + m.b2 * a2 + m.c2 * a3,
+        m.a3 * a1 + m.b3 * a2 + m.c3 * a3,
+        m.a1 * b1 + m.b1 * b2 + m.c1 * b3,
+        m.a2 * b1 + m.b2 * b2 + m.c2 * b3,
+        m.a3 * b1 + m.b3 * b2 + m.c3 * b3,
+        m.a1 * c1 + m.b1 * c2 + m.c1 * c3,
+        m.a2 * c1 + m.b2 * c2 + m.c2 * c3,
+        m.a3 * c1 + m.b3 * c2 + m.c3 * c3);
+    return *this;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -84,130 +84,130 @@ template <typename TReal>
 template <typename TOther>
 aiMatrix3x3t<TReal>::operator aiMatrix3x3t<TOther> () const
 {
-	return aiMatrix3x3t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),
-		static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),
-		static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3));
+    return aiMatrix3x3t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),
+        static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),
+        static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3));
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix3x3t<TReal> aiMatrix3x3t<TReal>::operator* (const aiMatrix3x3t<TReal>& m) const
 {
-	aiMatrix3x3t<TReal> temp( *this);
-	temp *= m;
-	return temp;
+    aiMatrix3x3t<TReal> temp( *this);
+    temp *= m;
+    return temp;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 inline TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex)
 {
-	return &this->a1 + p_iIndex * 3;
+    return &this->a1 + p_iIndex * 3;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 inline const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) const
 {
-	return &this->a1 + p_iIndex * 3;
+    return &this->a1 + p_iIndex * 3;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 inline bool aiMatrix3x3t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const
 {
-	return a1 == m.a1 && a2 == m.a2 && a3 == m.a3 &&
-		   b1 == m.b1 && b2 == m.b2 && b3 == m.b3 &&
-		   c1 == m.c1 && c2 == m.c2 && c3 == m.c3;
+    return a1 == m.a1 && a2 == m.a2 && a3 == m.a3 &&
+           b1 == m.b1 && b2 == m.b2 && b3 == m.b3 &&
+           c1 == m.c1 && c2 == m.c2 && c3 == m.c3;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 inline bool aiMatrix3x3t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const
 {
-	return !(*this == m);
+    return !(*this == m);
 }
 
 // ---------------------------------------------------------------------------
 template<typename TReal>
 inline bool aiMatrix3x3t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
-	return
-		std::abs(a1 - m.a1) <= epsilon &&
-		std::abs(a2 - m.a2) <= epsilon &&
-		std::abs(a3 - m.a3) <= epsilon &&
-		std::abs(b1 - m.b1) <= epsilon &&
-		std::abs(b2 - m.b2) <= epsilon &&
-		std::abs(b3 - m.b3) <= epsilon &&
-		std::abs(c1 - m.c1) <= epsilon &&
-		std::abs(c2 - m.c2) <= epsilon &&
-		std::abs(c3 - m.c3) <= epsilon;
+    return
+        std::abs(a1 - m.a1) <= epsilon &&
+        std::abs(a2 - m.a2) <= epsilon &&
+        std::abs(a3 - m.a3) <= epsilon &&
+        std::abs(b1 - m.b1) <= epsilon &&
+        std::abs(b2 - m.b2) <= epsilon &&
+        std::abs(b3 - m.b3) <= epsilon &&
+        std::abs(c1 - m.c1) <= epsilon &&
+        std::abs(c2 - m.c2) <= epsilon &&
+        std::abs(c3 - m.c3) <= epsilon;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Transpose()
 {
-	// (TReal&) don't remove, GCC complains cause of packed fields
-	std::swap( (TReal&)a2, (TReal&)b1);
-	std::swap( (TReal&)a3, (TReal&)c1);
-	std::swap( (TReal&)b3, (TReal&)c2);
-	return *this;
+    // (TReal&) don't remove, GCC complains cause of packed fields
+    std::swap( (TReal&)a2, (TReal&)b1);
+    std::swap( (TReal&)a3, (TReal&)c1);
+    std::swap( (TReal&)b3, (TReal&)c2);
+    return *this;
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline TReal aiMatrix3x3t<TReal>::Determinant() const
 {
-	return a1*b2*c3 - a1*b3*c2 + a2*b3*c1 - a2*b1*c3 + a3*b1*c2 - a3*b2*c1;
+    return a1*b2*c3 - a1*b3*c2 + a2*b3*c1 - a2*b1*c3 + a3*b1*c2 - a3*b2*c1;
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Inverse()
 {
-	// Compute the reciprocal determinant
-	TReal det = Determinant();
-	if(det == static_cast<TReal>(0.0))
-	{
-		// Matrix not invertible. Setting all elements to nan is not really
-		// correct in a mathematical sense; but at least qnans are easy to
-		// spot. XXX we might throw an exception instead, which would
-		// be even much better to spot :/.
-		const TReal nan = std::numeric_limits<TReal>::quiet_NaN();
-		*this = aiMatrix3x3t<TReal>( nan,nan,nan,nan,nan,nan,nan,nan,nan);
-
-		return *this;
-	}
-
-	TReal invdet = static_cast<TReal>(1.0) / det;
-
-	aiMatrix3x3t<TReal> res;
-	res.a1 = invdet  * (b2 * c3 - b3 * c2);
-	res.a2 = -invdet * (a2 * c3 - a3 * c2);
-	res.a3 = invdet  * (a2 * b3 - a3 * b2);
-	res.b1 = -invdet * (b1 * c3 - b3 * c1);
-	res.b2 = invdet  * (a1 * c3 - a3 * c1);
-	res.b3 = -invdet * (a1 * b3 - a3 * b1);
-	res.c1 = invdet  * (b1 * c2 - b2 * c1);
-	res.c2 = -invdet * (a1 * c2 - a2 * c1);
-	res.c3 = invdet  * (a1 * b2 - a2 * b1);
-	*this = res;
-
-	return *this;
+    // Compute the reciprocal determinant
+    TReal det = Determinant();
+    if(det == static_cast<TReal>(0.0))
+    {
+        // Matrix not invertible. Setting all elements to nan is not really
+        // correct in a mathematical sense; but at least qnans are easy to
+        // spot. XXX we might throw an exception instead, which would
+        // be even much better to spot :/.
+        const TReal nan = std::numeric_limits<TReal>::quiet_NaN();
+        *this = aiMatrix3x3t<TReal>( nan,nan,nan,nan,nan,nan,nan,nan,nan);
+
+        return *this;
+    }
+
+    TReal invdet = static_cast<TReal>(1.0) / det;
+
+    aiMatrix3x3t<TReal> res;
+    res.a1 = invdet  * (b2 * c3 - b3 * c2);
+    res.a2 = -invdet * (a2 * c3 - a3 * c2);
+    res.a3 = invdet  * (a2 * b3 - a3 * b2);
+    res.b1 = -invdet * (b1 * c3 - b3 * c1);
+    res.b2 = invdet  * (a1 * c3 - a3 * c1);
+    res.b3 = -invdet * (a1 * b3 - a3 * b1);
+    res.c1 = invdet  * (b1 * c2 - b2 * c1);
+    res.c2 = -invdet * (a1 * c2 - a2 * c1);
+    res.c3 = invdet  * (a1 * b2 - a2 * b1);
+    *this = res;
+
+    return *this;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::RotationZ(TReal a, aiMatrix3x3t<TReal>& out)
 {
-	out.a1 = out.b2 = std::cos(a);
-	out.b1 = std::sin(a);
-	out.a2 = - out.b1;
+    out.a1 = out.b2 = std::cos(a);
+    out.b1 = std::sin(a);
+    out.a2 = - out.b1;
 
-	out.a3 = out.b3 = out.c1 = out.c2 = 0.f;
-	out.c3 = 1.f;
+    out.a3 = out.b3 = out.c1 = out.c2 = 0.f;
+    out.c3 = 1.f;
 
-	return out;
+    return out;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -230,10 +230,10 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Rotation( TReal a, const aiVect
 template <typename TReal>
 inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Translation( const aiVector2t<TReal>& v, aiMatrix3x3t<TReal>& out)
 {
-	out = aiMatrix3x3t<TReal>();
-	out.a3 = v.x;
-	out.b3 = v.y;
-	return out;
+    out = aiMatrix3x3t<TReal>();
+    out.a3 = v.x;
+    out.b3 = v.y;
+    return out;
 }
 
 // ----------------------------------------------------------------------------------------
@@ -248,83 +248,83 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Translation( const aiVector2t<T
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
-	const aiVector3t<TReal>& to, aiMatrix3x3t<TReal>& mtx)
+    const aiVector3t<TReal>& to, aiMatrix3x3t<TReal>& mtx)
 {
-	const TReal e = from * to;
-	const TReal f = (e < 0)? -e:e;
-
-	if (f > static_cast<TReal>(1.0) - static_cast<TReal>(0.00001))     /* "from" and "to"-vector almost parallel */
-	{
-		aiVector3D u,v;     /* temporary storage vectors */
-		aiVector3D x;       /* vector most nearly orthogonal to "from" */
-
-		x.x = (from.x > 0.0)? from.x : -from.x;
-		x.y = (from.y > 0.0)? from.y : -from.y;
-		x.z = (from.z > 0.0)? from.z : -from.z;
-
-		if (x.x < x.y)
-		{
-			if (x.x < x.z)
-			{
-				x.x = static_cast<TReal>(1.0); x.y = x.z = static_cast<TReal>(0.0);
-			}
-			else
-			{
-				x.z = static_cast<TReal>(1.0); x.y = x.z = static_cast<TReal>(0.0);
-			}
-		}
-		else
-		{
-			if (x.y < x.z)
-			{
-				x.y = static_cast<TReal>(1.0); x.x = x.z = static_cast<TReal>(0.0);
-			}
-			else
-			{
-				x.z = static_cast<TReal>(1.0); x.x = x.y = static_cast<TReal>(0.0);
-			}
-		}
-
-		u.x = x.x - from.x; u.y = x.y - from.y; u.z = x.z - from.z;
-		v.x = x.x - to.x;   v.y = x.y - to.y;   v.z = x.z - to.z;
-
-		const TReal c1 = static_cast<TReal>(2.0) / (u * u);
-		const TReal c2 = static_cast<TReal>(2.0) / (v * v);
-		const TReal c3 = c1 * c2  * (u * v);
-
-		for (unsigned int i = 0; i < 3; i++)
-		{
-			for (unsigned int j = 0; j < 3; j++)
-			{
-				mtx[i][j] =  - c1 * u[i] * u[j] - c2 * v[i] * v[j]
-					+ c3 * v[i] * u[j];
-			}
-			mtx[i][i] += static_cast<TReal>(1.0);
-		}
-	}
-	else  /* the most common case, unless "from"="to", or "from"=-"to" */
-	{
-		const aiVector3D v = from ^ to;
-		/* ... use this hand optimized version (9 mults less) */
-		const TReal h = static_cast<TReal>(1.0)/(static_cast<TReal>(1.0) + e);      /* optimization by Gottfried Chen */
-		const TReal hvx = h * v.x;
-		const TReal hvz = h * v.z;
-		const TReal hvxy = hvx * v.y;
-		const TReal hvxz = hvx * v.z;
-		const TReal hvyz = hvz * v.y;
-		mtx[0][0] = e + hvx * v.x;
-		mtx[0][1] = hvxy - v.z;
-		mtx[0][2] = hvxz + v.y;
-
-		mtx[1][0] = hvxy + v.z;
-		mtx[1][1] = e + h * v.y * v.y;
-		mtx[1][2] = hvyz - v.x;
-
-		mtx[2][0] = hvxz - v.y;
-		mtx[2][1] = hvyz + v.x;
-		mtx[2][2] = e + hvz * v.z;
-	}
-	return mtx;
+    const TReal e = from * to;
+    const TReal f = (e < 0)? -e:e;
+
+    if (f > static_cast<TReal>(1.0) - static_cast<TReal>(0.00001))     /* "from" and "to"-vector almost parallel */
+    {
+        aiVector3D u,v;     /* temporary storage vectors */
+        aiVector3D x;       /* vector most nearly orthogonal to "from" */
+
+        x.x = (from.x > 0.0)? from.x : -from.x;
+        x.y = (from.y > 0.0)? from.y : -from.y;
+        x.z = (from.z > 0.0)? from.z : -from.z;
+
+        if (x.x < x.y)
+        {
+            if (x.x < x.z)
+            {
+                x.x = static_cast<TReal>(1.0); x.y = x.z = static_cast<TReal>(0.0);
+            }
+            else
+            {
+                x.z = static_cast<TReal>(1.0); x.y = x.z = static_cast<TReal>(0.0);
+            }
+        }
+        else
+        {
+            if (x.y < x.z)
+            {
+                x.y = static_cast<TReal>(1.0); x.x = x.z = static_cast<TReal>(0.0);
+            }
+            else
+            {
+                x.z = static_cast<TReal>(1.0); x.x = x.y = static_cast<TReal>(0.0);
+            }
+        }
+
+        u.x = x.x - from.x; u.y = x.y - from.y; u.z = x.z - from.z;
+        v.x = x.x - to.x;   v.y = x.y - to.y;   v.z = x.z - to.z;
+
+        const TReal c1 = static_cast<TReal>(2.0) / (u * u);
+        const TReal c2 = static_cast<TReal>(2.0) / (v * v);
+        const TReal c3 = c1 * c2  * (u * v);
+
+        for (unsigned int i = 0; i < 3; i++)
+        {
+            for (unsigned int j = 0; j < 3; j++)
+            {
+                mtx[i][j] =  - c1 * u[i] * u[j] - c2 * v[i] * v[j]
+                    + c3 * v[i] * u[j];
+            }
+            mtx[i][i] += static_cast<TReal>(1.0);
+        }
+    }
+    else  /* the most common case, unless "from"="to", or "from"=-"to" */
+    {
+        const aiVector3D v = from ^ to;
+        /* ... use this hand optimized version (9 mults less) */
+        const TReal h = static_cast<TReal>(1.0)/(static_cast<TReal>(1.0) + e);      /* optimization by Gottfried Chen */
+        const TReal hvx = h * v.x;
+        const TReal hvz = h * v.z;
+        const TReal hvxy = hvx * v.y;
+        const TReal hvxz = hvx * v.z;
+        const TReal hvyz = hvz * v.y;
+        mtx[0][0] = e + hvx * v.x;
+        mtx[0][1] = hvxy - v.z;
+        mtx[0][2] = hvxz + v.y;
+
+        mtx[1][0] = hvxy + v.z;
+        mtx[1][1] = e + h * v.y * v.y;
+        mtx[1][2] = hvyz - v.x;
+
+        mtx[2][0] = hvxz - v.y;
+        mtx[2][1] = hvyz + v.x;
+        mtx[2][2] = e + hvz * v.z;
+    }
+    return mtx;
 }
 
 

include/assimp/matrix4x4.h

@@ -67,166 +67,166 @@ class aiMatrix4x4t
 {
 public:
 
-	/** set to identity */
-	aiMatrix4x4t ();
+    /** set to identity */
+    aiMatrix4x4t ();
 
-	/** construction from single values */
-	aiMatrix4x4t (	TReal _a1, TReal _a2, TReal _a3, TReal _a4,
-					TReal _b1, TReal _b2, TReal _b3, TReal _b4,
-					TReal _c1, TReal _c2, TReal _c3, TReal _c4,
-					TReal _d1, TReal _d2, TReal _d3, TReal _d4);
+    /** construction from single values */
+    aiMatrix4x4t (  TReal _a1, TReal _a2, TReal _a3, TReal _a4,
+                    TReal _b1, TReal _b2, TReal _b3, TReal _b4,
+                    TReal _c1, TReal _c2, TReal _c3, TReal _c4,
+                    TReal _d1, TReal _d2, TReal _d3, TReal _d4);
 
 
-	/** construction from 3x3 matrix, remaining elements are set to identity */
-	explicit aiMatrix4x4t( const aiMatrix3x3t<TReal>& m);
+    /** construction from 3x3 matrix, remaining elements are set to identity */
+    explicit aiMatrix4x4t( const aiMatrix3x3t<TReal>& m);
 
-	/** construction from position, rotation and scaling components
-	 * @param scaling The scaling for the x,y,z axes
-	 * @param rotation The rotation as a hamilton quaternion
-	 * @param position The position for the x,y,z axes
-	 */
-	aiMatrix4x4t(const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation,
-		const aiVector3t<TReal>& position);
+    /** construction from position, rotation and scaling components
+     * @param scaling The scaling for the x,y,z axes
+     * @param rotation The rotation as a hamilton quaternion
+     * @param position The position for the x,y,z axes
+     */
+    aiMatrix4x4t(const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation,
+        const aiVector3t<TReal>& position);
 
 public:
 
-	// array access operators
-	TReal* operator[]       (unsigned int p_iIndex);
-	const TReal* operator[] (unsigned int p_iIndex) const;
+    // array access operators
+    TReal* operator[]       (unsigned int p_iIndex);
+    const TReal* operator[] (unsigned int p_iIndex) const;
 
-	// comparison operators
-	bool operator== (const aiMatrix4x4t& m) const;
-	bool operator!= (const aiMatrix4x4t& m) const;
+    // comparison operators
+    bool operator== (const aiMatrix4x4t& m) const;
+    bool operator!= (const aiMatrix4x4t& m) const;
 
-	bool Equal(const aiMatrix4x4t& m, TReal epsilon = 1e-6) const;
+    bool Equal(const aiMatrix4x4t& m, TReal epsilon = 1e-6) const;
 
-	// matrix multiplication.
-	aiMatrix4x4t& operator *= (const aiMatrix4x4t& m);
-	aiMatrix4x4t  operator *  (const aiMatrix4x4t& m) const;
+    // matrix multiplication.
+    aiMatrix4x4t& operator *= (const aiMatrix4x4t& m);
+    aiMatrix4x4t  operator *  (const aiMatrix4x4t& m) const;
 
-	template <typename TOther>
-	operator aiMatrix4x4t<TOther> () const;
+    template <typename TOther>
+    operator aiMatrix4x4t<TOther> () const;
 
 public:
 
-	// -------------------------------------------------------------------
-	/** @brief Transpose the matrix */
-	aiMatrix4x4t& Transpose();
-
-	// -------------------------------------------------------------------
-	/** @brief Invert the matrix.
-	 *  If the matrix is not invertible all elements are set to qnan.
-	 *  Beware, use (f != f) to check whether a TReal f is qnan.
-	 */
-	aiMatrix4x4t& Inverse();
-	TReal Determinant() const;
-
-
-	// -------------------------------------------------------------------
-	/** @brief Returns true of the matrix is the identity matrix.
-	 *  The check is performed against a not so small epsilon.
-	 */
-	inline bool IsIdentity() const;
-
-	// -------------------------------------------------------------------
-	/** @brief Decompose a trafo matrix into its original components
-	 *  @param scaling Receives the output scaling for the x,y,z axes
-	 *  @param rotation Receives the output rotation as a hamilton
-	 *   quaternion
-	 *  @param position Receives the output position for the x,y,z axes
-	 */
-	void Decompose (aiVector3t<TReal>& scaling, aiQuaterniont<TReal>& rotation,
-		aiVector3t<TReal>& position) const;
-
-	// -------------------------------------------------------------------
-	/** @brief Decompose a trafo matrix with no scaling into its
-	 *    original components
-	 *  @param rotation Receives the output rotation as a hamilton
-	 *    quaternion
-	 *  @param position Receives the output position for the x,y,z axes
-	 */
-	void DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
-		aiVector3t<TReal>& position) const;
-
-
-	// -------------------------------------------------------------------
-	/** @brief Creates a trafo matrix from a set of euler angles
-	 *  @param x Rotation angle for the x-axis, in radians
-	 *  @param y Rotation angle for the y-axis, in radians
-	 *  @param z Rotation angle for the z-axis, in radians
-	 */
-	aiMatrix4x4t& FromEulerAnglesXYZ(TReal x, TReal y, TReal z);
-	aiMatrix4x4t& FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb);
+    // -------------------------------------------------------------------
+    /** @brief Transpose the matrix */
+    aiMatrix4x4t& Transpose();
+
+    // -------------------------------------------------------------------
+    /** @brief Invert the matrix.
+     *  If the matrix is not invertible all elements are set to qnan.
+     *  Beware, use (f != f) to check whether a TReal f is qnan.
+     */
+    aiMatrix4x4t& Inverse();
+    TReal Determinant() const;
+
+
+    // -------------------------------------------------------------------
+    /** @brief Returns true of the matrix is the identity matrix.
+     *  The check is performed against a not so small epsilon.
+     */
+    inline bool IsIdentity() const;
+
+    // -------------------------------------------------------------------
+    /** @brief Decompose a trafo matrix into its original components
+     *  @param scaling Receives the output scaling for the x,y,z axes
+     *  @param rotation Receives the output rotation as a hamilton
+     *   quaternion
+     *  @param position Receives the output position for the x,y,z axes
+     */
+    void Decompose (aiVector3t<TReal>& scaling, aiQuaterniont<TReal>& rotation,
+        aiVector3t<TReal>& position) const;
+
+    // -------------------------------------------------------------------
+    /** @brief Decompose a trafo matrix with no scaling into its
+     *    original components
+     *  @param rotation Receives the output rotation as a hamilton
+     *    quaternion
+     *  @param position Receives the output position for the x,y,z axes
+     */
+    void DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
+        aiVector3t<TReal>& position) const;
+
+
+    // -------------------------------------------------------------------
+    /** @brief Creates a trafo matrix from a set of euler angles
+     *  @param x Rotation angle for the x-axis, in radians
+     *  @param y Rotation angle for the y-axis, in radians
+     *  @param z Rotation angle for the z-axis, in radians
+     */
+    aiMatrix4x4t& FromEulerAnglesXYZ(TReal x, TReal y, TReal z);
+    aiMatrix4x4t& FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb);
 
 public:
-	// -------------------------------------------------------------------
-	/** @brief Returns a rotation matrix for a rotation around the x axis
-	 *  @param a Rotation angle, in radians
-	 *  @param out Receives the output matrix
-	 *  @return Reference to the output matrix
-	 */
-	static aiMatrix4x4t& RotationX(TReal a, aiMatrix4x4t& out);
-
-	// -------------------------------------------------------------------
-	/** @brief Returns a rotation matrix for a rotation around the y axis
-	 *  @param a Rotation angle, in radians
-	 *  @param out Receives the output matrix
-	 *  @return Reference to the output matrix
-	 */
-	static aiMatrix4x4t& RotationY(TReal a, aiMatrix4x4t& out);
-
-	// -------------------------------------------------------------------
-	/** @brief Returns a rotation matrix for a rotation around the z axis
-	 *  @param a Rotation angle, in radians
-	 *  @param out Receives the output matrix
-	 *  @return Reference to the output matrix
-	 */
-	static aiMatrix4x4t& RotationZ(TReal a, aiMatrix4x4t& out);
-
-	// -------------------------------------------------------------------
-	/** Returns a rotation matrix for a rotation around an arbitrary axis.
-	 *  @param a Rotation angle, in radians
-	 *  @param axis Rotation axis, should be a normalized vector.
-	 *  @param out Receives the output matrix
-	 *  @return Reference to the output matrix
-	 */
-	static aiMatrix4x4t& Rotation(TReal a, const aiVector3t<TReal>& axis,
-		aiMatrix4x4t& out);
-
-	// -------------------------------------------------------------------
-	/** @brief Returns a translation matrix
-	 *  @param v Translation vector
-	 *  @param out Receives the output matrix
-	 *  @return Reference to the output matrix
-	 */
-	static aiMatrix4x4t& Translation( const aiVector3t<TReal>& v, aiMatrix4x4t& out);
-
-	// -------------------------------------------------------------------
-	/** @brief Returns a scaling matrix
-	 *  @param v Scaling vector
-	 *  @param out Receives the output matrix
-	 *  @return Reference to the output matrix
-	 */
-	static aiMatrix4x4t& Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t& out);
-
-	// -------------------------------------------------------------------
-	/** @brief A function for creating a rotation matrix that rotates a
-	 *  vector called "from" into another vector called "to".
-	 * Input : from[3], to[3] which both must be *normalized* non-zero vectors
-	 * Output: mtx[3][3] -- a 3x3 matrix in colum-major form
-	 * Authors: Tomas Möller, John Hughes
-	 *          "Efficiently Building a Matrix to Rotate One Vector to Another"
-	 *          Journal of Graphics Tools, 4(4):1-4, 1999
-	 */
-	static aiMatrix4x4t& FromToMatrix(const aiVector3t<TReal>& from,
-		const aiVector3t<TReal>& to, aiMatrix4x4t& out);
+    // -------------------------------------------------------------------
+    /** @brief Returns a rotation matrix for a rotation around the x axis
+     *  @param a Rotation angle, in radians
+     *  @param out Receives the output matrix
+     *  @return Reference to the output matrix
+     */
+    static aiMatrix4x4t& RotationX(TReal a, aiMatrix4x4t& out);
+
+    // -------------------------------------------------------------------
+    /** @brief Returns a rotation matrix for a rotation around the y axis
+     *  @param a Rotation angle, in radians
+     *  @param out Receives the output matrix
+     *  @return Reference to the output matrix
+     */
+    static aiMatrix4x4t& RotationY(TReal a, aiMatrix4x4t& out);
+
+    // -------------------------------------------------------------------
+    /** @brief Returns a rotation matrix for a rotation around the z axis
+     *  @param a Rotation angle, in radians
+     *  @param out Receives the output matrix
+     *  @return Reference to the output matrix
+     */
+    static aiMatrix4x4t& RotationZ(TReal a, aiMatrix4x4t& out);
+
+    // -------------------------------------------------------------------
+    /** Returns a rotation matrix for a rotation around an arbitrary axis.
+     *  @param a Rotation angle, in radians
+     *  @param axis Rotation axis, should be a normalized vector.
+     *  @param out Receives the output matrix
+     *  @return Reference to the output matrix
+     */
+    static aiMatrix4x4t& Rotation(TReal a, const aiVector3t<TReal>& axis,
+        aiMatrix4x4t& out);
+
+    // -------------------------------------------------------------------
+    /** @brief Returns a translation matrix
+     *  @param v Translation vector
+     *  @param out Receives the output matrix
+     *  @return Reference to the output matrix
+     */
+    static aiMatrix4x4t& Translation( const aiVector3t<TReal>& v, aiMatrix4x4t& out);
+
+    // -------------------------------------------------------------------
+    /** @brief Returns a scaling matrix
+     *  @param v Scaling vector
+     *  @param out Receives the output matrix
+     *  @return Reference to the output matrix
+     */
+    static aiMatrix4x4t& Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t& out);
+
+    // -------------------------------------------------------------------
+    /** @brief A function for creating a rotation matrix that rotates a
+     *  vector called "from" into another vector called "to".
+     * Input : from[3], to[3] which both must be *normalized* non-zero vectors
+     * Output: mtx[3][3] -- a 3x3 matrix in colum-major form
+     * Authors: Tomas Möller, John Hughes
+     *          "Efficiently Building a Matrix to Rotate One Vector to Another"
+     *          Journal of Graphics Tools, 4(4):1-4, 1999
+     */
+    static aiMatrix4x4t& FromToMatrix(const aiVector3t<TReal>& from,
+        const aiVector3t<TReal>& to, aiMatrix4x4t& out);
 
 public:
 
-	TReal a1, a2, a3, a4;
-	TReal b1, b2, b3, b4;
-	TReal c1, c2, c3, c4;
-	TReal d1, d2, d3, d4;
+    TReal a1, a2, a3, a4;
+    TReal b1, b2, b3, b4;
+    TReal c1, c2, c3, c4;
+    TReal d1, d2, d3, d4;
 
 } PACK_STRUCT;
 
@@ -235,10 +235,10 @@ typedef aiMatrix4x4t<float> aiMatrix4x4;
 #else
 
 struct aiMatrix4x4 {
-	float a1, a2, a3, a4;
-	float b1, b2, b3, b4;
-	float c1, c2, c3, c4;
-	float d1, d2, d3, d4;
+    float a1, a2, a3, a4;
+    float b1, b2, b3, b4;
+    float c1, c2, c3, c4;
+    float d1, d2, d3, d4;
 };
 
 

include/assimp/matrix4x4.inl

@@ -58,10 +58,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 aiMatrix4x4t<TReal> ::aiMatrix4x4t () :
-	a1(1.0f), a2(), a3(), a4(),
-	b1(), b2(1.0f), b3(), b4(),
-	c1(), c2(), c3(1.0f), c4(),
-	d1(), d2(), d3(), d4(1.0f)
+    a1(1.0f), a2(), a3(), a4(),
+    b1(), b2(1.0f), b3(), b4(),
+    c1(), c2(), c3(1.0f), c4(),
+    d1(), d2(), d3(), d4(1.0f)
 {
 
 }
@@ -69,13 +69,13 @@ aiMatrix4x4t<TReal> ::aiMatrix4x4t () :
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 aiMatrix4x4t<TReal> ::aiMatrix4x4t (TReal _a1, TReal _a2, TReal _a3, TReal _a4,
-			  TReal _b1, TReal _b2, TReal _b3, TReal _b4,
-			  TReal _c1, TReal _c2, TReal _c3, TReal _c4,
-			  TReal _d1, TReal _d2, TReal _d3, TReal _d4) :
-	a1(_a1), a2(_a2), a3(_a3), a4(_a4),
-	b1(_b1), b2(_b2), b3(_b3), b4(_b4),
-	c1(_c1), c2(_c2), c3(_c3), c4(_c4),
-	d1(_d1), d2(_d2), d3(_d3), d4(_d4)
+              TReal _b1, TReal _b2, TReal _b3, TReal _b4,
+              TReal _c1, TReal _c2, TReal _c3, TReal _c4,
+              TReal _d1, TReal _d2, TReal _d3, TReal _d4) :
+    a1(_a1), a2(_a2), a3(_a3), a4(_a4),
+    b1(_b1), b2(_b2), b3(_b3), b4(_b4),
+    c1(_c1), c2(_c2), c3(_c3), c4(_c4),
+    d1(_d1), d2(_d2), d3(_d3), d4(_d4)
 {
 
 }
@@ -85,10 +85,10 @@ template <typename TReal>
 template <typename TOther>
 aiMatrix4x4t<TReal>::operator aiMatrix4x4t<TOther> () const
 {
-	return aiMatrix4x4t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),static_cast<TOther>(a4),
-		static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),static_cast<TOther>(b4),
-		static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3),static_cast<TOther>(c4),
-		static_cast<TOther>(d1),static_cast<TOther>(d2),static_cast<TOther>(d3),static_cast<TOther>(d4));
+    return aiMatrix4x4t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),static_cast<TOther>(a4),
+        static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),static_cast<TOther>(b4),
+        static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3),static_cast<TOther>(c4),
+        static_cast<TOther>(d1),static_cast<TOther>(d2),static_cast<TOther>(d3),static_cast<TOther>(d4));
 }
 
 
@@ -96,71 +96,71 @@ aiMatrix4x4t<TReal>::operator aiMatrix4x4t<TOther> () const
 template <typename TReal>
 inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiMatrix3x3t<TReal>& m)
 {
-	a1 = m.a1; a2 = m.a2; a3 = m.a3; a4 = static_cast<TReal>(0.0);
-	b1 = m.b1; b2 = m.b2; b3 = m.b3; b4 = static_cast<TReal>(0.0);
-	c1 = m.c1; c2 = m.c2; c3 = m.c3; c4 = static_cast<TReal>(0.0);
-	d1 = static_cast<TReal>(0.0); d2 = static_cast<TReal>(0.0); d3 = static_cast<TReal>(0.0); d4 = static_cast<TReal>(1.0);
+    a1 = m.a1; a2 = m.a2; a3 = m.a3; a4 = static_cast<TReal>(0.0);
+    b1 = m.b1; b2 = m.b2; b3 = m.b3; b4 = static_cast<TReal>(0.0);
+    c1 = m.c1; c2 = m.c2; c3 = m.c3; c4 = static_cast<TReal>(0.0);
+    d1 = static_cast<TReal>(0.0); d2 = static_cast<TReal>(0.0); d3 = static_cast<TReal>(0.0); d4 = static_cast<TReal>(1.0);
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation, const aiVector3t<TReal>& position)
 {
-	// build a 3x3 rotation matrix
-	aiMatrix3x3t<TReal> m = rotation.GetMatrix();
-
-	a1 = m.a1 * scaling.x;
-	a2 = m.a2 * scaling.x;
-	a3 = m.a3 * scaling.x;
-	a4 = position.x;
-
-	b1 = m.b1 * scaling.y;
-	b2 = m.b2 * scaling.y;
-	b3 = m.b3 * scaling.y;
-	b4 = position.y;
-
-	c1 = m.c1 * scaling.z;
-	c2 = m.c2 * scaling.z;
-	c3 = m.c3 * scaling.z;
-	c4= position.z;
-
-	d1 = static_cast<TReal>(0.0);
-	d2 = static_cast<TReal>(0.0);
-	d3 = static_cast<TReal>(0.0);
-	d4 = static_cast<TReal>(1.0);
+    // build a 3x3 rotation matrix
+    aiMatrix3x3t<TReal> m = rotation.GetMatrix();
+
+    a1 = m.a1 * scaling.x;
+    a2 = m.a2 * scaling.x;
+    a3 = m.a3 * scaling.x;
+    a4 = position.x;
+
+    b1 = m.b1 * scaling.y;
+    b2 = m.b2 * scaling.y;
+    b3 = m.b3 * scaling.y;
+    b4 = position.y;
+
+    c1 = m.c1 * scaling.z;
+    c2 = m.c2 * scaling.z;
+    c3 = m.c3 * scaling.z;
+    c4= position.z;
+
+    d1 = static_cast<TReal>(0.0);
+    d2 = static_cast<TReal>(0.0);
+    d3 = static_cast<TReal>(0.0);
+    d4 = static_cast<TReal>(1.0);
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::operator *= (const aiMatrix4x4t<TReal>& m)
 {
-	*this = aiMatrix4x4t<TReal>(
-		m.a1 * a1 + m.b1 * a2 + m.c1 * a3 + m.d1 * a4,
-		m.a2 * a1 + m.b2 * a2 + m.c2 * a3 + m.d2 * a4,
-		m.a3 * a1 + m.b3 * a2 + m.c3 * a3 + m.d3 * a4,
-		m.a4 * a1 + m.b4 * a2 + m.c4 * a3 + m.d4 * a4,
-		m.a1 * b1 + m.b1 * b2 + m.c1 * b3 + m.d1 * b4,
-		m.a2 * b1 + m.b2 * b2 + m.c2 * b3 + m.d2 * b4,
-		m.a3 * b1 + m.b3 * b2 + m.c3 * b3 + m.d3 * b4,
-		m.a4 * b1 + m.b4 * b2 + m.c4 * b3 + m.d4 * b4,
-		m.a1 * c1 + m.b1 * c2 + m.c1 * c3 + m.d1 * c4,
-		m.a2 * c1 + m.b2 * c2 + m.c2 * c3 + m.d2 * c4,
-		m.a3 * c1 + m.b3 * c2 + m.c3 * c3 + m.d3 * c4,
-		m.a4 * c1 + m.b4 * c2 + m.c4 * c3 + m.d4 * c4,
-		m.a1 * d1 + m.b1 * d2 + m.c1 * d3 + m.d1 * d4,
-		m.a2 * d1 + m.b2 * d2 + m.c2 * d3 + m.d2 * d4,
-		m.a3 * d1 + m.b3 * d2 + m.c3 * d3 + m.d3 * d4,
-		m.a4 * d1 + m.b4 * d2 + m.c4 * d3 + m.d4 * d4);
-	return *this;
+    *this = aiMatrix4x4t<TReal>(
+        m.a1 * a1 + m.b1 * a2 + m.c1 * a3 + m.d1 * a4,
+        m.a2 * a1 + m.b2 * a2 + m.c2 * a3 + m.d2 * a4,
+        m.a3 * a1 + m.b3 * a2 + m.c3 * a3 + m.d3 * a4,
+        m.a4 * a1 + m.b4 * a2 + m.c4 * a3 + m.d4 * a4,
+        m.a1 * b1 + m.b1 * b2 + m.c1 * b3 + m.d1 * b4,
+        m.a2 * b1 + m.b2 * b2 + m.c2 * b3 + m.d2 * b4,
+        m.a3 * b1 + m.b3 * b2 + m.c3 * b3 + m.d3 * b4,
+        m.a4 * b1 + m.b4 * b2 + m.c4 * b3 + m.d4 * b4,
+        m.a1 * c1 + m.b1 * c2 + m.c1 * c3 + m.d1 * c4,
+        m.a2 * c1 + m.b2 * c2 + m.c2 * c3 + m.d2 * c4,
+        m.a3 * c1 + m.b3 * c2 + m.c3 * c3 + m.d3 * c4,
+        m.a4 * c1 + m.b4 * c2 + m.c4 * c3 + m.d4 * c4,
+        m.a1 * d1 + m.b1 * d2 + m.c1 * d3 + m.d1 * d4,
+        m.a2 * d1 + m.b2 * d2 + m.c2 * d3 + m.d2 * d4,
+        m.a3 * d1 + m.b3 * d2 + m.c3 * d3 + m.d3 * d4,
+        m.a4 * d1 + m.b4 * d2 + m.c4 * d3 + m.d4 * d4);
+    return *this;
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const aiMatrix4x4t<TReal>& m) const
 {
-	aiMatrix4x4t<TReal> temp( *this);
-	temp *= m;
-	return temp;
+    aiMatrix4x4t<TReal> temp( *this);
+    temp *= m;
+    return temp;
 }
 
 
@@ -168,14 +168,14 @@ inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const aiMatrix4x4t<TR
 template <typename TReal>
 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Transpose()
 {
-	// (TReal&) don't remove, GCC complains cause of packed fields
-	std::swap( (TReal&)b1, (TReal&)a2);
-	std::swap( (TReal&)c1, (TReal&)a3);
-	std::swap( (TReal&)c2, (TReal&)b3);
-	std::swap( (TReal&)d1, (TReal&)a4);
-	std::swap( (TReal&)d2, (TReal&)b4);
-	std::swap( (TReal&)d3, (TReal&)c4);
-	return *this;
+    // (TReal&) don't remove, GCC complains cause of packed fields
+    std::swap( (TReal&)b1, (TReal&)a2);
+    std::swap( (TReal&)c1, (TReal&)a3);
+    std::swap( (TReal&)c2, (TReal&)b3);
+    std::swap( (TReal&)d1, (TReal&)a4);
+    std::swap( (TReal&)d2, (TReal&)b4);
+    std::swap( (TReal&)d3, (TReal&)c4);
+    return *this;
 }
 
 
@@ -183,291 +183,291 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Transpose()
 template <typename TReal>
 inline TReal aiMatrix4x4t<TReal>::Determinant() const
 {
-	return a1*b2*c3*d4 - a1*b2*c4*d3 + a1*b3*c4*d2 - a1*b3*c2*d4
-		+ a1*b4*c2*d3 - a1*b4*c3*d2 - a2*b3*c4*d1 + a2*b3*c1*d4
-		- a2*b4*c1*d3 + a2*b4*c3*d1 - a2*b1*c3*d4 + a2*b1*c4*d3
-		+ a3*b4*c1*d2 - a3*b4*c2*d1 + a3*b1*c2*d4 - a3*b1*c4*d2
-		+ a3*b2*c4*d1 - a3*b2*c1*d4 - a4*b1*c2*d3 + a4*b1*c3*d2
-		- a4*b2*c3*d1 + a4*b2*c1*d3 - a4*b3*c1*d2 + a4*b3*c2*d1;
+    return a1*b2*c3*d4 - a1*b2*c4*d3 + a1*b3*c4*d2 - a1*b3*c2*d4
+        + a1*b4*c2*d3 - a1*b4*c3*d2 - a2*b3*c4*d1 + a2*b3*c1*d4
+        - a2*b4*c1*d3 + a2*b4*c3*d1 - a2*b1*c3*d4 + a2*b1*c4*d3
+        + a3*b4*c1*d2 - a3*b4*c2*d1 + a3*b1*c2*d4 - a3*b1*c4*d2
+        + a3*b2*c4*d1 - a3*b2*c1*d4 - a4*b1*c2*d3 + a4*b1*c3*d2
+        - a4*b2*c3*d1 + a4*b2*c1*d3 - a4*b3*c1*d2 + a4*b3*c2*d1;
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Inverse()
 {
-	// Compute the reciprocal determinant
-	const TReal det = Determinant();
-	if(det == static_cast<TReal>(0.0))
-	{
-		// Matrix not invertible. Setting all elements to nan is not really
-		// correct in a mathematical sense but it is easy to debug for the
-		// programmer.
-		const TReal nan = std::numeric_limits<TReal>::quiet_NaN();
-		*this = aiMatrix4x4t<TReal>(
-			nan,nan,nan,nan,
-			nan,nan,nan,nan,
-			nan,nan,nan,nan,
-			nan,nan,nan,nan);
-
-		return *this;
-	}
-
-	const TReal invdet = static_cast<TReal>(1.0) / det;
-
-	aiMatrix4x4t<TReal> res;
-	res.a1 = invdet  * (b2 * (c3 * d4 - c4 * d3) + b3 * (c4 * d2 - c2 * d4) + b4 * (c2 * d3 - c3 * d2));
-	res.a2 = -invdet * (a2 * (c3 * d4 - c4 * d3) + a3 * (c4 * d2 - c2 * d4) + a4 * (c2 * d3 - c3 * d2));
-	res.a3 = invdet  * (a2 * (b3 * d4 - b4 * d3) + a3 * (b4 * d2 - b2 * d4) + a4 * (b2 * d3 - b3 * d2));
-	res.a4 = -invdet * (a2 * (b3 * c4 - b4 * c3) + a3 * (b4 * c2 - b2 * c4) + a4 * (b2 * c3 - b3 * c2));
-	res.b1 = -invdet * (b1 * (c3 * d4 - c4 * d3) + b3 * (c4 * d1 - c1 * d4) + b4 * (c1 * d3 - c3 * d1));
-	res.b2 = invdet  * (a1 * (c3 * d4 - c4 * d3) + a3 * (c4 * d1 - c1 * d4) + a4 * (c1 * d3 - c3 * d1));
-	res.b3 = -invdet * (a1 * (b3 * d4 - b4 * d3) + a3 * (b4 * d1 - b1 * d4) + a4 * (b1 * d3 - b3 * d1));
-	res.b4 = invdet  * (a1 * (b3 * c4 - b4 * c3) + a3 * (b4 * c1 - b1 * c4) + a4 * (b1 * c3 - b3 * c1));
-	res.c1 = invdet  * (b1 * (c2 * d4 - c4 * d2) + b2 * (c4 * d1 - c1 * d4) + b4 * (c1 * d2 - c2 * d1));
-	res.c2 = -invdet * (a1 * (c2 * d4 - c4 * d2) + a2 * (c4 * d1 - c1 * d4) + a4 * (c1 * d2 - c2 * d1));
-	res.c3 = invdet  * (a1 * (b2 * d4 - b4 * d2) + a2 * (b4 * d1 - b1 * d4) + a4 * (b1 * d2 - b2 * d1));
-	res.c4 = -invdet * (a1 * (b2 * c4 - b4 * c2) + a2 * (b4 * c1 - b1 * c4) + a4 * (b1 * c2 - b2 * c1));
-	res.d1 = -invdet * (b1 * (c2 * d3 - c3 * d2) + b2 * (c3 * d1 - c1 * d3) + b3 * (c1 * d2 - c2 * d1));
-	res.d2 = invdet  * (a1 * (c2 * d3 - c3 * d2) + a2 * (c3 * d1 - c1 * d3) + a3 * (c1 * d2 - c2 * d1));
-	res.d3 = -invdet * (a1 * (b2 * d3 - b3 * d2) + a2 * (b3 * d1 - b1 * d3) + a3 * (b1 * d2 - b2 * d1));
-	res.d4 = invdet  * (a1 * (b2 * c3 - b3 * c2) + a2 * (b3 * c1 - b1 * c3) + a3 * (b1 * c2 - b2 * c1));
-	*this = res;
-
-	return *this;
+    // Compute the reciprocal determinant
+    const TReal det = Determinant();
+    if(det == static_cast<TReal>(0.0))
+    {
+        // Matrix not invertible. Setting all elements to nan is not really
+        // correct in a mathematical sense but it is easy to debug for the
+        // programmer.
+        const TReal nan = std::numeric_limits<TReal>::quiet_NaN();
+        *this = aiMatrix4x4t<TReal>(
+            nan,nan,nan,nan,
+            nan,nan,nan,nan,
+            nan,nan,nan,nan,
+            nan,nan,nan,nan);
+
+        return *this;
+    }
+
+    const TReal invdet = static_cast<TReal>(1.0) / det;
+
+    aiMatrix4x4t<TReal> res;
+    res.a1 = invdet  * (b2 * (c3 * d4 - c4 * d3) + b3 * (c4 * d2 - c2 * d4) + b4 * (c2 * d3 - c3 * d2));
+    res.a2 = -invdet * (a2 * (c3 * d4 - c4 * d3) + a3 * (c4 * d2 - c2 * d4) + a4 * (c2 * d3 - c3 * d2));
+    res.a3 = invdet  * (a2 * (b3 * d4 - b4 * d3) + a3 * (b4 * d2 - b2 * d4) + a4 * (b2 * d3 - b3 * d2));
+    res.a4 = -invdet * (a2 * (b3 * c4 - b4 * c3) + a3 * (b4 * c2 - b2 * c4) + a4 * (b2 * c3 - b3 * c2));
+    res.b1 = -invdet * (b1 * (c3 * d4 - c4 * d3) + b3 * (c4 * d1 - c1 * d4) + b4 * (c1 * d3 - c3 * d1));
+    res.b2 = invdet  * (a1 * (c3 * d4 - c4 * d3) + a3 * (c4 * d1 - c1 * d4) + a4 * (c1 * d3 - c3 * d1));
+    res.b3 = -invdet * (a1 * (b3 * d4 - b4 * d3) + a3 * (b4 * d1 - b1 * d4) + a4 * (b1 * d3 - b3 * d1));
+    res.b4 = invdet  * (a1 * (b3 * c4 - b4 * c3) + a3 * (b4 * c1 - b1 * c4) + a4 * (b1 * c3 - b3 * c1));
+    res.c1 = invdet  * (b1 * (c2 * d4 - c4 * d2) + b2 * (c4 * d1 - c1 * d4) + b4 * (c1 * d2 - c2 * d1));
+    res.c2 = -invdet * (a1 * (c2 * d4 - c4 * d2) + a2 * (c4 * d1 - c1 * d4) + a4 * (c1 * d2 - c2 * d1));
+    res.c3 = invdet  * (a1 * (b2 * d4 - b4 * d2) + a2 * (b4 * d1 - b1 * d4) + a4 * (b1 * d2 - b2 * d1));
+    res.c4 = -invdet * (a1 * (b2 * c4 - b4 * c2) + a2 * (b4 * c1 - b1 * c4) + a4 * (b1 * c2 - b2 * c1));
+    res.d1 = -invdet * (b1 * (c2 * d3 - c3 * d2) + b2 * (c3 * d1 - c1 * d3) + b3 * (c1 * d2 - c2 * d1));
+    res.d2 = invdet  * (a1 * (c2 * d3 - c3 * d2) + a2 * (c3 * d1 - c1 * d3) + a3 * (c1 * d2 - c2 * d1));
+    res.d3 = -invdet * (a1 * (b2 * d3 - b3 * d2) + a2 * (b3 * d1 - b1 * d3) + a3 * (b1 * d2 - b2 * d1));
+    res.d4 = invdet  * (a1 * (b2 * c3 - b3 * c2) + a2 * (b3 * c1 - b1 * c3) + a3 * (b1 * c2 - b2 * c1));
+    *this = res;
+
+    return *this;
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex)
 {
-	// XXX this is UB. Has been for years. The fact that it works now does not make it better.
-	return &this->a1 + p_iIndex * 4;
+    // XXX this is UB. Has been for years. The fact that it works now does not make it better.
+    return &this->a1 + p_iIndex * 4;
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline const TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) const
 {
-	// XXX same
-	return &this->a1 + p_iIndex * 4;
+    // XXX same
+    return &this->a1 + p_iIndex * 4;
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline bool aiMatrix4x4t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const
 {
-	return (a1 == m.a1 && a2 == m.a2 && a3 == m.a3 && a4 == m.a4 &&
-			b1 == m.b1 && b2 == m.b2 && b3 == m.b3 && b4 == m.b4 &&
-			c1 == m.c1 && c2 == m.c2 && c3 == m.c3 && c4 == m.c4 &&
-			d1 == m.d1 && d2 == m.d2 && d3 == m.d3 && d4 == m.d4);
+    return (a1 == m.a1 && a2 == m.a2 && a3 == m.a3 && a4 == m.a4 &&
+            b1 == m.b1 && b2 == m.b2 && b3 == m.b3 && b4 == m.b4 &&
+            c1 == m.c1 && c2 == m.c2 && c3 == m.c3 && c4 == m.c4 &&
+            d1 == m.d1 && d2 == m.d2 && d3 == m.d3 && d4 == m.d4);
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline bool aiMatrix4x4t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const
 {
-	return !(*this == m);
+    return !(*this == m);
 }
 
 // ---------------------------------------------------------------------------
 template<typename TReal>
 inline bool aiMatrix4x4t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
-	return
-		std::abs(a1 - m.a1) <= epsilon &&
-		std::abs(a2 - m.a2) <= epsilon &&
-		std::abs(a3 - m.a3) <= epsilon &&
-		std::abs(a4 - m.a4) <= epsilon &&
-		std::abs(b1 - m.b1) <= epsilon &&
-		std::abs(b2 - m.b2) <= epsilon &&
-		std::abs(b3 - m.b3) <= epsilon &&
-		std::abs(b4 - m.b4) <= epsilon &&
-		std::abs(c1 - m.c1) <= epsilon &&
-		std::abs(c2 - m.c2) <= epsilon &&
-		std::abs(c3 - m.c3) <= epsilon &&
-		std::abs(c4 - m.c4) <= epsilon &&
-		std::abs(d1 - m.d1) <= epsilon &&
-		std::abs(d2 - m.d2) <= epsilon &&
-		std::abs(d3 - m.d3) <= epsilon &&
-		std::abs(d4 - m.d4) <= epsilon;
+    return
+        std::abs(a1 - m.a1) <= epsilon &&
+        std::abs(a2 - m.a2) <= epsilon &&
+        std::abs(a3 - m.a3) <= epsilon &&
+        std::abs(a4 - m.a4) <= epsilon &&
+        std::abs(b1 - m.b1) <= epsilon &&
+        std::abs(b2 - m.b2) <= epsilon &&
+        std::abs(b3 - m.b3) <= epsilon &&
+        std::abs(b4 - m.b4) <= epsilon &&
+        std::abs(c1 - m.c1) <= epsilon &&
+        std::abs(c2 - m.c2) <= epsilon &&
+        std::abs(c3 - m.c3) <= epsilon &&
+        std::abs(c4 - m.c4) <= epsilon &&
+        std::abs(d1 - m.d1) <= epsilon &&
+        std::abs(d2 - m.d2) <= epsilon &&
+        std::abs(d3 - m.d3) <= epsilon &&
+        std::abs(d4 - m.d4) <= epsilon;
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline void aiMatrix4x4t<TReal>::Decompose (aiVector3t<TReal>& scaling, aiQuaterniont<TReal>& rotation,
-	aiVector3t<TReal>& position) const
+    aiVector3t<TReal>& position) const
 {
-	const aiMatrix4x4t<TReal>& _this = *this;
-
-	// extract translation
-	position.x = _this[0][3];
-	position.y = _this[1][3];
-	position.z = _this[2][3];
-
-	// extract the rows of the matrix
-	aiVector3t<TReal> vRows[3] = {
-		aiVector3t<TReal>(_this[0][0],_this[1][0],_this[2][0]),
-		aiVector3t<TReal>(_this[0][1],_this[1][1],_this[2][1]),
-		aiVector3t<TReal>(_this[0][2],_this[1][2],_this[2][2])
-	};
-
-	// extract the scaling factors
-	scaling.x = vRows[0].Length();
-	scaling.y = vRows[1].Length();
-	scaling.z = vRows[2].Length();
-
-	// and the sign of the scaling
-	if (Determinant() < 0) {
-		scaling.x = -scaling.x;
-		scaling.y = -scaling.y;
-		scaling.z = -scaling.z;
-	}
-
-	// and remove all scaling from the matrix
-	if(scaling.x)
-	{
-		vRows[0] /= scaling.x;
-	}
-	if(scaling.y)
-	{
-		vRows[1] /= scaling.y;
-	}
-	if(scaling.z)
-	{
-		vRows[2] /= scaling.z;
-	}
-
-	// build a 3x3 rotation matrix
-	aiMatrix3x3t<TReal> m(vRows[0].x,vRows[1].x,vRows[2].x,
-		vRows[0].y,vRows[1].y,vRows[2].y,
-		vRows[0].z,vRows[1].z,vRows[2].z);
-
-	// and generate the rotation quaternion from it
-	rotation = aiQuaterniont<TReal>(m);
+    const aiMatrix4x4t<TReal>& _this = *this;
+
+    // extract translation
+    position.x = _this[0][3];
+    position.y = _this[1][3];
+    position.z = _this[2][3];
+
+    // extract the rows of the matrix
+    aiVector3t<TReal> vRows[3] = {
+        aiVector3t<TReal>(_this[0][0],_this[1][0],_this[2][0]),
+        aiVector3t<TReal>(_this[0][1],_this[1][1],_this[2][1]),
+        aiVector3t<TReal>(_this[0][2],_this[1][2],_this[2][2])
+    };
+
+    // extract the scaling factors
+    scaling.x = vRows[0].Length();
+    scaling.y = vRows[1].Length();
+    scaling.z = vRows[2].Length();
+
+    // and the sign of the scaling
+    if (Determinant() < 0) {
+        scaling.x = -scaling.x;
+        scaling.y = -scaling.y;
+        scaling.z = -scaling.z;
+    }
+
+    // and remove all scaling from the matrix
+    if(scaling.x)
+    {
+        vRows[0] /= scaling.x;
+    }
+    if(scaling.y)
+    {
+        vRows[1] /= scaling.y;
+    }
+    if(scaling.z)
+    {
+        vRows[2] /= scaling.z;
+    }
+
+    // build a 3x3 rotation matrix
+    aiMatrix3x3t<TReal> m(vRows[0].x,vRows[1].x,vRows[2].x,
+        vRows[0].y,vRows[1].y,vRows[2].y,
+        vRows[0].z,vRows[1].z,vRows[2].z);
+
+    // and generate the rotation quaternion from it
+    rotation = aiQuaterniont<TReal>(m);
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline void aiMatrix4x4t<TReal>::DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
-	aiVector3t<TReal>& position) const
+    aiVector3t<TReal>& position) const
 {
-	const aiMatrix4x4t<TReal>& _this = *this;
+    const aiMatrix4x4t<TReal>& _this = *this;
 
-	// extract translation
-	position.x = _this[0][3];
-	position.y = _this[1][3];
-	position.z = _this[2][3];
+    // extract translation
+    position.x = _this[0][3];
+    position.y = _this[1][3];
+    position.z = _this[2][3];
 
-	// extract rotation
-	rotation = aiQuaterniont<TReal>((aiMatrix3x3t<TReal>)_this);
+    // extract rotation
+    rotation = aiQuaterniont<TReal>((aiMatrix3x3t<TReal>)_this);
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb)
 {
-	return FromEulerAnglesXYZ(blubb.x,blubb.y,blubb.z);
+    return FromEulerAnglesXYZ(blubb.x,blubb.y,blubb.z);
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(TReal x, TReal y, TReal z)
 {
-	aiMatrix4x4t<TReal>& _this = *this;
+    aiMatrix4x4t<TReal>& _this = *this;
 
-	TReal cr = std::cos( x );
-	TReal sr = std::sin( x );
-	TReal cp = std::cos( y );
-	TReal sp = std::sin( y );
-	TReal cy = std::cos( z );
-	TReal sy = std::sin( z );
+    TReal cr = std::cos( x );
+    TReal sr = std::sin( x );
+    TReal cp = std::cos( y );
+    TReal sp = std::sin( y );
+    TReal cy = std::cos( z );
+    TReal sy = std::sin( z );
 
-	_this.a1 = cp*cy ;
-	_this.a2 = cp*sy;
-	_this.a3 = -sp ;
+    _this.a1 = cp*cy ;
+    _this.a2 = cp*sy;
+    _this.a3 = -sp ;
 
-	TReal srsp = sr*sp;
-	TReal crsp = cr*sp;
+    TReal srsp = sr*sp;
+    TReal crsp = cr*sp;
 
-	_this.b1 = srsp*cy-cr*sy ;
-	_this.b2 = srsp*sy+cr*cy ;
-	_this.b3 = sr*cp ;
+    _this.b1 = srsp*cy-cr*sy ;
+    _this.b2 = srsp*sy+cr*cy ;
+    _this.b3 = sr*cp ;
 
-	_this.c1 =  crsp*cy+sr*sy ;
-	_this.c2 =  crsp*sy-sr*cy ;
-	_this.c3 = cr*cp ;
+    _this.c1 =  crsp*cy+sr*sy ;
+    _this.c2 =  crsp*sy-sr*cy ;
+    _this.c3 = cr*cp ;
 
-	return *this;
+    return *this;
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline bool aiMatrix4x4t<TReal>::IsIdentity() const
 {
-	// Use a small epsilon to solve floating-point inaccuracies
-	const static TReal epsilon = 10e-3f;
-
-	return (a2 <= epsilon && a2 >= -epsilon &&
-			a3 <= epsilon && a3 >= -epsilon &&
-			a4 <= epsilon && a4 >= -epsilon &&
-			b1 <= epsilon && b1 >= -epsilon &&
-			b3 <= epsilon && b3 >= -epsilon &&
-			b4 <= epsilon && b4 >= -epsilon &&
-			c1 <= epsilon && c1 >= -epsilon &&
-			c2 <= epsilon && c2 >= -epsilon &&
-			c4 <= epsilon && c4 >= -epsilon &&
-			d1 <= epsilon && d1 >= -epsilon &&
-			d2 <= epsilon && d2 >= -epsilon &&
-			d3 <= epsilon && d3 >= -epsilon &&
-			a1 <= 1.f+epsilon && a1 >= 1.f-epsilon &&
-			b2 <= 1.f+epsilon && b2 >= 1.f-epsilon &&
-			c3 <= 1.f+epsilon && c3 >= 1.f-epsilon &&
-			d4 <= 1.f+epsilon && d4 >= 1.f-epsilon);
+    // Use a small epsilon to solve floating-point inaccuracies
+    const static TReal epsilon = 10e-3f;
+
+    return (a2 <= epsilon && a2 >= -epsilon &&
+            a3 <= epsilon && a3 >= -epsilon &&
+            a4 <= epsilon && a4 >= -epsilon &&
+            b1 <= epsilon && b1 >= -epsilon &&
+            b3 <= epsilon && b3 >= -epsilon &&
+            b4 <= epsilon && b4 >= -epsilon &&
+            c1 <= epsilon && c1 >= -epsilon &&
+            c2 <= epsilon && c2 >= -epsilon &&
+            c4 <= epsilon && c4 >= -epsilon &&
+            d1 <= epsilon && d1 >= -epsilon &&
+            d2 <= epsilon && d2 >= -epsilon &&
+            d3 <= epsilon && d3 >= -epsilon &&
+            a1 <= 1.f+epsilon && a1 >= 1.f-epsilon &&
+            b2 <= 1.f+epsilon && b2 >= 1.f-epsilon &&
+            c3 <= 1.f+epsilon && c3 >= 1.f-epsilon &&
+            d4 <= 1.f+epsilon && d4 >= 1.f-epsilon);
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationX(TReal a, aiMatrix4x4t<TReal>& out)
 {
-	/*
-	     |  1  0       0       0 |
+    /*
+         |  1  0       0       0 |
      M = |  0  cos(A) -sin(A)  0 |
          |  0  sin(A)  cos(A)  0 |
-         |  0  0       0       1 |	*/
-	out = aiMatrix4x4t<TReal>();
-	out.b2 = out.c3 = std::cos(a);
-	out.b3 = -(out.c2 = std::sin(a));
-	return out;
+         |  0  0       0       1 |  */
+    out = aiMatrix4x4t<TReal>();
+    out.b2 = out.c3 = std::cos(a);
+    out.b3 = -(out.c2 = std::sin(a));
+    return out;
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationY(TReal a, aiMatrix4x4t<TReal>& out)
 {
-	/*
-	     |  cos(A)  0   sin(A)  0 |
+    /*
+         |  cos(A)  0   sin(A)  0 |
      M = |  0       1   0       0 |
          | -sin(A)  0   cos(A)  0 |
          |  0       0   0       1 |
-		*/
-	out = aiMatrix4x4t<TReal>();
-	out.a1 = out.c3 = std::cos(a);
-	out.c1 = -(out.a3 = std::sin(a));
-	return out;
+        */
+    out = aiMatrix4x4t<TReal>();
+    out.a1 = out.c3 = std::cos(a);
+    out.c1 = -(out.a3 = std::sin(a));
+    return out;
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationZ(TReal a, aiMatrix4x4t<TReal>& out)
 {
-	/*
-	     |  cos(A)  -sin(A)   0   0 |
+    /*
+         |  cos(A)  -sin(A)   0   0 |
      M = |  sin(A)   cos(A)   0   0 |
          |  0        0        1   0 |
-         |  0        0        0   1 |	*/
-	out = aiMatrix4x4t<TReal>();
-	out.a1 = out.b2 = std::cos(a);
-	out.a2 = -(out.b1 = std::sin(a));
-	return out;
+         |  0        0        0   1 |   */
+    out = aiMatrix4x4t<TReal>();
+    out.a1 = out.b2 = std::cos(a);
+    out.a2 = -(out.b1 = std::sin(a));
+    return out;
 }
 
 // ----------------------------------------------------------------------------------------
@@ -493,22 +493,22 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Rotation( TReal a, const aiVect
 template <typename TReal>
 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Translation( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out)
 {
-	out = aiMatrix4x4t<TReal>();
-	out.a4 = v.x;
-	out.b4 = v.y;
-	out.c4 = v.z;
-	return out;
+    out = aiMatrix4x4t<TReal>();
+    out.a4 = v.x;
+    out.b4 = v.y;
+    out.c4 = v.z;
+    return out;
 }
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out)
 {
-	out = aiMatrix4x4t<TReal>();
-	out.a1 = v.x;
-	out.b2 = v.y;
-	out.c3 = v.z;
-	return out;
+    out = aiMatrix4x4t<TReal>();
+    out.a1 = v.x;
+    out.b2 = v.y;
+    out.c3 = v.z;
+    return out;
 }
 
 // ----------------------------------------------------------------------------------------
@@ -523,12 +523,12 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Scaling( const aiVector3t<TReal
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
-	const aiVector3t<TReal>& to, aiMatrix4x4t<TReal>& mtx)
+    const aiVector3t<TReal>& to, aiMatrix4x4t<TReal>& mtx)
 {
-	aiMatrix3x3t<TReal> m3;
-	aiMatrix3x3t<TReal>::FromToMatrix(from,to,m3);
-	mtx = aiMatrix4x4t<TReal>(m3);
-	return mtx;
+    aiMatrix3x3t<TReal> m3;
+    aiMatrix3x3t<TReal>::FromToMatrix(from,to,m3);
+    mtx = aiMatrix4x4t<TReal>(m3);
+    return mtx;
 }
 
 #endif // __cplusplus

include/assimp/mesh.h

@@ -62,42 +62,42 @@ extern "C" {
  *  Maximum number of indices per face (polygon). */
 
 #ifndef AI_MAX_FACE_INDICES
-#	define AI_MAX_FACE_INDICES 0x7fff
+#   define AI_MAX_FACE_INDICES 0x7fff
 #endif
 
 /** @def AI_MAX_BONE_WEIGHTS
  *  Maximum number of indices per face (polygon). */
 
 #ifndef AI_MAX_BONE_WEIGHTS
-#	define AI_MAX_BONE_WEIGHTS 0x7fffffff
+#   define AI_MAX_BONE_WEIGHTS 0x7fffffff
 #endif
 
 /** @def AI_MAX_VERTICES
  *  Maximum number of vertices per mesh.  */
 
 #ifndef AI_MAX_VERTICES
-#	define AI_MAX_VERTICES 0x7fffffff
+#   define AI_MAX_VERTICES 0x7fffffff
 #endif
 
 /** @def AI_MAX_FACES
  *  Maximum number of faces per mesh. */
 
 #ifndef AI_MAX_FACES
-#	define AI_MAX_FACES 0x7fffffff
+#   define AI_MAX_FACES 0x7fffffff
 #endif
 
 /** @def AI_MAX_NUMBER_OF_COLOR_SETS
  *  Supported number of vertex color sets per mesh. */
 
 #ifndef AI_MAX_NUMBER_OF_COLOR_SETS
-#	define AI_MAX_NUMBER_OF_COLOR_SETS 0x8
+#   define AI_MAX_NUMBER_OF_COLOR_SETS 0x8
 #endif // !! AI_MAX_NUMBER_OF_COLOR_SETS
 
 /** @def AI_MAX_NUMBER_OF_TEXTURECOORDS
  *  Supported number of texture coord sets (UV(W) channels) per mesh */
 
 #ifndef AI_MAX_NUMBER_OF_TEXTURECOORDS
-#	define AI_MAX_NUMBER_OF_TEXTURECOORDS 0x8
+#   define AI_MAX_NUMBER_OF_TEXTURECOORDS 0x8
 #endif // !! AI_MAX_NUMBER_OF_TEXTURECOORDS
 
 // ---------------------------------------------------------------------------
@@ -124,73 +124,73 @@ extern "C" {
  */
 struct aiFace
 {
-	//! Number of indices defining this face.
-	//! The maximum value for this member is #AI_MAX_FACE_INDICES.
-	unsigned int mNumIndices;
+    //! Number of indices defining this face.
+    //! The maximum value for this member is #AI_MAX_FACE_INDICES.
+    unsigned int mNumIndices;
 
-	//! Pointer to the indices array. Size of the array is given in numIndices.
-	unsigned int* mIndices;
+    //! Pointer to the indices array. Size of the array is given in numIndices.
+    unsigned int* mIndices;
 
 #ifdef __cplusplus
 
-	//! Default constructor
-	aiFace()
+    //! Default constructor
+    aiFace()
       : mNumIndices( 0 )
       , mIndices( NULL )
-	{
-	}
+    {
+    }
 
-	//! Default destructor. Delete the index array
-	~aiFace()
-	{
-		delete [] mIndices;
-	}
+    //! Default destructor. Delete the index array
+    ~aiFace()
+    {
+        delete [] mIndices;
+    }
 
-	//! Copy constructor. Copy the index array
-	aiFace( const aiFace& o)
+    //! Copy constructor. Copy the index array
+    aiFace( const aiFace& o)
       : mIndices( NULL )
-	{
-		*this = o;
-	}
-
-	//! Assignment operator. Copy the index array
-	aiFace& operator = ( const aiFace& o)
-	{
-		if (&o == this)
-			return *this;
-
-		delete[] mIndices;
-		mNumIndices = o.mNumIndices;
-		if (mNumIndices) {
-			mIndices = new unsigned int[mNumIndices];
-			::memcpy( mIndices, o.mIndices, mNumIndices * sizeof( unsigned int));
-		}
-		else {
-			mIndices = NULL;
-		}
-		return *this;
-	}
-
-	//! Comparison operator. Checks whether the index array
-	//! of two faces is identical
-	bool operator== (const aiFace& o) const
-	{
-		if (mIndices == o.mIndices)return true;
-		else if (mIndices && mNumIndices == o.mNumIndices)
-		{
-			for (unsigned int i = 0;i < this->mNumIndices;++i)
-				if (mIndices[i] != o.mIndices[i])return false;
-			return true;
-		}
-		return false;
-	}
-
-	//! Inverse comparison operator. Checks whether the index
-	//! array of two faces is NOT identical
-	bool operator != (const aiFace& o) const
-	{
-		return !(*this == o);
-	}
+    {
+        *this = o;
+    }
+
+    //! Assignment operator. Copy the index array
+    aiFace& operator = ( const aiFace& o)
+    {
+        if (&o == this)
+            return *this;
+
+        delete[] mIndices;
+        mNumIndices = o.mNumIndices;
+        if (mNumIndices) {
+            mIndices = new unsigned int[mNumIndices];
+            ::memcpy( mIndices, o.mIndices, mNumIndices * sizeof( unsigned int));
+        }
+        else {
+            mIndices = NULL;
+        }
+        return *this;
+    }
+
+    //! Comparison operator. Checks whether the index array
+    //! of two faces is identical
+    bool operator== (const aiFace& o) const
+    {
+        if (mIndices == o.mIndices)return true;
+        else if (mIndices && mNumIndices == o.mNumIndices)
+        {
+            for (unsigned int i = 0;i < this->mNumIndices;++i)
+                if (mIndices[i] != o.mIndices[i])return false;
+            return true;
+        }
+        return false;
+    }
+
+    //! Inverse comparison operator. Checks whether the index
+    //! array of two faces is NOT identical
+    bool operator != (const aiFace& o) const
+    {
+        return !(*this == o);
+    }
 #endif // __cplusplus
 }; // struct aiFace
 
@@ -200,24 +200,24 @@ struct aiFace
  */
 struct aiVertexWeight
 {
-	//! Index of the vertex which is influenced by the bone.
-	unsigned int mVertexId;
+    //! Index of the vertex which is influenced by the bone.
+    unsigned int mVertexId;
 
-	//! The strength of the influence in the range (0...1).
-	//! The influence from all bones at one vertex amounts to 1.
-	float mWeight;
+    //! The strength of the influence in the range (0...1).
+    //! The influence from all bones at one vertex amounts to 1.
+    float mWeight;
 
 #ifdef __cplusplus
 
-	//! Default constructor
-	aiVertexWeight() { }
+    //! Default constructor
+    aiVertexWeight() { }
 
-	//! Initialisation from a given index and vertex weight factor
-	//! \param pID ID
-	//! \param pWeight Vertex weight factor
-	aiVertexWeight( unsigned int pID, float pWeight)
-		: mVertexId( pID), mWeight( pWeight)
-	{ /* nothing to do here */ }
+    //! Initialisation from a given index and vertex weight factor
+    //! \param pID ID
+    //! \param pWeight Vertex weight factor
+    aiVertexWeight( unsigned int pID, float pWeight)
+        : mVertexId( pID), mWeight( pWeight)
+    { /* nothing to do here */ }
 
 #endif // __cplusplus
 };
@@ -232,46 +232,46 @@ struct aiVertexWeight
  */
 struct aiBone
 {
-	//! The name of the bone.
-	C_STRUCT aiString mName;
+    //! The name of the bone.
+    C_STRUCT aiString mName;
 
-	//! The number of vertices affected by this bone
-	//! The maximum value for this member is #AI_MAX_BONE_WEIGHTS.
-	unsigned int mNumWeights;
+    //! The number of vertices affected by this bone
+    //! The maximum value for this member is #AI_MAX_BONE_WEIGHTS.
+    unsigned int mNumWeights;
 
-	//! The vertices affected by this bone
-	C_STRUCT aiVertexWeight* mWeights;
+    //! The vertices affected by this bone
+    C_STRUCT aiVertexWeight* mWeights;
 
-	//! Matrix that transforms from mesh space to bone space in bind pose
-	C_STRUCT aiMatrix4x4 mOffsetMatrix;
+    //! Matrix that transforms from mesh space to bone space in bind pose
+    C_STRUCT aiMatrix4x4 mOffsetMatrix;
 
 #ifdef __cplusplus
 
-	//! Default constructor
-	aiBone()
+    //! Default constructor
+    aiBone()
       : mNumWeights( 0 )
       , mWeights( NULL )
-	{
-	}
+    {
+    }
 
-	//! Copy constructor
-	aiBone(const aiBone& other)
+    //! Copy constructor
+    aiBone(const aiBone& other)
       : mName( other.mName )
       , mNumWeights( other.mNumWeights )
       , mOffsetMatrix( other.mOffsetMatrix )
-	{
-		if (other.mWeights && other.mNumWeights)
-		{
-			mWeights = new aiVertexWeight[mNumWeights];
-			::memcpy(mWeights,other.mWeights,mNumWeights * sizeof(aiVertexWeight));
-		}
-	}
-
-	//! Destructor - deletes the array of vertex weights
-	~aiBone()
-	{
-		delete [] mWeights;
-	}
+    {
+        if (other.mWeights && other.mNumWeights)
+        {
+            mWeights = new aiVertexWeight[mNumWeights];
+            ::memcpy(mWeights,other.mWeights,mNumWeights * sizeof(aiVertexWeight));
+        }
+    }
+
+    //! Destructor - deletes the array of vertex weights
+    ~aiBone()
+    {
+        delete [] mWeights;
+    }
 #endif // __cplusplus
 };
 
@@ -286,47 +286,47 @@ struct aiBone
  */
 enum aiPrimitiveType
 {
-	/** A point primitive.
-	 *
-	 * This is just a single vertex in the virtual world,
-	 * #aiFace contains just one index for such a primitive.
-	 */
-	aiPrimitiveType_POINT       = 0x1,
-
-	/** A line primitive.
-	 *
-	 * This is a line defined through a start and an end position.
-	 * #aiFace contains exactly two indices for such a primitive.
-	 */
-	aiPrimitiveType_LINE        = 0x2,
-
-	/** A triangular primitive.
-	 *
-	 * A triangle consists of three indices.
-	 */
-	aiPrimitiveType_TRIANGLE    = 0x4,
-
-	/** A higher-level polygon with more than 3 edges.
-	 *
-	 * A triangle is a polygon, but polygon in this context means
-	 * "all polygons that are not triangles". The "Triangulate"-Step
-	 * is provided for your convenience, it splits all polygons in
-	 * triangles (which are much easier to handle).
-	 */
-	aiPrimitiveType_POLYGON     = 0x8,
-
-
-	/** This value is not used. It is just here to force the
-	 *  compiler to map this enum to a 32 Bit integer.
-	 */
+    /** A point primitive.
+     *
+     * This is just a single vertex in the virtual world,
+     * #aiFace contains just one index for such a primitive.
+     */
+    aiPrimitiveType_POINT       = 0x1,
+
+    /** A line primitive.
+     *
+     * This is a line defined through a start and an end position.
+     * #aiFace contains exactly two indices for such a primitive.
+     */
+    aiPrimitiveType_LINE        = 0x2,
+
+    /** A triangular primitive.
+     *
+     * A triangle consists of three indices.
+     */
+    aiPrimitiveType_TRIANGLE    = 0x4,
+
+    /** A higher-level polygon with more than 3 edges.
+     *
+     * A triangle is a polygon, but polygon in this context means
+     * "all polygons that are not triangles". The "Triangulate"-Step
+     * is provided for your convenience, it splits all polygons in
+     * triangles (which are much easier to handle).
+     */
+    aiPrimitiveType_POLYGON     = 0x8,
+
+
+    /** This value is not used. It is just here to force the
+     *  compiler to map this enum to a 32 Bit integer.
+     */
 #ifndef SWIG
-	_aiPrimitiveType_Force32Bit = INT_MAX
+    _aiPrimitiveType_Force32Bit = INT_MAX
 #endif
 }; //! enum aiPrimitiveType
 
 // Get the #aiPrimitiveType flag for a specific number of face indices
 #define AI_PRIMITIVE_TYPE_FOR_N_INDICES(n) \
-	((n) > 3 ? aiPrimitiveType_POLYGON : (aiPrimitiveType)(1u << ((n)-1)))
+    ((n) > 3 ? aiPrimitiveType_POLYGON : (aiPrimitiveType)(1u << ((n)-1)))
 
 
 
@@ -343,103 +343,103 @@ enum aiPrimitiveType
 */
 struct aiAnimMesh
 {
-	/** Replacement for aiMesh::mVertices. If this array is non-NULL,
-	 *  it *must* contain mNumVertices entries. The corresponding
-	 *  array in the host mesh must be non-NULL as well - animation
-	 *  meshes may neither add or nor remove vertex components (if
-	 *  a replacement array is NULL and the corresponding source
-	 *  array is not, the source data is taken instead)*/
-	C_STRUCT aiVector3D* mVertices;
-
-	/** Replacement for aiMesh::mNormals.  */
-	C_STRUCT aiVector3D* mNormals;
-
-	/** Replacement for aiMesh::mTangents. */
-	C_STRUCT aiVector3D* mTangents;
-
-	/** Replacement for aiMesh::mBitangents. */
-	C_STRUCT aiVector3D* mBitangents;
-
-	/** Replacement for aiMesh::mColors */
-	C_STRUCT aiColor4D* mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
-
-	/** Replacement for aiMesh::mTextureCoords */
-	C_STRUCT aiVector3D* mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
-
-	/** The number of vertices in the aiAnimMesh, and thus the length of all
-	 * the member arrays.
-	 *
-	 * This has always the same value as the mNumVertices property in the
-	 * corresponding aiMesh. It is duplicated here merely to make the length
-	 * of the member arrays accessible even if the aiMesh is not known, e.g.
-	 * from language bindings.
-	 */
-	unsigned int mNumVertices;
+    /** Replacement for aiMesh::mVertices. If this array is non-NULL,
+     *  it *must* contain mNumVertices entries. The corresponding
+     *  array in the host mesh must be non-NULL as well - animation
+     *  meshes may neither add or nor remove vertex components (if
+     *  a replacement array is NULL and the corresponding source
+     *  array is not, the source data is taken instead)*/
+    C_STRUCT aiVector3D* mVertices;
+
+    /** Replacement for aiMesh::mNormals.  */
+    C_STRUCT aiVector3D* mNormals;
+
+    /** Replacement for aiMesh::mTangents. */
+    C_STRUCT aiVector3D* mTangents;
+
+    /** Replacement for aiMesh::mBitangents. */
+    C_STRUCT aiVector3D* mBitangents;
+
+    /** Replacement for aiMesh::mColors */
+    C_STRUCT aiColor4D* mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
+
+    /** Replacement for aiMesh::mTextureCoords */
+    C_STRUCT aiVector3D* mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+
+    /** The number of vertices in the aiAnimMesh, and thus the length of all
+     * the member arrays.
+     *
+     * This has always the same value as the mNumVertices property in the
+     * corresponding aiMesh. It is duplicated here merely to make the length
+     * of the member arrays accessible even if the aiMesh is not known, e.g.
+     * from language bindings.
+     */
+    unsigned int mNumVertices;
 
 #ifdef __cplusplus
 
-	aiAnimMesh()
-		: mVertices( NULL )
-		, mNormals( NULL )
-		, mTangents( NULL )
-		, mBitangents( NULL )
-		, mNumVertices( 0 )
-	{
-		// fixme consider moving this to the ctor initializer list as well
-		for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++){
-			mTextureCoords[a] = NULL;
-		}
-		for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) {
-			mColors[a] = NULL;
-		}
-	}
-
-	~aiAnimMesh()
-	{
-		delete [] mVertices;
-		delete [] mNormals;
-		delete [] mTangents;
-		delete [] mBitangents;
-		for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) {
-			delete [] mTextureCoords[a];
-		}
-		for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) {
-			delete [] mColors[a];
-		}
-	}
-
-	/** Check whether the anim mesh overrides the vertex positions
-	 *  of its host mesh*/
-	bool HasPositions() const {
-		return mVertices != NULL;
-	}
-
-	/** Check whether the anim mesh overrides the vertex normals
-	 *  of its host mesh*/
-	bool HasNormals() const {
-		return mNormals != NULL;
-	}
-
-	/** Check whether the anim mesh overrides the vertex tangents
-	 *  and bitangents of its host mesh. As for aiMesh,
-	 *  tangents and bitangents always go together. */
-	bool HasTangentsAndBitangents() const {
-		return mTangents != NULL;
-	}
-
-	/** Check whether the anim mesh overrides a particular
-	 * set of vertex colors on his host mesh.
-	 *  @param pIndex 0<index<AI_MAX_NUMBER_OF_COLOR_SETS */
-	bool HasVertexColors( unsigned int pIndex) const	{
-		return pIndex >= AI_MAX_NUMBER_OF_COLOR_SETS ? false : mColors[pIndex] != NULL;
-	}
-
-	/** Check whether the anim mesh overrides a particular
-	 * set of texture coordinates on his host mesh.
-	 *  @param pIndex 0<index<AI_MAX_NUMBER_OF_TEXTURECOORDS */
-	bool HasTextureCoords( unsigned int pIndex) const	{
-		return pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS ? false : mTextureCoords[pIndex] != NULL;
-	}
+    aiAnimMesh()
+        : mVertices( NULL )
+        , mNormals( NULL )
+        , mTangents( NULL )
+        , mBitangents( NULL )
+        , mNumVertices( 0 )
+    {
+        // fixme consider moving this to the ctor initializer list as well
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++){
+            mTextureCoords[a] = NULL;
+        }
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) {
+            mColors[a] = NULL;
+        }
+    }
+
+    ~aiAnimMesh()
+    {
+        delete [] mVertices;
+        delete [] mNormals;
+        delete [] mTangents;
+        delete [] mBitangents;
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) {
+            delete [] mTextureCoords[a];
+        }
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) {
+            delete [] mColors[a];
+        }
+    }
+
+    /** Check whether the anim mesh overrides the vertex positions
+     *  of its host mesh*/
+    bool HasPositions() const {
+        return mVertices != NULL;
+    }
+
+    /** Check whether the anim mesh overrides the vertex normals
+     *  of its host mesh*/
+    bool HasNormals() const {
+        return mNormals != NULL;
+    }
+
+    /** Check whether the anim mesh overrides the vertex tangents
+     *  and bitangents of its host mesh. As for aiMesh,
+     *  tangents and bitangents always go together. */
+    bool HasTangentsAndBitangents() const {
+        return mTangents != NULL;
+    }
+
+    /** Check whether the anim mesh overrides a particular
+     * set of vertex colors on his host mesh.
+     *  @param pIndex 0<index<AI_MAX_NUMBER_OF_COLOR_SETS */
+    bool HasVertexColors( unsigned int pIndex) const    {
+        return pIndex >= AI_MAX_NUMBER_OF_COLOR_SETS ? false : mColors[pIndex] != NULL;
+    }
+
+    /** Check whether the anim mesh overrides a particular
+     * set of texture coordinates on his host mesh.
+     *  @param pIndex 0<index<AI_MAX_NUMBER_OF_TEXTURECOORDS */
+    bool HasTextureCoords( unsigned int pIndex) const   {
+        return pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS ? false : mTextureCoords[pIndex] != NULL;
+    }
 
 #endif
 };
@@ -466,267 +466,267 @@ struct aiAnimMesh
 */
 struct aiMesh
 {
-	/** Bitwise combination of the members of the #aiPrimitiveType enum.
-	 * This specifies which types of primitives are present in the mesh.
-	 * The "SortByPrimitiveType"-Step can be used to make sure the
-	 * output meshes consist of one primitive type each.
-	 */
-	unsigned int mPrimitiveTypes;
-
-	/** The number of vertices in this mesh.
-	* This is also the size of all of the per-vertex data arrays.
-	* The maximum value for this member is #AI_MAX_VERTICES.
-	*/
-	unsigned int mNumVertices;
-
-	/** The number of primitives (triangles, polygons, lines) in this  mesh.
-	* This is also the size of the mFaces array.
-	* The maximum value for this member is #AI_MAX_FACES.
-	*/
-	unsigned int mNumFaces;
-
-	/** Vertex positions.
-	* This array is always present in a mesh. The array is
-	* mNumVertices in size.
-	*/
-	C_STRUCT aiVector3D* mVertices;
-
-	/** Vertex normals.
-	* The array contains normalized vectors, NULL if not present.
-	* The array is mNumVertices in size. Normals are undefined for
-	* point and line primitives. A mesh consisting of points and
-	* lines only may not have normal vectors. Meshes with mixed
-	* primitive types (i.e. lines and triangles) may have normals,
-	* but the normals for vertices that are only referenced by
-	* point or line primitives are undefined and set to QNaN (WARN:
-	* qNaN compares to inequal to *everything*, even to qNaN itself.
-	* Using code like this to check whether a field is qnan is:
-	* @code
-	* #define IS_QNAN(f) (f != f)
-	* @endcode
-	* still dangerous because even 1.f == 1.f could evaluate to false! (
-	* remember the subtleties of IEEE754 artithmetics). Use stuff like
-	* @c fpclassify instead.
-	* @note Normal vectors computed by Assimp are always unit-length.
-	* However, this needn't apply for normals that have been taken
-	*   directly from the model file.
-	*/
-	C_STRUCT aiVector3D* mNormals;
-
-	/** Vertex tangents.
-	* The tangent of a vertex points in the direction of the positive
-	* X texture axis. The array contains normalized vectors, NULL if
-	* not present. The array is mNumVertices in size. A mesh consisting
-	* of points and lines only may not have normal vectors. Meshes with
-	* mixed primitive types (i.e. lines and triangles) may have
-	* normals, but the normals for vertices that are only referenced by
-	* point or line primitives are undefined and set to qNaN.  See
-	* the #mNormals member for a detailled discussion of qNaNs.
-	* @note If the mesh contains tangents, it automatically also
-	* contains bitangents.
-	*/
-	C_STRUCT aiVector3D* mTangents;
-
-	/** Vertex bitangents.
-	* The bitangent of a vertex points in the direction of the positive
-	* Y texture axis. The array contains normalized vectors, NULL if not
-	* present. The array is mNumVertices in size.
-	* @note If the mesh contains tangents, it automatically also contains
-	* bitangents.
-	*/
-	C_STRUCT aiVector3D* mBitangents;
-
-	/** Vertex color sets.
-	* A mesh may contain 0 to #AI_MAX_NUMBER_OF_COLOR_SETS vertex
-	* colors per vertex. NULL if not present. Each array is
-	* mNumVertices in size if present.
-	*/
-	C_STRUCT aiColor4D* mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
-
-	/** Vertex texture coords, also known as UV channels.
-	* A mesh may contain 0 to AI_MAX_NUMBER_OF_TEXTURECOORDS per
-	* vertex. NULL if not present. The array is mNumVertices in size.
-	*/
-	C_STRUCT aiVector3D* mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
-
-	/** Specifies the number of components for a given UV channel.
-	* Up to three channels are supported (UVW, for accessing volume
-	* or cube maps). If the value is 2 for a given channel n, the
-	* component p.z of mTextureCoords[n][p] is set to 0.0f.
-	* If the value is 1 for a given channel, p.y is set to 0.0f, too.
-	* @note 4D coords are not supported
-	*/
-	unsigned int mNumUVComponents[AI_MAX_NUMBER_OF_TEXTURECOORDS];
-
-	/** The faces the mesh is constructed from.
-	* Each face refers to a number of vertices by their indices.
-	* This array is always present in a mesh, its size is given
-	* in mNumFaces. If the #AI_SCENE_FLAGS_NON_VERBOSE_FORMAT
-	* is NOT set each face references an unique set of vertices.
-	*/
-	C_STRUCT aiFace* mFaces;
-
-	/** The number of bones this mesh contains.
-	* Can be 0, in which case the mBones array is NULL.
-	*/
-	unsigned int mNumBones;
-
-	/** The bones of this mesh.
-	* A bone consists of a name by which it can be found in the
-	* frame hierarchy and a set of vertex weights.
-	*/
-	C_STRUCT aiBone** mBones;
-
-	/** The material used by this mesh.
-	 * A mesh does use only a single material. If an imported model uses
-	 * multiple materials, the import splits up the mesh. Use this value
-	 * as index into the scene's material list.
-	 */
-	unsigned int mMaterialIndex;
-
-	/** Name of the mesh. Meshes can be named, but this is not a
-	 *  requirement and leaving this field empty is totally fine.
-	 *  There are mainly three uses for mesh names:
-	 *   - some formats name nodes and meshes independently.
-	 *   - importers tend to split meshes up to meet the
-	 *      one-material-per-mesh requirement. Assigning
-	 *      the same (dummy) name to each of the result meshes
-	 *      aids the caller at recovering the original mesh
-	 *      partitioning.
-	 *   - Vertex animations refer to meshes by their names.
-	 **/
-	C_STRUCT aiString mName;
-
-
-	/** NOT CURRENTLY IN USE. The number of attachment meshes */
-	unsigned int mNumAnimMeshes;
-
-	/** NOT CURRENTLY IN USE. Attachment meshes for this mesh, for vertex-based animation.
-	 *  Attachment meshes carry replacement data for some of the
-	 *  mesh'es vertex components (usually positions, normals). */
-	C_STRUCT aiAnimMesh** mAnimMeshes;
+    /** Bitwise combination of the members of the #aiPrimitiveType enum.
+     * This specifies which types of primitives are present in the mesh.
+     * The "SortByPrimitiveType"-Step can be used to make sure the
+     * output meshes consist of one primitive type each.
+     */
+    unsigned int mPrimitiveTypes;
+
+    /** The number of vertices in this mesh.
+    * This is also the size of all of the per-vertex data arrays.
+    * The maximum value for this member is #AI_MAX_VERTICES.
+    */
+    unsigned int mNumVertices;
+
+    /** The number of primitives (triangles, polygons, lines) in this  mesh.
+    * This is also the size of the mFaces array.
+    * The maximum value for this member is #AI_MAX_FACES.
+    */
+    unsigned int mNumFaces;
+
+    /** Vertex positions.
+    * This array is always present in a mesh. The array is
+    * mNumVertices in size.
+    */
+    C_STRUCT aiVector3D* mVertices;
+
+    /** Vertex normals.
+    * The array contains normalized vectors, NULL if not present.
+    * The array is mNumVertices in size. Normals are undefined for
+    * point and line primitives. A mesh consisting of points and
+    * lines only may not have normal vectors. Meshes with mixed
+    * primitive types (i.e. lines and triangles) may have normals,
+    * but the normals for vertices that are only referenced by
+    * point or line primitives are undefined and set to QNaN (WARN:
+    * qNaN compares to inequal to *everything*, even to qNaN itself.
+    * Using code like this to check whether a field is qnan is:
+    * @code
+    * #define IS_QNAN(f) (f != f)
+    * @endcode
+    * still dangerous because even 1.f == 1.f could evaluate to false! (
+    * remember the subtleties of IEEE754 artithmetics). Use stuff like
+    * @c fpclassify instead.
+    * @note Normal vectors computed by Assimp are always unit-length.
+    * However, this needn't apply for normals that have been taken
+    *   directly from the model file.
+    */
+    C_STRUCT aiVector3D* mNormals;
+
+    /** Vertex tangents.
+    * The tangent of a vertex points in the direction of the positive
+    * X texture axis. The array contains normalized vectors, NULL if
+    * not present. The array is mNumVertices in size. A mesh consisting
+    * of points and lines only may not have normal vectors. Meshes with
+    * mixed primitive types (i.e. lines and triangles) may have
+    * normals, but the normals for vertices that are only referenced by
+    * point or line primitives are undefined and set to qNaN.  See
+    * the #mNormals member for a detailled discussion of qNaNs.
+    * @note If the mesh contains tangents, it automatically also
+    * contains bitangents.
+    */
+    C_STRUCT aiVector3D* mTangents;
+
+    /** Vertex bitangents.
+    * The bitangent of a vertex points in the direction of the positive
+    * Y texture axis. The array contains normalized vectors, NULL if not
+    * present. The array is mNumVertices in size.
+    * @note If the mesh contains tangents, it automatically also contains
+    * bitangents.
+    */
+    C_STRUCT aiVector3D* mBitangents;
+
+    /** Vertex color sets.
+    * A mesh may contain 0 to #AI_MAX_NUMBER_OF_COLOR_SETS vertex
+    * colors per vertex. NULL if not present. Each array is
+    * mNumVertices in size if present.
+    */
+    C_STRUCT aiColor4D* mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
+
+    /** Vertex texture coords, also known as UV channels.
+    * A mesh may contain 0 to AI_MAX_NUMBER_OF_TEXTURECOORDS per
+    * vertex. NULL if not present. The array is mNumVertices in size.
+    */
+    C_STRUCT aiVector3D* mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+
+    /** Specifies the number of components for a given UV channel.
+    * Up to three channels are supported (UVW, for accessing volume
+    * or cube maps). If the value is 2 for a given channel n, the
+    * component p.z of mTextureCoords[n][p] is set to 0.0f.
+    * If the value is 1 for a given channel, p.y is set to 0.0f, too.
+    * @note 4D coords are not supported
+    */
+    unsigned int mNumUVComponents[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+
+    /** The faces the mesh is constructed from.
+    * Each face refers to a number of vertices by their indices.
+    * This array is always present in a mesh, its size is given
+    * in mNumFaces. If the #AI_SCENE_FLAGS_NON_VERBOSE_FORMAT
+    * is NOT set each face references an unique set of vertices.
+    */
+    C_STRUCT aiFace* mFaces;
+
+    /** The number of bones this mesh contains.
+    * Can be 0, in which case the mBones array is NULL.
+    */
+    unsigned int mNumBones;
+
+    /** The bones of this mesh.
+    * A bone consists of a name by which it can be found in the
+    * frame hierarchy and a set of vertex weights.
+    */
+    C_STRUCT aiBone** mBones;
+
+    /** The material used by this mesh.
+     * A mesh does use only a single material. If an imported model uses
+     * multiple materials, the import splits up the mesh. Use this value
+     * as index into the scene's material list.
+     */
+    unsigned int mMaterialIndex;
+
+    /** Name of the mesh. Meshes can be named, but this is not a
+     *  requirement and leaving this field empty is totally fine.
+     *  There are mainly three uses for mesh names:
+     *   - some formats name nodes and meshes independently.
+     *   - importers tend to split meshes up to meet the
+     *      one-material-per-mesh requirement. Assigning
+     *      the same (dummy) name to each of the result meshes
+     *      aids the caller at recovering the original mesh
+     *      partitioning.
+     *   - Vertex animations refer to meshes by their names.
+     **/
+    C_STRUCT aiString mName;
+
+
+    /** NOT CURRENTLY IN USE. The number of attachment meshes */
+    unsigned int mNumAnimMeshes;
+
+    /** NOT CURRENTLY IN USE. Attachment meshes for this mesh, for vertex-based animation.
+     *  Attachment meshes carry replacement data for some of the
+     *  mesh'es vertex components (usually positions, normals). */
+    C_STRUCT aiAnimMesh** mAnimMeshes;
 
 
 #ifdef __cplusplus
 
-	//! Default constructor. Initializes all members to 0
-	aiMesh()
-		: mPrimitiveTypes( 0 )
-		, mNumVertices( 0 )
-		, mNumFaces( 0 )
-		, mVertices( NULL )
-		, mNormals( NULL )
-		, mTangents( NULL )
-		, mBitangents( NULL )
-		, mFaces( NULL )
-		, mNumBones( 0 )
-		, mBones( NULL )
-		, mMaterialIndex( 0 )
-		, mNumAnimMeshes( 0 )
-		, mAnimMeshes( NULL )
-	{
-		for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++)
-		{
-			mNumUVComponents[a] = 0;
-			mTextureCoords[a] = NULL;
-		}
-
-		for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++)
-			mColors[a] = NULL;
-	}
-
-	//! Deletes all storage allocated for the mesh
-	~aiMesh()
-	{
-		delete [] mVertices;
-		delete [] mNormals;
-		delete [] mTangents;
-		delete [] mBitangents;
-		for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) {
-			delete [] mTextureCoords[a];
-		}
-		for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) {
-			delete [] mColors[a];
-		}
-
-		// DO NOT REMOVE THIS ADDITIONAL CHECK
-		if (mNumBones && mBones)	{
-			for( unsigned int a = 0; a < mNumBones; a++) {
-				delete mBones[a];
-			}
-			delete [] mBones;
-		}
-
-		if (mNumAnimMeshes && mAnimMeshes)	{
-			for( unsigned int a = 0; a < mNumAnimMeshes; a++) {
-				delete mAnimMeshes[a];
-			}
-			delete [] mAnimMeshes;
-		}
-
-		delete [] mFaces;
-	}
-
-	//! Check whether the mesh contains positions. Provided no special
-	//! scene flags are set, this will always be true
-	bool HasPositions() const
-		{ return mVertices != NULL && mNumVertices > 0; }
-
-	//! Check whether the mesh contains faces. If no special scene flags
-	//! are set this should always return true
-	bool HasFaces() const
-		{ return mFaces != NULL && mNumFaces > 0; }
-
-	//! Check whether the mesh contains normal vectors
-	bool HasNormals() const
-		{ return mNormals != NULL && mNumVertices > 0; }
-
-	//! Check whether the mesh contains tangent and bitangent vectors
-	//! It is not possible that it contains tangents and no bitangents
-	//! (or the other way round). The existence of one of them
-	//! implies that the second is there, too.
-	bool HasTangentsAndBitangents() const
-		{ return mTangents != NULL && mBitangents != NULL && mNumVertices > 0; }
-
-	//! Check whether the mesh contains a vertex color set
-	//! \param pIndex Index of the vertex color set
-	bool HasVertexColors( unsigned int pIndex) const
-	{
-		if( pIndex >= AI_MAX_NUMBER_OF_COLOR_SETS)
-			return false;
-		else
-			return mColors[pIndex] != NULL && mNumVertices > 0;
-	}
-
-	//! Check whether the mesh contains a texture coordinate set
-	//! \param pIndex Index of the texture coordinates set
-	bool HasTextureCoords( unsigned int pIndex) const
-	{
-		if( pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS)
-			return false;
-		else
-			return mTextureCoords[pIndex] != NULL && mNumVertices > 0;
-	}
-
-	//! Get the number of UV channels the mesh contains
-	unsigned int GetNumUVChannels() const
-	{
-		unsigned int n = 0;
-		while (n < AI_MAX_NUMBER_OF_TEXTURECOORDS && mTextureCoords[n])++n;
-		return n;
-	}
-
-	//! Get the number of vertex color channels the mesh contains
-	unsigned int GetNumColorChannels() const
-	{
-		unsigned int n = 0;
-		while (n < AI_MAX_NUMBER_OF_COLOR_SETS && mColors[n])++n;
-		return n;
-	}
-
-	//! Check whether the mesh contains bones
-	inline bool HasBones() const
-		{ return mBones != NULL && mNumBones > 0; }
+    //! Default constructor. Initializes all members to 0
+    aiMesh()
+        : mPrimitiveTypes( 0 )
+        , mNumVertices( 0 )
+        , mNumFaces( 0 )
+        , mVertices( NULL )
+        , mNormals( NULL )
+        , mTangents( NULL )
+        , mBitangents( NULL )
+        , mFaces( NULL )
+        , mNumBones( 0 )
+        , mBones( NULL )
+        , mMaterialIndex( 0 )
+        , mNumAnimMeshes( 0 )
+        , mAnimMeshes( NULL )
+    {
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++)
+        {
+            mNumUVComponents[a] = 0;
+            mTextureCoords[a] = NULL;
+        }
+
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++)
+            mColors[a] = NULL;
+    }
+
+    //! Deletes all storage allocated for the mesh
+    ~aiMesh()
+    {
+        delete [] mVertices;
+        delete [] mNormals;
+        delete [] mTangents;
+        delete [] mBitangents;
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) {
+            delete [] mTextureCoords[a];
+        }
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) {
+            delete [] mColors[a];
+        }
+
+        // DO NOT REMOVE THIS ADDITIONAL CHECK
+        if (mNumBones && mBones)    {
+            for( unsigned int a = 0; a < mNumBones; a++) {
+                delete mBones[a];
+            }
+            delete [] mBones;
+        }
+
+        if (mNumAnimMeshes && mAnimMeshes)  {
+            for( unsigned int a = 0; a < mNumAnimMeshes; a++) {
+                delete mAnimMeshes[a];
+            }
+            delete [] mAnimMeshes;
+        }
+
+        delete [] mFaces;
+    }
+
+    //! Check whether the mesh contains positions. Provided no special
+    //! scene flags are set, this will always be true
+    bool HasPositions() const
+        { return mVertices != NULL && mNumVertices > 0; }
+
+    //! Check whether the mesh contains faces. If no special scene flags
+    //! are set this should always return true
+    bool HasFaces() const
+        { return mFaces != NULL && mNumFaces > 0; }
+
+    //! Check whether the mesh contains normal vectors
+    bool HasNormals() const
+        { return mNormals != NULL && mNumVertices > 0; }
+
+    //! Check whether the mesh contains tangent and bitangent vectors
+    //! It is not possible that it contains tangents and no bitangents
+    //! (or the other way round). The existence of one of them
+    //! implies that the second is there, too.
+    bool HasTangentsAndBitangents() const
+        { return mTangents != NULL && mBitangents != NULL && mNumVertices > 0; }
+
+    //! Check whether the mesh contains a vertex color set
+    //! \param pIndex Index of the vertex color set
+    bool HasVertexColors( unsigned int pIndex) const
+    {
+        if( pIndex >= AI_MAX_NUMBER_OF_COLOR_SETS)
+            return false;
+        else
+            return mColors[pIndex] != NULL && mNumVertices > 0;
+    }
+
+    //! Check whether the mesh contains a texture coordinate set
+    //! \param pIndex Index of the texture coordinates set
+    bool HasTextureCoords( unsigned int pIndex) const
+    {
+        if( pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS)
+            return false;
+        else
+            return mTextureCoords[pIndex] != NULL && mNumVertices > 0;
+    }
+
+    //! Get the number of UV channels the mesh contains
+    unsigned int GetNumUVChannels() const
+    {
+        unsigned int n = 0;
+        while (n < AI_MAX_NUMBER_OF_TEXTURECOORDS && mTextureCoords[n])++n;
+        return n;
+    }
+
+    //! Get the number of vertex color channels the mesh contains
+    unsigned int GetNumColorChannels() const
+    {
+        unsigned int n = 0;
+        while (n < AI_MAX_NUMBER_OF_COLOR_SETS && mColors[n])++n;
+        return n;
+    }
+
+    //! Check whether the mesh contains bones
+    inline bool HasBones() const
+        { return mBones != NULL && mNumBones > 0; }
 
 #endif // __cplusplus
 };

include/assimp/metadata.h

@@ -63,15 +63,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  // -------------------------------------------------------------------------------
 typedef enum aiMetadataType
 {
-	AI_BOOL = 0,
-	AI_INT = 1,
-	AI_UINT64 = 2,
-	AI_FLOAT = 3,
-	AI_AISTRING = 4,
-	AI_AIVECTOR3D = 5,
+    AI_BOOL = 0,
+    AI_INT = 1,
+    AI_UINT64 = 2,
+    AI_FLOAT = 3,
+    AI_AISTRING = 4,
+    AI_AIVECTOR3D = 5,
 
 #ifndef SWIG
-	FORCE_32BIT = INT_MAX
+    FORCE_32BIT = INT_MAX
 #endif
 } aiMetadataType;
 
@@ -86,8 +86,8 @@ typedef enum aiMetadataType
  // -------------------------------------------------------------------------------
 struct aiMetadataEntry
 {
-	aiMetadataType mType;
-	void* mData;
+    aiMetadataType mType;
+    void* mData;
 };
 
 
@@ -125,117 +125,117 @@ inline aiMetadataType GetAiType( aiVector3D ) { return AI_AIVECTOR3D; }
  // -------------------------------------------------------------------------------
 struct aiMetadata
 {
-	/** Length of the mKeys and mValues arrays, respectively */
-	unsigned int mNumProperties;
+    /** Length of the mKeys and mValues arrays, respectively */
+    unsigned int mNumProperties;
 
-	/** Arrays of keys, may not be NULL. Entries in this array may not be NULL as well. */
-	C_STRUCT aiString* mKeys;
+    /** Arrays of keys, may not be NULL. Entries in this array may not be NULL as well. */
+    C_STRUCT aiString* mKeys;
 
-	/** Arrays of values, may not be NULL. Entries in this array may be NULL if the
-	  * corresponding property key has no assigned value. */
-	C_STRUCT aiMetadataEntry* mValues;
+    /** Arrays of values, may not be NULL. Entries in this array may be NULL if the
+      * corresponding property key has no assigned value. */
+    C_STRUCT aiMetadataEntry* mValues;
 
 #ifdef __cplusplus
 
-	/** Constructor */
-	aiMetadata()
-		// set all members to zero by default
-		: mNumProperties(0)
-		, mKeys(NULL)
-		, mValues(NULL)
-	{}
+    /** Constructor */
+    aiMetadata()
+        // set all members to zero by default
+        : mNumProperties(0)
+        , mKeys(NULL)
+        , mValues(NULL)
+    {}
 
 
-	/** Destructor */
-	~aiMetadata()
-	{
+    /** Destructor */
+    ~aiMetadata()
+    {
         delete[] mKeys;
         mKeys = NULL;
-		if (mValues)
-		{
-			// Delete each metadata entry
-			for (unsigned i=0; i<mNumProperties; ++i)
-			{
-				void* data = mValues[i].mData;
-				switch (mValues[i].mType)
-				{
-				case AI_BOOL:
-					delete static_cast<bool*>(data);
-					break;
-				case AI_INT:
-					delete static_cast<int*>(data);
-					break;
-				case AI_UINT64:
-					delete static_cast<uint64_t*>(data);
-					break;
-				case AI_FLOAT:
-					delete static_cast<float*>(data);
-					break;
-				case AI_AISTRING:
-					delete static_cast<aiString*>(data);
-					break;
-				case AI_AIVECTOR3D:
-					delete static_cast<aiVector3D*>(data);
-					break;
-				default:
-					assert(false);
-					break;
-				}
-			}
-
-			// Delete the metadata array
-			delete [] mValues;
+        if (mValues)
+        {
+            // Delete each metadata entry
+            for (unsigned i=0; i<mNumProperties; ++i)
+            {
+                void* data = mValues[i].mData;
+                switch (mValues[i].mType)
+                {
+                case AI_BOOL:
+                    delete static_cast<bool*>(data);
+                    break;
+                case AI_INT:
+                    delete static_cast<int*>(data);
+                    break;
+                case AI_UINT64:
+                    delete static_cast<uint64_t*>(data);
+                    break;
+                case AI_FLOAT:
+                    delete static_cast<float*>(data);
+                    break;
+                case AI_AISTRING:
+                    delete static_cast<aiString*>(data);
+                    break;
+                case AI_AIVECTOR3D:
+                    delete static_cast<aiVector3D*>(data);
+                    break;
+                default:
+                    assert(false);
+                    break;
+                }
+            }
+
+            // Delete the metadata array
+            delete [] mValues;
             mValues = NULL;
-		}
-	}
+        }
+    }
 
 
 
-	template<typename T>
-	inline void Set( unsigned index, const std::string& key, const T& value )
-	{
-		// In range assertion
-		assert(index < mNumProperties);
+    template<typename T>
+    inline void Set( unsigned index, const std::string& key, const T& value )
+    {
+        // In range assertion
+        assert(index < mNumProperties);
 
-		// Set metadata key
-		mKeys[index] = key;
+        // Set metadata key
+        mKeys[index] = key;
 
-		// Set metadata type
-		mValues[index].mType = GetAiType(value);
-		// Copy the given value to the dynamic storage
-		mValues[index].mData = new T(value);
-	}
+        // Set metadata type
+        mValues[index].mType = GetAiType(value);
+        // Copy the given value to the dynamic storage
+        mValues[index].mData = new T(value);
+    }
 
-	template<typename T>
-	inline bool Get( unsigned index, T& value )
-	{
-		// In range assertion
-		assert(index < mNumProperties);
+    template<typename T>
+    inline bool Get( unsigned index, T& value )
+    {
+        // In range assertion
+        assert(index < mNumProperties);
 
-		// Return false if the output data type does
-		// not match the found value's data type
+        // Return false if the output data type does
+        // not match the found value's data type
         if ( GetAiType( value ) != mValues[ index ].mType ) {
             return false;
         }
 
-		// Otherwise, output the found value and
-		// return true
-		value = *static_cast<T*>(mValues[index].mData);
-		return true;
-	}
-
-	template<typename T>
-	inline bool Get( const aiString& key, T& value )
-	{
-		// Search for the given key
-		for (unsigned i=0; i<mNumProperties; ++i)
-			if (mKeys[i]==key)
-				return Get(i, value);
-		return false;
-	}
-
-	template<typename T>
-	inline bool Get( const std::string& key, T& value ) {
+        // Otherwise, output the found value and
+        // return true
+        value = *static_cast<T*>(mValues[index].mData);
+        return true;
+    }
+
+    template<typename T>
+    inline bool Get( const aiString& key, T& value )
+    {
+        // Search for the given key
+        for (unsigned i=0; i<mNumProperties; ++i)
+            if (mKeys[i]==key)
+                return Get(i, value);
+        return false;
+    }
+
+    template<typename T>
+    inline bool Get( const std::string& key, T& value ) {
         return Get(aiString(key), value);
     }
 

include/assimp/postprocess.h

@@ -65,469 +65,469 @@ extern "C" {
 enum aiPostProcessSteps
 {
 
-	// -------------------------------------------------------------------------
-	/** <hr>Calculates the tangents and bitangents for the imported meshes.
-	 *
-	 * Does nothing if a mesh does not have normals. You might want this post
-	 * processing step to be executed if you plan to use tangent space calculations
-	 * such as normal mapping  applied to the meshes. There's an importer property,
-	 * <tt>#AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE</tt>, which allows you to specify
-	 * a maximum smoothing angle for the algorithm. However, usually you'll
-	 * want to leave it at the default value.
-	 */
-	aiProcess_CalcTangentSpace = 0x1,
-
-	// -------------------------------------------------------------------------
-	/** <hr>Identifies and joins identical vertex data sets within all
-	 *  imported meshes.
-	 *
-	 * After this step is run, each mesh contains unique vertices,
-	 * so a vertex may be used by multiple faces. You usually want
-	 * to use this post processing step. If your application deals with
-	 * indexed geometry, this step is compulsory or you'll just waste rendering
-	 * time. <b>If this flag is not specified</b>, no vertices are referenced by
-	 * more than one face and <b>no index buffer is required</b> for rendering.
-	 */
-	aiProcess_JoinIdenticalVertices = 0x2,
-
-	// -------------------------------------------------------------------------
-	/** <hr>Converts all the imported data to a left-handed coordinate space.
-	 *
-	 * By default the data is returned in a right-handed coordinate space (which
-	 * OpenGL prefers). In this space, +X points to the right,
-	 * +Z points towards the viewer, and +Y points upwards. In the DirectX
+    // -------------------------------------------------------------------------
+    /** <hr>Calculates the tangents and bitangents for the imported meshes.
+     *
+     * Does nothing if a mesh does not have normals. You might want this post
+     * processing step to be executed if you plan to use tangent space calculations
+     * such as normal mapping  applied to the meshes. There's an importer property,
+     * <tt>#AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE</tt>, which allows you to specify
+     * a maximum smoothing angle for the algorithm. However, usually you'll
+     * want to leave it at the default value.
+     */
+    aiProcess_CalcTangentSpace = 0x1,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Identifies and joins identical vertex data sets within all
+     *  imported meshes.
+     *
+     * After this step is run, each mesh contains unique vertices,
+     * so a vertex may be used by multiple faces. You usually want
+     * to use this post processing step. If your application deals with
+     * indexed geometry, this step is compulsory or you'll just waste rendering
+     * time. <b>If this flag is not specified</b>, no vertices are referenced by
+     * more than one face and <b>no index buffer is required</b> for rendering.
+     */
+    aiProcess_JoinIdenticalVertices = 0x2,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Converts all the imported data to a left-handed coordinate space.
+     *
+     * By default the data is returned in a right-handed coordinate space (which
+     * OpenGL prefers). In this space, +X points to the right,
+     * +Z points towards the viewer, and +Y points upwards. In the DirectX
      * coordinate space +X points to the right, +Y points upwards, and +Z points
      * away from the viewer.
-	 *
-	 * You'll probably want to consider this flag if you use Direct3D for
-	 * rendering. The #aiProcess_ConvertToLeftHanded flag supersedes this
-	 * setting and bundles all conversions typically required for D3D-based
-	 * applications.
-	 */
-	aiProcess_MakeLeftHanded = 0x4,
-
-	// -------------------------------------------------------------------------
-	/** <hr>Triangulates all faces of all meshes.
-	 *
-	 * By default the imported mesh data might contain faces with more than 3
-	 * indices. For rendering you'll usually want all faces to be triangles.
-	 * This post processing step splits up faces with more than 3 indices into
-	 * triangles. Line and point primitives are *not* modified! If you want
-	 * 'triangles only' with no other kinds of primitives, try the following
-	 * solution:
-	 * <ul>
-	 * <li>Specify both #aiProcess_Triangulate and #aiProcess_SortByPType </li>
-	 * <li>Ignore all point and line meshes when you process assimp's output</li>
-	 * </ul>
-	 */
-	aiProcess_Triangulate = 0x8,
-
-	// -------------------------------------------------------------------------
-	/** <hr>Removes some parts of the data structure (animations, materials,
-	 *  light sources, cameras, textures, vertex components).
-	 *
-	 * The  components to be removed are specified in a separate
-	 * importer property, <tt>#AI_CONFIG_PP_RVC_FLAGS</tt>. This is quite useful
-	 * if you don't need all parts of the output structure. Vertex colors
-	 * are rarely used today for example... Calling this step to remove unneeded
-	 * data from the pipeline as early as possible results in increased
-	 * performance and a more optimized output data structure.
-	 * This step is also useful if you want to force Assimp to recompute
-	 * normals or tangents. The corresponding steps don't recompute them if
-	 * they're already there (loaded from the source asset). By using this
-	 * step you can make sure they are NOT there.
-	 *
-	 * This flag is a poor one, mainly because its purpose is usually
+     *
+     * You'll probably want to consider this flag if you use Direct3D for
+     * rendering. The #aiProcess_ConvertToLeftHanded flag supersedes this
+     * setting and bundles all conversions typically required for D3D-based
+     * applications.
+     */
+    aiProcess_MakeLeftHanded = 0x4,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Triangulates all faces of all meshes.
+     *
+     * By default the imported mesh data might contain faces with more than 3
+     * indices. For rendering you'll usually want all faces to be triangles.
+     * This post processing step splits up faces with more than 3 indices into
+     * triangles. Line and point primitives are *not* modified! If you want
+     * 'triangles only' with no other kinds of primitives, try the following
+     * solution:
+     * <ul>
+     * <li>Specify both #aiProcess_Triangulate and #aiProcess_SortByPType </li>
+     * <li>Ignore all point and line meshes when you process assimp's output</li>
+     * </ul>
+     */
+    aiProcess_Triangulate = 0x8,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Removes some parts of the data structure (animations, materials,
+     *  light sources, cameras, textures, vertex components).
+     *
+     * The  components to be removed are specified in a separate
+     * importer property, <tt>#AI_CONFIG_PP_RVC_FLAGS</tt>. This is quite useful
+     * if you don't need all parts of the output structure. Vertex colors
+     * are rarely used today for example... Calling this step to remove unneeded
+     * data from the pipeline as early as possible results in increased
+     * performance and a more optimized output data structure.
+     * This step is also useful if you want to force Assimp to recompute
+     * normals or tangents. The corresponding steps don't recompute them if
+     * they're already there (loaded from the source asset). By using this
+     * step you can make sure they are NOT there.
+     *
+     * This flag is a poor one, mainly because its purpose is usually
      * misunderstood. Consider the following case: a 3D model has been exported
-	 * from a CAD app, and it has per-face vertex colors. Vertex positions can't be
-	 * shared, thus the #aiProcess_JoinIdenticalVertices step fails to
-	 * optimize the data because of these nasty little vertex colors.
-	 * Most apps don't even process them, so it's all for nothing. By using
-	 * this step, unneeded components are excluded as early as possible
-	 * thus opening more room for internal optimizations.
-	 */
-	aiProcess_RemoveComponent = 0x10,
-
-	// -------------------------------------------------------------------------
-	/** <hr>Generates normals for all faces of all meshes.
-	 *
-	 * This is ignored if normals are already there at the time this flag
-	 * is evaluated. Model importers try to load them from the source file, so
-	 * they're usually already there. Face normals are shared between all points
-	 * of a single face, so a single point can have multiple normals, which
-	 * forces the library to duplicate vertices in some cases.
-	 * #aiProcess_JoinIdenticalVertices is *senseless* then.
-	 *
-	 * This flag may not be specified together with #aiProcess_GenSmoothNormals.
-	 */
-	aiProcess_GenNormals = 0x20,
-
-	// -------------------------------------------------------------------------
-	/** <hr>Generates smooth normals for all vertices in the mesh.
-	*
-	* This is ignored if normals are already there at the time this flag
-	* is evaluated. Model importers try to load them from the source file, so
-	* they're usually already there.
-	*
-	* This flag may not be specified together with
-	* #aiProcess_GenNormals. There's a importer property,
-	* <tt>#AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE</tt> which allows you to specify
-	* an angle maximum for the normal smoothing algorithm. Normals exceeding
-	* this limit are not smoothed, resulting in a 'hard' seam between two faces.
-	* Using a decent angle here (e.g. 80 degrees) results in very good visual
-	* appearance.
-	*/
-	aiProcess_GenSmoothNormals = 0x40,
-
-	// -------------------------------------------------------------------------
-	/** <hr>Splits large meshes into smaller sub-meshes.
-	*
-	* This is quite useful for real-time rendering, where the number of triangles
-	* which can be maximally processed in a single draw-call is limited
-	* by the video driver/hardware. The maximum vertex buffer is usually limited
-	* too. Both requirements can be met with this step: you may specify both a
-	* triangle and vertex limit for a single mesh.
-	*
-	* The split limits can (and should!) be set through the
-	* <tt>#AI_CONFIG_PP_SLM_VERTEX_LIMIT</tt> and <tt>#AI_CONFIG_PP_SLM_TRIANGLE_LIMIT</tt>
-	* importer properties. The default values are <tt>#AI_SLM_DEFAULT_MAX_VERTICES</tt> and
-	* <tt>#AI_SLM_DEFAULT_MAX_TRIANGLES</tt>.
-	*
-	* Note that splitting is generally a time-consuming task, but only if there's
-	* something to split. The use of this step is recommended for most users.
-	*/
-	aiProcess_SplitLargeMeshes = 0x80,
-
-	// -------------------------------------------------------------------------
-	/** <hr>Removes the node graph and pre-transforms all vertices with
-	* the local transformation matrices of their nodes.
-	*
-	* The output scene still contains nodes, however there is only a
-	* root node with children, each one referencing only one mesh,
-	* and each mesh referencing one material. For rendering, you can
-	* simply render all meshes in order - you don't need to pay
-	* attention to local transformations and the node hierarchy.
-	* Animations are removed during this step.
-	* This step is intended for applications without a scenegraph.
-	* The step CAN cause some problems: if e.g. a mesh of the asset
-	* contains normals and another, using the same material index, does not,
-	* they will be brought together, but the first meshes's part of
-	* the normal list is zeroed. However, these artifacts are rare.
-	* @note The <tt>#AI_CONFIG_PP_PTV_NORMALIZE</tt> configuration property
-	* can be set to normalize the scene's spatial dimension to the -1...1
-	* range.
-	*/
-	aiProcess_PreTransformVertices = 0x100,
-
-	// -------------------------------------------------------------------------
-	/** <hr>Limits the number of bones simultaneously affecting a single vertex
-	*  to a maximum value.
-	*
-	* If any vertex is affected by more than the maximum number of bones, the least
-	* important vertex weights are removed and the remaining vertex weights are
-	* renormalized so that the weights still sum up to 1.
-	* The default bone weight limit is 4 (defined as <tt>#AI_LMW_MAX_WEIGHTS</tt> in
-	* config.h), but you can use the <tt>#AI_CONFIG_PP_LBW_MAX_WEIGHTS</tt> importer
-	* property to supply your own limit to the post processing step.
-	*
-	* If you intend to perform the skinning in hardware, this post processing
-	* step might be of interest to you.
-	*/
-	aiProcess_LimitBoneWeights = 0x200,
-
-	// -------------------------------------------------------------------------
-	/** <hr>Validates the imported scene data structure.
-	 * This makes sure that all indices are valid, all animations and
-	 * bones are linked correctly, all material references are correct .. etc.
-	 *
-	 * It is recommended that you capture Assimp's log output if you use this flag,
-	 * so you can easily find out what's wrong if a file fails the
-	 * validation. The validator is quite strict and will find *all*
-	 * inconsistencies in the data structure... It is recommended that plugin
-	 * developers use it to debug their loaders. There are two types of
-	 * validation failures:
-	 * <ul>
-	 * <li>Error: There's something wrong with the imported data. Further
-	 *   postprocessing is not possible and the data is not usable at all.
-	 *   The import fails. #Importer::GetErrorString() or #aiGetErrorString()
-	 *   carry the error message around.</li>
-	 * <li>Warning: There are some minor issues (e.g. 1000000 animation
-	 *   keyframes with the same time), but further postprocessing and use
-	 *   of the data structure is still safe. Warning details are written
-	 *   to the log file, <tt>#AI_SCENE_FLAGS_VALIDATION_WARNING</tt> is set
-	 *   in #aiScene::mFlags</li>
-	 * </ul>
-	 *
-	 * This post-processing step is not time-consuming. Its use is not
-	 * compulsory, but recommended.
-	*/
-	aiProcess_ValidateDataStructure = 0x400,
-
-	// -------------------------------------------------------------------------
-	/** <hr>Reorders triangles for better vertex cache locality.
-	 *
-	 * The step tries to improve the ACMR (average post-transform vertex cache
-	 * miss ratio) for all meshes. The implementation runs in O(n) and is
-	 * roughly based on the 'tipsify' algorithm (see <a href="
-	 * http://www.cs.princeton.edu/gfx/pubs/Sander_2007_%3ETR/tipsy.pdf">this
-	 * paper</a>).
-	 *
-	 * If you intend to render huge models in hardware, this step might
-	 * be of interest to you. The <tt>#AI_CONFIG_PP_ICL_PTCACHE_SIZE</tt>
-	 * importer property can be used to fine-tune the cache optimization.
-	 */
-	aiProcess_ImproveCacheLocality = 0x800,
-
-	// -------------------------------------------------------------------------
-	/** <hr>Searches for redundant/unreferenced materials and removes them.
-	 *
-	 * This is especially useful in combination with the
-	 * #aiProcess_PreTransformVertices and #aiProcess_OptimizeMeshes flags.
-	 * Both join small meshes with equal characteristics, but they can't do
-	 * their work if two meshes have different materials. Because several
-	 * material settings are lost during Assimp's import filters,
-	 * (and because many exporters don't check for redundant materials), huge
-	 * models often have materials which are are defined several times with
-	 * exactly the same settings.
-	 *
-	 * Several material settings not contributing to the final appearance of
-	 * a surface are ignored in all comparisons (e.g. the material name).
-	 * So, if you're passing additional information through the
-	 * content pipeline (probably using *magic* material names), don't
-	 * specify this flag. Alternatively take a look at the
-	 * <tt>#AI_CONFIG_PP_RRM_EXCLUDE_LIST</tt> importer property.
-	 */
-	aiProcess_RemoveRedundantMaterials = 0x1000,
-
-	// -------------------------------------------------------------------------
-	/** <hr>This step tries to determine which meshes have normal vectors
-	 * that are facing inwards and inverts them.
-	 *
-	 * The algorithm is simple but effective:
-	 * the bounding box of all vertices + their normals is compared against
-	 * the volume of the bounding box of all vertices without their normals.
-	 * This works well for most objects, problems might occur with planar
-	 * surfaces. However, the step tries to filter such cases.
-	 * The step inverts all in-facing normals. Generally it is recommended
-	 * to enable this step, although the result is not always correct.
-	*/
-	aiProcess_FixInfacingNormals = 0x2000,
-
-	// -------------------------------------------------------------------------
-	/** <hr>This step splits meshes with more than one primitive type in
-	 *  homogeneous sub-meshes.
-	 *
-	 *  The step is executed after the triangulation step. After the step
-	 *  returns, just one bit is set in aiMesh::mPrimitiveTypes. This is
-	 *  especially useful for real-time rendering where point and line
-	 *  primitives are often ignored or rendered separately.
-	 *  You can use the <tt>#AI_CONFIG_PP_SBP_REMOVE</tt> importer property to
-	 *  specify which primitive types you need. This can be used to easily
-	 *  exclude lines and points, which are rarely used, from the import.
-	*/
-	aiProcess_SortByPType = 0x8000,
-
-	// -------------------------------------------------------------------------
-	/** <hr>This step searches all meshes for degenerate primitives and
-	 *  converts them to proper lines or points.
-	 *
-	 * A face is 'degenerate' if one or more of its points are identical.
-	 * To have the degenerate stuff not only detected and collapsed but
-	 * removed, try one of the following procedures:
-	 * <br><b>1.</b> (if you support lines and points for rendering but don't
-	 *    want the degenerates)<br>
-	 * <ul>
-	 *   <li>Specify the #aiProcess_FindDegenerates flag.
-	 *   </li>
-	 *   <li>Set the <tt>#AI_CONFIG_PP_FD_REMOVE</tt> importer property to
-	 *       1. This will cause the step to remove degenerate triangles from the
-	 *       import as soon as they're detected. They won't pass any further
-	 *       pipeline steps.
-	 *   </li>
-	 * </ul>
-	 * <br><b>2.</b>(if you don't support lines and points at all)<br>
-	 * <ul>
-	 *   <li>Specify the #aiProcess_FindDegenerates flag.
-	 *   </li>
-	 *   <li>Specify the #aiProcess_SortByPType flag. This moves line and
-	 *     point primitives to separate meshes.
-	 *   </li>
-	 *   <li>Set the <tt>#AI_CONFIG_PP_SBP_REMOVE</tt> importer property to
-	 *       @code aiPrimitiveType_POINTS | aiPrimitiveType_LINES
-	 *       @endcode to cause SortByPType to reject point
-	 *       and line meshes from the scene.
-	 *   </li>
-	 * </ul>
-	 * @note Degenerate polygons are not necessarily evil and that's why
-	 * they're not removed by default. There are several file formats which
-	 * don't support lines or points, and some exporters bypass the
-	 * format specification and write them as degenerate triangles instead.
-	*/
-	aiProcess_FindDegenerates = 0x10000,
-
-	// -------------------------------------------------------------------------
-	/** <hr>This step searches all meshes for invalid data, such as zeroed
-	 *  normal vectors or invalid UV coords and removes/fixes them. This is
-	 *  intended to get rid of some common exporter errors.
-	 *
-	 * This is especially useful for normals. If they are invalid, and
-	 * the step recognizes this, they will be removed and can later
-	 * be recomputed, i.e. by the #aiProcess_GenSmoothNormals flag.<br>
-	 * The step will also remove meshes that are infinitely small and reduce
-	 * animation tracks consisting of hundreds if redundant keys to a single
-	 * key. The <tt>AI_CONFIG_PP_FID_ANIM_ACCURACY</tt> config property decides
-	 * the accuracy of the check for duplicate animation tracks.
-	*/
-	aiProcess_FindInvalidData = 0x20000,
-
-	// -------------------------------------------------------------------------
-	/** <hr>This step converts non-UV mappings (such as spherical or
-	 *  cylindrical mapping) to proper texture coordinate channels.
-	 *
-	 * Most applications will support UV mapping only, so you will
-	 * probably want to specify this step in every case. Note that Assimp is not
-	 * always able to match the original mapping implementation of the
-	 * 3D app which produced a model perfectly. It's always better to let the
-	 * modelling app compute the UV channels - 3ds max, Maya, Blender,
-	 * LightWave, and Modo do this for example.
-	 *
-	 * @note If this step is not requested, you'll need to process the
-	 * <tt>#AI_MATKEY_MAPPING</tt> material property in order to display all assets
-	 * properly.
-	 */
-	aiProcess_GenUVCoords = 0x40000,
-
-	// -------------------------------------------------------------------------
-	/** <hr>This step applies per-texture UV transformations and bakes
-	 *  them into stand-alone vtexture coordinate channels.
-	 *
-	 * UV transformations are specified per-texture - see the
-	 * <tt>#AI_MATKEY_UVTRANSFORM</tt> material key for more information.
-	 * This step processes all textures with
-	 * transformed input UV coordinates and generates a new (pre-transformed) UV channel
-	 * which replaces the old channel. Most applications won't support UV
-	 * transformations, so you will probably want to specify this step.
-     *
-	 * @note UV transformations are usually implemented in real-time apps by
-	 * transforming texture coordinates at vertex shader stage with a 3x3
-	 * (homogenous) transformation matrix.
-	*/
-	aiProcess_TransformUVCoords = 0x80000,
-
-	// -------------------------------------------------------------------------
-	/** <hr>This step searches for duplicate meshes and replaces them
-	 *  with references to the first mesh.
-	 *
-	 *  This step takes a while, so don't use it if speed is a concern.
-	 *  Its main purpose is to workaround the fact that many export
-	 *  file formats don't support instanced meshes, so exporters need to
-	 *  duplicate meshes. This step removes the duplicates again. Please
- 	 *  note that Assimp does not currently support per-node material
-	 *  assignment to meshes, which means that identical meshes with
-	 *  different materials are currently *not* joined, although this is
-	 *  planned for future versions.
-	 */
-	aiProcess_FindInstances = 0x100000,
-
-	// -------------------------------------------------------------------------
-	/** <hr>A postprocessing step to reduce the number of meshes.
-	 *
-	 *  This will, in fact, reduce the number of draw calls.
-	 *
-	 *  This is a very effective optimization and is recommended to be used
-	 *  together with #aiProcess_OptimizeGraph, if possible. The flag is fully
-	 *  compatible with both #aiProcess_SplitLargeMeshes and #aiProcess_SortByPType.
-	*/
-	aiProcess_OptimizeMeshes  = 0x200000,
-
-
-	// -------------------------------------------------------------------------
-	/** <hr>A postprocessing step to optimize the scene hierarchy.
-	 *
-	 *  Nodes without animations, bones, lights or cameras assigned are
-	 *  collapsed and joined.
-	 *
-	 *  Node names can be lost during this step. If you use special 'tag nodes'
-	 *  to pass additional information through your content pipeline, use the
-	 *  <tt>#AI_CONFIG_PP_OG_EXCLUDE_LIST</tt> importer property to specify a
-	 *  list of node names you want to be kept. Nodes matching one of the names
-	 *  in this list won't be touched or modified.
-	 *
-	 *  Use this flag with caution. Most simple files will be collapsed to a
-	 *  single node, so complex hierarchies are usually completely lost. This is not
-	 *  useful for editor environments, but probably a very effective
-	 *  optimization if you just want to get the model data, convert it to your
-	 *  own format, and render it as fast as possible.
-	 *
-	 *  This flag is designed to be used with #aiProcess_OptimizeMeshes for best
-	 *  results.
-	 *
-	 *  @note 'Crappy' scenes with thousands of extremely small meshes packed
-	 *  in deeply nested nodes exist for almost all file formats.
-	 *  #aiProcess_OptimizeMeshes in combination with #aiProcess_OptimizeGraph
-	 *  usually fixes them all and makes them renderable.
-	*/
-	aiProcess_OptimizeGraph  = 0x400000,
-
-	// -------------------------------------------------------------------------
-	/** <hr>This step flips all UV coordinates along the y-axis and adjusts
-	 * material settings and bitangents accordingly.
-	 *
-	 * <b>Output UV coordinate system:</b>
-	 * @code
-	 * 0y|0y ---------- 1x|0y
+     * from a CAD app, and it has per-face vertex colors. Vertex positions can't be
+     * shared, thus the #aiProcess_JoinIdenticalVertices step fails to
+     * optimize the data because of these nasty little vertex colors.
+     * Most apps don't even process them, so it's all for nothing. By using
+     * this step, unneeded components are excluded as early as possible
+     * thus opening more room for internal optimizations.
+     */
+    aiProcess_RemoveComponent = 0x10,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Generates normals for all faces of all meshes.
+     *
+     * This is ignored if normals are already there at the time this flag
+     * is evaluated. Model importers try to load them from the source file, so
+     * they're usually already there. Face normals are shared between all points
+     * of a single face, so a single point can have multiple normals, which
+     * forces the library to duplicate vertices in some cases.
+     * #aiProcess_JoinIdenticalVertices is *senseless* then.
+     *
+     * This flag may not be specified together with #aiProcess_GenSmoothNormals.
+     */
+    aiProcess_GenNormals = 0x20,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Generates smooth normals for all vertices in the mesh.
+    *
+    * This is ignored if normals are already there at the time this flag
+    * is evaluated. Model importers try to load them from the source file, so
+    * they're usually already there.
+    *
+    * This flag may not be specified together with
+    * #aiProcess_GenNormals. There's a importer property,
+    * <tt>#AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE</tt> which allows you to specify
+    * an angle maximum for the normal smoothing algorithm. Normals exceeding
+    * this limit are not smoothed, resulting in a 'hard' seam between two faces.
+    * Using a decent angle here (e.g. 80 degrees) results in very good visual
+    * appearance.
+    */
+    aiProcess_GenSmoothNormals = 0x40,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Splits large meshes into smaller sub-meshes.
+    *
+    * This is quite useful for real-time rendering, where the number of triangles
+    * which can be maximally processed in a single draw-call is limited
+    * by the video driver/hardware. The maximum vertex buffer is usually limited
+    * too. Both requirements can be met with this step: you may specify both a
+    * triangle and vertex limit for a single mesh.
+    *
+    * The split limits can (and should!) be set through the
+    * <tt>#AI_CONFIG_PP_SLM_VERTEX_LIMIT</tt> and <tt>#AI_CONFIG_PP_SLM_TRIANGLE_LIMIT</tt>
+    * importer properties. The default values are <tt>#AI_SLM_DEFAULT_MAX_VERTICES</tt> and
+    * <tt>#AI_SLM_DEFAULT_MAX_TRIANGLES</tt>.
+    *
+    * Note that splitting is generally a time-consuming task, but only if there's
+    * something to split. The use of this step is recommended for most users.
+    */
+    aiProcess_SplitLargeMeshes = 0x80,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Removes the node graph and pre-transforms all vertices with
+    * the local transformation matrices of their nodes.
+    *
+    * The output scene still contains nodes, however there is only a
+    * root node with children, each one referencing only one mesh,
+    * and each mesh referencing one material. For rendering, you can
+    * simply render all meshes in order - you don't need to pay
+    * attention to local transformations and the node hierarchy.
+    * Animations are removed during this step.
+    * This step is intended for applications without a scenegraph.
+    * The step CAN cause some problems: if e.g. a mesh of the asset
+    * contains normals and another, using the same material index, does not,
+    * they will be brought together, but the first meshes's part of
+    * the normal list is zeroed. However, these artifacts are rare.
+    * @note The <tt>#AI_CONFIG_PP_PTV_NORMALIZE</tt> configuration property
+    * can be set to normalize the scene's spatial dimension to the -1...1
+    * range.
+    */
+    aiProcess_PreTransformVertices = 0x100,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Limits the number of bones simultaneously affecting a single vertex
+    *  to a maximum value.
+    *
+    * If any vertex is affected by more than the maximum number of bones, the least
+    * important vertex weights are removed and the remaining vertex weights are
+    * renormalized so that the weights still sum up to 1.
+    * The default bone weight limit is 4 (defined as <tt>#AI_LMW_MAX_WEIGHTS</tt> in
+    * config.h), but you can use the <tt>#AI_CONFIG_PP_LBW_MAX_WEIGHTS</tt> importer
+    * property to supply your own limit to the post processing step.
+    *
+    * If you intend to perform the skinning in hardware, this post processing
+    * step might be of interest to you.
+    */
+    aiProcess_LimitBoneWeights = 0x200,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Validates the imported scene data structure.
+     * This makes sure that all indices are valid, all animations and
+     * bones are linked correctly, all material references are correct .. etc.
+     *
+     * It is recommended that you capture Assimp's log output if you use this flag,
+     * so you can easily find out what's wrong if a file fails the
+     * validation. The validator is quite strict and will find *all*
+     * inconsistencies in the data structure... It is recommended that plugin
+     * developers use it to debug their loaders. There are two types of
+     * validation failures:
+     * <ul>
+     * <li>Error: There's something wrong with the imported data. Further
+     *   postprocessing is not possible and the data is not usable at all.
+     *   The import fails. #Importer::GetErrorString() or #aiGetErrorString()
+     *   carry the error message around.</li>
+     * <li>Warning: There are some minor issues (e.g. 1000000 animation
+     *   keyframes with the same time), but further postprocessing and use
+     *   of the data structure is still safe. Warning details are written
+     *   to the log file, <tt>#AI_SCENE_FLAGS_VALIDATION_WARNING</tt> is set
+     *   in #aiScene::mFlags</li>
+     * </ul>
+     *
+     * This post-processing step is not time-consuming. Its use is not
+     * compulsory, but recommended.
+    */
+    aiProcess_ValidateDataStructure = 0x400,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Reorders triangles for better vertex cache locality.
+     *
+     * The step tries to improve the ACMR (average post-transform vertex cache
+     * miss ratio) for all meshes. The implementation runs in O(n) and is
+     * roughly based on the 'tipsify' algorithm (see <a href="
+     * http://www.cs.princeton.edu/gfx/pubs/Sander_2007_%3ETR/tipsy.pdf">this
+     * paper</a>).
+     *
+     * If you intend to render huge models in hardware, this step might
+     * be of interest to you. The <tt>#AI_CONFIG_PP_ICL_PTCACHE_SIZE</tt>
+     * importer property can be used to fine-tune the cache optimization.
+     */
+    aiProcess_ImproveCacheLocality = 0x800,
+
+    // -------------------------------------------------------------------------
+    /** <hr>Searches for redundant/unreferenced materials and removes them.
+     *
+     * This is especially useful in combination with the
+     * #aiProcess_PreTransformVertices and #aiProcess_OptimizeMeshes flags.
+     * Both join small meshes with equal characteristics, but they can't do
+     * their work if two meshes have different materials. Because several
+     * material settings are lost during Assimp's import filters,
+     * (and because many exporters don't check for redundant materials), huge
+     * models often have materials which are are defined several times with
+     * exactly the same settings.
+     *
+     * Several material settings not contributing to the final appearance of
+     * a surface are ignored in all comparisons (e.g. the material name).
+     * So, if you're passing additional information through the
+     * content pipeline (probably using *magic* material names), don't
+     * specify this flag. Alternatively take a look at the
+     * <tt>#AI_CONFIG_PP_RRM_EXCLUDE_LIST</tt> importer property.
+     */
+    aiProcess_RemoveRedundantMaterials = 0x1000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step tries to determine which meshes have normal vectors
+     * that are facing inwards and inverts them.
+     *
+     * The algorithm is simple but effective:
+     * the bounding box of all vertices + their normals is compared against
+     * the volume of the bounding box of all vertices without their normals.
+     * This works well for most objects, problems might occur with planar
+     * surfaces. However, the step tries to filter such cases.
+     * The step inverts all in-facing normals. Generally it is recommended
+     * to enable this step, although the result is not always correct.
+    */
+    aiProcess_FixInfacingNormals = 0x2000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step splits meshes with more than one primitive type in
+     *  homogeneous sub-meshes.
+     *
+     *  The step is executed after the triangulation step. After the step
+     *  returns, just one bit is set in aiMesh::mPrimitiveTypes. This is
+     *  especially useful for real-time rendering where point and line
+     *  primitives are often ignored or rendered separately.
+     *  You can use the <tt>#AI_CONFIG_PP_SBP_REMOVE</tt> importer property to
+     *  specify which primitive types you need. This can be used to easily
+     *  exclude lines and points, which are rarely used, from the import.
+    */
+    aiProcess_SortByPType = 0x8000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step searches all meshes for degenerate primitives and
+     *  converts them to proper lines or points.
+     *
+     * A face is 'degenerate' if one or more of its points are identical.
+     * To have the degenerate stuff not only detected and collapsed but
+     * removed, try one of the following procedures:
+     * <br><b>1.</b> (if you support lines and points for rendering but don't
+     *    want the degenerates)<br>
+     * <ul>
+     *   <li>Specify the #aiProcess_FindDegenerates flag.
+     *   </li>
+     *   <li>Set the <tt>#AI_CONFIG_PP_FD_REMOVE</tt> importer property to
+     *       1. This will cause the step to remove degenerate triangles from the
+     *       import as soon as they're detected. They won't pass any further
+     *       pipeline steps.
+     *   </li>
+     * </ul>
+     * <br><b>2.</b>(if you don't support lines and points at all)<br>
+     * <ul>
+     *   <li>Specify the #aiProcess_FindDegenerates flag.
+     *   </li>
+     *   <li>Specify the #aiProcess_SortByPType flag. This moves line and
+     *     point primitives to separate meshes.
+     *   </li>
+     *   <li>Set the <tt>#AI_CONFIG_PP_SBP_REMOVE</tt> importer property to
+     *       @code aiPrimitiveType_POINTS | aiPrimitiveType_LINES
+     *       @endcode to cause SortByPType to reject point
+     *       and line meshes from the scene.
+     *   </li>
+     * </ul>
+     * @note Degenerate polygons are not necessarily evil and that's why
+     * they're not removed by default. There are several file formats which
+     * don't support lines or points, and some exporters bypass the
+     * format specification and write them as degenerate triangles instead.
+    */
+    aiProcess_FindDegenerates = 0x10000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step searches all meshes for invalid data, such as zeroed
+     *  normal vectors or invalid UV coords and removes/fixes them. This is
+     *  intended to get rid of some common exporter errors.
+     *
+     * This is especially useful for normals. If they are invalid, and
+     * the step recognizes this, they will be removed and can later
+     * be recomputed, i.e. by the #aiProcess_GenSmoothNormals flag.<br>
+     * The step will also remove meshes that are infinitely small and reduce
+     * animation tracks consisting of hundreds if redundant keys to a single
+     * key. The <tt>AI_CONFIG_PP_FID_ANIM_ACCURACY</tt> config property decides
+     * the accuracy of the check for duplicate animation tracks.
+    */
+    aiProcess_FindInvalidData = 0x20000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step converts non-UV mappings (such as spherical or
+     *  cylindrical mapping) to proper texture coordinate channels.
+     *
+     * Most applications will support UV mapping only, so you will
+     * probably want to specify this step in every case. Note that Assimp is not
+     * always able to match the original mapping implementation of the
+     * 3D app which produced a model perfectly. It's always better to let the
+     * modelling app compute the UV channels - 3ds max, Maya, Blender,
+     * LightWave, and Modo do this for example.
+     *
+     * @note If this step is not requested, you'll need to process the
+     * <tt>#AI_MATKEY_MAPPING</tt> material property in order to display all assets
+     * properly.
+     */
+    aiProcess_GenUVCoords = 0x40000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step applies per-texture UV transformations and bakes
+     *  them into stand-alone vtexture coordinate channels.
+     *
+     * UV transformations are specified per-texture - see the
+     * <tt>#AI_MATKEY_UVTRANSFORM</tt> material key for more information.
+     * This step processes all textures with
+     * transformed input UV coordinates and generates a new (pre-transformed) UV channel
+     * which replaces the old channel. Most applications won't support UV
+     * transformations, so you will probably want to specify this step.
+     *
+     * @note UV transformations are usually implemented in real-time apps by
+     * transforming texture coordinates at vertex shader stage with a 3x3
+     * (homogenous) transformation matrix.
+    */
+    aiProcess_TransformUVCoords = 0x80000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step searches for duplicate meshes and replaces them
+     *  with references to the first mesh.
+     *
+     *  This step takes a while, so don't use it if speed is a concern.
+     *  Its main purpose is to workaround the fact that many export
+     *  file formats don't support instanced meshes, so exporters need to
+     *  duplicate meshes. This step removes the duplicates again. Please
+     *  note that Assimp does not currently support per-node material
+     *  assignment to meshes, which means that identical meshes with
+     *  different materials are currently *not* joined, although this is
+     *  planned for future versions.
+     */
+    aiProcess_FindInstances = 0x100000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>A postprocessing step to reduce the number of meshes.
+     *
+     *  This will, in fact, reduce the number of draw calls.
+     *
+     *  This is a very effective optimization and is recommended to be used
+     *  together with #aiProcess_OptimizeGraph, if possible. The flag is fully
+     *  compatible with both #aiProcess_SplitLargeMeshes and #aiProcess_SortByPType.
+    */
+    aiProcess_OptimizeMeshes  = 0x200000,
+
+
+    // -------------------------------------------------------------------------
+    /** <hr>A postprocessing step to optimize the scene hierarchy.
+     *
+     *  Nodes without animations, bones, lights or cameras assigned are
+     *  collapsed and joined.
+     *
+     *  Node names can be lost during this step. If you use special 'tag nodes'
+     *  to pass additional information through your content pipeline, use the
+     *  <tt>#AI_CONFIG_PP_OG_EXCLUDE_LIST</tt> importer property to specify a
+     *  list of node names you want to be kept. Nodes matching one of the names
+     *  in this list won't be touched or modified.
+     *
+     *  Use this flag with caution. Most simple files will be collapsed to a
+     *  single node, so complex hierarchies are usually completely lost. This is not
+     *  useful for editor environments, but probably a very effective
+     *  optimization if you just want to get the model data, convert it to your
+     *  own format, and render it as fast as possible.
+     *
+     *  This flag is designed to be used with #aiProcess_OptimizeMeshes for best
+     *  results.
+     *
+     *  @note 'Crappy' scenes with thousands of extremely small meshes packed
+     *  in deeply nested nodes exist for almost all file formats.
+     *  #aiProcess_OptimizeMeshes in combination with #aiProcess_OptimizeGraph
+     *  usually fixes them all and makes them renderable.
+    */
+    aiProcess_OptimizeGraph  = 0x400000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step flips all UV coordinates along the y-axis and adjusts
+     * material settings and bitangents accordingly.
+     *
+     * <b>Output UV coordinate system:</b>
+     * @code
+     * 0y|0y ---------- 1x|0y
      * |                 |
      * |                 |
      * |                 |
      * 0x|1y ---------- 1x|1y
-	 * @endcode
-	 *
-	 * You'll probably want to consider this flag if you use Direct3D for
-	 * rendering. The #aiProcess_ConvertToLeftHanded flag supersedes this
-	 * setting and bundles all conversions typically required for D3D-based
-	 * applications.
-	*/
-	aiProcess_FlipUVs = 0x800000,
-
-	// -------------------------------------------------------------------------
-	/** <hr>This step adjusts the output face winding order to be CW.
-	 *
-	 * The default face winding order is counter clockwise (CCW).
-	 *
-	 * <b>Output face order:</b>
-	 * @code
-	 *       x2
-	 *
-	 *                         x0
-	 *  x1
-	 * @endcode
-	*/
-	aiProcess_FlipWindingOrder  = 0x1000000,
-
-	// -------------------------------------------------------------------------
-	/** <hr>This step splits meshes with many bones into sub-meshes so that each
-	 * su-bmesh has fewer or as many bones as a given limit.
+     * @endcode
+     *
+     * You'll probably want to consider this flag if you use Direct3D for
+     * rendering. The #aiProcess_ConvertToLeftHanded flag supersedes this
+     * setting and bundles all conversions typically required for D3D-based
+     * applications.
+    */
+    aiProcess_FlipUVs = 0x800000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step adjusts the output face winding order to be CW.
+     *
+     * The default face winding order is counter clockwise (CCW).
+     *
+     * <b>Output face order:</b>
+     * @code
+     *       x2
+     *
+     *                         x0
+     *  x1
+     * @endcode
+    */
+    aiProcess_FlipWindingOrder  = 0x1000000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step splits meshes with many bones into sub-meshes so that each
+     * su-bmesh has fewer or as many bones as a given limit.
     */
-	aiProcess_SplitByBoneCount  = 0x2000000,
-
-	// -------------------------------------------------------------------------
-	/** <hr>This step removes bones losslessly or according to some threshold.
-	 *
-	 *  In some cases (i.e. formats that require it) exporters are forced to
-	 *  assign dummy bone weights to otherwise static meshes assigned to
-	 *  animated meshes. Full, weight-based skinning is expensive while
-	 *  animating nodes is extremely cheap, so this step is offered to clean up
-	 *  the data in that regard.
-	 *
-	 *  Use <tt>#AI_CONFIG_PP_DB_THRESHOLD</tt> to control this.
-	 *  Use <tt>#AI_CONFIG_PP_DB_ALL_OR_NONE</tt> if you want bones removed if and
-	 *	only if all bones within the scene qualify for removal.
+    aiProcess_SplitByBoneCount  = 0x2000000,
+
+    // -------------------------------------------------------------------------
+    /** <hr>This step removes bones losslessly or according to some threshold.
+     *
+     *  In some cases (i.e. formats that require it) exporters are forced to
+     *  assign dummy bone weights to otherwise static meshes assigned to
+     *  animated meshes. Full, weight-based skinning is expensive while
+     *  animating nodes is extremely cheap, so this step is offered to clean up
+     *  the data in that regard.
+     *
+     *  Use <tt>#AI_CONFIG_PP_DB_THRESHOLD</tt> to control this.
+     *  Use <tt>#AI_CONFIG_PP_DB_ALL_OR_NONE</tt> if you want bones removed if and
+     *  only if all bones within the scene qualify for removal.
     */
-	aiProcess_Debone  = 0x4000000
+    aiProcess_Debone  = 0x4000000
 
-	// aiProcess_GenEntityMeshes = 0x100000,
-	// aiProcess_OptimizeAnimations = 0x200000
-	// aiProcess_FixTexturePaths = 0x200000
+    // aiProcess_GenEntityMeshes = 0x100000,
+    // aiProcess_OptimizeAnimations = 0x200000
+    // aiProcess_FixTexturePaths = 0x200000
 };
 
 
@@ -543,10 +543,10 @@ enum aiPostProcessSteps
  *  @deprecated
  */
 #define aiProcess_ConvertToLeftHanded ( \
-	aiProcess_MakeLeftHanded     | \
-	aiProcess_FlipUVs            | \
-	aiProcess_FlipWindingOrder   | \
-	0 )
+    aiProcess_MakeLeftHanded     | \
+    aiProcess_FlipUVs            | \
+    aiProcess_FlipWindingOrder   | \
+    0 )
 
 
 // ---------------------------------------------------------------------------------------
@@ -564,13 +564,13 @@ enum aiPostProcessSteps
  *  use for you so it might be better to not specify them.
  */
 #define aiProcessPreset_TargetRealtime_Fast ( \
-	aiProcess_CalcTangentSpace		|  \
-	aiProcess_GenNormals			|  \
-	aiProcess_JoinIdenticalVertices |  \
-	aiProcess_Triangulate			|  \
-	aiProcess_GenUVCoords           |  \
-	aiProcess_SortByPType           |  \
-	0 )
+    aiProcess_CalcTangentSpace      |  \
+    aiProcess_GenNormals            |  \
+    aiProcess_JoinIdenticalVertices |  \
+    aiProcess_Triangulate           |  \
+    aiProcess_GenUVCoords           |  \
+    aiProcess_SortByPType           |  \
+    0 )
 
  // ---------------------------------------------------------------------------------------
  /** @def aiProcessPreset_TargetRealtime_Quality
@@ -589,19 +589,19 @@ enum aiPostProcessSteps
   *  of use for you so it might be better to not specify them.
   */
 #define aiProcessPreset_TargetRealtime_Quality ( \
-	aiProcess_CalcTangentSpace				|  \
-	aiProcess_GenSmoothNormals				|  \
-	aiProcess_JoinIdenticalVertices			|  \
-	aiProcess_ImproveCacheLocality			|  \
-	aiProcess_LimitBoneWeights				|  \
-	aiProcess_RemoveRedundantMaterials      |  \
-	aiProcess_SplitLargeMeshes				|  \
-	aiProcess_Triangulate					|  \
-	aiProcess_GenUVCoords                   |  \
-	aiProcess_SortByPType                   |  \
-	aiProcess_FindDegenerates               |  \
-	aiProcess_FindInvalidData               |  \
-	0 )
+    aiProcess_CalcTangentSpace              |  \
+    aiProcess_GenSmoothNormals              |  \
+    aiProcess_JoinIdenticalVertices         |  \
+    aiProcess_ImproveCacheLocality          |  \
+    aiProcess_LimitBoneWeights              |  \
+    aiProcess_RemoveRedundantMaterials      |  \
+    aiProcess_SplitLargeMeshes              |  \
+    aiProcess_Triangulate                   |  \
+    aiProcess_GenUVCoords                   |  \
+    aiProcess_SortByPType                   |  \
+    aiProcess_FindDegenerates               |  \
+    aiProcess_FindInvalidData               |  \
+    0 )
 
  // ---------------------------------------------------------------------------------------
  /** @def aiProcessPreset_TargetRealtime_MaxQuality
@@ -619,11 +619,11 @@ enum aiPostProcessSteps
   *  of use for you so it might be better to not specify them.
   */
 #define aiProcessPreset_TargetRealtime_MaxQuality ( \
-	aiProcessPreset_TargetRealtime_Quality   |  \
-	aiProcess_FindInstances                  |  \
-	aiProcess_ValidateDataStructure          |  \
-	aiProcess_OptimizeMeshes                 |  \
-	0 )
+    aiProcessPreset_TargetRealtime_Quality   |  \
+    aiProcess_FindInstances                  |  \
+    aiProcess_ValidateDataStructure          |  \
+    aiProcess_OptimizeMeshes                 |  \
+    0 )
 
 
 #ifdef __cplusplus

include/assimp/quaternion.h

@@ -55,61 +55,61 @@ template <typename TReal>
 class aiQuaterniont
 {
 public:
-	aiQuaterniont() : w(1.0), x(), y(), z() {}
-	aiQuaterniont(TReal pw, TReal px, TReal py, TReal pz)
-		: w(pw), x(px), y(py), z(pz) {}
+    aiQuaterniont() : w(1.0), x(), y(), z() {}
+    aiQuaterniont(TReal pw, TReal px, TReal py, TReal pz)
+        : w(pw), x(px), y(py), z(pz) {}
 
-	/** Construct from rotation matrix. Result is undefined if the matrix is not orthonormal. */
-	aiQuaterniont( const aiMatrix3x3t<TReal>& pRotMatrix);
+    /** Construct from rotation matrix. Result is undefined if the matrix is not orthonormal. */
+    aiQuaterniont( const aiMatrix3x3t<TReal>& pRotMatrix);
 
-	/** Construct from euler angles */
-	aiQuaterniont( TReal rotx, TReal roty, TReal rotz);
+    /** Construct from euler angles */
+    aiQuaterniont( TReal rotx, TReal roty, TReal rotz);
 
-	/** Construct from an axis-angle pair */
-	aiQuaterniont( aiVector3t<TReal> axis, TReal angle);
+    /** Construct from an axis-angle pair */
+    aiQuaterniont( aiVector3t<TReal> axis, TReal angle);
 
-	/** Construct from a normalized quaternion stored in a vec3 */
-	aiQuaterniont( aiVector3t<TReal> normalized);
+    /** Construct from a normalized quaternion stored in a vec3 */
+    aiQuaterniont( aiVector3t<TReal> normalized);
 
-	/** Returns a matrix representation of the quaternion */
-	aiMatrix3x3t<TReal> GetMatrix() const;
+    /** Returns a matrix representation of the quaternion */
+    aiMatrix3x3t<TReal> GetMatrix() const;
 
 public:
 
-	bool operator== (const aiQuaterniont& o) const;
-	bool operator!= (const aiQuaterniont& o) const;
+    bool operator== (const aiQuaterniont& o) const;
+    bool operator!= (const aiQuaterniont& o) const;
 
-	bool Equal(const aiQuaterniont& o, TReal epsilon = 1e-6) const;
+    bool Equal(const aiQuaterniont& o, TReal epsilon = 1e-6) const;
 
 public:
 
-	/** Normalize the quaternion */
-	aiQuaterniont& Normalize();
+    /** Normalize the quaternion */
+    aiQuaterniont& Normalize();
 
-	/** Compute quaternion conjugate */
-	aiQuaterniont& Conjugate ();
+    /** Compute quaternion conjugate */
+    aiQuaterniont& Conjugate ();
 
-	/** Rotate a point by this quaternion */
-	aiVector3t<TReal> Rotate (const aiVector3t<TReal>& in);
+    /** Rotate a point by this quaternion */
+    aiVector3t<TReal> Rotate (const aiVector3t<TReal>& in);
 
-	/** Multiply two quaternions */
-	aiQuaterniont operator* (const aiQuaterniont& two) const;
+    /** Multiply two quaternions */
+    aiQuaterniont operator* (const aiQuaterniont& two) const;
 
 public:
 
-	/** Performs a spherical interpolation between two quaternions and writes the result into the third.
-	 * @param pOut Target object to received the interpolated rotation.
-	 * @param pStart Start rotation of the interpolation at factor == 0.
-	 * @param pEnd End rotation, factor == 1.
-	 * @param pFactor Interpolation factor between 0 and 1. Values outside of this range yield undefined results.
-	 */
-	static void Interpolate( aiQuaterniont& pOut, const aiQuaterniont& pStart,
-		const aiQuaterniont& pEnd, TReal pFactor);
+    /** Performs a spherical interpolation between two quaternions and writes the result into the third.
+     * @param pOut Target object to received the interpolated rotation.
+     * @param pStart Start rotation of the interpolation at factor == 0.
+     * @param pEnd End rotation, factor == 1.
+     * @param pFactor Interpolation factor between 0 and 1. Values outside of this range yield undefined results.
+     */
+    static void Interpolate( aiQuaterniont& pOut, const aiQuaterniont& pStart,
+        const aiQuaterniont& pEnd, TReal pFactor);
 
 public:
 
-	//! w,x,y,z components of the quaternion
-	TReal w, x, y, z;
+    //! w,x,y,z components of the quaternion
+    TReal w, x, y, z;
 } ;
 
 typedef aiQuaterniont<float> aiQuaternion;
@@ -117,7 +117,7 @@ typedef aiQuaterniont<float> aiQuaternion;
 #else
 
 struct aiQuaternion {
-	float w, x, y, z;
+    float w, x, y, z;
 };
 
 #endif

include/assimp/quaternion.inl

@@ -54,24 +54,24 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 template<typename TReal>
 bool aiQuaterniont<TReal>::operator== (const aiQuaterniont& o) const
 {
-	return x == o.x && y == o.y && z == o.z && w == o.w;
+    return x == o.x && y == o.y && z == o.z && w == o.w;
 }
 
 // ---------------------------------------------------------------------------
 template<typename TReal>
 bool aiQuaterniont<TReal>::operator!= (const aiQuaterniont& o) const
 {
-	return !(*this == o);
+    return !(*this == o);
 }
 
 // ---------------------------------------------------------------------------
 template<typename TReal>
 inline bool aiQuaterniont<TReal>::Equal(const aiQuaterniont& o, TReal epsilon) const {
-	return
-		std::abs(x - o.x) <= epsilon &&
-		std::abs(y - o.y) <= epsilon &&
-		std::abs(z - o.z) <= epsilon &&
-		std::abs(w - o.w) <= epsilon;
+    return
+        std::abs(x - o.x) <= epsilon &&
+        std::abs(y - o.y) <= epsilon &&
+        std::abs(z - o.z) <= epsilon &&
+        std::abs(w - o.w) <= epsilon;
 }
 
 // ---------------------------------------------------------------------------
@@ -79,43 +79,43 @@ inline bool aiQuaterniont<TReal>::Equal(const aiQuaterniont& o, TReal epsilon) c
 template<typename TReal>
 inline aiQuaterniont<TReal>::aiQuaterniont( const aiMatrix3x3t<TReal> &pRotMatrix)
 {
-	TReal t = pRotMatrix.a1 + pRotMatrix.b2 + pRotMatrix.c3;
-
-	// large enough
-	if( t > static_cast<TReal>(0))
-	{
-		TReal s = std::sqrt(1 + t) * static_cast<TReal>(2.0);
-		x = (pRotMatrix.c2 - pRotMatrix.b3) / s;
-		y = (pRotMatrix.a3 - pRotMatrix.c1) / s;
-		z = (pRotMatrix.b1 - pRotMatrix.a2) / s;
-		w = static_cast<TReal>(0.25) * s;
-	} // else we have to check several cases
-	else if( pRotMatrix.a1 > pRotMatrix.b2 && pRotMatrix.a1 > pRotMatrix.c3 )
-	{
-		// Column 0:
-		TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.a1 - pRotMatrix.b2 - pRotMatrix.c3) * static_cast<TReal>(2.0);
-		x = static_cast<TReal>(0.25) * s;
-		y = (pRotMatrix.b1 + pRotMatrix.a2) / s;
-		z = (pRotMatrix.a3 + pRotMatrix.c1) / s;
-		w = (pRotMatrix.c2 - pRotMatrix.b3) / s;
-	}
-	else if( pRotMatrix.b2 > pRotMatrix.c3)
-	{
-		// Column 1:
-		TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.b2 - pRotMatrix.a1 - pRotMatrix.c3) * static_cast<TReal>(2.0);
-		x = (pRotMatrix.b1 + pRotMatrix.a2) / s;
-		y = static_cast<TReal>(0.25) * s;
-		z = (pRotMatrix.c2 + pRotMatrix.b3) / s;
-		w = (pRotMatrix.a3 - pRotMatrix.c1) / s;
-	} else
-	{
-		// Column 2:
-		TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.c3 - pRotMatrix.a1 - pRotMatrix.b2) * static_cast<TReal>(2.0);
-		x = (pRotMatrix.a3 + pRotMatrix.c1) / s;
-		y = (pRotMatrix.c2 + pRotMatrix.b3) / s;
-		z = static_cast<TReal>(0.25) * s;
-		w = (pRotMatrix.b1 - pRotMatrix.a2) / s;
-	}
+    TReal t = pRotMatrix.a1 + pRotMatrix.b2 + pRotMatrix.c3;
+
+    // large enough
+    if( t > static_cast<TReal>(0))
+    {
+        TReal s = std::sqrt(1 + t) * static_cast<TReal>(2.0);
+        x = (pRotMatrix.c2 - pRotMatrix.b3) / s;
+        y = (pRotMatrix.a3 - pRotMatrix.c1) / s;
+        z = (pRotMatrix.b1 - pRotMatrix.a2) / s;
+        w = static_cast<TReal>(0.25) * s;
+    } // else we have to check several cases
+    else if( pRotMatrix.a1 > pRotMatrix.b2 && pRotMatrix.a1 > pRotMatrix.c3 )
+    {
+        // Column 0:
+        TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.a1 - pRotMatrix.b2 - pRotMatrix.c3) * static_cast<TReal>(2.0);
+        x = static_cast<TReal>(0.25) * s;
+        y = (pRotMatrix.b1 + pRotMatrix.a2) / s;
+        z = (pRotMatrix.a3 + pRotMatrix.c1) / s;
+        w = (pRotMatrix.c2 - pRotMatrix.b3) / s;
+    }
+    else if( pRotMatrix.b2 > pRotMatrix.c3)
+    {
+        // Column 1:
+        TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.b2 - pRotMatrix.a1 - pRotMatrix.c3) * static_cast<TReal>(2.0);
+        x = (pRotMatrix.b1 + pRotMatrix.a2) / s;
+        y = static_cast<TReal>(0.25) * s;
+        z = (pRotMatrix.c2 + pRotMatrix.b3) / s;
+        w = (pRotMatrix.a3 - pRotMatrix.c1) / s;
+    } else
+    {
+        // Column 2:
+        TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.c3 - pRotMatrix.a1 - pRotMatrix.b2) * static_cast<TReal>(2.0);
+        x = (pRotMatrix.a3 + pRotMatrix.c1) / s;
+        y = (pRotMatrix.c2 + pRotMatrix.b3) / s;
+        z = static_cast<TReal>(0.25) * s;
+        w = (pRotMatrix.b1 - pRotMatrix.a2) / s;
+    }
 }
 
 // ---------------------------------------------------------------------------
@@ -123,18 +123,18 @@ inline aiQuaterniont<TReal>::aiQuaterniont( const aiMatrix3x3t<TReal> &pRotMatri
 template<typename TReal>
 inline aiQuaterniont<TReal>::aiQuaterniont( TReal fPitch, TReal fYaw, TReal fRoll )
 {
-	const TReal fSinPitch(std::sin(fPitch*static_cast<TReal>(0.5)));
-	const TReal fCosPitch(std::cos(fPitch*static_cast<TReal>(0.5)));
-	const TReal fSinYaw(std::sin(fYaw*static_cast<TReal>(0.5)));
-	const TReal fCosYaw(std::cos(fYaw*static_cast<TReal>(0.5)));
-	const TReal fSinRoll(std::sin(fRoll*static_cast<TReal>(0.5)));
-	const TReal fCosRoll(std::cos(fRoll*static_cast<TReal>(0.5)));
-	const TReal fCosPitchCosYaw(fCosPitch*fCosYaw);
-	const TReal fSinPitchSinYaw(fSinPitch*fSinYaw);
-	x = fSinRoll * fCosPitchCosYaw     - fCosRoll * fSinPitchSinYaw;
-	y = fCosRoll * fSinPitch * fCosYaw + fSinRoll * fCosPitch * fSinYaw;
-	z = fCosRoll * fCosPitch * fSinYaw - fSinRoll * fSinPitch * fCosYaw;
-	w = fCosRoll * fCosPitchCosYaw     + fSinRoll * fSinPitchSinYaw;
+    const TReal fSinPitch(std::sin(fPitch*static_cast<TReal>(0.5)));
+    const TReal fCosPitch(std::cos(fPitch*static_cast<TReal>(0.5)));
+    const TReal fSinYaw(std::sin(fYaw*static_cast<TReal>(0.5)));
+    const TReal fCosYaw(std::cos(fYaw*static_cast<TReal>(0.5)));
+    const TReal fSinRoll(std::sin(fRoll*static_cast<TReal>(0.5)));
+    const TReal fCosRoll(std::cos(fRoll*static_cast<TReal>(0.5)));
+    const TReal fCosPitchCosYaw(fCosPitch*fCosYaw);
+    const TReal fSinPitchSinYaw(fSinPitch*fSinYaw);
+    x = fSinRoll * fCosPitchCosYaw     - fCosRoll * fSinPitchSinYaw;
+    y = fCosRoll * fSinPitch * fCosYaw + fSinRoll * fCosPitch * fSinYaw;
+    z = fCosRoll * fCosPitch * fSinYaw - fSinRoll * fSinPitch * fCosYaw;
+    w = fCosRoll * fCosPitchCosYaw     + fSinRoll * fSinPitchSinYaw;
 }
 
 // ---------------------------------------------------------------------------
@@ -142,18 +142,18 @@ inline aiQuaterniont<TReal>::aiQuaterniont( TReal fPitch, TReal fYaw, TReal fRol
 template<typename TReal>
 inline aiMatrix3x3t<TReal> aiQuaterniont<TReal>::GetMatrix() const
 {
-	aiMatrix3x3t<TReal> resMatrix;
-	resMatrix.a1 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (y * y + z * z);
-	resMatrix.a2 = static_cast<TReal>(2.0) * (x * y - z * w);
-	resMatrix.a3 = static_cast<TReal>(2.0) * (x * z + y * w);
-	resMatrix.b1 = static_cast<TReal>(2.0) * (x * y + z * w);
-	resMatrix.b2 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (x * x + z * z);
-	resMatrix.b3 = static_cast<TReal>(2.0) * (y * z - x * w);
-	resMatrix.c1 = static_cast<TReal>(2.0) * (x * z - y * w);
-	resMatrix.c2 = static_cast<TReal>(2.0) * (y * z + x * w);
-	resMatrix.c3 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (x * x + y * y);
-
-	return resMatrix;
+    aiMatrix3x3t<TReal> resMatrix;
+    resMatrix.a1 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (y * y + z * z);
+    resMatrix.a2 = static_cast<TReal>(2.0) * (x * y - z * w);
+    resMatrix.a3 = static_cast<TReal>(2.0) * (x * z + y * w);
+    resMatrix.b1 = static_cast<TReal>(2.0) * (x * y + z * w);
+    resMatrix.b2 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (x * x + z * z);
+    resMatrix.b3 = static_cast<TReal>(2.0) * (y * z - x * w);
+    resMatrix.c1 = static_cast<TReal>(2.0) * (x * z - y * w);
+    resMatrix.c2 = static_cast<TReal>(2.0) * (y * z + x * w);
+    resMatrix.c3 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (x * x + y * y);
+
+    return resMatrix;
 }
 
 // ---------------------------------------------------------------------------
@@ -161,30 +161,30 @@ inline aiMatrix3x3t<TReal> aiQuaterniont<TReal>::GetMatrix() const
 template<typename TReal>
 inline aiQuaterniont<TReal>::aiQuaterniont( aiVector3t<TReal> axis, TReal angle)
 {
-	axis.Normalize();
-
-	const TReal sin_a = std::sin( angle / 2 );
-	const TReal cos_a = std::cos( angle / 2 );
-	x    = axis.x * sin_a;
-	y    = axis.y * sin_a;
-	z    = axis.z * sin_a;
-	w    = cos_a;
+    axis.Normalize();
+
+    const TReal sin_a = std::sin( angle / 2 );
+    const TReal cos_a = std::cos( angle / 2 );
+    x    = axis.x * sin_a;
+    y    = axis.y * sin_a;
+    z    = axis.z * sin_a;
+    w    = cos_a;
 }
 // ---------------------------------------------------------------------------
 // Construction from am existing, normalized quaternion
 template<typename TReal>
 inline aiQuaterniont<TReal>::aiQuaterniont( aiVector3t<TReal> normalized)
 {
-	x = normalized.x;
-	y = normalized.y;
-	z = normalized.z;
+    x = normalized.x;
+    y = normalized.y;
+    z = normalized.z;
 
-	const TReal t = static_cast<TReal>(1.0) - (x*x) - (y*y) - (z*z);
+    const TReal t = static_cast<TReal>(1.0) - (x*x) - (y*y) - (z*z);
 
-	if (t < static_cast<TReal>(0.0)) {
-		w = static_cast<TReal>(0.0);
-	}
-	else w = std::sqrt (t);
+    if (t < static_cast<TReal>(0.0)) {
+        w = static_cast<TReal>(0.0);
+    }
+    else w = std::sqrt (t);
 }
 
 // ---------------------------------------------------------------------------
@@ -194,89 +194,89 @@ inline aiQuaterniont<TReal>::aiQuaterniont( aiVector3t<TReal> normalized)
 template<typename TReal>
 inline void aiQuaterniont<TReal>::Interpolate( aiQuaterniont& pOut, const aiQuaterniont& pStart, const aiQuaterniont& pEnd, TReal pFactor)
 {
-	// calc cosine theta
-	TReal cosom = pStart.x * pEnd.x + pStart.y * pEnd.y + pStart.z * pEnd.z + pStart.w * pEnd.w;
-
-	// adjust signs (if necessary)
-	aiQuaterniont end = pEnd;
-	if( cosom < static_cast<TReal>(0.0))
-	{
-		cosom = -cosom;
-		end.x = -end.x;   // Reverse all signs
-		end.y = -end.y;
-		end.z = -end.z;
-		end.w = -end.w;
-	}
-
-	// Calculate coefficients
-	TReal sclp, sclq;
-	if( (static_cast<TReal>(1.0) - cosom) > static_cast<TReal>(0.0001)) // 0.0001 -> some epsillon
-	{
-		// Standard case (slerp)
-		TReal omega, sinom;
-		omega = std::acos( cosom); // extract theta from dot product's cos theta
-		sinom = std::sin( omega);
-		sclp  = std::sin( (static_cast<TReal>(1.0) - pFactor) * omega) / sinom;
-		sclq  = std::sin( pFactor * omega) / sinom;
-	} else
-	{
-		// Very close, do linear interp (because it's faster)
-		sclp = static_cast<TReal>(1.0) - pFactor;
-		sclq = pFactor;
-	}
-
-	pOut.x = sclp * pStart.x + sclq * end.x;
-	pOut.y = sclp * pStart.y + sclq * end.y;
-	pOut.z = sclp * pStart.z + sclq * end.z;
-	pOut.w = sclp * pStart.w + sclq * end.w;
+    // calc cosine theta
+    TReal cosom = pStart.x * pEnd.x + pStart.y * pEnd.y + pStart.z * pEnd.z + pStart.w * pEnd.w;
+
+    // adjust signs (if necessary)
+    aiQuaterniont end = pEnd;
+    if( cosom < static_cast<TReal>(0.0))
+    {
+        cosom = -cosom;
+        end.x = -end.x;   // Reverse all signs
+        end.y = -end.y;
+        end.z = -end.z;
+        end.w = -end.w;
+    }
+
+    // Calculate coefficients
+    TReal sclp, sclq;
+    if( (static_cast<TReal>(1.0) - cosom) > static_cast<TReal>(0.0001)) // 0.0001 -> some epsillon
+    {
+        // Standard case (slerp)
+        TReal omega, sinom;
+        omega = std::acos( cosom); // extract theta from dot product's cos theta
+        sinom = std::sin( omega);
+        sclp  = std::sin( (static_cast<TReal>(1.0) - pFactor) * omega) / sinom;
+        sclq  = std::sin( pFactor * omega) / sinom;
+    } else
+    {
+        // Very close, do linear interp (because it's faster)
+        sclp = static_cast<TReal>(1.0) - pFactor;
+        sclq = pFactor;
+    }
+
+    pOut.x = sclp * pStart.x + sclq * end.x;
+    pOut.y = sclp * pStart.y + sclq * end.y;
+    pOut.z = sclp * pStart.z + sclq * end.z;
+    pOut.w = sclp * pStart.w + sclq * end.w;
 }
 
 // ---------------------------------------------------------------------------
 template<typename TReal>
 inline aiQuaterniont<TReal>& aiQuaterniont<TReal>::Normalize()
 {
-	// compute the magnitude and divide through it
-	const TReal mag = std::sqrt(x*x + y*y + z*z + w*w);
-	if (mag)
-	{
-		const TReal invMag = static_cast<TReal>(1.0)/mag;
-		x *= invMag;
-		y *= invMag;
-		z *= invMag;
-		w *= invMag;
-	}
-	return *this;
+    // compute the magnitude and divide through it
+    const TReal mag = std::sqrt(x*x + y*y + z*z + w*w);
+    if (mag)
+    {
+        const TReal invMag = static_cast<TReal>(1.0)/mag;
+        x *= invMag;
+        y *= invMag;
+        z *= invMag;
+        w *= invMag;
+    }
+    return *this;
 }
 
 // ---------------------------------------------------------------------------
 template<typename TReal>
 inline aiQuaterniont<TReal> aiQuaterniont<TReal>::operator* (const aiQuaterniont& t) const
 {
-	return aiQuaterniont(w*t.w - x*t.x - y*t.y - z*t.z,
-		w*t.x + x*t.w + y*t.z - z*t.y,
-		w*t.y + y*t.w + z*t.x - x*t.z,
-		w*t.z + z*t.w + x*t.y - y*t.x);
+    return aiQuaterniont(w*t.w - x*t.x - y*t.y - z*t.z,
+        w*t.x + x*t.w + y*t.z - z*t.y,
+        w*t.y + y*t.w + z*t.x - x*t.z,
+        w*t.z + z*t.w + x*t.y - y*t.x);
 }
 
 // ---------------------------------------------------------------------------
 template<typename TReal>
 inline aiQuaterniont<TReal>& aiQuaterniont<TReal>::Conjugate ()
 {
-	x = -x;
-	y = -y;
-	z = -z;
-	return *this;
+    x = -x;
+    y = -y;
+    z = -z;
+    return *this;
 }
 
 // ---------------------------------------------------------------------------
 template<typename TReal>
 inline aiVector3t<TReal> aiQuaterniont<TReal>::Rotate (const aiVector3t<TReal>& v)
 {
-	aiQuaterniont q2(0.f,v.x,v.y,v.z), q = *this, qinv = q;
-	qinv.Conjugate();
+    aiQuaterniont q2(0.f,v.x,v.y,v.z), q = *this, qinv = q;
+    qinv.Conjugate();
 
-	q = q*q2*qinv;
-	return aiVector3t<TReal>(q.x,q.y,q.z);
+    q = q*q2*qinv;
+    return aiVector3t<TReal>(q.x,q.y,q.z);
 }
 
 #endif

include/assimp/scene.h

@@ -70,145 +70,145 @@ extern "C" {
 // -------------------------------------------------------------------------------
 struct aiNode
 {
-	/** The name of the node.
-	 *
-	 * The name might be empty (length of zero) but all nodes which
-	 * need to be referenced by either bones or animations are named.
-	 * Multiple nodes may have the same name, except for nodes which are referenced
-	 * by bones (see #aiBone and #aiMesh::mBones). Their names *must* be unique.
-	 *
-	 * Cameras and lights reference a specific node by name - if there
-	 * are multiple nodes with this name, they are assigned to each of them.
-	 * <br>
-	 * There are no limitations with regard to the characters contained in
-	 * the name string as it is usually taken directly from the source file.
-	 *
-	 * Implementations should be able to handle tokens such as whitespace, tabs,
-	 * line feeds, quotation marks, ampersands etc.
-	 *
-	 * Sometimes assimp introduces new nodes not present in the source file
-	 * into the hierarchy (usually out of necessity because sometimes the
-	 * source hierarchy format is simply not compatible). Their names are
-	 * surrounded by @verbatim <> @endverbatim e.g.
-	 *  @verbatim<DummyRootNode> @endverbatim.
-	 */
-	C_STRUCT aiString mName;
-
-	/** The transformation relative to the node's parent. */
-	C_STRUCT aiMatrix4x4 mTransformation;
-
-	/** Parent node. NULL if this node is the root node. */
-	C_STRUCT aiNode* mParent;
-
-	/** The number of child nodes of this node. */
-	unsigned int mNumChildren;
-
-	/** The child nodes of this node. NULL if mNumChildren is 0. */
-	C_STRUCT aiNode** mChildren;
-
-	/** The number of meshes of this node. */
-	unsigned int mNumMeshes;
-
-	/** The meshes of this node. Each entry is an index into the mesh */
-	unsigned int* mMeshes;
-
-	/** Metadata associated with this node or NULL if there is no metadata.
-	  *  Whether any metadata is generated depends on the source file format. See the
-	  * @link importer_notes @endlink page for more information on every source file
-	  * format. Importers that don't document any metadata don't write any.
-	  */
-	C_STRUCT aiMetadata* mMetaData;
+    /** The name of the node.
+     *
+     * The name might be empty (length of zero) but all nodes which
+     * need to be referenced by either bones or animations are named.
+     * Multiple nodes may have the same name, except for nodes which are referenced
+     * by bones (see #aiBone and #aiMesh::mBones). Their names *must* be unique.
+     *
+     * Cameras and lights reference a specific node by name - if there
+     * are multiple nodes with this name, they are assigned to each of them.
+     * <br>
+     * There are no limitations with regard to the characters contained in
+     * the name string as it is usually taken directly from the source file.
+     *
+     * Implementations should be able to handle tokens such as whitespace, tabs,
+     * line feeds, quotation marks, ampersands etc.
+     *
+     * Sometimes assimp introduces new nodes not present in the source file
+     * into the hierarchy (usually out of necessity because sometimes the
+     * source hierarchy format is simply not compatible). Their names are
+     * surrounded by @verbatim <> @endverbatim e.g.
+     *  @verbatim<DummyRootNode> @endverbatim.
+     */
+    C_STRUCT aiString mName;
+
+    /** The transformation relative to the node's parent. */
+    C_STRUCT aiMatrix4x4 mTransformation;
+
+    /** Parent node. NULL if this node is the root node. */
+    C_STRUCT aiNode* mParent;
+
+    /** The number of child nodes of this node. */
+    unsigned int mNumChildren;
+
+    /** The child nodes of this node. NULL if mNumChildren is 0. */
+    C_STRUCT aiNode** mChildren;
+
+    /** The number of meshes of this node. */
+    unsigned int mNumMeshes;
+
+    /** The meshes of this node. Each entry is an index into the mesh */
+    unsigned int* mMeshes;
+
+    /** Metadata associated with this node or NULL if there is no metadata.
+      *  Whether any metadata is generated depends on the source file format. See the
+      * @link importer_notes @endlink page for more information on every source file
+      * format. Importers that don't document any metadata don't write any.
+      */
+    C_STRUCT aiMetadata* mMetaData;
 
 #ifdef __cplusplus
-	/** Constructor */
-	aiNode()
-		// set all members to zero by default
-		: mName("")
-		, mParent(NULL)
-		, mNumChildren(0)
-		, mChildren(NULL)
-		, mNumMeshes(0)
-		, mMeshes(NULL)
-		, mMetaData(NULL)
-	{
-	}
-
-
-	/** Construction from a specific name */
-	aiNode(const std::string& name)
-		// set all members to zero by default
-		: mName(name)
-		, mParent(NULL)
-		, mNumChildren(0)
-		, mChildren(NULL)
-		, mNumMeshes(0)
-		, mMeshes(NULL)
-		, mMetaData(NULL)
-	{
-	}
-
-	/** Destructor */
-	~aiNode()
-	{
-		// delete all children recursively
-		// to make sure we won't crash if the data is invalid ...
-		if (mChildren && mNumChildren)
-		{
-			for( unsigned int a = 0; a < mNumChildren; a++)
-				delete mChildren[a];
-		}
-		delete [] mChildren;
-		delete [] mMeshes;
-		delete mMetaData;
-	}
-
-
-	/** Searches for a node with a specific name, beginning at this
-	 *  nodes. Normally you will call this method on the root node
-	 *  of the scene.
-	 *
-	 *  @param name Name to search for
-	 *  @return NULL or a valid Node if the search was successful.
-	 */
-	inline const aiNode* FindNode(const aiString& name) const
-	{
-		return FindNode(name.data);
-	}
-
-
-	inline aiNode* FindNode(const aiString& name)
-	{
-		return FindNode(name.data);
-	}
-
-
-	inline const aiNode* FindNode(const char* name) const
-	{
-		if (!::strcmp( mName.data,name))return this;
-		for (unsigned int i = 0; i < mNumChildren;++i)
-		{
-			const aiNode* const p = mChildren[i]->FindNode(name);
-			if (p) {
-				return p;
-			}
-		}
-		// there is definitely no sub-node with this name
-		return NULL;
-	}
-
-	inline aiNode* FindNode(const char* name)
-	{
-		if (!::strcmp( mName.data,name))return this;
-		for (unsigned int i = 0; i < mNumChildren;++i)
-		{
-			aiNode* const p = mChildren[i]->FindNode(name);
-			if (p) {
-				return p;
-			}
-		}
-		// there is definitely no sub-node with this name
-		return NULL;
-	}
+    /** Constructor */
+    aiNode()
+        // set all members to zero by default
+        : mName("")
+        , mParent(NULL)
+        , mNumChildren(0)
+        , mChildren(NULL)
+        , mNumMeshes(0)
+        , mMeshes(NULL)
+        , mMetaData(NULL)
+    {
+    }
+
+
+    /** Construction from a specific name */
+    aiNode(const std::string& name)
+        // set all members to zero by default
+        : mName(name)
+        , mParent(NULL)
+        , mNumChildren(0)
+        , mChildren(NULL)
+        , mNumMeshes(0)
+        , mMeshes(NULL)
+        , mMetaData(NULL)
+    {
+    }
+
+    /** Destructor */
+    ~aiNode()
+    {
+        // delete all children recursively
+        // to make sure we won't crash if the data is invalid ...
+        if (mChildren && mNumChildren)
+        {
+            for( unsigned int a = 0; a < mNumChildren; a++)
+                delete mChildren[a];
+        }
+        delete [] mChildren;
+        delete [] mMeshes;
+        delete mMetaData;
+    }
+
+
+    /** Searches for a node with a specific name, beginning at this
+     *  nodes. Normally you will call this method on the root node
+     *  of the scene.
+     *
+     *  @param name Name to search for
+     *  @return NULL or a valid Node if the search was successful.
+     */
+    inline const aiNode* FindNode(const aiString& name) const
+    {
+        return FindNode(name.data);
+    }
+
+
+    inline aiNode* FindNode(const aiString& name)
+    {
+        return FindNode(name.data);
+    }
+
+
+    inline const aiNode* FindNode(const char* name) const
+    {
+        if (!::strcmp( mName.data,name))return this;
+        for (unsigned int i = 0; i < mNumChildren;++i)
+        {
+            const aiNode* const p = mChildren[i]->FindNode(name);
+            if (p) {
+                return p;
+            }
+        }
+        // there is definitely no sub-node with this name
+        return NULL;
+    }
+
+    inline aiNode* FindNode(const char* name)
+    {
+        if (!::strcmp( mName.data,name))return this;
+        for (unsigned int i = 0; i < mNumChildren;++i)
+        {
+            aiNode* const p = mChildren[i]->FindNode(name);
+            if (p) {
+                return p;
+            }
+        }
+        // there is definitely no sub-node with this name
+        return NULL;
+    }
 
 #endif // __cplusplus
 };
@@ -221,14 +221,14 @@ struct aiNode
  * of animation skeletons, material libraries or camera animation paths
  * using Assimp. Most applications won't support such data.
  */
-#define AI_SCENE_FLAGS_INCOMPLETE	0x1
+#define AI_SCENE_FLAGS_INCOMPLETE   0x1
 
 /**
  * This flag is set by the validation postprocess-step (aiPostProcess_ValidateDS)
  * if the validation is successful. In a validated scene you can be sure that
  * any cross references in the data structure (e.g. vertex indices) are valid.
  */
-#define AI_SCENE_FLAGS_VALIDATED	0x2
+#define AI_SCENE_FLAGS_VALIDATED    0x2
 
 /**
  * This flag is set by the validation postprocess-step (aiPostProcess_ValidateDS)
@@ -238,7 +238,7 @@ struct aiNode
  * In most cases you should still be able to use the import. This flag could
  * be useful for applications which don't capture Assimp's log output.
  */
-#define AI_SCENE_FLAGS_VALIDATION_WARNING  	0x4
+#define AI_SCENE_FLAGS_VALIDATION_WARNING   0x4
 
 /**
  * This flag is currently only set by the aiProcess_JoinIdenticalVertices step.
@@ -246,7 +246,7 @@ struct aiNode
  * verbose format anymore. In the verbose format all vertices are unique,
  * no vertex is ever referenced by more than one face.
  */
-#define AI_SCENE_FLAGS_NON_VERBOSE_FORMAT  	0x8
+#define AI_SCENE_FLAGS_NON_VERBOSE_FORMAT   0x8
 
  /**
  * Denotes pure height-map terrain data. Pure terrains usually consist of quads,
@@ -275,146 +275,146 @@ struct aiNode
 struct aiScene
 {
 
-	/** Any combination of the AI_SCENE_FLAGS_XXX flags. By default
-	* this value is 0, no flags are set. Most applications will
-	* want to reject all scenes with the AI_SCENE_FLAGS_INCOMPLETE
-	* bit set.
-	*/
-	unsigned int mFlags;
+    /** Any combination of the AI_SCENE_FLAGS_XXX flags. By default
+    * this value is 0, no flags are set. Most applications will
+    * want to reject all scenes with the AI_SCENE_FLAGS_INCOMPLETE
+    * bit set.
+    */
+    unsigned int mFlags;
 
 
-	/** The root node of the hierarchy.
-	*
-	* There will always be at least the root node if the import
-	* was successful (and no special flags have been set).
-	* Presence of further nodes depends on the format and content
-	* of the imported file.
-	*/
-	C_STRUCT aiNode* mRootNode;
+    /** The root node of the hierarchy.
+    *
+    * There will always be at least the root node if the import
+    * was successful (and no special flags have been set).
+    * Presence of further nodes depends on the format and content
+    * of the imported file.
+    */
+    C_STRUCT aiNode* mRootNode;
 
 
 
-	/** The number of meshes in the scene. */
-	unsigned int mNumMeshes;
+    /** The number of meshes in the scene. */
+    unsigned int mNumMeshes;
 
-	/** The array of meshes.
-	*
-	* Use the indices given in the aiNode structure to access
-	* this array. The array is mNumMeshes in size. If the
-	* AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always
-	* be at least ONE material.
-	*/
-	C_STRUCT aiMesh** mMeshes;
+    /** The array of meshes.
+    *
+    * Use the indices given in the aiNode structure to access
+    * this array. The array is mNumMeshes in size. If the
+    * AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always
+    * be at least ONE material.
+    */
+    C_STRUCT aiMesh** mMeshes;
 
 
 
-	/** The number of materials in the scene. */
-	unsigned int mNumMaterials;
+    /** The number of materials in the scene. */
+    unsigned int mNumMaterials;
 
-	/** The array of materials.
-	*
-	* Use the index given in each aiMesh structure to access this
-	* array. The array is mNumMaterials in size. If the
-	* AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always
-	* be at least ONE material.
-	*/
-	C_STRUCT aiMaterial** mMaterials;
+    /** The array of materials.
+    *
+    * Use the index given in each aiMesh structure to access this
+    * array. The array is mNumMaterials in size. If the
+    * AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always
+    * be at least ONE material.
+    */
+    C_STRUCT aiMaterial** mMaterials;
 
 
 
-	/** The number of animations in the scene. */
-	unsigned int mNumAnimations;
+    /** The number of animations in the scene. */
+    unsigned int mNumAnimations;
 
-	/** The array of animations.
-	*
-	* All animations imported from the given file are listed here.
-	* The array is mNumAnimations in size.
-	*/
-	C_STRUCT aiAnimation** mAnimations;
+    /** The array of animations.
+    *
+    * All animations imported from the given file are listed here.
+    * The array is mNumAnimations in size.
+    */
+    C_STRUCT aiAnimation** mAnimations;
 
 
 
-	/** The number of textures embedded into the file */
-	unsigned int mNumTextures;
+    /** The number of textures embedded into the file */
+    unsigned int mNumTextures;
 
-	/** The array of embedded textures.
-	*
-	* Not many file formats embed their textures into the file.
-	* An example is Quake's MDL format (which is also used by
-	* some GameStudio versions)
-	*/
-	C_STRUCT aiTexture** mTextures;
+    /** The array of embedded textures.
+    *
+    * Not many file formats embed their textures into the file.
+    * An example is Quake's MDL format (which is also used by
+    * some GameStudio versions)
+    */
+    C_STRUCT aiTexture** mTextures;
 
 
-	/** The number of light sources in the scene. Light sources
-	* are fully optional, in most cases this attribute will be 0
+    /** The number of light sources in the scene. Light sources
+    * are fully optional, in most cases this attribute will be 0
         */
-	unsigned int mNumLights;
+    unsigned int mNumLights;
 
-	/** The array of light sources.
-	*
-	* All light sources imported from the given file are
-	* listed here. The array is mNumLights in size.
-	*/
-	C_STRUCT aiLight** mLights;
+    /** The array of light sources.
+    *
+    * All light sources imported from the given file are
+    * listed here. The array is mNumLights in size.
+    */
+    C_STRUCT aiLight** mLights;
 
 
-	/** The number of cameras in the scene. Cameras
-	* are fully optional, in most cases this attribute will be 0
+    /** The number of cameras in the scene. Cameras
+    * are fully optional, in most cases this attribute will be 0
         */
-	unsigned int mNumCameras;
+    unsigned int mNumCameras;
 
-	/** The array of cameras.
-	*
-	* All cameras imported from the given file are listed here.
-	* The array is mNumCameras in size. The first camera in the
-	* array (if existing) is the default camera view into
-	* the scene.
-	*/
-	C_STRUCT aiCamera** mCameras;
+    /** The array of cameras.
+    *
+    * All cameras imported from the given file are listed here.
+    * The array is mNumCameras in size. The first camera in the
+    * array (if existing) is the default camera view into
+    * the scene.
+    */
+    C_STRUCT aiCamera** mCameras;
 
 #ifdef __cplusplus
 
-	//! Default constructor - set everything to 0/NULL
-	ASSIMP_API aiScene();
+    //! Default constructor - set everything to 0/NULL
+    ASSIMP_API aiScene();
 
-	//! Destructor
-	ASSIMP_API ~aiScene();
+    //! Destructor
+    ASSIMP_API ~aiScene();
 
-	//! Check whether the scene contains meshes
-	//! Unless no special scene flags are set this will always be true.
-	inline bool HasMeshes() const
-		{ return mMeshes != NULL && mNumMeshes > 0; }
+    //! Check whether the scene contains meshes
+    //! Unless no special scene flags are set this will always be true.
+    inline bool HasMeshes() const
+        { return mMeshes != NULL && mNumMeshes > 0; }
 
-	//! Check whether the scene contains materials
-	//! Unless no special scene flags are set this will always be true.
-	inline bool HasMaterials() const
-		{ return mMaterials != NULL && mNumMaterials > 0; }
+    //! Check whether the scene contains materials
+    //! Unless no special scene flags are set this will always be true.
+    inline bool HasMaterials() const
+        { return mMaterials != NULL && mNumMaterials > 0; }
 
-	//! Check whether the scene contains lights
-	inline bool HasLights() const
-		{ return mLights != NULL && mNumLights > 0; }
+    //! Check whether the scene contains lights
+    inline bool HasLights() const
+        { return mLights != NULL && mNumLights > 0; }
 
-	//! Check whether the scene contains textures
-	inline bool HasTextures() const
-		{ return mTextures != NULL && mNumTextures > 0; }
+    //! Check whether the scene contains textures
+    inline bool HasTextures() const
+        { return mTextures != NULL && mNumTextures > 0; }
 
-	//! Check whether the scene contains cameras
-	inline bool HasCameras() const
-		{ return mCameras != NULL && mNumCameras > 0; }
+    //! Check whether the scene contains cameras
+    inline bool HasCameras() const
+        { return mCameras != NULL && mNumCameras > 0; }
 
-	//! Check whether the scene contains animations
-	inline bool HasAnimations() const
-		{ return mAnimations != NULL && mNumAnimations > 0; }
+    //! Check whether the scene contains animations
+    inline bool HasAnimations() const
+        { return mAnimations != NULL && mNumAnimations > 0; }
 
 #endif // __cplusplus
 
 
-	/**  Internal data, do not touch */
+    /**  Internal data, do not touch */
 #ifdef __cplusplus
-	void* mPrivate;
+    void* mPrivate;
 #else
-	char* mPrivate;
+    char* mPrivate;
 #endif
 
 };

include/assimp/texture.h

@@ -66,7 +66,7 @@ extern "C" {
  *  (zero-based, in the aiScene::mTextures array)
  */
 #if (!defined AI_MAKE_EMBEDDED_TEXNAME)
-#	define AI_MAKE_EMBEDDED_TEXNAME(_n_) "*" # _n_
+#   define AI_MAKE_EMBEDDED_TEXNAME(_n_) "*" # _n_
 #endif
 
 
@@ -79,28 +79,28 @@ extern "C" {
 */
 struct aiTexel
 {
-	unsigned char b,g,r,a;
+    unsigned char b,g,r,a;
 
 #ifdef __cplusplus
-	//! Comparison operator
-	bool operator== (const aiTexel& other) const
-	{
-		return b == other.b && r == other.r &&
-			   g == other.g && a == other.a;
-	}
-
-	//! Inverse comparison operator
-	bool operator!= (const aiTexel& other) const
-	{
-		return b != other.b || r != other.r ||
-			   g != other.g || a != other.a;
-	}
-
-	//! Conversion to a floating-point 4d color
-	operator aiColor4D() const
-	{
-		return aiColor4D(r/255.f,g/255.f,b/255.f,a/255.f);
-	}
+    //! Comparison operator
+    bool operator== (const aiTexel& other) const
+    {
+        return b == other.b && r == other.r &&
+               g == other.g && a == other.a;
+    }
+
+    //! Inverse comparison operator
+    bool operator!= (const aiTexel& other) const
+    {
+        return b != other.b || r != other.r ||
+               g != other.g || a != other.a;
+    }
+
+    //! Conversion to a floating-point 4d color
+    operator aiColor4D() const
+    {
+        return aiColor4D(r/255.f,g/255.f,b/255.f,a/255.f);
+    }
 #endif // __cplusplus
 
 } PACK_STRUCT;
@@ -119,73 +119,73 @@ struct aiTexel
  */
 struct aiTexture
 {
-	/** Width of the texture, in pixels
-	 *
-	 * If mHeight is zero the texture is compressed in a format
-	 * like JPEG. In this case mWidth specifies the size of the
-	 * memory area pcData is pointing to, in bytes.
-	 */
-	unsigned int mWidth;
-
-	/** Height of the texture, in pixels
-	 *
-	 * If this value is zero, pcData points to an compressed texture
-	 * in any format (e.g. JPEG).
-	 */
-	unsigned int mHeight;
-
-	/** A hint from the loader to make it easier for applications
-	 *  to determine the type of embedded compressed textures.
-	 *
-	 * If mHeight != 0 this member is undefined. Otherwise it
-	 * is set set to '\\0\\0\\0\\0' if the loader has no additional
-	 * information about the texture file format used OR the
-	 * file extension of the format without a trailing dot. If there
-	 * are multiple file extensions for a format, the shortest
-	 * extension is chosen (JPEG maps to 'jpg', not to 'jpeg').
-	 * E.g. 'dds\\0', 'pcx\\0', 'jpg\\0'.  All characters are lower-case.
-	 * The fourth character will always be '\\0'.
-	 */
-	char achFormatHint[4];
-
-	/** Data of the texture.
-	 *
-	 * Points to an array of mWidth * mHeight aiTexel's.
-	 * The format of the texture data is always ARGB8888 to
-	 * make the implementation for user of the library as easy
-	 * as possible. If mHeight = 0 this is a pointer to a memory
-	 * buffer of size mWidth containing the compressed texture
-	 * data. Good luck, have fun!
-	 */
-	C_STRUCT aiTexel* pcData;
+    /** Width of the texture, in pixels
+     *
+     * If mHeight is zero the texture is compressed in a format
+     * like JPEG. In this case mWidth specifies the size of the
+     * memory area pcData is pointing to, in bytes.
+     */
+    unsigned int mWidth;
+
+    /** Height of the texture, in pixels
+     *
+     * If this value is zero, pcData points to an compressed texture
+     * in any format (e.g. JPEG).
+     */
+    unsigned int mHeight;
+
+    /** A hint from the loader to make it easier for applications
+     *  to determine the type of embedded compressed textures.
+     *
+     * If mHeight != 0 this member is undefined. Otherwise it
+     * is set set to '\\0\\0\\0\\0' if the loader has no additional
+     * information about the texture file format used OR the
+     * file extension of the format without a trailing dot. If there
+     * are multiple file extensions for a format, the shortest
+     * extension is chosen (JPEG maps to 'jpg', not to 'jpeg').
+     * E.g. 'dds\\0', 'pcx\\0', 'jpg\\0'.  All characters are lower-case.
+     * The fourth character will always be '\\0'.
+     */
+    char achFormatHint[4];
+
+    /** Data of the texture.
+     *
+     * Points to an array of mWidth * mHeight aiTexel's.
+     * The format of the texture data is always ARGB8888 to
+     * make the implementation for user of the library as easy
+     * as possible. If mHeight = 0 this is a pointer to a memory
+     * buffer of size mWidth containing the compressed texture
+     * data. Good luck, have fun!
+     */
+    C_STRUCT aiTexel* pcData;
 
 #ifdef __cplusplus
 
-	//! For compressed textures (mHeight == 0): compare the
-	//! format hint against a given string.
-	//! @param s Input string. 3 characters are maximally processed.
-	//!        Example values: "jpg", "png"
-	//! @return true if the given string matches the format hint
-	bool CheckFormat(const char* s) const
-	{
-		return (0 == ::strncmp(achFormatHint,s,3));
-	}
-
-	// Construction
-	aiTexture ()
-		: mWidth  (0)
-		, mHeight (0)
-		, pcData  (NULL)
-	{
-		achFormatHint[0] = achFormatHint[1] = 0;
-		achFormatHint[2] = achFormatHint[3] = 0;
-	}
-
-	// Destruction
-	~aiTexture ()
-	{
-		delete[] pcData;
-	}
+    //! For compressed textures (mHeight == 0): compare the
+    //! format hint against a given string.
+    //! @param s Input string. 3 characters are maximally processed.
+    //!        Example values: "jpg", "png"
+    //! @return true if the given string matches the format hint
+    bool CheckFormat(const char* s) const
+    {
+        return (0 == ::strncmp(achFormatHint,s,3));
+    }
+
+    // Construction
+    aiTexture ()
+        : mWidth  (0)
+        , mHeight (0)
+        , pcData  (NULL)
+    {
+        achFormatHint[0] = achFormatHint[1] = 0;
+        achFormatHint[2] = achFormatHint[3] = 0;
+    }
+
+    // Destruction
+    ~aiTexture ()
+    {
+        delete[] pcData;
+    }
 #endif
 };
 

include/assimp/types.h

@@ -66,43 +66,43 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef __cplusplus
 #include <cstring>
-#include <new>		// for std::nothrow_t
-#include <string>	// for aiString::Set(const std::string&)
-
-namespace Assimp	{
-	//! @cond never
-namespace Intern		{
-	// --------------------------------------------------------------------
-	/** @brief Internal helper class to utilize our internal new/delete
-	 *    routines for allocating object of this and derived classes.
-	 *
-	 * By doing this you can safely share class objects between Assimp
-	 * and the application - it works even over DLL boundaries. A good
-	 * example is the #IOSystem where the application allocates its custom
-	 * #IOSystem, then calls #Importer::SetIOSystem(). When the Importer
-	 * destructs, Assimp calls operator delete on the stored #IOSystem.
-	 * If it lies on a different heap than Assimp is working with,
-	 * the application is determined to crash.
-	 */
-	// --------------------------------------------------------------------
+#include <new>      // for std::nothrow_t
+#include <string>   // for aiString::Set(const std::string&)
+
+namespace Assimp    {
+    //! @cond never
+namespace Intern        {
+    // --------------------------------------------------------------------
+    /** @brief Internal helper class to utilize our internal new/delete
+     *    routines for allocating object of this and derived classes.
+     *
+     * By doing this you can safely share class objects between Assimp
+     * and the application - it works even over DLL boundaries. A good
+     * example is the #IOSystem where the application allocates its custom
+     * #IOSystem, then calls #Importer::SetIOSystem(). When the Importer
+     * destructs, Assimp calls operator delete on the stored #IOSystem.
+     * If it lies on a different heap than Assimp is working with,
+     * the application is determined to crash.
+     */
+    // --------------------------------------------------------------------
 #ifndef SWIG
-	struct ASSIMP_API AllocateFromAssimpHeap	{
-		// http://www.gotw.ca/publications/mill15.htm
+    struct ASSIMP_API AllocateFromAssimpHeap    {
+        // http://www.gotw.ca/publications/mill15.htm
 
-		// new/delete overload
-		void *operator new    ( size_t num_bytes) /* throw( std::bad_alloc ) */;
-		void *operator new    ( size_t num_bytes, const std::nothrow_t& ) throw();
-		void  operator delete ( void* data);
+        // new/delete overload
+        void *operator new    ( size_t num_bytes) /* throw( std::bad_alloc ) */;
+        void *operator new    ( size_t num_bytes, const std::nothrow_t& ) throw();
+        void  operator delete ( void* data);
 
-		// array new/delete overload
-		void *operator new[]    ( size_t num_bytes) /* throw( std::bad_alloc ) */;
-		void *operator new[]    ( size_t num_bytes, const std::nothrow_t& )  throw();
-		void  operator delete[] ( void* data);
+        // array new/delete overload
+        void *operator new[]    ( size_t num_bytes) /* throw( std::bad_alloc ) */;
+        void *operator new[]    ( size_t num_bytes, const std::nothrow_t& )  throw();
+        void  operator delete[] ( void* data);
 
-	}; // struct AllocateFromAssimpHeap
+    }; // struct AllocateFromAssimpHeap
 #endif
 } // namespace Intern
-	//! @endcond
+    //! @endcond
 } // namespace Assimp
 
 extern "C" {
@@ -112,7 +112,7 @@ extern "C" {
 #ifdef __cplusplus
 const size_t MAXLEN = 1024;
 #else
-#	define MAXLEN 1024
+#   define MAXLEN 1024
 #endif
 
 #include "./Compiler/pushpack1.h"
@@ -123,16 +123,16 @@ const size_t MAXLEN = 1024;
 struct aiPlane
 {
 #ifdef __cplusplus
-	aiPlane () : a(0.f), b(0.f), c(0.f), d(0.f) {}
-	aiPlane (float _a, float _b, float _c, float _d)
-		: a(_a), b(_b), c(_c), d(_d) {}
+    aiPlane () : a(0.f), b(0.f), c(0.f), d(0.f) {}
+    aiPlane (float _a, float _b, float _c, float _d)
+        : a(_a), b(_b), c(_c), d(_d) {}
 
-	aiPlane (const aiPlane& o) : a(o.a), b(o.b), c(o.c), d(o.d) {}
+    aiPlane (const aiPlane& o) : a(o.a), b(o.b), c(o.c), d(o.d) {}
 
 #endif // !__cplusplus
 
-	//! Plane equation
-	float a,b,c,d;
+    //! Plane equation
+    float a,b,c,d;
 } PACK_STRUCT; // !struct aiPlane
 
 // ----------------------------------------------------------------------------------
@@ -141,16 +141,16 @@ struct aiPlane
 struct aiRay
 {
 #ifdef __cplusplus
-	aiRay () {}
-	aiRay (const aiVector3D& _pos, const aiVector3D& _dir)
-		: pos(_pos), dir(_dir) {}
+    aiRay () {}
+    aiRay (const aiVector3D& _pos, const aiVector3D& _dir)
+        : pos(_pos), dir(_dir) {}
 
-	aiRay (const aiRay& o) : pos (o.pos), dir (o.dir) {}
+    aiRay (const aiRay& o) : pos (o.pos), dir (o.dir) {}
 
 #endif // !__cplusplus
 
-	//! Position and direction of the ray
-	C_STRUCT aiVector3D pos, dir;
+    //! Position and direction of the ray
+    C_STRUCT aiVector3D pos, dir;
 } PACK_STRUCT; // !struct aiRay
 
 // ----------------------------------------------------------------------------------
@@ -159,71 +159,71 @@ struct aiRay
 struct aiColor3D
 {
 #ifdef __cplusplus
-	aiColor3D () : r(0.0f), g(0.0f), b(0.0f) {}
-	aiColor3D (float _r, float _g, float _b) : r(_r), g(_g), b(_b) {}
-	aiColor3D (float _r) : r(_r), g(_r), b(_r) {}
-	aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {}
-
-	/** Component-wise comparison */
-	// TODO: add epsilon?
-	bool operator == (const aiColor3D& other) const
-		{return r == other.r && g == other.g && b == other.b;}
-
-	/** Component-wise inverse comparison */
-	// TODO: add epsilon?
-	bool operator != (const aiColor3D& other) const
-		{return r != other.r || g != other.g || b != other.b;}
-
-	/** Component-wise comparison */
-	// TODO: add epsilon?
-	bool operator < (const aiColor3D& other) const {
-		return r < other.r || (
-			r == other.r && (g < other.g ||
-				(g == other.g && b < other.b)
-			)
-		);
-	}
-
-	/** Component-wise addition */
-	aiColor3D operator+(const aiColor3D& c) const {
-		return aiColor3D(r+c.r,g+c.g,b+c.b);
-	}
-
-	/** Component-wise subtraction */
-	aiColor3D operator-(const aiColor3D& c) const {
-		return aiColor3D(r-c.r,g-c.g,b-c.b);
-	}
-
-	/** Component-wise multiplication */
-	aiColor3D operator*(const aiColor3D& c) const {
-		return aiColor3D(r*c.r,g*c.g,b*c.b);
-	}
-
-	/** Multiply with a scalar */
-	aiColor3D operator*(float f) const {
-		return aiColor3D(r*f,g*f,b*f);
-	}
-
-	/** Access a specific color component */
-	float operator[](unsigned int i) const {
-		return *(&r + i);
-	}
-
-	/** Access a specific color component */
-	float& operator[](unsigned int i) {
-		return *(&r + i);
-	}
-
-	/** Check whether a color is black */
-	bool IsBlack() const {
-		static const float epsilon = 10e-3f;
-		return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon;
-	}
+    aiColor3D () : r(0.0f), g(0.0f), b(0.0f) {}
+    aiColor3D (float _r, float _g, float _b) : r(_r), g(_g), b(_b) {}
+    aiColor3D (float _r) : r(_r), g(_r), b(_r) {}
+    aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {}
+
+    /** Component-wise comparison */
+    // TODO: add epsilon?
+    bool operator == (const aiColor3D& other) const
+        {return r == other.r && g == other.g && b == other.b;}
+
+    /** Component-wise inverse comparison */
+    // TODO: add epsilon?
+    bool operator != (const aiColor3D& other) const
+        {return r != other.r || g != other.g || b != other.b;}
+
+    /** Component-wise comparison */
+    // TODO: add epsilon?
+    bool operator < (const aiColor3D& other) const {
+        return r < other.r || (
+            r == other.r && (g < other.g ||
+                (g == other.g && b < other.b)
+            )
+        );
+    }
+
+    /** Component-wise addition */
+    aiColor3D operator+(const aiColor3D& c) const {
+        return aiColor3D(r+c.r,g+c.g,b+c.b);
+    }
+
+    /** Component-wise subtraction */
+    aiColor3D operator-(const aiColor3D& c) const {
+        return aiColor3D(r-c.r,g-c.g,b-c.b);
+    }
+
+    /** Component-wise multiplication */
+    aiColor3D operator*(const aiColor3D& c) const {
+        return aiColor3D(r*c.r,g*c.g,b*c.b);
+    }
+
+    /** Multiply with a scalar */
+    aiColor3D operator*(float f) const {
+        return aiColor3D(r*f,g*f,b*f);
+    }
+
+    /** Access a specific color component */
+    float operator[](unsigned int i) const {
+        return *(&r + i);
+    }
+
+    /** Access a specific color component */
+    float& operator[](unsigned int i) {
+        return *(&r + i);
+    }
+
+    /** Check whether a color is black */
+    bool IsBlack() const {
+        static const float epsilon = 10e-3f;
+        return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon;
+    }
 
 #endif // !__cplusplus
 
-	//! Red, green and blue color values
-	float r, g, b;
+    //! Red, green and blue color values
+    float r, g, b;
 } PACK_STRUCT;  // !struct aiColor3D
 #include "./Compiler/poppack1.h"
 
@@ -251,143 +251,143 @@ struct aiColor3D
 struct aiString
 {
 #ifdef __cplusplus
-	/** Default constructor, the string is set to have zero length */
-	aiString() :
-		length(0)
-	{
-		data[0] = '\0';
+    /** Default constructor, the string is set to have zero length */
+    aiString() :
+        length(0)
+    {
+        data[0] = '\0';
 
 #ifdef ASSIMP_BUILD_DEBUG
-		// Debug build: overwrite the string on its full length with ESC (27)
-		memset(data+1,27,MAXLEN-1);
+        // Debug build: overwrite the string on its full length with ESC (27)
+        memset(data+1,27,MAXLEN-1);
 #endif
-	}
-
-	/** Copy constructor */
-	aiString(const aiString& rOther) :
-		length(rOther.length)
-	{
-		// Crop the string to the maximum length
-		length = length>=MAXLEN?MAXLEN-1:length;
-		memcpy( data, rOther.data, length);
-		data[length] = '\0';
-	}
-
-	/** Constructor from std::string */
-	explicit aiString(const std::string& pString) :
-		length(pString.length())
-	{
-		length = length>=MAXLEN?MAXLEN-1:length;
-		memcpy( data, pString.c_str(), length);
-		data[length] = '\0';
-	}
-
-	/** Copy a std::string to the aiString */
-	void Set( const std::string& pString) {
-		if( pString.length() > MAXLEN - 1) {
-			return;
-		}
-		length = pString.length();
-		memcpy( data, pString.c_str(), length);
-		data[length] = 0;
-	}
-
-	/** Copy a const char* to the aiString */
-	void Set( const char* sz) {
-		const size_t len = ::strlen(sz);
-		if( len > MAXLEN - 1) {
-			return;
-		}
-		length = len;
-		memcpy( data, sz, len);
-		data[len] = 0;
-	}
-
-	/** Assign a const char* to the string */
-	aiString& operator = (const char* sz) {
-		Set(sz);
-		return *this;
-	}
-
-	/** Assign a cstd::string to the string */
-	aiString& operator = ( const std::string& pString) {
-		Set(pString);
-		return *this;
-	}
-
-	/** Comparison operator */
-	bool operator==(const aiString& other) const {
-		return  (length == other.length && 0 == memcmp(data,other.data,length));
-	}
-
-	/** Inverse comparison operator */
-	bool operator!=(const aiString& other) const {
-		return  (length != other.length || 0 != memcmp(data,other.data,length));
-	}
-
-	/** Append a string to the string */
-	void Append (const char* app)	{
-		const size_t len = ::strlen(app);
-		if (!len) {
-			return;
-		}
-		if (length + len >= MAXLEN) {
-			return;
-		}
-
-		memcpy(&data[length],app,len+1);
-		length += len;
-	}
-
-	/** Clear the string - reset its length to zero */
-	void Clear ()	{
-		length  = 0;
-		data[0] = '\0';
+    }
+
+    /** Copy constructor */
+    aiString(const aiString& rOther) :
+        length(rOther.length)
+    {
+        // Crop the string to the maximum length
+        length = length>=MAXLEN?MAXLEN-1:length;
+        memcpy( data, rOther.data, length);
+        data[length] = '\0';
+    }
+
+    /** Constructor from std::string */
+    explicit aiString(const std::string& pString) :
+        length(pString.length())
+    {
+        length = length>=MAXLEN?MAXLEN-1:length;
+        memcpy( data, pString.c_str(), length);
+        data[length] = '\0';
+    }
+
+    /** Copy a std::string to the aiString */
+    void Set( const std::string& pString) {
+        if( pString.length() > MAXLEN - 1) {
+            return;
+        }
+        length = pString.length();
+        memcpy( data, pString.c_str(), length);
+        data[length] = 0;
+    }
+
+    /** Copy a const char* to the aiString */
+    void Set( const char* sz) {
+        const size_t len = ::strlen(sz);
+        if( len > MAXLEN - 1) {
+            return;
+        }
+        length = len;
+        memcpy( data, sz, len);
+        data[len] = 0;
+    }
+
+    /** Assign a const char* to the string */
+    aiString& operator = (const char* sz) {
+        Set(sz);
+        return *this;
+    }
+
+    /** Assign a cstd::string to the string */
+    aiString& operator = ( const std::string& pString) {
+        Set(pString);
+        return *this;
+    }
+
+    /** Comparison operator */
+    bool operator==(const aiString& other) const {
+        return  (length == other.length && 0 == memcmp(data,other.data,length));
+    }
+
+    /** Inverse comparison operator */
+    bool operator!=(const aiString& other) const {
+        return  (length != other.length || 0 != memcmp(data,other.data,length));
+    }
+
+    /** Append a string to the string */
+    void Append (const char* app)   {
+        const size_t len = ::strlen(app);
+        if (!len) {
+            return;
+        }
+        if (length + len >= MAXLEN) {
+            return;
+        }
+
+        memcpy(&data[length],app,len+1);
+        length += len;
+    }
+
+    /** Clear the string - reset its length to zero */
+    void Clear ()   {
+        length  = 0;
+        data[0] = '\0';
 
 #ifdef ASSIMP_BUILD_DEBUG
-		// Debug build: overwrite the string on its full length with ESC (27)
-		memset(data+1,27,MAXLEN-1);
+        // Debug build: overwrite the string on its full length with ESC (27)
+        memset(data+1,27,MAXLEN-1);
 #endif
-	}
+    }
 
-	/** Returns a pointer to the underlying zero-terminated array of characters */
-	const char* C_Str() const {
-		return data;
-	}
+    /** Returns a pointer to the underlying zero-terminated array of characters */
+    const char* C_Str() const {
+        return data;
+    }
 
 #endif // !__cplusplus
 
-	/** Binary length of the string excluding the terminal 0. This is NOT the
-	 *  logical length of strings containing UTF-8 multibyte sequences! It's
-	 *  the number of bytes from the beginning of the string to its end.*/
-	size_t length;
+    /** Binary length of the string excluding the terminal 0. This is NOT the
+     *  logical length of strings containing UTF-8 multibyte sequences! It's
+     *  the number of bytes from the beginning of the string to its end.*/
+    size_t length;
 
-	/** String buffer. Size limit is MAXLEN */
-	char data[MAXLEN];
+    /** String buffer. Size limit is MAXLEN */
+    char data[MAXLEN];
 } ;  // !struct aiString
 
 
 // ----------------------------------------------------------------------------------
-/**	Standard return type for some library functions.
+/** Standard return type for some library functions.
  * Rarely used, and if, mostly in the C API.
  */
 typedef enum aiReturn
 {
-	/** Indicates that a function was successful */
-	aiReturn_SUCCESS = 0x0,
+    /** Indicates that a function was successful */
+    aiReturn_SUCCESS = 0x0,
 
-	/** Indicates that a function failed */
-	aiReturn_FAILURE = -0x1,
+    /** Indicates that a function failed */
+    aiReturn_FAILURE = -0x1,
 
-	/** Indicates that not enough memory was available
-	 * to perform the requested operation
-	 */
-	aiReturn_OUTOFMEMORY = -0x3,
+    /** Indicates that not enough memory was available
+     * to perform the requested operation
+     */
+    aiReturn_OUTOFMEMORY = -0x3,
 
-	/** @cond never
-	 *  Force 32-bit size enum
-	 */
-	_AI_ENFORCE_ENUM_SIZE = 0x7fffffff
+    /** @cond never
+     *  Force 32-bit size enum
+     */
+    _AI_ENFORCE_ENUM_SIZE = 0x7fffffff
 
     /// @endcond
 } aiReturn;  // !enum aiReturn
@@ -403,21 +403,21 @@ typedef enum aiReturn
  */
 enum aiOrigin
 {
-	/** Beginning of the file */
-	aiOrigin_SET = 0x0,
+    /** Beginning of the file */
+    aiOrigin_SET = 0x0,
 
-	/** Current position of the file pointer */
-	aiOrigin_CUR = 0x1,
+    /** Current position of the file pointer */
+    aiOrigin_CUR = 0x1,
 
-	/** End of the file, offsets must be negative */
-	aiOrigin_END = 0x2,
+    /** End of the file, offsets must be negative */
+    aiOrigin_END = 0x2,
 
-	/**  @cond never
-	 *   Force 32-bit size enum
-	 */
-	_AI_ORIGIN_ENFORCE_ENUM_SIZE = 0x7fffffff
+    /**  @cond never
+     *   Force 32-bit size enum
+     */
+    _AI_ORIGIN_ENFORCE_ENUM_SIZE = 0x7fffffff
 
-	/// @endcond
+    /// @endcond
 }; // !enum aiOrigin
 
 // ----------------------------------------------------------------------------------
@@ -427,25 +427,25 @@ enum aiOrigin
  */
 enum aiDefaultLogStream
 {
-	/** Stream the log to a file */
-	aiDefaultLogStream_FILE = 0x1,
+    /** Stream the log to a file */
+    aiDefaultLogStream_FILE = 0x1,
 
-	/** Stream the log to std::cout */
-	aiDefaultLogStream_STDOUT = 0x2,
+    /** Stream the log to std::cout */
+    aiDefaultLogStream_STDOUT = 0x2,
 
-	/** Stream the log to std::cerr */
-	aiDefaultLogStream_STDERR = 0x4,
+    /** Stream the log to std::cerr */
+    aiDefaultLogStream_STDERR = 0x4,
 
-	/** MSVC only: Stream the log the the debugger
-	 * (this relies on OutputDebugString from the Win32 SDK)
-	 */
-	aiDefaultLogStream_DEBUGGER = 0x8,
+    /** MSVC only: Stream the log the the debugger
+     * (this relies on OutputDebugString from the Win32 SDK)
+     */
+    aiDefaultLogStream_DEBUGGER = 0x8,
 
-	/** @cond never
-	 *  Force 32-bit size enum
-	 */
-	_AI_DLS_ENFORCE_ENUM_SIZE = 0x7fffffff
-	/// @endcond
+    /** @cond never
+     *  Force 32-bit size enum
+     */
+    _AI_DLS_ENFORCE_ENUM_SIZE = 0x7fffffff
+    /// @endcond
 }; // !enum aiDefaultLogStream
 
 // just for backwards compatibility, don't use these constants anymore
@@ -463,43 +463,43 @@ struct aiMemoryInfo
 {
 #ifdef __cplusplus
 
-	/** Default constructor */
-	aiMemoryInfo()
-		: textures   (0)
-		, materials  (0)
-		, meshes     (0)
-		, nodes      (0)
-		, animations (0)
-		, cameras	 (0)
-		, lights	 (0)
-		, total      (0)
-	{}
+    /** Default constructor */
+    aiMemoryInfo()
+        : textures   (0)
+        , materials  (0)
+        , meshes     (0)
+        , nodes      (0)
+        , animations (0)
+        , cameras    (0)
+        , lights     (0)
+        , total      (0)
+    {}
 
 #endif
 
-	/** Storage allocated for texture data */
-	unsigned int textures;
+    /** Storage allocated for texture data */
+    unsigned int textures;
 
-	/** Storage allocated for material data  */
-	unsigned int materials;
+    /** Storage allocated for material data  */
+    unsigned int materials;
 
-	/** Storage allocated for mesh data */
-	unsigned int meshes;
+    /** Storage allocated for mesh data */
+    unsigned int meshes;
 
-	/** Storage allocated for node data */
-	unsigned int nodes;
+    /** Storage allocated for node data */
+    unsigned int nodes;
 
-	/** Storage allocated for animation data */
-	unsigned int animations;
+    /** Storage allocated for animation data */
+    unsigned int animations;
 
-	/** Storage allocated for camera data */
-	unsigned int cameras;
+    /** Storage allocated for camera data */
+    unsigned int cameras;
 
-	/** Storage allocated for light data */
-	unsigned int lights;
+    /** Storage allocated for light data */
+    unsigned int lights;
 
-	/** Total storage allocated for the full import. */
-	unsigned int total;
+    /** Total storage allocated for the full import. */
+    unsigned int total;
 }; // !struct aiMemoryInfo
 
 #ifdef __cplusplus

include/assimp/vector2.h

@@ -62,40 +62,40 @@ class aiVector2t
 {
 public:
 
-	aiVector2t () : x(), y() {}
-	aiVector2t (TReal _x, TReal _y) : x(_x), y(_y) {}
-	explicit aiVector2t (TReal _xyz) : x(_xyz), y(_xyz) {}
-	aiVector2t (const aiVector2t& o) : x(o.x), y(o.y) {}
+    aiVector2t () : x(), y() {}
+    aiVector2t (TReal _x, TReal _y) : x(_x), y(_y) {}
+    explicit aiVector2t (TReal _xyz) : x(_xyz), y(_xyz) {}
+    aiVector2t (const aiVector2t& o) : x(o.x), y(o.y) {}
 
 public:
 
-	void Set( TReal pX, TReal pY);
-	TReal SquareLength() const ;
-	TReal Length() const ;
-	aiVector2t& Normalize();
+    void Set( TReal pX, TReal pY);
+    TReal SquareLength() const ;
+    TReal Length() const ;
+    aiVector2t& Normalize();
 
 public:
 
-	const aiVector2t& operator += (const aiVector2t& o);
-	const aiVector2t& operator -= (const aiVector2t& o);
-	const aiVector2t& operator *= (TReal f);
-	const aiVector2t& operator /= (TReal f);
+    const aiVector2t& operator += (const aiVector2t& o);
+    const aiVector2t& operator -= (const aiVector2t& o);
+    const aiVector2t& operator *= (TReal f);
+    const aiVector2t& operator /= (TReal f);
 
-	TReal operator[](unsigned int i) const;
-	TReal& operator[](unsigned int i);
+    TReal operator[](unsigned int i) const;
+    TReal& operator[](unsigned int i);
 
-	bool operator== (const aiVector2t& other) const;
-	bool operator!= (const aiVector2t& other) const;
+    bool operator== (const aiVector2t& other) const;
+    bool operator!= (const aiVector2t& other) const;
 
-	bool Equal(const aiVector2t& other, TReal epsilon = 1e-6) const;
+    bool Equal(const aiVector2t& other, TReal epsilon = 1e-6) const;
 
-	aiVector2t& operator= (TReal f);
-	const aiVector2t SymMul(const aiVector2t& o);
+    aiVector2t& operator= (TReal f);
+    const aiVector2t SymMul(const aiVector2t& o);
 
-	template <typename TOther>
-	operator aiVector2t<TOther> () const;
+    template <typename TOther>
+    operator aiVector2t<TOther> () const;
 
-	TReal x, y;
+    TReal x, y;
 } PACK_STRUCT;
 
 typedef aiVector2t<float> aiVector2D;
@@ -103,7 +103,7 @@ typedef aiVector2t<float> aiVector2D;
 #else
 
 struct aiVector2D {
-	float x,y;
+    float x,y;
 };
 
 #endif // __cplusplus

include/assimp/vector2.inl

@@ -54,104 +54,104 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 template <typename TReal>
 template <typename TOther>
 aiVector2t<TReal>::operator aiVector2t<TOther> () const {
-	return aiVector2t<TOther>(static_cast<TOther>(x),static_cast<TOther>(y));
+    return aiVector2t<TOther>(static_cast<TOther>(x),static_cast<TOther>(y));
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 void aiVector2t<TReal>::Set( TReal pX, TReal pY) {
-	x = pX; y = pY;
+    x = pX; y = pY;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 TReal aiVector2t<TReal>::SquareLength() const {
-	return x*x + y*y;
+    return x*x + y*y;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 TReal aiVector2t<TReal>::Length() const {
-	return std::sqrt( SquareLength());
+    return std::sqrt( SquareLength());
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 aiVector2t<TReal>& aiVector2t<TReal>::Normalize() {
-	*this /= Length();
-	return *this;
+    *this /= Length();
+    return *this;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 const aiVector2t<TReal>& aiVector2t<TReal>::operator += (const aiVector2t& o) {
-	x += o.x; y += o.y;
-	return *this;
+    x += o.x; y += o.y;
+    return *this;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 const aiVector2t<TReal>& aiVector2t<TReal>::operator -= (const aiVector2t& o) {
-	x -= o.x; y -= o.y;
-	return *this;
+    x -= o.x; y -= o.y;
+    return *this;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 const aiVector2t<TReal>& aiVector2t<TReal>::operator *= (TReal f) {
-	x *= f; y *= f;
-	return *this;
+    x *= f; y *= f;
+    return *this;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 const aiVector2t<TReal>& aiVector2t<TReal>::operator /= (TReal f) {
-	x /= f; y /= f;
-	return *this;
+    x /= f; y /= f;
+    return *this;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 TReal aiVector2t<TReal>::operator[](unsigned int i) const {
-	return *(&x + i);
+    return *(&x + i);
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 TReal& aiVector2t<TReal>::operator[](unsigned int i) {
-	return *(&x + i);
+    return *(&x + i);
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 bool aiVector2t<TReal>::operator== (const aiVector2t& other) const {
-	return x == other.x && y == other.y;
+    return x == other.x && y == other.y;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 bool aiVector2t<TReal>::operator!= (const aiVector2t& other) const {
-	return x != other.x || y != other.y;
+    return x != other.x || y != other.y;
 }
 
 // ---------------------------------------------------------------------------
 template<typename TReal>
 bool aiVector2t<TReal>::Equal(const aiVector2t& other, TReal epsilon) const {
-	return
-		std::abs(x - other.x) <= epsilon &&
-		std::abs(y - other.y) <= epsilon;
+    return
+        std::abs(x - other.x) <= epsilon &&
+        std::abs(y - other.y) <= epsilon;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
-aiVector2t<TReal>& aiVector2t<TReal>::operator= (TReal f)	{
-	x = y = f;
-	return *this;
+aiVector2t<TReal>& aiVector2t<TReal>::operator= (TReal f)   {
+    x = y = f;
+    return *this;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 const aiVector2t<TReal> aiVector2t<TReal>::SymMul(const aiVector2t& o) {
-	return aiVector2t(x*o.x,y*o.y);
+    return aiVector2t(x*o.x,y*o.y);
 }
 
 
@@ -160,7 +160,7 @@ const aiVector2t<TReal> aiVector2t<TReal>::SymMul(const aiVector2t& o) {
 template <typename TReal>
 inline aiVector2t<TReal> operator + (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2)
 {
-	return aiVector2t<TReal>( v1.x + v2.x, v1.y + v2.y);
+    return aiVector2t<TReal>( v1.x + v2.x, v1.y + v2.y);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -168,7 +168,7 @@ inline aiVector2t<TReal> operator + (const aiVector2t<TReal>& v1, const aiVector
 template <typename TReal>
 inline aiVector2t<TReal> operator - (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2)
 {
-	return aiVector2t<TReal>( v1.x - v2.x, v1.y - v2.y);
+    return aiVector2t<TReal>( v1.x - v2.x, v1.y - v2.y);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -176,7 +176,7 @@ inline aiVector2t<TReal> operator - (const aiVector2t<TReal>& v1, const aiVector
 template <typename TReal>
 inline TReal operator * (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2)
 {
-	return v1.x*v2.x + v1.y*v2.y;
+    return v1.x*v2.x + v1.y*v2.y;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -184,7 +184,7 @@ inline TReal operator * (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v
 template <typename TReal>
 inline aiVector2t<TReal> operator * ( TReal f, const aiVector2t<TReal>& v)
 {
-	return aiVector2t<TReal>( f*v.x, f*v.y);
+    return aiVector2t<TReal>( f*v.x, f*v.y);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -192,7 +192,7 @@ inline aiVector2t<TReal> operator * ( TReal f, const aiVector2t<TReal>& v)
 template <typename TReal>
 inline aiVector2t<TReal> operator * ( const aiVector2t<TReal>& v, TReal f)
 {
-	return aiVector2t<TReal>( f*v.x, f*v.y);
+    return aiVector2t<TReal>( f*v.x, f*v.y);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -201,7 +201,7 @@ template <typename TReal>
 inline aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, TReal f)
 {
 
-	return v * (1/f);
+    return v * (1/f);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -209,7 +209,7 @@ inline aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, TReal f)
 template <typename TReal>
 inline aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, const aiVector2t<TReal>& v2)
 {
-	return aiVector2t<TReal>(v.x / v2.x,v.y / v2.y);
+    return aiVector2t<TReal>(v.x / v2.x,v.y / v2.y);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -217,7 +217,7 @@ inline aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, const aiVector
 template <typename TReal>
 inline aiVector2t<TReal> operator - ( const aiVector2t<TReal>& v)
 {
-	return aiVector2t<TReal>( -v.x, -v.y);
+    return aiVector2t<TReal>( -v.x, -v.y);
 }
 
 #endif

include/assimp/vector3.h

@@ -64,66 +64,66 @@ class aiVector3t
 {
 public:
 
-	aiVector3t () : x(), y(), z() {}
-	aiVector3t (TReal _x, TReal _y, TReal _z) : x(_x), y(_y), z(_z) {}
-	explicit aiVector3t (TReal _xyz) : x(_xyz), y(_xyz), z(_xyz) {}
-	aiVector3t (const aiVector3t& o) : x(o.x), y(o.y), z(o.z) {}
+    aiVector3t () : x(), y(), z() {}
+    aiVector3t (TReal _x, TReal _y, TReal _z) : x(_x), y(_y), z(_z) {}
+    explicit aiVector3t (TReal _xyz) : x(_xyz), y(_xyz), z(_xyz) {}
+    aiVector3t (const aiVector3t& o) : x(o.x), y(o.y), z(o.z) {}
 
 public:
 
-	// combined operators
-	const aiVector3t& operator += (const aiVector3t& o);
-	const aiVector3t& operator -= (const aiVector3t& o);
-	const aiVector3t& operator *= (TReal f);
-	const aiVector3t& operator /= (TReal f);
+    // combined operators
+    const aiVector3t& operator += (const aiVector3t& o);
+    const aiVector3t& operator -= (const aiVector3t& o);
+    const aiVector3t& operator *= (TReal f);
+    const aiVector3t& operator /= (TReal f);
 
-	// transform vector by matrix
-	aiVector3t& operator *= (const aiMatrix3x3t<TReal>& mat);
-	aiVector3t& operator *= (const aiMatrix4x4t<TReal>& mat);
+    // transform vector by matrix
+    aiVector3t& operator *= (const aiMatrix3x3t<TReal>& mat);
+    aiVector3t& operator *= (const aiMatrix4x4t<TReal>& mat);
 
-	// access a single element
-	TReal operator[](unsigned int i) const;
-	TReal& operator[](unsigned int i);
+    // access a single element
+    TReal operator[](unsigned int i) const;
+    TReal& operator[](unsigned int i);
 
-	// comparison
-	bool operator== (const aiVector3t& other) const;
-	bool operator!= (const aiVector3t& other) const;
-	bool operator < (const aiVector3t& other) const;
+    // comparison
+    bool operator== (const aiVector3t& other) const;
+    bool operator!= (const aiVector3t& other) const;
+    bool operator < (const aiVector3t& other) const;
 
-	bool Equal(const aiVector3t& other, TReal epsilon = 1e-6) const;
+    bool Equal(const aiVector3t& other, TReal epsilon = 1e-6) const;
 
-	template <typename TOther>
-	operator aiVector3t<TOther> () const;
+    template <typename TOther>
+    operator aiVector3t<TOther> () const;
 
 public:
 
-	/** @brief Set the components of a vector
-	 *  @param pX X component
-	 *  @param pY Y component
-	 *  @param pZ Z component  */
-	void Set( TReal pX, TReal pY, TReal pZ);
+    /** @brief Set the components of a vector
+     *  @param pX X component
+     *  @param pY Y component
+     *  @param pZ Z component  */
+    void Set( TReal pX, TReal pY, TReal pZ);
 
-	/** @brief Get the squared length of the vector
-	 *  @return Square length */
-	TReal SquareLength() const;
+    /** @brief Get the squared length of the vector
+     *  @return Square length */
+    TReal SquareLength() const;
 
 
-	/** @brief Get the length of the vector
-	 *  @return length */
-	TReal Length() const;
+    /** @brief Get the length of the vector
+     *  @return length */
+    TReal Length() const;
 
 
-	/** @brief Normalize the vector */
-	aiVector3t& Normalize();
+    /** @brief Normalize the vector */
+    aiVector3t& Normalize();
 
 
-	/** @brief Componentwise multiplication of two vectors
-	 *
-	 *  Note that vec*vec yields the dot product.
-	 *  @param o Second factor */
-	const aiVector3t SymMul(const aiVector3t& o);
+    /** @brief Componentwise multiplication of two vectors
+     *
+     *  Note that vec*vec yields the dot product.
+     *  @param o Second factor */
+    const aiVector3t SymMul(const aiVector3t& o);
 
-	TReal x, y, z;
+    TReal x, y, z;
 } PACK_STRUCT;
 
 
@@ -133,7 +133,7 @@ typedef aiVector3t<float> aiVector3D;
 
 struct aiVector3D {
 
-	float x,y,z;
+    float x,y,z;
 } PACK_STRUCT;
 
 #endif // __cplusplus

include/assimp/vector3.inl

@@ -55,11 +55,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 template <typename TReal>
 inline aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const aiVector3t<TReal>& pVector)
 {
-	aiVector3t<TReal> res;
-	res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z;
-	res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z;
-	res.z = pMatrix.c1 * pVector.x + pMatrix.c2 * pVector.y + pMatrix.c3 * pVector.z;
-	return res;
+    aiVector3t<TReal> res;
+    res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z;
+    res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z;
+    res.z = pMatrix.c1 * pVector.x + pMatrix.c2 * pVector.y + pMatrix.c3 * pVector.z;
+    return res;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -67,159 +67,159 @@ inline aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const a
 template <typename TReal>
 inline aiVector3t<TReal> operator * (const aiMatrix4x4t<TReal>& pMatrix, const aiVector3t<TReal>& pVector)
 {
-	aiVector3t<TReal> res;
-	res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z + pMatrix.a4;
-	res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z + pMatrix.b4;
-	res.z = pMatrix.c1 * pVector.x + pMatrix.c2 * pVector.y + pMatrix.c3 * pVector.z + pMatrix.c4;
-	return res;
+    aiVector3t<TReal> res;
+    res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z + pMatrix.a4;
+    res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z + pMatrix.b4;
+    res.z = pMatrix.c1 * pVector.x + pMatrix.c2 * pVector.y + pMatrix.c3 * pVector.z + pMatrix.c4;
+    return res;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 template <typename TOther>
 aiVector3t<TReal>::operator aiVector3t<TOther> () const {
-	return aiVector3t<TOther>(static_cast<TOther>(x),static_cast<TOther>(y),static_cast<TOther>(z));
+    return aiVector3t<TOther>(static_cast<TOther>(x),static_cast<TOther>(y),static_cast<TOther>(z));
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE void aiVector3t<TReal>::Set( TReal pX, TReal pY, TReal pZ) {
-	x = pX; y = pY; z = pZ;
+    x = pX; y = pY; z = pZ;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE TReal aiVector3t<TReal>::SquareLength() const {
-	return x*x + y*y + z*z;
+    return x*x + y*y + z*z;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE TReal aiVector3t<TReal>::Length() const {
-	return std::sqrt( SquareLength());
+    return std::sqrt( SquareLength());
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::Normalize() {
-	*this /= Length(); return *this;
+    *this /= Length(); return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator += (const aiVector3t<TReal>& o) {
-	x += o.x; y += o.y; z += o.z; return *this;
+    x += o.x; y += o.y; z += o.z; return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator -= (const aiVector3t<TReal>& o) {
-	x -= o.x; y -= o.y; z -= o.z; return *this;
+    x -= o.x; y -= o.y; z -= o.z; return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator *= (TReal f) {
-	x *= f; y *= f; z *= f; return *this;
+    x *= f; y *= f; z *= f; return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator /= (TReal f) {
-	x /= f; y /= f; z /= f; return *this;
+    x /= f; y /= f; z /= f; return *this;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& mat){
-	return(*this =  mat * (*this));
+    return(*this =  mat * (*this));
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix4x4t<TReal>& mat){
-	return(*this = mat * (*this));
+    return(*this = mat * (*this));
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE TReal aiVector3t<TReal>::operator[](unsigned int i) const {
-	return *(&x + i);
+    return *(&x + i);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE TReal& aiVector3t<TReal>::operator[](unsigned int i) {
-	return *(&x + i);
+    return *(&x + i);
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE bool aiVector3t<TReal>::operator== (const aiVector3t<TReal>& other) const {
-	return x == other.x && y == other.y && z == other.z;
+    return x == other.x && y == other.y && z == other.z;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE bool aiVector3t<TReal>::operator!= (const aiVector3t<TReal>& other) const {
-	return x != other.x || y != other.y || z != other.z;
+    return x != other.x || y != other.y || z != other.z;
 }
 // ---------------------------------------------------------------------------
 template<typename TReal>
 AI_FORCE_INLINE bool aiVector3t<TReal>::Equal(const aiVector3t<TReal>& other, TReal epsilon) const {
-	return
-		std::abs(x - other.x) <= epsilon &&
-		std::abs(y - other.y) <= epsilon &&
-		std::abs(z - other.z) <= epsilon;
+    return
+        std::abs(x - other.x) <= epsilon &&
+        std::abs(y - other.y) <= epsilon &&
+        std::abs(z - other.z) <= epsilon;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE bool aiVector3t<TReal>::operator < (const aiVector3t<TReal>& other) const {
-	return x != other.x ? x < other.x : y != other.y ? y < other.y : z < other.z;
+    return x != other.x ? x < other.x : y != other.y ? y < other.y : z < other.z;
 }
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE const aiVector3t<TReal> aiVector3t<TReal>::SymMul(const aiVector3t<TReal>& o) {
-	return aiVector3t<TReal>(x*o.x,y*o.y,z*o.z);
+    return aiVector3t<TReal>(x*o.x,y*o.y,z*o.z);
 }
 // ------------------------------------------------------------------------------------------------
 // symmetric addition
 template <typename TReal>
-AI_FORCE_INLINE aiVector3t<TReal> operator + (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2)	{
-	return aiVector3t<TReal>( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
+AI_FORCE_INLINE aiVector3t<TReal> operator + (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
+    return aiVector3t<TReal>( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
 }
 // ------------------------------------------------------------------------------------------------
 // symmetric subtraction
 template <typename TReal>
-AI_FORCE_INLINE aiVector3t<TReal> operator - (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2)	{
-	return aiVector3t<TReal>( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
+AI_FORCE_INLINE aiVector3t<TReal> operator - (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
+    return aiVector3t<TReal>( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
 }
 // ------------------------------------------------------------------------------------------------
 // scalar product
 template <typename TReal>
-AI_FORCE_INLINE TReal operator * (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2)	{
-	return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
+AI_FORCE_INLINE TReal operator * (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
+    return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
 }
 // ------------------------------------------------------------------------------------------------
 // scalar multiplication
 template <typename TReal>
-AI_FORCE_INLINE aiVector3t<TReal> operator * ( TReal f, const aiVector3t<TReal>& v)	{
-	return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z);
+AI_FORCE_INLINE aiVector3t<TReal> operator * ( TReal f, const aiVector3t<TReal>& v) {
+    return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z);
 }
 // ------------------------------------------------------------------------------------------------
 // and the other way around
 template <typename TReal>
-AI_FORCE_INLINE  aiVector3t<TReal> operator * ( const aiVector3t<TReal>& v, TReal f)	{
-	return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z);
+AI_FORCE_INLINE  aiVector3t<TReal> operator * ( const aiVector3t<TReal>& v, TReal f)    {
+    return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z);
 }
 // ------------------------------------------------------------------------------------------------
 // scalar division
 template <typename TReal>
-AI_FORCE_INLINE  aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, TReal f)	{
-	return v * (1/f);
+AI_FORCE_INLINE  aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, TReal f)    {
+    return v * (1/f);
 }
 // ------------------------------------------------------------------------------------------------
 // vector division
 template <typename TReal>
-AI_FORCE_INLINE  aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, const aiVector3t<TReal>& v2)	{
-	return aiVector3t<TReal>(v.x / v2.x,v.y / v2.y,v.z / v2.z);
+AI_FORCE_INLINE  aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, const aiVector3t<TReal>& v2)    {
+    return aiVector3t<TReal>(v.x / v2.x,v.y / v2.y,v.z / v2.z);
 }
 // ------------------------------------------------------------------------------------------------
 // cross product
 template <typename TReal>
-AI_FORCE_INLINE  aiVector3t<TReal> operator ^ ( const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2)	{
-	return aiVector3t<TReal>( v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x);
+AI_FORCE_INLINE  aiVector3t<TReal> operator ^ ( const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2)   {
+    return aiVector3t<TReal>( v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x);
 }
 // ------------------------------------------------------------------------------------------------
 // vector negation
 template <typename TReal>
-AI_FORCE_INLINE  aiVector3t<TReal> operator - ( const aiVector3t<TReal>& v)	{
-	return aiVector3t<TReal>( -v.x, -v.y, -v.z);
+AI_FORCE_INLINE  aiVector3t<TReal> operator - ( const aiVector3t<TReal>& v) {
+    return aiVector3t<TReal>( -v.x, -v.y, -v.z);
 }
 
 // ------------------------------------------------------------------------------------------------