Merge pull request #5 from assimp/master

Merge commits from head master.

Build.md

@@ -0,0 +1,7 @@
+# Build instructions
+
+> cmake CMakeLists.txt
+make -j4
+
+##UWP
+See https://stackoverflow.com/questions/40803170/cmake-uwp-using-cmake-to-build-universal-windows-app

CMakeLists.txt

@@ -210,8 +210,8 @@ ENDIF( UNIX )
 # Grouped compiler settings
 IF ((CMAKE_C_COMPILER_ID MATCHES "GNU") AND NOT CMAKE_COMPILER_IS_MINGW)
   # hide all not-exported symbols
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -fvisibility=hidden -fPIC -Wall -std=c++0x")
+  SET(CMAKE_CXX_FLAGS "-g -fvisibility=hidden -fPIC -fno-strict-aliasing -Wall -std=c++0x ${CMAKE_CXX_FLAGS}")
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
+  SET(CMAKE_C_FLAGS "-fPIC -fno-strict-aliasing ${CMAKE_C_FLAGS}")
   SET(LIBSTDC++_LIBRARIES -lstdc++)
 ELSEIF(MSVC)
   # enable multi-core compilation with MSVC
@@ -224,11 +224,11 @@ ELSEIF(MSVC)
     ADD_COMPILE_OPTIONS(/wd4351)
   ENDIF()
 ELSEIF ( "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" )
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -fvisibility=hidden -fPIC -Wall -Wno-long-long -std=c++11" )
+  SET(CMAKE_CXX_FLAGS "-g -fvisibility=hidden -fPIC -fno-strict-aliasing -Wall -Wno-long-long -std=c++11 ${CMAKE_CXX_FLAGS}" )
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
+  SET(CMAKE_C_FLAGS "-fPIC -fno-strict-aliasing ${CMAKE_C_FLAGS}")
 ELSEIF( CMAKE_COMPILER_IS_MINGW )
-  SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -Wall -Wno-long-long -std=c++11 -Wa,-mbig-obj" )
+  SET( CMAKE_CXX_FLAGS "-fvisibility=hidden -fno-strict-aliasing -Wall -Wno-long-long -std=c++11 -Wa,-mbig-obj ${CMAKE_CXX_FLAGS}" )
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC ")
+  SET(CMAKE_C_FLAGS "-fPIC -fno-strict-aliasing ${CMAKE_C_FLAGS} ")
   ADD_DEFINITIONS( -U__STRICT_ANSI__ )
 ENDIF()
 

code/3DSHelper.h

@@ -66,7 +66,7 @@ namespace D3DS  {
 */
 class Discreet3DS {
 private:
-    Discreet3DS() {
+    Discreet3DS() AI_NO_EXCEPT {
         // empty
     }
 
@@ -328,19 +328,17 @@ struct Face : public FaceWithSmoothingGroup
 
 // ---------------------------------------------------------------------------
 /** Helper structure representing a texture */
-struct Texture
+struct Texture {
-{
     //! Default constructor
-    Texture()
+    Texture() AI_NO_EXCEPT
-        : mOffsetU  (0.0)
+    : mOffsetU  (0.0)
-        , mOffsetV  (0.0)
+    , mOffsetV  (0.0)
-        , mScaleU   (1.0)
+    , mScaleU   (1.0)
-        , mScaleV   (1.0)
+    , mScaleV   (1.0)
-        , mRotation (0.0)
+    , mRotation (0.0)
-        , mMapMode  (aiTextureMapMode_Wrap)
+    , mMapMode  (aiTextureMapMode_Wrap)
-        , bPrivate()
+    , bPrivate()
-        , iUVSrc    (0)
+    , iUVSrc    (0) {
-    {
         mTextureBlend = get_qnan();
     }
 
@@ -394,7 +392,7 @@ struct Material
 
 
     //! Move constructor. This is explicitly written because MSVC doesn't support defaulting it
-    Material(Material &&other)
+    Material(Material &&other) AI_NO_EXCEPT
     : mName(std::move(other.mName))
     , mDiffuse(std::move(other.mDiffuse))
     , mSpecularExponent(std::move(other.mSpecularExponent))
@@ -418,7 +416,7 @@ struct Material
     }
 
 
-    Material &operator=(Material &&other) {
+    Material &operator=(Material &&other) AI_NO_EXCEPT {
         if (this == &other) {
             return *this;
         }
@@ -447,7 +445,7 @@ struct Material
     }
 
 
-    ~Material() {}
+    virtual ~Material() {}
 
 
     //! Name of the material

code/AMFImporter.hpp

@@ -63,8 +63,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // Header files, stdlib.
 #include <set>
 
-namespace Assimp
+namespace Assimp {
-{
+
 /// \class AMFImporter
 /// Class that holding scene graph which include: geometry, metadata, materials etc.
 ///
@@ -99,100 +99,49 @@ namespace Assimp
 ///            new - <texmap> and children <utex1>, <utex2>, <utex3>, <vtex1>, <vtex2>, <vtex3>
 ///            old - <map> and children <u1>, <u2>, <u3>, <v1>, <v2>, <v3>
 ///
-class AMFImporter : public BaseImporter
+class AMFImporter : public BaseImporter {
-{
-	/***********************************************/
-	/******************** Types ********************/
-	/***********************************************/
-
 private:
+    struct SPP_Material;// forward declaration
 
-	struct SPP_Material;// forward declaration
+                        /// \struct SPP_Composite
+                        /// Data type for post-processing step. More suitable container for part of material's composition.
+    struct SPP_Composite {
+        SPP_Material* Material;///< Pointer to material - part of composition.
+        std::string Formula;///< Formula for calculating ratio of \ref Material.
+    };
 
-	/// \struct SPP_Composite
+    /// \struct SPP_Material
-	/// Data type for postprocessing step. More suitable container for part of material's composition.
+    /// Data type for post-processing step. More suitable container for material.
-	struct SPP_Composite
+    struct SPP_Material {
-	{
+        std::string ID;///< Material ID.
-		SPP_Material* Material;///< Pointer to material - part of composition.
+        std::list<CAMFImporter_NodeElement_Metadata*> Metadata;///< Metadata of material.
-		std::string Formula;///< Formula for calculating ratio of \ref Material.
+        CAMFImporter_NodeElement_Color* Color;///< Color of material.
-	};
+        std::list<SPP_Composite> Composition;///< List of child materials if current material is composition of few another.
 
-	/// \struct SPP_Material
+        /// Return color calculated for specified coordinate.
-	/// Data type for postprocessing step. More suitable container for material.
+        /// \param [in] pX - "x" coordinate.
-	struct SPP_Material
+        /// \param [in] pY - "y" coordinate.
-	{
+        /// \param [in] pZ - "z" coordinate.
-		std::string ID;///< Material ID.
+        /// \return calculated color.
-		std::list<CAMFImporter_NodeElement_Metadata*> Metadata;///< Metadata of material.
+        aiColor4D GetColor(const float pX, const float pY, const float pZ) const;
-		CAMFImporter_NodeElement_Color* Color;///< Color of material.
+    };
-		std::list<SPP_Composite> Composition;///< List of child materials if current material is composition of few another.
 
-		/// \fn aiColor4D GetColor(const float pX, const float pY, const float pZ) const
+    /// Data type for post-processing step. More suitable container for texture.
-		/// Return color calculated for specified coordinate.
+    struct SPP_Texture {
-		/// \param [in] pX - "x" coordinate.
+        std::string ID;
-		/// \param [in] pY - "y" coordinate.
+        size_t      Width, Height, Depth;
-		/// \param [in] pZ - "z" coordinate.
+        bool        Tiled;
-		/// \return calculated color.
+        char        FormatHint[9];// 8 for string + 1 for terminator.
-		aiColor4D GetColor(const float pX, const float pY, const float pZ) const;
+        uint8_t    *Data;
-	};
+    };
 
-	/// \struct SPP_Texture
+    /// Data type for post-processing step. Contain face data.
-	/// Data type for post-processing step. More suitable container for texture.
+    struct SComplexFace {
-	struct SPP_Texture
+        aiFace Face;///< Face vertices.
-	{
+        const CAMFImporter_NodeElement_Color* Color;///< Face color. Equal to nullptr if color is not set for the face.
-		std::string ID;
+        const CAMFImporter_NodeElement_TexMap* TexMap;///< Face texture mapping data. Equal to nullptr if texture mapping is not set for the face.
-		size_t      Width, Height, Depth;
+    };
-		bool        Tiled;
-        char        FormatHint[ 9 ];// 8 for string + 1 for terminator.
-		uint8_t    *Data;
-	};
 
-	///	\struct SComplexFace
-	/// Data type for post-processing step. Contain face data.
-	struct SComplexFace
-	{
-		aiFace Face;///< Face vertices.
-		const CAMFImporter_NodeElement_Color* Color;///< Face color. Equal to nullptr if color is not set for the face.
-		const CAMFImporter_NodeElement_TexMap* TexMap;///< Face texture mapping data. Equal to nullptr if texture mapping is not set for the face.
-	};
-
-
-
-	/***********************************************/
-	/****************** Constants ******************/
-	/***********************************************/
-
-private:
-
-	static const aiImporterDesc Description;
-
-	/***********************************************/
-	/****************** Variables ******************/
-	/***********************************************/
-
-private:
-
-    CAMFImporter_NodeElement* mNodeElement_Cur;///< Current element.
-    std::list<CAMFImporter_NodeElement*> mNodeElement_List;///< All elements of scene graph.
-	irr::io::IrrXMLReader* mReader;///< Pointer to XML-reader object
-	std::string mUnit;
-	std::list<SPP_Material> mMaterial_Converted;///< List of converted materials for postprocessing step.
-	std::list<SPP_Texture> mTexture_Converted;///< List of converted textures for postprocessing step.
-
-	/***********************************************/
-	/****************** Functions ******************/
-	/***********************************************/
-
-private:
-
-	/// \fn AMFImporter(const AMFImporter& pScene)
-	/// Disabled copy constructor.
-	AMFImporter(const AMFImporter& pScene);
-
-	/// \fn AMFImporter& operator=(const AMFImporter& pScene)
-	/// Disabled assign operator.
-	AMFImporter& operator=(const AMFImporter& pScene);
-
-	/// \fn void Clear()
 	/// Clear all temporary data.
 	void Clear();
 
@@ -200,7 +149,6 @@ private:
 	/************* Functions: find set *************/
 	/***********************************************/
 
-	/// \fn bool Find_NodeElement(const std::string& pID, const CAMFImporter_NodeElement::EType pType, aiNode** pNode) const
 	/// Find specified node element in node elements list ( \ref mNodeElement_List).
 	/// \param [in] pID - ID(name) of requested node element.
 	/// \param [in] pType - type of node element.
@@ -208,7 +156,6 @@ private:
 	/// \return true - if the node element is found, else - false.
 	bool Find_NodeElement(const std::string& pID, const CAMFImporter_NodeElement::EType pType, CAMFImporter_NodeElement** pNodeElement) const;
 
-	/// \fn bool Find_ConvertedNode(const std::string& pID, std::list<aiNode*>& pNodeList, aiNode** pNode) const
 	/// Find requested aiNode in node list.
 	/// \param [in] pID - ID(name) of requested node.
 	/// \param [in] pNodeList - list of nodes where to find the node.
@@ -216,15 +163,13 @@ private:
 	/// \return true - if the node is found, else - false.
 	bool Find_ConvertedNode(const std::string& pID, std::list<aiNode*>& pNodeList, aiNode** pNode) const;
 
-	/// \fn bool Find_ConvertedMaterial(const std::string& pID, const SPP_Material** pConvertedMaterial) const
 	/// Find material in list for converted materials. Use at postprocessing step.
 	/// \param [in] pID - material ID.
 	/// \param [out] pConvertedMaterial - pointer to found converted material (\ref SPP_Material).
 	/// \return true - if the material is found, else - false.
 	bool Find_ConvertedMaterial(const std::string& pID, const SPP_Material** pConvertedMaterial) const;
 
-	/// \fn bool Find_ConvertedTexture(const std::string& pID_R, const std::string& pID_G, const std::string& pID_B, const std::string& pID_A, uint32_t* pConvertedTextureIndex = nullptr) const
+    /// Find texture in list of converted textures. Use at postprocessing step,
-	/// Find texture in list of converted textures. Use at postprocessing step,
 	/// \param [in] pID_R - ID of source "red" texture.
 	/// \param [in] pID_G - ID of source "green" texture.
 	/// \param [in] pID_B - ID of source "blue" texture.
@@ -235,11 +180,7 @@ private:
 	bool Find_ConvertedTexture(const std::string& pID_R, const std::string& pID_G, const std::string& pID_B, const std::string& pID_A,
 								uint32_t* pConvertedTextureIndex = nullptr) const;
 
-	/***********************************************/
-	/********* Functions: postprocess set **********/
-	/***********************************************/
 
-	/// \fn void PostprocessHelper_CreateMeshDataArray(const CAMFImporter_NodeElement_Mesh& pNodeElement, std::vector<aiVector3D>& pVertexCoordinateArray, std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray) const
 	/// Get data stored in <vertices> and place it to arrays.
 	/// \param [in] pNodeElement - reference to node element which kept <object> data.
 	/// \param [in] pVertexCoordinateArray - reference to vertices coordinates kept in <vertices>.
@@ -248,7 +189,6 @@ private:
 	void PostprocessHelper_CreateMeshDataArray(const CAMFImporter_NodeElement_Mesh& pNodeElement, std::vector<aiVector3D>& pVertexCoordinateArray,
 												std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray) const;
 
-	/// \fn size_t PostprocessHelper_GetTextureID_Or_Create(const std::string& pID_R, const std::string& pID_G, const std::string& pID_B, const std::string& pID_A)
 	/// Return converted texture ID which related to specified source textures ID's. If converted texture does not exist then it will be created and ID on new
 	/// converted texture will be returned. Conversion: set of textures from \ref CAMFImporter_NodeElement_Texture to one \ref SPP_Texture and place it
 	/// to converted textures list.
@@ -260,27 +200,23 @@ private:
 	/// \return index of the texture in array of the converted textures.
 	size_t PostprocessHelper_GetTextureID_Or_Create(const std::string& pID_R, const std::string& pID_G, const std::string& pID_B, const std::string& pID_A);
 
-	/// \fn void PostprocessHelper_SplitFacesByTextureID(std::list<SComplexFace>& pInputList, std::list<std::list<SComplexFace> > pOutputList_Separated)
 	/// Separate input list by texture IDs. This step is needed because aiMesh can contain mesh which is use only one texture (or set: diffuse, bump etc).
 	/// \param [in] pInputList - input list with faces. Some of them can contain color or texture mapping, or both of them, or nothing. Will be cleared after
 	/// processing.
 	/// \param [out] pOutputList_Separated - output list of the faces lists. Separated faces list by used texture IDs. Will be cleared before processing.
 	void PostprocessHelper_SplitFacesByTextureID(std::list<SComplexFace>& pInputList, std::list<std::list<SComplexFace> >& pOutputList_Separated);
 
-	/// \fn void Postprocess_AddMetadata(const std::list<CAMFImporter_NodeElement_Metadata*>& pMetadataList, aiNode& pSceneNode) const
 	/// Check if child elements of node element is metadata and add it to scene node.
 	/// \param [in] pMetadataList - reference to list with collected metadata.
 	/// \param [out] pSceneNode - scene node in which metadata will be added.
 	void Postprocess_AddMetadata(const std::list<CAMFImporter_NodeElement_Metadata*>& pMetadataList, aiNode& pSceneNode) const;
 
-	/// \fn void Postprocess_BuildNodeAndObject(const CAMFImporter_NodeElement_Object& pNodeElement, std::list<aiMesh*>& pMeshList, aiNode** pSceneNode)
 	/// To create aiMesh and aiNode for it from <object>.
 	/// \param [in] pNodeElement - reference to node element which kept <object> data.
 	/// \param [out] pMeshList - reference to a list with all aiMesh of the scene.
 	/// \param [out] pSceneNode - pointer to place where new aiNode will be created.
 	void Postprocess_BuildNodeAndObject(const CAMFImporter_NodeElement_Object& pNodeElement, std::list<aiMesh*>& pMeshList, aiNode** pSceneNode);
 
-	/// \fn void Postprocess_BuildMeshSet(const CAMFImporter_NodeElement_Mesh& pNodeElement, const std::vector<aiVector3D>& pVertexCoordinateArray, const std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray, const CAMFImporter_NodeElement_Color* pObjectColor, std::list<aiMesh*>& pMeshList, aiNode& pSceneNode)
 	/// Create mesh for every <volume> in <mesh>.
 	/// \param [in] pNodeElement - reference to node element which kept <mesh> data.
 	/// \param [in] pVertexCoordinateArray - reference to vertices coordinates for all <volume>'s.
@@ -294,27 +230,20 @@ private:
 									const std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray, const CAMFImporter_NodeElement_Color* pObjectColor,
 									std::list<aiMesh*>& pMeshList, aiNode& pSceneNode);
 
-	/// \fn void Postprocess_BuildMaterial(const CAMFImporter_NodeElement_Material& pMaterial)
 	/// Convert material from \ref CAMFImporter_NodeElement_Material to \ref SPP_Material.
 	/// \param [in] pMaterial - source CAMFImporter_NodeElement_Material.
 	void Postprocess_BuildMaterial(const CAMFImporter_NodeElement_Material& pMaterial);
 
-	/// \fn void Postprocess_BuildConstellation(CAMFImporter_NodeElement_Constellation& pConstellation, std::list<aiNode*>& pNodeList) const
 	/// Create and add to aiNode's list new part of scene graph defined by <constellation>.
 	/// \param [in] pConstellation - reference to <constellation> node.
 	/// \param [out] pNodeList - reference to aiNode's list.
 	void Postprocess_BuildConstellation(CAMFImporter_NodeElement_Constellation& pConstellation, std::list<aiNode*>& pNodeList) const;
 
-	/// \fn void Postprocess_BuildScene()
 	/// Build Assimp scene graph in aiScene from collected data.
 	/// \param [out] pScene - pointer to aiScene where tree will be built.
 	void Postprocess_BuildScene(aiScene* pScene);
 
-	/***********************************************/
-	/************* Functions: throw set ************/
-	/***********************************************/
 
-	/// \fn void Throw_CloseNotFound(const std::string& pNode)
 	/// Call that function when close tag of node not found and exception must be raised.
 	/// E.g.:
 	/// <amf>
@@ -324,19 +253,16 @@ private:
 	/// \param [in] pNode - node name in which exception happened.
 	void Throw_CloseNotFound(const std::string& pNode);
 
-	/// \fn void Throw_IncorrectAttr(const std::string& pAttrName)
 	/// Call that function when attribute name is incorrect and exception must be raised.
 	/// \param [in] pAttrName - attribute name.
 	/// \throw DeadlyImportError.
 	void Throw_IncorrectAttr(const std::string& pAttrName);
 
-	/// \fn void Throw_IncorrectAttrValue(const std::string& pAttrName)
 	/// Call that function when attribute value is incorrect and exception must be raised.
 	/// \param [in] pAttrName - attribute name.
 	/// \throw DeadlyImportError.
 	void Throw_IncorrectAttrValue(const std::string& pAttrName);
 
-	/// \fn void Throw_MoreThanOnceDefined(const std::string& pNode, const std::string& pDescription)
 	/// Call that function when some type of nodes are defined twice or more when must be used only once and exception must be raised.
 	/// E.g.:
 	/// <object>
@@ -348,204 +274,158 @@ private:
 	/// \param [in] pDescription - message about error. E.g. what the node defined while exception raised.
 	void Throw_MoreThanOnceDefined(const std::string& pNodeType, const std::string& pDescription);
 
-	/// \fn void Throw_ID_NotFound(const std::string& pID) const
 	/// Call that function when referenced element ID are not found in graph and exception must be raised.
 	/// \param [in] pID - ID of of element which not found.
 	/// \throw DeadlyImportError.
 	void Throw_ID_NotFound(const std::string& pID) const;
 
-	/***********************************************/
-	/************** Functions: LOG set *************/
-	/***********************************************/
-
-	/***********************************************/
-	/************** Functions: XML set *************/
-	/***********************************************/
-
-	/// \fn void XML_CheckNode_MustHaveChildren()
 	/// Check if current node have children: <node>...</node>. If not then exception will throwed.
 	void XML_CheckNode_MustHaveChildren();
 
-	/// \fn bool XML_CheckNode_NameEqual(const std::string& pNodeName)
 	/// Check if current node name is equal to pNodeName.
 	/// \param [in] pNodeName - name for checking.
 	/// return true if current node name is equal to pNodeName, else - false.
 	bool XML_CheckNode_NameEqual(const std::string& pNodeName) { return mReader->getNodeName() == pNodeName; }
 
-	/// \fn void XML_CheckNode_SkipUnsupported(const std::string& pParentNodeName)
 	/// Skip unsupported node and report about that. Depend on node name can be skipped begin tag of node all whole node.
 	/// \param [in] pParentNodeName - parent node name. Used for reporting.
 	void XML_CheckNode_SkipUnsupported(const std::string& pParentNodeName);
 
-	/// \fn bool XML_SearchNode(const std::string& pNodeName)
 	/// Search for specified node in file. XML file read pointer(mReader) will point to found node or file end after search is end.
 	/// \param [in] pNodeName - requested node name.
 	/// return true - if node is found, else - false.
 	bool XML_SearchNode(const std::string& pNodeName);
 
-	/// \fn bool XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx)
 	/// Read attribute value.
 	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
 	/// \return read data.
 	bool XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx);
 
-	/// \fn float XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx)
 	/// Read attribute value.
 	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
 	/// \return read data.
 	float XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx);
 
-	/// \fn uint32_t XML_ReadNode_GetAttrVal_AsU32(const int pAttrIdx)
 	/// Read attribute value.
 	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
 	/// \return read data.
 	uint32_t XML_ReadNode_GetAttrVal_AsU32(const int pAttrIdx);
 
-	/// \fn float XML_ReadNode_GetVal_AsFloat()
 	/// Read node value.
 	/// \return read data.
 	float XML_ReadNode_GetVal_AsFloat();
 
-	/// \fn uint32_t XML_ReadNode_GetVal_AsU32()
 	/// Read node value.
 	/// \return read data.
 	uint32_t XML_ReadNode_GetVal_AsU32();
 
-	/// \fn void XML_ReadNode_GetVal_AsString(std::string& pValue)
 	/// Read node value.
 	/// \return read data.
 	void XML_ReadNode_GetVal_AsString(std::string& pValue);
 
-	/***********************************************/
-	/******** Functions: parse set private *********/
-	/***********************************************/
-
-	/// \fn void ParseHelper_Node_Enter(CAMFImporter_NodeElement* pNode)
 	/// Make pNode as current and enter deeper for parsing child nodes. At end \ref ParseHelper_Node_Exit must be called.
 	/// \param [in] pNode - new current node.
 	void ParseHelper_Node_Enter(CAMFImporter_NodeElement* pNode);
 
-	/// \fn void ParseHelper_Group_End()
 	/// This function must be called when exiting from grouping node. \ref ParseHelper_Group_Begin.
 	void ParseHelper_Node_Exit();
 
-	/// \fn void ParseHelper_FixTruncatedFloatString(const char* pInStr, std::string& pOutString)
 	/// Attribute values of floating point types can take form ".x"(without leading zero). irrXMLReader can not read this form of values and it
 	/// must be converted to right form - "0.xxx".
 	/// \param [in] pInStr - pointer to input string which can contain incorrect form of values.
 	/// \param [out[ pOutString - output string with right form of values.
 	void ParseHelper_FixTruncatedFloatString(const char* pInStr, std::string& pOutString);
 
-	/// \fn void ParseHelper_Decode_Base64(const std::string& pInputBase64, std::vector<uint8_t>& pOutputData) const
 	/// Decode Base64-encoded data.
 	/// \param [in] pInputBase64 - reference to input Base64-encoded string.
 	/// \param [out] pOutputData - reference to output array for decoded data.
 	void ParseHelper_Decode_Base64(const std::string& pInputBase64, std::vector<uint8_t>& pOutputData) const;
 
-	/// \fn void ParseNode_Root()
 	/// Parse <AMF> node of the file.
 	void ParseNode_Root();
 
-	/******** Functions: top nodes *********/
-
-	/// \fn void ParseNode_Constellation()
 	/// Parse <constellation> node of the file.
 	void ParseNode_Constellation();
 
-	/// \fn void ParseNode_Constellation()
 	/// Parse <instance> node of the file.
 	void ParseNode_Instance();
 
-	/// \fn void ParseNode_Material()
 	/// Parse <material> node of the file.
 	void ParseNode_Material();
 
-	/// \fn void ParseNode_Metadata()
 	/// Parse <metadata> node.
 	void ParseNode_Metadata();
 
-	/// \fn void ParseNode_Object()
 	/// Parse <object> node of the file.
 	void ParseNode_Object();
 
-	/// \fn void ParseNode_Texture()
 	/// Parse <texture> node of the file.
 	void ParseNode_Texture();
 
-	/******** Functions: geometry nodes *********/
-
-	/// \fn void ParseNode_Coordinates()
 	/// Parse <coordinates> node of the file.
 	void ParseNode_Coordinates();
 
-	/// \fn void ParseNode_Edge()
 	/// Parse <edge> node of the file.
 	void ParseNode_Edge();
 
-	/// \fn void ParseNode_Mesh()
 	/// Parse <mesh> node of the file.
 	void ParseNode_Mesh();
 
-	/// \fn void ParseNode_Triangle()
 	/// Parse <triangle> node of the file.
 	void ParseNode_Triangle();
 
-	/// \fn void ParseNode_Vertex()
 	/// Parse <vertex> node of the file.
 	void ParseNode_Vertex();
 
-	/// \fn void ParseNode_Vertices()
 	/// Parse <vertices> node of the file.
 	void ParseNode_Vertices();
 
-	/// \fn void ParseNode_Volume()
 	/// Parse <volume> node of the file.
 	void ParseNode_Volume();
 
-	/******** Functions: material nodes *********/
-
-	/// \fn void ParseNode_Color()
 	/// Parse <color> node of the file.
 	void ParseNode_Color();
 
-	/// \fn void ParseNode_TexMap(const bool pUseOldName = false)
 	/// Parse <texmap> of <map> node of the file.
 	/// \param [in] pUseOldName - if true then use old name of node(and children) - <map>, instead of new name - <texmap>.
 	void ParseNode_TexMap(const bool pUseOldName = false);
 
 public:
-
-	/// \fn AMFImporter()
 	/// Default constructor.
-	AMFImporter()
+	AMFImporter() AI_NO_EXCEPT
-		: mNodeElement_Cur(nullptr), mReader(nullptr)
+    : mNodeElement_Cur(nullptr)
-	{}
+    , mReader(nullptr) {
+        // empty
+    }
 
-	/// \fn ~AMFImporter()
 	/// Default destructor.
 	~AMFImporter();
 
-	/***********************************************/
-	/******** Functions: parse set, public *********/
-	/***********************************************/
-
-	/// \fn void ParseFile(const std::string& pFile, IOSystem* pIOHandler)
 	/// Parse AMF file and fill scene graph. The function has no return value. Result can be found by analyzing the generated graph.
-	/// Also exception can be throwed if trouble will found.
+	/// Also exception can be thrown if trouble will found.
 	/// \param [in] pFile - name of file to be parsed.
 	/// \param [in] pIOHandler - pointer to IO helper object.
 	void ParseFile(const std::string& pFile, IOSystem* pIOHandler);
 
-	/***********************************************/
-	/********* Functions: BaseImporter set *********/
-	/***********************************************/
-
 	bool CanRead(const std::string& pFile, IOSystem* pIOHandler, bool pCheckSig) const;
 	void GetExtensionList(std::set<std::string>& pExtensionList);
 	void InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler);
 	const aiImporterDesc* GetInfo ()const;
 
-};// class AMFImporter
+    AMFImporter(const AMFImporter& pScene) = delete;
+    AMFImporter& operator=(const AMFImporter& pScene) = delete;
+
+private:
+    static const aiImporterDesc Description;
+
+    CAMFImporter_NodeElement* mNodeElement_Cur;///< Current element.
+    std::list<CAMFImporter_NodeElement*> mNodeElement_List;///< All elements of scene graph.
+    irr::io::IrrXMLReader* mReader;///< Pointer to XML-reader object
+    std::string mUnit;
+    std::list<SPP_Material> mMaterial_Converted;///< List of converted materials for postprocessing step.
+    std::list<SPP_Texture> mTexture_Converted;///< List of converted textures for postprocessing step.
+
+};
 
 }// namespace Assimp
 

code/AMFImporter_Material.cpp

@@ -68,10 +68,9 @@ namespace Assimp
 //   Multi elements - No.
 //   Red, Greed, Blue and Alpha (transparency) component of a color in sRGB space, values ranging from 0 to 1. The
 //   values can be specified as constants, or as a formula depending on the coordinates.
-void AMFImporter::ParseNode_Color()
+void AMFImporter::ParseNode_Color() {
-{
+    std::string profile;
-std::string profile;
+    CAMFImporter_NodeElement* ne;
-CAMFImporter_NodeElement* ne;
 
 	// Read attributes for node <color>.
 	MACRO_ATTRREAD_LOOPBEG;
@@ -98,15 +97,19 @@ CAMFImporter_NodeElement* ne;
 		MACRO_NODECHECK_LOOPEND("color");
 		ParseHelper_Node_Exit();
 		// check that all components was defined
-		if(!(read_flag[0] && read_flag[1] && read_flag[2])) throw DeadlyImportError("Not all color components are defined.");
+        if (!(read_flag[0] && read_flag[1] && read_flag[2])) {
-		// check if <a> is absent. Then manually add "a == 1".
+            throw DeadlyImportError("Not all color components are defined.");
-		if(!read_flag[3]) als.Color.a = 1;
+        }
 
-	}// if(!mReader->isEmptyElement())
+        // check if <a> is absent. Then manually add "a == 1".
+        if (!read_flag[3]) {
+            als.Color.a = 1;
+        }
+	}
 	else
 	{
 		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}// if(!mReader->isEmptyElement()) else
+	}
 
 	als.Composed = false;
 	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
@@ -119,10 +122,9 @@ CAMFImporter_NodeElement* ne;
 // An available material.
 // Multi elements - Yes.
 // Parent element - <amf>.
-void AMFImporter::ParseNode_Material()
+void AMFImporter::ParseNode_Material() {
-{
+    std::string id;
-std::string id;
+    CAMFImporter_NodeElement* ne;
-CAMFImporter_NodeElement* ne;
 
 	// Read attributes for node <color>.
 	MACRO_ATTRREAD_LOOPBEG;
@@ -131,9 +133,11 @@ CAMFImporter_NodeElement* ne;
 
 	// create new object.
 	ne = new CAMFImporter_NodeElement_Material(mNodeElement_Cur);
-	// and assign read data
+
+    // and assign read data
 	((CAMFImporter_NodeElement_Material*)ne)->ID = id;
-	// Check for child nodes
+
+    // Check for child nodes
 	if(!mReader->isEmptyElement())
 	{
 		bool col_read = false;
@@ -154,11 +158,11 @@ CAMFImporter_NodeElement* ne;
 			if(XML_CheckNode_NameEqual("metadata")) { ParseNode_Metadata(); continue; }
 		MACRO_NODECHECK_LOOPEND("material");
 		ParseHelper_Node_Exit();
-	}// if(!mReader->isEmptyElement())
+	}
 	else
 	{
 		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}// if(!mReader->isEmptyElement()) else
+	}
 
 	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
 }
@@ -181,14 +185,13 @@ CAMFImporter_NodeElement* ne;
 // Parent element - <amf>.
 void AMFImporter::ParseNode_Texture()
 {
-std::string id;
+    std::string id;
-uint32_t width = 0;
+    uint32_t width = 0;
-uint32_t height = 0;
+    uint32_t height = 0;
-uint32_t depth = 1;
+    uint32_t depth = 1;
-std::string type;
+    std::string type;
-bool tiled = false;
+    bool tiled = false;
-std::string enc64_data;
+    std::string enc64_data;
-CAMFImporter_NodeElement* ne;
 
 	// Read attributes for node <color>.
 	MACRO_ATTRREAD_LOOPBEG;
@@ -201,20 +204,34 @@ CAMFImporter_NodeElement* ne;
 	MACRO_ATTRREAD_LOOPEND;
 
 	// create new texture object.
-	ne = new CAMFImporter_NodeElement_Texture(mNodeElement_Cur);
+    CAMFImporter_NodeElement *ne = new CAMFImporter_NodeElement_Texture(mNodeElement_Cur);
 
 	CAMFImporter_NodeElement_Texture& als = *((CAMFImporter_NodeElement_Texture*)ne);// alias for convenience
 
 	// Check for child nodes
-	if(!mReader->isEmptyElement()) XML_ReadNode_GetVal_AsString(enc64_data);
+    if (!mReader->isEmptyElement()) {
+        XML_ReadNode_GetVal_AsString(enc64_data);
+    }
 
 	// check that all components was defined
-	if(id.empty()) throw DeadlyImportError("ID for texture must be defined.");
+    if (id.empty()) {
-	if(width < 1) Throw_IncorrectAttrValue("width");
+        throw DeadlyImportError("ID for texture must be defined.");
-	if(height < 1) Throw_IncorrectAttrValue("height");
+    }
-	if(depth < 1) Throw_IncorrectAttrValue("depth");
+    if (width < 1) {
-	if(type != "grayscale") Throw_IncorrectAttrValue("type");
+        Throw_IncorrectAttrValue("width");
-	if(enc64_data.empty()) throw DeadlyImportError("Texture data not defined.");
+    }
+    if (height < 1) {
+        Throw_IncorrectAttrValue("height");
+    }
+    if (depth < 1) {
+        Throw_IncorrectAttrValue("depth");
+    }
+    if (type != "grayscale") {
+        Throw_IncorrectAttrValue("type");
+    }
+    if (enc64_data.empty()) {
+        throw DeadlyImportError("Texture data not defined.");
+    }
 	// copy data
 	als.ID = id;
 	als.Width = width;
@@ -222,8 +239,11 @@ CAMFImporter_NodeElement* ne;
 	als.Depth = depth;
 	als.Tiled = tiled;
 	ParseHelper_Decode_Base64(enc64_data, als.Data);
-	// check data size
+
-	if((width * height * depth) != als.Data.size()) throw DeadlyImportError("Texture has incorrect data size.");
+    // check data size
+    if ((width * height * depth) != als.Data.size()) {
+        throw DeadlyImportError("Texture has incorrect data size.");
+    }
 
 	mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
 	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
@@ -243,10 +263,8 @@ CAMFImporter_NodeElement* ne;
 //   <utex1>, <utex2>, <utex3>, <vtex1>, <vtex2>, <vtex3>. Old name: <u1>, <u2>, <u3>, <v1>, <v2>, <v3>.
 //   Multi elements - No.
 //   Texture coordinates for every vertex of triangle.
-void AMFImporter::ParseNode_TexMap(const bool pUseOldName)
+void AMFImporter::ParseNode_TexMap(const bool pUseOldName) {
-{
+    std::string rtexid, gtexid, btexid, atexid;
-std::string rtexid, gtexid, btexid, atexid;
-CAMFImporter_NodeElement* ne;
 
 	// Read attributes for node <color>.
 	MACRO_ATTRREAD_LOOPBEG;
@@ -257,7 +275,7 @@ CAMFImporter_NodeElement* ne;
 	MACRO_ATTRREAD_LOOPEND;
 
 	// create new texture coordinates object.
-	ne = new CAMFImporter_NodeElement_TexMap(mNodeElement_Cur);
+    CAMFImporter_NodeElement *ne = new CAMFImporter_NodeElement_TexMap(mNodeElement_Cur);
 
 	CAMFImporter_NodeElement_TexMap& als = *((CAMFImporter_NodeElement_TexMap*)ne);// alias for convenience
 	// check data

code/AMFImporter_Node.hpp

@@ -62,7 +62,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /// \class CAMFImporter_NodeElement
 /// Base class for elements of nodes.
 class CAMFImporter_NodeElement {
-
 public:
 	/// Define what data type contain node element.
 	enum EType {
@@ -96,15 +95,11 @@ public:                                               /// Destructor, virtual..
         // empty
     }
 
-private:
+	/// Disabled copy constructor and co.
-	/// Disabled copy constructor.
+	CAMFImporter_NodeElement(const CAMFImporter_NodeElement& pNodeElement) = delete;
-	CAMFImporter_NodeElement(const CAMFImporter_NodeElement& pNodeElement);
+    CAMFImporter_NodeElement(CAMFImporter_NodeElement&&) = delete;
-
+    CAMFImporter_NodeElement& operator=(const CAMFImporter_NodeElement& pNodeElement) = delete;
-	/// Disabled assign operator.
+	CAMFImporter_NodeElement() = delete;
-	CAMFImporter_NodeElement& operator=(const CAMFImporter_NodeElement& pNodeElement);
-
-	/// Disabled default constructor.
-	CAMFImporter_NodeElement();
 
 protected:
 	/// In constructor inheritor must set element type.
@@ -121,9 +116,7 @@ protected:
 
 /// \struct CAMFImporter_NodeElement_Constellation
 /// A collection of objects or constellations with specific relative locations.
-struct CAMFImporter_NodeElement_Constellation : public CAMFImporter_NodeElement
+struct CAMFImporter_NodeElement_Constellation : public CAMFImporter_NodeElement {
-{
-	/// \fn CAMFImporter_NodeElement_Constellation(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Constellation(CAMFImporter_NodeElement* pParent)
@@ -134,9 +127,7 @@ struct CAMFImporter_NodeElement_Constellation : public CAMFImporter_NodeElement
 
 /// \struct CAMFImporter_NodeElement_Instance
 /// Part of constellation.
-struct CAMFImporter_NodeElement_Instance : public CAMFImporter_NodeElement
+struct CAMFImporter_NodeElement_Instance : public CAMFImporter_NodeElement {
-{
-	/****************** Variables ******************/
 
 	std::string ObjectID;///< ID of object for instantiation.
 	/// \var Delta - The distance of translation in the x, y, or z direction, respectively, in the referenced object's coordinate system, to
@@ -147,237 +138,185 @@ struct CAMFImporter_NodeElement_Instance : public CAMFImporter_NodeElement
 	/// instance of the object in the current constellation. Rotations shall be executed in order of x first, then y, then z.
 	aiVector3D Rotation;
 
-	/****************** Functions ******************/
-
-	/// \fn CAMFImporter_NodeElement_Instance(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Instance(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Instance, pParent)
 	{}
-
+};
-};// struct CAMFImporter_NodeElement_Instance
 
 /// \struct CAMFImporter_NodeElement_Metadata
 /// Structure that define metadata node.
-struct CAMFImporter_NodeElement_Metadata : public CAMFImporter_NodeElement
+struct CAMFImporter_NodeElement_Metadata : public CAMFImporter_NodeElement {
-{
-	/****************** Variables ******************/
 
 	std::string Type;///< Type of "Value". 
 	std::string Value;///< Value.
 
-	/****************** Functions ******************/
-
-	/// \fn CAMFImporter_NodeElement_Metadata(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Metadata(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Metadata, pParent)
 	{}
-
+};
-};// struct CAMFImporter_NodeElement_Metadata
 
 /// \struct CAMFImporter_NodeElement_Root
 /// Structure that define root node.
-struct CAMFImporter_NodeElement_Root : public CAMFImporter_NodeElement
+struct CAMFImporter_NodeElement_Root : public CAMFImporter_NodeElement {
-{
-	/****************** Variables ******************/
 
 	std::string Unit;///< The units to be used. May be "inch", "millimeter", "meter", "feet", or "micron".
 	std::string Version;///< Version of format.
 
-	/****************** Functions ******************/
-
-	/// \fn CAMFImporter_NodeElement_Root(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Root(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Root, pParent)
 	{}
-
+};
-};// struct CAMFImporter_NodeElement_Root
 
 /// \struct CAMFImporter_NodeElement_Color
 /// Structure that define object node.
-struct CAMFImporter_NodeElement_Color : public CAMFImporter_NodeElement
+struct CAMFImporter_NodeElement_Color : public CAMFImporter_NodeElement {
-{
+	bool Composed;                  ///< Type of color stored: if true then look for formula in \ref Color_Composed[4], else - in \ref Color.
-	/****************** Variables ******************/
+	std::string Color_Composed[4];  ///< By components formulas of composed color. [0..3] - RGBA.
+	aiColor4D Color;                ///< Constant color.
+	std::string Profile;            ///< The ICC color space used to interpret the three color channels r, g and b..
 
-	bool Composed;///< Type of color stored: if true then look for formula in \ref Color_Composed[4], else - in \ref Color.
+	/// @brief  Constructor.
-	std::string Color_Composed[4];///< By components formulas of composed color. [0..3] => RGBA.
+	/// @param [in] pParent - pointer to parent node.
-	aiColor4D Color;///< Constant color.
-	std::string Profile;///< The ICC color space used to interpret the three color channels <r>, <g> and <b>..
-
-	/****************** Functions ******************/
-
-	/// \fn CAMFImporter_NodeElement_Color(CAMFImporter_NodeElement* pParent)
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Color(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_Color, pParent)
+	: CAMFImporter_NodeElement(ENET_Color, pParent)
-	{}
+    , Composed( false )
-
+    , Color()
-};// struct CAMFImporter_NodeElement_Color
+    , Profile() {
+        // empty
+    }
+};
 
 /// \struct CAMFImporter_NodeElement_Material
 /// Structure that define material node.
-struct CAMFImporter_NodeElement_Material : public CAMFImporter_NodeElement
+struct CAMFImporter_NodeElement_Material : public CAMFImporter_NodeElement {
-{
+	
-	/// \fn CAMFImporter_NodeElement_Material(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Material(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Material, pParent)
 	{}
 
-};// struct CAMFImporter_NodeElement_Material
+};
 
 /// \struct CAMFImporter_NodeElement_Object
 /// Structure that define object node.
-struct CAMFImporter_NodeElement_Object : public CAMFImporter_NodeElement
+struct CAMFImporter_NodeElement_Object : public CAMFImporter_NodeElement {
-{
+
-	/// \fn CAMFImporter_NodeElement_Object(CAMFImporter_NodeElement* pParent)
+    /// Constructor.
-	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Object(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Object, pParent)
 	{}
-
+};
-};// struct CAMFImporter_NodeElement_Object
 
 /// \struct CAMFImporter_NodeElement_Mesh
 /// Structure that define mesh node.
-struct CAMFImporter_NodeElement_Mesh : public CAMFImporter_NodeElement
+struct CAMFImporter_NodeElement_Mesh : public CAMFImporter_NodeElement {
-{
-	/// \fn CAMFImporter_NodeElement_Mesh(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Mesh(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Mesh, pParent)
 	{}
-
+};
-};// struct CAMFImporter_NodeElement_Mesh
 
 /// \struct CAMFImporter_NodeElement_Vertex
 /// Structure that define vertex node.
-struct CAMFImporter_NodeElement_Vertex : public CAMFImporter_NodeElement
+struct CAMFImporter_NodeElement_Vertex : public CAMFImporter_NodeElement {
-{
-	/// \fn CAMFImporter_NodeElement_Vertex(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Vertex(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Vertex, pParent)
 	{}
-
+};
-};// struct CAMFImporter_NodeElement_Vertex
 
 /// \struct CAMFImporter_NodeElement_Edge
 /// Structure that define edge node.
-struct CAMFImporter_NodeElement_Edge : public CAMFImporter_NodeElement
+struct CAMFImporter_NodeElement_Edge : public CAMFImporter_NodeElement {
-{
-	/// \fn CAMFImporter_NodeElement_Edge(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Edge(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Edge, pParent)
 	{}
 
-};// struct CAMFImporter_NodeElement_Vertex
+};
 
 /// \struct CAMFImporter_NodeElement_Vertices
 /// Structure that define vertices node.
-struct CAMFImporter_NodeElement_Vertices : public CAMFImporter_NodeElement
+struct CAMFImporter_NodeElement_Vertices : public CAMFImporter_NodeElement {
-{
-	/// \fn CAMFImporter_NodeElement_Vertices(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Vertices(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Vertices, pParent)
 	{}
-
+};
-};// struct CAMFImporter_NodeElement_Vertices
 
 /// \struct CAMFImporter_NodeElement_Volume
 /// Structure that define volume node.
-struct CAMFImporter_NodeElement_Volume : public CAMFImporter_NodeElement
+struct CAMFImporter_NodeElement_Volume : public CAMFImporter_NodeElement {
-{
-	/****************** Variables ******************/
-
 	std::string MaterialID;///< Which material to use.
 	std::string Type;///< What this volume describes can be “region” or “support”. If none specified, “object” is assumed.
 
-	/****************** Functions ******************/
-
-	/// \fn CAMFImporter_NodeElement_Volume(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Volume(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Volume, pParent)
 	{}
-
+};
-};// struct CAMFImporter_NodeElement_Volume
 
 /// \struct CAMFImporter_NodeElement_Coordinates
 /// Structure that define coordinates node.
 struct CAMFImporter_NodeElement_Coordinates : public CAMFImporter_NodeElement
 {
-	/****************** Variables ******************/
-
 	aiVector3D Coordinate;///< Coordinate.
 
-	/****************** Functions ******************/
-
-	/// \fn CAMFImporter_NodeElement_Coordinates(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Coordinates(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Coordinates, pParent)
 	{}
 
-};// struct CAMFImporter_NodeElement_Coordinates
+};
 
 /// \struct CAMFImporter_NodeElement_TexMap
 /// Structure that define texture coordinates node.
-struct CAMFImporter_NodeElement_TexMap : public CAMFImporter_NodeElement
+struct CAMFImporter_NodeElement_TexMap : public CAMFImporter_NodeElement {
-{
-	/****************** Variables ******************/
-
 	aiVector3D TextureCoordinate[3];///< Texture coordinates.
 	std::string TextureID_R;///< Texture ID for red color component.
 	std::string TextureID_G;///< Texture ID for green color component.
 	std::string TextureID_B;///< Texture ID for blue color component.
 	std::string TextureID_A;///< Texture ID for alpha color component.
 
-	/****************** Functions ******************/
-
-	/// \fn CAMFImporter_NodeElement_TexMap(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_TexMap(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_TexMap, pParent)
+	: CAMFImporter_NodeElement(ENET_TexMap, pParent)
-	{}
+    , TextureCoordinate{}
-
+    , TextureID_R()
-};// struct CAMFImporter_NodeElement_TexMap
+    , TextureID_G()
+    , TextureID_B()
+    , TextureID_A()	{
+        // empty
+    }
+};
 
 /// \struct CAMFImporter_NodeElement_Triangle
 /// Structure that define triangle node.
-struct CAMFImporter_NodeElement_Triangle : public CAMFImporter_NodeElement
+struct CAMFImporter_NodeElement_Triangle : public CAMFImporter_NodeElement {
-{
-	/****************** Variables ******************/
-
 	size_t V[3];///< Triangle vertices.
 
-	/****************** Functions ******************/
-
-	/// \fn CAMFImporter_NodeElement_Triangle(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Triangle(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_Triangle, pParent)
+	: CAMFImporter_NodeElement(ENET_Triangle, pParent) {
-	{}
+        // empty
-
+    }
-};// struct CAMFImporter_NodeElement_Triangle
+};
 
 /// Structure that define texture node.
 struct CAMFImporter_NodeElement_Texture : public CAMFImporter_NodeElement {
@@ -396,6 +335,6 @@ struct CAMFImporter_NodeElement_Texture : public CAMFImporter_NodeElement {
     , Tiled( false ){
         // empty
     }
-};// struct CAMFImporter_NodeElement_Texture
+};
 
 #endif // INCLUDED_AI_AMF_IMPORTER_NODE_H

code/ASEParser.h

@@ -71,21 +71,20 @@ struct Material : public D3DS::Material
     //! Default constructor has been deleted
     Material() = delete;
 
-
     //! Constructor with explicit name
     explicit Material(const std::string &name)
     : D3DS::Material(name)
     , pcInstance(NULL)
-    , bNeed (false)
+    , bNeed (false) {
-    {}
+        // empty
-
+    }
 
     Material(const Material &other)            = default;
     Material &operator=(const Material &other) = default;
 
 
     //! Move constructor. This is explicitly written because MSVC doesn't support defaulting it
-    Material(Material &&other)
+    Material(Material &&other) AI_NO_EXCEPT
     : D3DS::Material(std::move(other))
     , avSubMaterials(std::move(other.avSubMaterials))
     , pcInstance(std::move(other.pcInstance))
@@ -95,7 +94,7 @@ struct Material : public D3DS::Material
     }
 
 
-    Material &operator=(Material &&other) {
+    Material &operator=(Material &&other) AI_NO_EXCEPT {
         if (this == &other) {
             return *this;
         }
@@ -127,19 +126,12 @@ struct Material : public D3DS::Material
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent an ASE file face */
-struct Face : public FaceWithSmoothingGroup
+struct Face : public FaceWithSmoothingGroup {
-{
     //! Default constructor. Initializes everything with 0
-    Face()
+    Face() AI_NO_EXCEPT
-    {
+    : iMaterial(DEFAULT_MATINDEX)
-        mColorIndices[0] = mColorIndices[1] = mColorIndices[2] = 0;
+    , iFace(0) {
-        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
+        // empty
-        {
-            amUVIndices[i][0] = amUVIndices[i][1] = amUVIndices[i][2] = 0;
-        }
-
-        iMaterial = DEFAULT_MATINDEX;
-        iFace = 0;
     }
 
     //! special value to indicate that no material index has
@@ -147,8 +139,6 @@ struct Face : public FaceWithSmoothingGroup
     //! will replace this value later.
     static const unsigned int DEFAULT_MATINDEX = 0xFFFFFFFF;
 
-
-
     //! Indices into each list of texture coordinates
     unsigned int amUVIndices[AI_MAX_NUMBER_OF_TEXTURECOORDS][3];
 
@@ -166,15 +156,15 @@ struct Face : public FaceWithSmoothingGroup
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent an ASE file bone */
-struct Bone
+struct Bone {
-{
     //! Constructor
     Bone() = delete;
 
     //! Construction from an existing name
     explicit Bone( const std::string& name)
-        :   mName   (name)
+    : mName(name) {
-    {}
+        // empty
+    }
 
     //! Name of the bone
     std::string mName;
@@ -182,29 +172,22 @@ struct Bone
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent an ASE file bone vertex */
-struct BoneVertex
+struct BoneVertex {
-{
     //! Bone and corresponding vertex weight.
     //! -1 for unrequired bones ....
     std::vector<std::pair<int,float> > mBoneWeights;
-
-    //! Position of the bone vertex.
-    //! MUST be identical to the vertex position
-    //aiVector3D mPosition;
 };
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent an ASE file animation */
-struct Animation
+struct Animation {
-{
+    enum Type {
-    enum Type
-    {
         TRACK   = 0x0,
         BEZIER  = 0x1,
         TCB     = 0x2
     } mRotationType, mScalingType, mPositionType;
 
-    Animation()
+    Animation() AI_NO_EXCEPT
         :   mRotationType   (TRACK)
         ,   mScalingType    (TRACK)
         ,   mPositionType   (TRACK)
@@ -218,19 +201,16 @@ struct Animation
 
     //! List of track scaling keyframes
     std::vector< aiVectorKey > akeyScaling;
-
 };
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent the inheritance information of an ASE node */
-struct InheritanceInfo
+struct InheritanceInfo {
-{
     //! Default constructor
-    InheritanceInfo()
+    InheritanceInfo() AI_NO_EXCEPT {
-    {
+        for ( size_t i=0; i<3; ++i ) {
-        // set the inheritance flag for all axes by default to true
-        for (unsigned int i = 0; i < 3;++i)
             abInheritPosition[i] = abInheritRotation[i] = abInheritScaling[i] = true;
+        }
     }
 
     //! Inherit the parent's position?, axis order is x,y,z
@@ -245,17 +225,19 @@ struct InheritanceInfo
 
 // ---------------------------------------------------------------------------
 /** Represents an ASE file node. Base class for mesh, light and cameras */
-struct BaseNode
+struct BaseNode {
-{
+    enum Type {
-    enum Type {Light, Camera, Mesh, Dummy} mType;
+        Light, 
-
+        Camera, 
+        Mesh, 
+        Dummy
+    } mType;
 
     //! Construction from an existing name
     BaseNode(Type _mType, const std::string &name)
     : mType         (_mType)
     , mName         (name)
-    , mProcessed    (false)
+    , mProcessed    (false) {
-    {
         // Set mTargetPosition to qnan
         const ai_real qnan = get_qnan();
         mTargetPosition.x = qnan;
@@ -291,24 +273,23 @@ struct BaseNode
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent an ASE file mesh */
-struct Mesh : public MeshWithSmoothingGroups<ASE::Face>, public BaseNode
+struct Mesh : public MeshWithSmoothingGroups<ASE::Face>, public BaseNode {
-{
     //! Default constructor has been deleted
     Mesh() = delete;
 
-
     //! Construction from an existing name
     explicit Mesh(const std::string &name)
-    : BaseNode  (BaseNode::Mesh, name)
+    : BaseNode( BaseNode::Mesh, name )
+    , mVertexColors()
+    , mBoneVertices()
+    , mBones()
     , iMaterialIndex(Face::DEFAULT_MATINDEX)
-    , bSkip     (false)
+    , bSkip     (false) {
-    {
+        for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c) {
-        // use 2 texture vertex components by default
-        for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c)
             this->mNumUVComponents[c] = 2;
+        }
     }
 
-
     //! List of all texture coordinate sets
     std::vector<aiVector3D> amTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
 
@@ -396,12 +377,11 @@ struct Camera : public BaseNode
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent an ASE helper object (dummy) */
-struct Dummy : public BaseNode
+struct Dummy : public BaseNode {
-{
     //! Constructor
-    Dummy()
+    Dummy() AI_NO_EXCEPT
-        : BaseNode  (BaseNode::Dummy, "DUMMY")
+    : BaseNode  (BaseNode::Dummy, "DUMMY") {
-    {
+        // empty
     }
 };
 
@@ -416,12 +396,11 @@ struct Dummy : public BaseNode
 // -------------------------------------------------------------------------------
 /** \brief Class to parse ASE files
  */
-class Parser
+class Parser {
-{
-
 private:
-
+    Parser() AI_NO_EXCEPT {
-    Parser() {}
+        // empty
+    }
 
 public:
 

code/AssbinExporter.cpp

@@ -824,8 +824,7 @@ public:
     }
 };
 
-void ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
+void ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/) {
-{
     AssbinExport exporter;
     exporter.WriteBinaryDump( pFile, pIOSystem, pScene );
 }

code/AssbinLoader.cpp

@@ -547,7 +547,6 @@ void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex) {
             stream->Read(tex->pcData,1,tex->mWidth*tex->mHeight*4);
         }
     }
-
 }
 
 // -----------------------------------------------------------------------------------

code/BaseImporter.cpp

@@ -65,7 +65,7 @@ using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-BaseImporter::BaseImporter()
+BaseImporter::BaseImporter() AI_NO_EXCEPT
 : m_progress() {
     // nothing to do here
 }

code/BaseProcess.cpp

@@ -53,7 +53,7 @@ using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-BaseProcess::BaseProcess()
+BaseProcess::BaseProcess() AI_NO_EXCEPT
 : shared()
 , progress()
 {

code/BaseProcess.h

@@ -211,20 +211,16 @@ private:
  * should be executed. If the function returns true, the class' Execute()
  * function is called subsequently.
  */
-class ASSIMP_API_WINONLY BaseProcess
+class ASSIMP_API_WINONLY BaseProcess {
-{
     friend class Importer;
 
 public:
-
     /** Constructor to be privately used by Importer */
-    BaseProcess();
+    BaseProcess() AI_NO_EXCEPT;
 
     /** Destructor, private as well */
     virtual ~BaseProcess();
 
-public:
-
     // -------------------------------------------------------------------
     /** Returns whether the processing step is present in the given flag.
      * @param pFlags The processing flags the importer was called with. A

code/COBLoader.cpp

@@ -137,9 +137,7 @@ void COBImporter::SetupProperties(const Importer* /*pImp*/)
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void COBImporter::InternReadFile( const std::string& pFile,
+void COBImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) {
-    aiScene* pScene, IOSystem* pIOHandler)
-{
     COB::Scene scene;
     std::unique_ptr<StreamReaderLE> stream(new StreamReaderLE( pIOHandler->Open(pFile,"rb")) );
 

code/EmbedTexturesProcess.cpp

@@ -119,7 +119,7 @@ bool EmbedTexturesProcess::addTexture(aiScene* pScene, std::string path) const {
         }
     }
 
-    aiTexel* imageContent = new aiTexel[1u + imageSize / sizeof(aiTexel)];
+    aiTexel* imageContent = new aiTexel[ 1ul + static_cast<unsigned long>( imageSize ) / sizeof(aiTexel)];
     file.seekg(0, std::ios::beg);
     file.read(reinterpret_cast<char*>(imageContent), imageSize);
 

code/FBXConverter.cpp

@@ -185,12 +185,8 @@ void FBXConverter::ConvertNodes( uint64_t id, aiNode& parent, const aiMatrix4x4&
                 }
 
                 if ( !name_carrier ) {
-                    NodeNameCache::const_iterator it = mNodeNames.find(original_name);
+                    std::string old_original_name = original_name;
-                    if ( it != mNodeNames.end() ) {
+                    GetUniqueName(old_original_name, original_name);
-                        original_name = original_name + std::string( "001" );
-                    }
-
-                    mNodeNames.insert( original_name );
                     nodes_chain.push_back( new aiNode( original_name ) );
                 } else {
                     original_name = nodes_chain.back()->mName.C_Str();

code/FBXMeshGeometry.cpp

@@ -437,7 +437,7 @@ void ResolveVertexDataArray(std::vector<T>& data_out, const Scope& source,
     // deal with this more elegantly and with less redundancy, but right
     // now it seems unavoidable.
     if (MappingInformationType == "ByVertice" && isDirect) {
-        if (!HasElement(source, indexDataElementName)) {
+        if (!HasElement(source, dataElementName)) {
             return;
         }
         std::vector<T> tempData;

code/Importer.h

@@ -120,11 +120,11 @@ public:
     SharedPostProcessInfo* mPPShared;
 
     /// The default class constructor.
-    ImporterPimpl();
+    ImporterPimpl() AI_NO_EXCEPT;
 };
 
 inline
-ImporterPimpl::ImporterPimpl()
+ImporterPimpl::ImporterPimpl() AI_NO_EXCEPT
 : mIOHandler( nullptr )
 , mIsDefaultHandler( false )
 , mProgressHandler( nullptr )

code/LWOAnimation.h

@@ -113,14 +113,14 @@ enum PrePostBehaviour
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a LWO animation keyframe
  */
-struct Key
+struct Key {
-{
+    Key() AI_NO_EXCEPT 
-    Key()
+    : time()
-        : time(),
+    , value()
-        value(),
+    , inter(IT_LINE)
-        inter   (IT_LINE),
+    , params() {
-        params()
+        // empty
-    {}
+    }
 
     //! Current time
     double time;
@@ -144,17 +144,16 @@ struct Key
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a LWO animation envelope
  */
-struct Envelope
+struct Envelope {
-{
+    Envelope() AI_NO_EXCEPT
-    Envelope()
+    : index()
-        :   index()
+    , type(EnvelopeType_Unknown)
-        ,   type    (EnvelopeType_Unknown)
+    , pre(PrePostBehaviour_Constant)
-        ,   pre     (PrePostBehaviour_Constant)
+    , post(PrePostBehaviour_Constant)
-        ,   post    (PrePostBehaviour_Constant)
+    , old_first(0)
-
+    , old_last(0) {
-        ,   old_first (0)
+        // empty
-        ,   old_last  (0)
+    }
-    {}
 
     //! Index of this envelope
     unsigned int index;
@@ -162,7 +161,7 @@ struct Envelope
     //! Type of envelope
     EnvelopeType type;
 
-    //! Pre and post-behaviour
+    //! Pre- and post-behavior
     PrePostBehaviour pre,post;
 
     //! Keyframes for this envelope

code/LWOFileData.h

@@ -261,14 +261,14 @@ namespace LWO {
  * \note We can't use the code in SmoothingGroups.inl here - the mesh
  *   structures of 3DS/ASE and LWO are too different.
  */
-struct Face : public aiFace
+struct Face : public aiFace {
-{
     //! Default construction
-    Face()
+    Face() AI_NO_EXCEPT
-        : surfaceIndex  (0)
+    : surfaceIndex( 0 )
-        , smoothGroup   (0)
+    , smoothGroup( 0 )
-        , type          (AI_LWO_FACE)
+    , type( AI_LWO_FACE ) {
-    {}
+        // empty
+    }
 
     //! Construction from given type
     explicit Face(uint32_t _type)

code/LimitBoneWeightsProcess.h

@@ -120,7 +120,7 @@ public:
     {
         unsigned int mBone; ///< Index of the bone
         float mWeight;      ///< Weight of that bone on this vertex
-        Weight()
+        Weight() AI_NO_EXCEPT
         : mBone(0)
         , mWeight(0.0f)
         { }

code/MD3Loader.h

@@ -125,7 +125,7 @@ enum AlphaTestFunc
  */
 struct ShaderMapBlock
 {
-    ShaderMapBlock()
+    ShaderMapBlock() AI_NO_EXCEPT
          :  blend_src   (BLEND_NONE)
          ,  blend_dest  (BLEND_NONE)
          ,  alpha_test  (AT_NONE)
@@ -150,7 +150,7 @@ struct ShaderMapBlock
  */
 struct ShaderDataBlock
 {
-    ShaderDataBlock()
+    ShaderDataBlock() AI_NO_EXCEPT
         :   cull    (CULL_CW)
     {}
 

code/MD5Parser.h

@@ -192,14 +192,14 @@ typedef std::vector< FrameDesc > FrameList;
 // ---------------------------------------------------------------------------
 /** Represents a vertex  descriptor in a MD5 file
 */
-struct VertexDesc
+struct VertexDesc {
-{
+    VertexDesc() AI_NO_EXCEPT
-    VertexDesc()
+    : mFirstWeight(0)
-        : mFirstWeight  (0)
+    , mNumWeights(0) {
-        , mNumWeights   (0)
+        // empty
-    {}
+    }
 
-    //! UV cordinate of the vertex
+    //! UV coordinate of the vertex
     aiVector2D mUV;
 
     //! Index of the first weight of the vertex in

code/MDCFileData.h

@@ -61,7 +61,6 @@ http://themdcfile.planetwolfenstein.gamespy.com/MDC_File_Format.pdf
 namespace Assimp {
 namespace MDC {
 
-
 // to make it easier for us, we test the magic word against both "endianesses"
 #define AI_MDC_MAGIC_NUMBER_BE  AI_MAKE_MAGIC("CPDI")
 #define AI_MDC_MAGIC_NUMBER_LE  AI_MAKE_MAGIC("IDPC")
@@ -79,8 +78,7 @@ namespace MDC {
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a MDC file's main header
  */
-struct Header
+struct Header {
-{
     uint32_t ulIdent ;
     uint32_t ulVersion ;
     char ucName [ AI_MDC_MAXQPATH ] ;
@@ -100,8 +98,7 @@ struct Header
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a MDC file's surface header
  */
-struct Surface
+struct Surface {
-{
     uint32_t ulIdent ;
     char ucName [ AI_MDC_MAXQPATH ] ;
     uint32_t ulFlags ;
@@ -118,23 +115,22 @@ struct Surface
     uint32_t ulOffsetFrameBaseFrames ;
     uint32_t ulOffsetFrameCompFrames ;
     uint32_t ulOffsetEnd;
-    Surface()
+    Surface() AI_NO_EXCEPT
-        : ulIdent(),
+    : ulIdent()
-        ulFlags(),
+    , ulFlags()
-        ulNumCompFrames(),
+    , ulNumCompFrames()
-        ulNumBaseFrames(),
+    , ulNumBaseFrames()
-        ulNumShaders(),
+    , ulNumShaders() 
-        ulNumVertices(),
+    , ulNumVertices()
-        ulNumTriangles(),
+    , ulNumTriangles()
-        ulOffsetTriangles(),
+    , ulOffsetTriangles()
-        ulOffsetShaders(),
+    , ulOffsetShaders()
-        ulOffsetTexCoords(),
+    , ulOffsetTexCoords()
-        ulOffsetBaseVerts(),
+    , ulOffsetBaseVerts() 
-        ulOffsetCompVerts(),
+    , ulOffsetCompVerts()
-        ulOffsetFrameBaseFrames(),
+    , ulOffsetFrameBaseFrames()
-        ulOffsetFrameCompFrames(),
+    , ulOffsetFrameCompFrames()
-        ulOffsetEnd()
+    , ulOffsetEnd() {
-    {
         ucName[AI_MDC_MAXQPATH-1] = '\0';
     }
 } PACK_STRUCT;
@@ -142,8 +138,7 @@ struct Surface
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a MDC frame
  */
-struct Frame
+struct Frame {
-{
     //! bounding box minimum coords
     aiVector3D bboxMin ;
 
@@ -163,24 +158,21 @@ struct Frame
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a MDC triangle
  */
-struct Triangle
+struct Triangle {
-{
     uint32_t aiIndices[3];
 } PACK_STRUCT;
 
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a MDC texture coordinate
  */
-struct TexturCoord
+struct TexturCoord {
-{
     float u,v;
 } PACK_STRUCT;
 
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a MDC base vertex
  */
-struct BaseVertex
+struct BaseVertex {
-{
     int16_t x,y,z;
     uint16_t normal;
 } PACK_STRUCT;
@@ -188,25 +180,20 @@ struct BaseVertex
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a MDC compressed vertex
  */
-struct CompressedVertex
+struct CompressedVertex {
-{
     uint8_t xd,yd,zd,nd;
 } PACK_STRUCT;
 
-
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a MDC shader
  */
-struct Shader
+struct Shader {
-{
     char ucName [ AI_MDC_MAXQPATH ] ;
     uint32_t ulPath;
-
 } PACK_STRUCT;
 
 #include <assimp/Compiler/poppack1.h>
 
-
 // ---------------------------------------------------------------------------
 /** Build a floating point vertex from the compressed data in MDC files
  */
@@ -215,6 +202,7 @@ void BuildVertex(const Frame& frame,
     const CompressedVertex& cvert,
     aiVector3D& vXYZOut,
     aiVector3D& vNorOut);
-}}
+}
+}
 
 #endif // !! AI_MDCFILEHELPER_H_INC

code/MDLFileData.h

@@ -717,11 +717,9 @@ struct GroupFrame
  */
 struct IntFace_MDL7 {
     // provide a constructor for our own convenience
-    IntFace_MDL7()
+    IntFace_MDL7() AI_NO_EXCEPT {
-    {
+        ::memset( mIndices, 0, sizeof(uint32_t) *3);
-        // set everything to zero
+        ::memset( iMatIndex, 0, sizeof( unsigned int) *2);
-        mIndices[0] = mIndices[1] = mIndices[2] = 0;
-        iMatIndex[0] = iMatIndex[1] = 0;
     }
 
     //! Vertex indices
@@ -737,13 +735,11 @@ struct IntFace_MDL7 {
  *  which has been created from two single materials along with the
  *  original material indices.
  */
-struct IntMaterial_MDL7
+struct IntMaterial_MDL7 {
-{
     // provide a constructor for our own convenience
-    IntMaterial_MDL7()
+    IntMaterial_MDL7() AI_NO_EXCEPT
-    {
+    : pcMat( nullptr ) {
-        pcMat = NULL;
+        ::memset( iOldMatIndices, 0, sizeof(unsigned int) *2);
-        iOldMatIndices[0] = iOldMatIndices[1] = 0;
     }
 
     //! Material instance
@@ -761,7 +757,7 @@ struct IntMaterial_MDL7
 struct IntBone_MDL7 : aiBone
 {
     //! Default constructor
-    IntBone_MDL7() : iParent (0xffff)
+    IntBone_MDL7() AI_NO_EXCEPT : iParent (0xffff)
     {
         pkeyPositions.reserve(30);
         pkeyScalings.reserve(30);
@@ -806,12 +802,12 @@ struct IntFrameInfo_MDL7
 struct IntGroupInfo_MDL7
 {
     //! Default constructor
-    IntGroupInfo_MDL7()
+    IntGroupInfo_MDL7() AI_NO_EXCEPT
         :   iIndex(0)
-        ,   pcGroup(NULL)
+        ,   pcGroup(nullptr)
-        ,   pcGroupUVs(NULL)
+        ,   pcGroupUVs(nullptr)
-        ,   pcGroupTris(NULL)
+        ,   pcGroupTris(nullptr)
-        ,   pcGroupVerts(NULL)
+        ,   pcGroupVerts(nullptr)
         {}
 
     //! Construction from an existing group header
@@ -843,7 +839,7 @@ struct IntGroupInfo_MDL7
 //! Holds the data that belongs to a MDL7 mesh group
 struct IntGroupData_MDL7
 {
-    IntGroupData_MDL7()
+    IntGroupData_MDL7() AI_NO_EXCEPT
         : bNeed2UV(false)
     {}
 
@@ -872,10 +868,9 @@ struct IntGroupData_MDL7
 
 // -------------------------------------------------------------------------------------
 //! Holds data from an MDL7 file that is shared by all mesh groups
-struct IntSharedData_MDL7
+struct IntSharedData_MDL7 {
-{
     //! Default constructor
-    IntSharedData_MDL7()
+    IntSharedData_MDL7() AI_NO_EXCEPT
         : apcOutBones(),
         iNum()
     {

code/MMDImporter.cpp

@@ -72,18 +72,16 @@ using namespace std;
 // ------------------------------------------------------------------------------------------------
 //  Default constructor
 MMDImporter::MMDImporter()
-    : m_Buffer(),
+: m_Buffer()
-      // m_pRootObject( NULL ),
+, m_strAbsPath("") {
-      m_strAbsPath("") {
+    DefaultIOSystem io;
-  DefaultIOSystem io;
+    m_strAbsPath = io.getOsSeparator();
-  m_strAbsPath = io.getOsSeparator();
 }
 
 // ------------------------------------------------------------------------------------------------
 //  Destructor.
 MMDImporter::~MMDImporter() {
-  // delete m_pRootObject;
+    // empty
-  // m_pRootObject = NULL;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -96,8 +94,7 @@ bool MMDImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler,
   } else // Check file Header
   {
     static const char *pTokens[] = {"PMX "};
-    return BaseImporter::SearchFileHeaderForToken(pIOHandler, pFile, pTokens,
+    return BaseImporter::SearchFileHeaderForToken(pIOHandler, pFile, pTokens, 1);
-                                                  1);
   }
 }
 
@@ -354,8 +351,11 @@ aiMaterial *MMDImporter::CreateMaterial(const pmx::PmxMaterial *pMat,
   float shininess = pMat->specularlity;
   mat->AddProperty(&shininess, 1, AI_MATKEY_SHININESS_STRENGTH);
 
-  aiString texture_path(pModel->textures[pMat->diffuse_texture_index]);
+  if(pMat->diffuse_texture_index >= 0) {
-  mat->AddProperty(&texture_path, AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0));
+      aiString texture_path(pModel->textures[pMat->diffuse_texture_index]);
+      mat->AddProperty(&texture_path, AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0));
+  }
+
   int mapping_uvwsrc = 0;
   mat->AddProperty(&mapping_uvwsrc, 1,
                    AI_MATKEY_UVWSRC(aiTextureType_DIFFUSE, 0));

code/MMDPmxParser.cpp

@@ -94,16 +94,15 @@ namespace pmx
 		if (encoding == 0)
 		{
 			// UTF16 to UTF8
-			std::string result;
+			const uint16_t* sourceStart = (uint16_t*)buffer.data();
-
-			const char* sourceStart = buffer.data();
 			const unsigned int targetSize = size * 3; // enough to encode
-			char* targetStart = new char[targetSize]();
+			char *targetStart = new char[targetSize];
-			const char* targetReserved = targetStart;
+            std::memset(targetStart, 0, targetSize * sizeof(char));
-            utf8::utf16to8( sourceStart, sourceStart + size, targetStart );
             
-			result.assign(targetReserved, targetStart - targetReserved);
+            utf8::utf16to8( sourceStart, sourceStart + size/2, targetStart );
-			delete[] targetReserved;
+
+			std::string result(targetStart);
+            delete [] targetStart;
 			return result;
 		}
 		else
@@ -475,7 +474,6 @@ namespace pmx
 
     void PmxSoftBody::Read(std::istream * /*stream*/, PmxSetting * /*setting*/)
 	{
-		// 未実装
 		std::cerr << "Not Implemented Exception" << std::endl;
         throw DeadlyImportError("MMD: Not Implemented Exception");
     }
@@ -511,31 +509,27 @@ namespace pmx
 
 	void PmxModel::Read(std::istream *stream)
 	{
-		// マジック
 		char magic[4];
 		stream->read((char*) magic, sizeof(char) * 4);
 		if (magic[0] != 0x50 || magic[1] != 0x4d || magic[2] != 0x58 || magic[3] != 0x20)
 		{
 			std::cerr << "invalid magic number." << std::endl;
-            throw DeadlyImportError("MMD: invalid magic number.");
+      throw DeadlyImportError("MMD: invalid magic number.");
-        }
+    }
-		// バージョン
 		stream->read((char*) &version, sizeof(float));
 		if (version != 2.0f && version != 2.1f)
 		{
 			std::cerr << "this is not ver2.0 or ver2.1 but " << version << "." << std::endl;
             throw DeadlyImportError("MMD: this is not ver2.0 or ver2.1 but " + to_string(version));
-        }
+    }
-		// ファイル設定
 		this->setting.Read(stream);
 
-		// モデル情報
 		this->model_name = ReadString(stream, setting.encoding);
 		this->model_english_name = ReadString(stream, setting.encoding);
 		this->model_comment = ReadString(stream, setting.encoding);
 		this->model_english_comment = ReadString(stream, setting.encoding);
 
-		// 頂点
+		// read vertices
 		stream->read((char*) &vertex_count, sizeof(int));
 		this->vertices = mmd::make_unique<PmxVertex []>(vertex_count);
 		for (int i = 0; i < vertex_count; i++)
@@ -543,7 +537,7 @@ namespace pmx
 			vertices[i].Read(stream, &setting);
 		}
 
-		// 面
+		// read indices
 		stream->read((char*) &index_count, sizeof(int));
 		this->indices = mmd::make_unique<int []>(index_count);
 		for (int i = 0; i < index_count; i++)
@@ -551,7 +545,7 @@ namespace pmx
 			this->indices[i] = ReadIndex(stream, setting.vertex_index_size);
 		}
 
-		// テクスチャ
+		// read texture names
 		stream->read((char*) &texture_count, sizeof(int));
 		this->textures = mmd::make_unique<std::string []>(texture_count);
 		for (int i = 0; i < texture_count; i++)
@@ -559,7 +553,7 @@ namespace pmx
 			this->textures[i] = ReadString(stream, setting.encoding);
 		}
 
-		// マテリアル
+		// read materials
 		stream->read((char*) &material_count, sizeof(int));
 		this->materials = mmd::make_unique<PmxMaterial []>(material_count);
 		for (int i = 0; i < material_count; i++)
@@ -567,7 +561,7 @@ namespace pmx
 			this->materials[i].Read(stream, &setting);
 		}
 
-		// ボーン
+		// read bones
 		stream->read((char*) &this->bone_count, sizeof(int));
 		this->bones = mmd::make_unique<PmxBone []>(this->bone_count);
 		for (int i = 0; i < this->bone_count; i++)
@@ -575,7 +569,7 @@ namespace pmx
 			this->bones[i].Read(stream, &setting);
 		}
 
-		// モーフ
+		// read morphs
 		stream->read((char*) &this->morph_count, sizeof(int));
 		this->morphs = mmd::make_unique<PmxMorph []>(this->morph_count);
 		for (int i = 0; i < this->morph_count; i++)
@@ -583,7 +577,7 @@ namespace pmx
 			this->morphs[i].Read(stream, &setting);
 		}
 
-		// 表示枠
+		// read display frames
 		stream->read((char*) &this->frame_count, sizeof(int));
 		this->frames = mmd::make_unique<PmxFrame []>(this->frame_count);
 		for (int i = 0; i < this->frame_count; i++)
@@ -591,7 +585,7 @@ namespace pmx
 			this->frames[i].Read(stream, &setting);
 		}
 
-		// 剛体
+		// read rigid bodies
 		stream->read((char*) &this->rigid_body_count, sizeof(int));
 		this->rigid_bodies = mmd::make_unique<PmxRigidBody []>(this->rigid_body_count);
 		for (int i = 0; i < this->rigid_body_count; i++)
@@ -599,7 +593,7 @@ namespace pmx
 			this->rigid_bodies[i].Read(stream, &setting);
 		}
 
-		// ジョイント
+		// read joints
 		stream->read((char*) &this->joint_count, sizeof(int));
 		this->joints = mmd::make_unique<PmxJoint []>(this->joint_count);
 		for (int i = 0; i < this->joint_count; i++)

code/OptimizeMeshes.h

@@ -67,20 +67,22 @@ namespace Assimp    {
 class OptimizeMeshesProcess : public BaseProcess
 {
 public:
-
+    /// @brief  The class constructor.
     OptimizeMeshesProcess();
+
+    /// @brief  The class destcructor,
     ~OptimizeMeshesProcess();
 
 
     /** @brief Internal utility to store additional mesh info
      */
-    struct MeshInfo
+    struct MeshInfo {
-    {
+        MeshInfo() AI_NO_EXCEPT
-        MeshInfo()
+        : instance_cnt(0)
-            :   instance_cnt  (0)
+        , vertex_format(0)
-            ,   vertex_format (0)
+        , output_id(0xffffffff) {
-            ,   output_id     (0xffffffff)
+            // empty
-        {}
+        }
 
         //! Number of times this mesh is referenced
         unsigned int instance_cnt;

code/PlyParser.h

@@ -209,7 +209,7 @@ enum EElementSemantic {
 class Property {
 public:
     //! Default constructor
-    Property()
+    Property() AI_NO_EXCEPT
     : eType (EDT_Int)
     , Semantic()
     , bIsList(false)
@@ -257,7 +257,7 @@ public:
 class Element {
 public:
     //! Default constructor
-    Element()
+    Element() AI_NO_EXCEPT
     : eSemantic (EEST_INVALID)
     , NumOccur(0) {
         // empty
@@ -297,8 +297,9 @@ class PropertyInstance
 public:
 
     //! Default constructor
-    PropertyInstance ()
+    PropertyInstance() AI_NO_EXCEPT {
-    {}
+        // empty
+    }
 
     union ValueUnion
     {
@@ -356,13 +357,13 @@ public:
 // ---------------------------------------------------------------------------------
 /** \brief Class for an element instance in a PLY file
  */
-class ElementInstance
+class ElementInstance {
-{
 public:
-
     //! Default constructor
-    ElementInstance ()
+    ElementInstance()  AI_NO_EXCEPT
-    {}
+    : alProperties() {
+        // empty
+    }
 
     //! List of all parsed properties
     std::vector< PropertyInstance > alProperties;
@@ -386,8 +387,10 @@ class ElementInstanceList
 public:
 
     //! Default constructor
-    ElementInstanceList ()
+    ElementInstanceList() AI_NO_EXCEPT
-    {}
+    : alInstances() {
+        // empty
+    }
 
     //! List of all element instances
     std::vector< ElementInstance > alInstances;
@@ -411,8 +414,11 @@ class DOM
 public:
 
     //! Default constructor
-    DOM()
+    DOM() AI_NO_EXCEPT
-    {}
+    : alElements()
+    , alElementData() {
+
+    }
 
 
     //! Contains all elements of the file format

code/SMDLoader.h

@@ -62,17 +62,17 @@ struct aiNode;
 // STL headers
 #include <vector>
 
-namespace Assimp    {
+namespace Assimp {
-
+namespace SMD {
-namespace SMD   {
 
 // ---------------------------------------------------------------------------
 /** Data structure for a vertex in a SMD file
 */
-struct Vertex
+struct Vertex {
-{
+    Vertex() AI_NO_EXCEPT
-    Vertex() : iParentNode(UINT_MAX)
+    : iParentNode(UINT_MAX) {
-     {}
+        // empty
+    }
 
     //! Vertex position, normal and texture coordinate
     aiVector3D pos,nor,uv;
@@ -90,10 +90,12 @@ struct Vertex
 // ---------------------------------------------------------------------------
 /** Data structure for a face in a SMD file
 */
-struct Face
+struct Face {
-{
+    Face() AI_NO_EXCEPT
-    Face() : iTexture(0x0)
+    : iTexture(0x0)
-     {}
+    , avVertices{} {
+        // empty
+    }
 
     //! Texture index for the face
     unsigned int iTexture;
@@ -105,11 +107,12 @@ struct Face
 // ---------------------------------------------------------------------------
 /** Data structure for a bone in a SMD file
 */
-struct Bone
+struct Bone {
-{
     //! Default constructor
-    Bone() : iParent(UINT_MAX), bIsUsed(false)
+    Bone() AI_NO_EXCEPT
-    {
+    : iParent(UINT_MAX)
+    , bIsUsed(false) {
+        // empty
     }
 
     //! Destructor
@@ -124,12 +127,10 @@ struct Bone
     uint32_t iParent;
 
     //! Animation of the bone
-    struct Animation
+    struct Animation {
-    {
         //! Public default constructor
-        Animation()
+        Animation() AI_NO_EXCEPT
-            : iFirstTimeKey()
+        : iFirstTimeKey() {
-        {
             asKeys.reserve(20);
         }
 

code/ScenePrivate.h

@@ -56,7 +56,7 @@ class Importer;
 
 struct ScenePrivateData {
     //  The struct constructor.
-    ScenePrivateData();
+    ScenePrivateData() AI_NO_EXCEPT;
 
     // Importer that originally loaded the scene though the C-API
     // If set, this object is owned by this private data instance.
@@ -74,7 +74,7 @@ struct ScenePrivateData {
 };
 
 inline
-ScenePrivateData::ScenePrivateData()
+ScenePrivateData::ScenePrivateData() AI_NO_EXCEPT
 : mOrigImporter( nullptr )
 , mPPStepsApplied( 0 )
 , mIsCopy( false ) {

code/TextureTransform.h

@@ -65,14 +65,14 @@ namespace Assimp    {
 /** Small helper structure representing a shortcut into the material list
  *  to be able to update some values quickly.
 */
-struct TTUpdateInfo
+struct TTUpdateInfo {
-{
+    TTUpdateInfo() AI_NO_EXCEPT
-    TTUpdateInfo() :
+    : directShortcut(nullptr)
-            directShortcut  (NULL)
+    , mat(nullptr)
-        ,   mat             (NULL)
+    , semantic(0)
-        ,   semantic        (0)
+    , index(0) {
-        ,   index           (0)
+        // empty
-    {}
+    }
 
     //! Direct shortcut, if available
     unsigned int* directShortcut;
@@ -88,15 +88,14 @@ struct TTUpdateInfo
 // ---------------------------------------------------------------------------
 /** Helper class representing texture coordinate transformations
 */
-struct STransformVecInfo : public aiUVTransform
+struct STransformVecInfo : public aiUVTransform {
-{
+    STransformVecInfo() AI_NO_EXCEPT
-
+    : uvIndex(0)
-    STransformVecInfo()
+    , mapU(aiTextureMapMode_Wrap)
-        :   uvIndex     (0)
+    , mapV(aiTextureMapMode_Wrap)
-        ,   mapU        (aiTextureMapMode_Wrap)
+    , lockedPos(AI_TT_UV_IDX_LOCK_NONE) {
-        ,   mapV        (aiTextureMapMode_Wrap)
+        // empty
-        ,   lockedPos   (AI_TT_UV_IDX_LOCK_NONE)
+    }
-    {}
 
     //! Source texture coordinate index
     unsigned int uvIndex;

code/XFileHelper.h

@@ -55,32 +55,33 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/anim.h>
 #include <assimp/Defines.h>
 
-namespace Assimp
+namespace Assimp {
-{
+namespace XFile {
-namespace XFile
-{
 
 /** Helper structure representing a XFile mesh face */
-struct Face
+struct Face {
-{
     std::vector<unsigned int> mIndices;
 };
 
 /** Helper structure representing a texture filename inside a material and its potential source */
-struct TexEntry
+struct TexEntry {
-{
     std::string mName;
     bool mIsNormalMap; // true if the texname was specified in a NormalmapFilename tag
 
-    TexEntry() { mIsNormalMap = false; }
+    TexEntry() AI_NO_EXCEPT
-    TexEntry( const std::string& pName, bool pIsNormalMap = false)
+    : mName()
-        : mName( pName), mIsNormalMap( pIsNormalMap)
+    , mIsNormalMap(false) {
-    { /* done */ }
+        // empty
+    }
+    TexEntry(const std::string& pName, bool pIsNormalMap = false)
+    : mName(pName)
+    , mIsNormalMap(pIsNormalMap) {
+        // empty
+    }
 };
 
 /** Helper structure representing a XFile material */
-struct Material
+struct Material {
-{
     std::string mName;
     bool mIsReference; // if true, mName holds a name by which the actual material can be found in the material list
     aiColor4D mDiffuse;
@@ -88,19 +89,18 @@ struct Material
     aiColor3D mSpecular;
     aiColor3D mEmissive;
     std::vector<TexEntry> mTextures;
-
     size_t sceneIndex; ///< the index under which it was stored in the scene's material list
 
-    Material()
+    Material() AI_NO_EXCEPT
-        : mIsReference(false),
+    : mIsReference(false)
-        mSpecularExponent(),
+    , mSpecularExponent()
-        sceneIndex(SIZE_MAX)
+    , sceneIndex(SIZE_MAX) {
-    {}
+        // empty
+    }
 };
 
 /** Helper structure to represent a bone weight */
-struct BoneWeight
+struct BoneWeight {
-{
     unsigned int mVertex;
     ai_real mWeight;
 };
@@ -114,8 +114,7 @@ struct Bone
 };
 
 /** Helper structure to represent an XFile mesh */
-struct Mesh
+struct Mesh {
-{
     std::string mName;
     std::vector<aiVector3D> mPositions;
     std::vector<Face> mPosFaces;
@@ -131,38 +130,65 @@ struct Mesh
 
     std::vector<Bone> mBones;
 
-    explicit Mesh(const std::string &pName = "") { mName = pName; mNumTextures = 0; mNumColorSets = 0; }
+    explicit Mesh(const std::string &pName = "") AI_NO_EXCEPT
+    : mName( pName )
+    , mPositions()
+    , mPosFaces()
+    , mNormals()
+    , mNormFaces()
+    , mNumTextures(0)
+    , mTexCoords{}
+    , mNumColorSets(0)
+    , mColors{}
+    , mFaceMaterials()
+    , mMaterials()
+    , mBones() {
+        // empty
+    }
 };
 
 /** Helper structure to represent a XFile frame */
-struct Node
+struct Node {
-{
     std::string mName;
     aiMatrix4x4 mTrafoMatrix;
     Node* mParent;
     std::vector<Node*> mChildren;
     std::vector<Mesh*> mMeshes;
 
-    Node() { mParent = NULL; }
+    Node() AI_NO_EXCEPT
-    explicit Node( Node* pParent) { mParent = pParent; }
+    : mName()
-    ~Node()
+    , mTrafoMatrix()
-    {
+    , mParent(nullptr)
-        for( unsigned int a = 0; a < mChildren.size(); a++)
+    , mChildren()
+    , mMeshes() {
+        // empty
+    }
+    explicit Node( Node* pParent)
+    : mName()
+    , mTrafoMatrix()
+    , mParent(pParent)
+    , mChildren()
+    , mMeshes() {
+        // empty
+    }
+
+    ~Node() {
+        for (unsigned int a = 0; a < mChildren.size(); ++a ) {
             delete mChildren[a];
-        for( unsigned int a = 0; a < mMeshes.size(); a++)
+        }
+        for (unsigned int a = 0; a < mMeshes.size(); ++a) {
             delete mMeshes[a];
+        }
     }
 };
 
-struct MatrixKey
+struct MatrixKey {
-{
     double mTime;
     aiMatrix4x4 mMatrix;
 };
 
 /** Helper structure representing a single animated bone in a XFile */
-struct AnimBone
+struct AnimBone {
-{
     std::string mBoneName;
     std::vector<aiVectorKey> mPosKeys;  // either three separate key sequences for position, rotation, scaling
     std::vector<aiQuatKey> mRotKeys;
@@ -194,14 +220,22 @@ struct Scene
     std::vector<Animation*> mAnims;
     unsigned int mAnimTicksPerSecond;
 
-    Scene() { mRootNode = NULL; mAnimTicksPerSecond = 0; }
+    Scene() AI_NO_EXCEPT
-    ~Scene()
+    : mRootNode(nullptr)
-    {
+    , mGlobalMeshes()
+    , mGlobalMaterials()
+    , mAnimTicksPerSecond(0) {
+        // empty
+    }
+    ~Scene() {
         delete mRootNode;
-        for( unsigned int a = 0; a < mGlobalMeshes.size(); a++)
+        mRootNode = nullptr;
+        for (unsigned int a = 0; a < mGlobalMeshes.size(); ++a ) {
             delete mGlobalMeshes[a];
-        for( unsigned int a = 0; a < mAnims.size(); a++)
+        }
+        for (unsigned int a = 0; a < mAnims.size(); ++a ) {
             delete mAnims[a];
+        }
     }
 };
 

code/glTF2Asset.h

@@ -659,7 +659,7 @@ namespace glTF2
         int width, height;
 
     private:
-        uint8_t* mData;
+        std::unique_ptr<uint8_t[]> mData;
         size_t mDataLength;
 
     public:
@@ -674,7 +674,7 @@ namespace glTF2
             { return mDataLength; }
 
         inline const uint8_t* GetData() const
-            { return mData; }
+            { return mData.get(); }
 
         inline uint8_t* StealData();
 

code/glTF2Asset.inl

@@ -688,7 +688,6 @@ T Accessor::Indexer::GetValue(int i)
 inline Image::Image()
     : width(0)
     , height(0)
-    , mData(0)
     , mDataLength(0)
 {
 
@@ -704,7 +703,9 @@ inline void Image::Read(Value& obj, Asset& r)
             if (ParseDataURI(uristr, uri->GetStringLength(), dataURI)) {
                 mimeType = dataURI.mediaType;
                 if (dataURI.base64) {
-                    mDataLength = Util::DecodeBase64(dataURI.data, dataURI.dataLength, mData);
+                    uint8_t *ptr = nullptr;
+                    mDataLength = Util::DecodeBase64(dataURI.data, dataURI.dataLength, ptr);
+                    mData.reset(ptr);
                 }
             }
             else {
@@ -717,8 +718,9 @@ inline void Image::Read(Value& obj, Asset& r)
 
             this->mDataLength = this->bufferView->byteLength;
             // maybe this memcpy could be avoided if aiTexture does not delete[] pcData at destruction.
-            this->mData = new uint8_t [this->mDataLength];
+			
-            memcpy(this->mData, buffer->GetPointer() + this->bufferView->byteOffset, this->mDataLength);
+			this->mData.reset(new uint8_t[this->mDataLength]);
+			memcpy(this->mData.get(), buffer->GetPointer() + this->bufferView->byteOffset, this->mDataLength);
 
             if (Value* mtype = FindString(obj, "mimeType")) {
                 this->mimeType = mtype->GetString();
@@ -729,10 +731,8 @@ inline void Image::Read(Value& obj, Asset& r)
 
 inline uint8_t* Image::StealData()
 {
-    uint8_t* data = mData;
+	mDataLength = 0;
-    mDataLength = 0;
+	return mData.release();
-    mData = 0;
-    return data;
 }
 
 inline void Image::SetData(uint8_t* data, size_t length, Asset& r)
@@ -747,8 +747,8 @@ inline void Image::SetData(uint8_t* data, size_t length, Asset& r)
         bufferView->byteOffset = b->AppendData(data, length);
     }
     else { // text file: will be stored as a data uri
-        this->mData = data;
+		this->mData.reset(data);
-        this->mDataLength = length;
+		this->mDataLength = length;
     }
 }
 

code/glTF2Exporter.cpp

@@ -641,7 +641,7 @@ void ExportSkin(Asset& mAsset, const aiMesh* aimesh, Ref<Mesh>& meshRef, Ref<Buf
         unsigned int bytesPerComp = ComponentTypeSize(vertexJointAccessor->componentType);
         size_t s_bytesLen = bytesLen * s_bytesPerComp / bytesPerComp;
         Ref<Buffer> buf = vertexJointAccessor->bufferView->buffer;
-        uint8_t* arrys = new uint8_t[s_bytesLen];
+        uint8_t* arrys = new uint8_t[bytesLen];
         unsigned int i = 0;
         for ( unsigned int j = 0; j <= bytesLen; j += bytesPerComp ){
             size_t len_p = offset + j;
@@ -652,8 +652,9 @@ void ExportSkin(Asset& mAsset, const aiMesh* aimesh, Ref<Mesh>& meshRef, Ref<Buf
             memcpy(&arrys[i*s_bytesPerComp], data, s_bytesPerComp);
             ++i;
         }
-        buf->ReplaceData_joint(offset, bytesLen, arrys, s_bytesLen);
+        buf->ReplaceData_joint(offset, bytesLen, arrys, bytesLen);
         vertexJointAccessor->componentType = ComponentType_UNSIGNED_SHORT;
+        vertexJointAccessor->bufferView->byteLength = s_bytesLen;
 
         p.attributes.joint.push_back( vertexJointAccessor );
     }

code/glTF2Importer.cpp

@@ -818,7 +818,7 @@ void glTF2Importer::ImportEmbeddedTextures(glTF2::Asset& r)
 
     // Add the embedded textures
     for (size_t i = 0; i < r.images.Size(); ++i) {
-        Image img = r.images[i];
+        Image &img = r.images[i];
         if (!img.HasData()) continue;
 
         int idx = mScene->mNumTextures++;

contrib/irrXML/irrArray.h

@@ -21,7 +21,6 @@ class array
 {
 
 public:
-
 	array() 
 		: data(0), allocated(0), used(0),
 			free_when_destroyed(true), is_sorted(true)

include/assimp/BaseImporter.h

@@ -77,19 +77,17 @@ class IOStream;
  * imports the given file. ReadFile is not overridable, it just calls
  * InternReadFile() and catches any ImportErrorException that might occur.
  */
-class ASSIMP_API BaseImporter
+class ASSIMP_API BaseImporter {
-{
     friend class Importer;
 
 public:
 
     /** Constructor to be privately used by #Importer */
-    BaseImporter();
+    BaseImporter() AI_NO_EXCEPT;
 
     /** Destructor, private as well */
     virtual ~BaseImporter();
 
-public:
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      *

include/assimp/ByteSwapper.h

@@ -60,9 +60,8 @@ namespace Assimp    {
  * This is required to read big-endian model formats on little-endian machines,
  * and vice versa. Direct use of this class is DEPRECATED. Use #StreamReader instead. */
 // --------------------------------------------------------------------------------------
-class ByteSwap
+class ByteSwap {
-{
+    ByteSwap() AI_NO_EXCEPT {}
-    ByteSwap() {}
 
 public:
 

include/assimp/DefaultIOStream.h

@@ -69,7 +69,7 @@ class ASSIMP_API DefaultIOStream : public IOStream
 #endif // __ANDROID__
 
 protected:
-    DefaultIOStream();
+    DefaultIOStream() AI_NO_EXCEPT;
     DefaultIOStream(FILE* pFile, const std::string &strFilename);
 
 public:
@@ -111,27 +111,25 @@ private:
     FILE* mFile;
     //  Filename
     std::string mFilename;
-
     // Cached file size
     mutable size_t mCachedSize;
 };
 
 // ----------------------------------------------------------------------------------
-inline DefaultIOStream::DefaultIOStream () :
+inline
-    mFile       (NULL),
+DefaultIOStream::DefaultIOStream() AI_NO_EXCEPT
-    mFilename   (""),
+: mFile(nullptr)
-    mCachedSize(SIZE_MAX)
+, mFilename("")
-{
+, mCachedSize(SIZE_MAX) {
     // empty
 }
 
 // ----------------------------------------------------------------------------------
-inline DefaultIOStream::DefaultIOStream (FILE* pFile,
+inline
-        const std::string &strFilename) :
+DefaultIOStream::DefaultIOStream (FILE* pFile, const std::string &strFilename)
-    mFile(pFile),
+: mFile(pFile)
-    mFilename(strFilename),
+, mFilename(strFilename)
-    mCachedSize(SIZE_MAX)
+, mCachedSize(SIZE_MAX) {
-{
     // empty
 }
 // ----------------------------------------------------------------------------------

include/assimp/DefaultIOSystem.h

@@ -50,8 +50,7 @@ namespace Assimp    {
 
 // ---------------------------------------------------------------------------
 /** Default implementation of IOSystem using the standard C file functions */
-class ASSIMP_API DefaultIOSystem : public IOSystem
+class ASSIMP_API DefaultIOSystem : public IOSystem {
-{
 public:
     // -------------------------------------------------------------------
     /** Tests for the existence of a file at the given path. */

include/assimp/IOStream.hpp

@@ -71,7 +71,7 @@ class ASSIMP_API IOStream
 {
 protected:
     /** Constructor protected, use IOSystem::Open() to create an instance. */
-    IOStream();
+    IOStream() AI_NO_EXCEPT;
 
 public:
     // -------------------------------------------------------------------
@@ -126,7 +126,7 @@ public:
 
 // ----------------------------------------------------------------------------------
 inline
-IOStream::IOStream() {
+IOStream::IOStream() AI_NO_EXCEPT {
     // empty
 }
 

include/assimp/IOSystem.hpp

@@ -95,7 +95,7 @@ public:
      *  Create an instance of your derived class and assign it to an
      *  #Assimp::Importer instance by calling Importer::SetIOHandler().
      */
-    IOSystem();
+    IOSystem() AI_NO_EXCEPT;
 
     // -------------------------------------------------------------------
     /** @brief Virtual destructor.
@@ -105,9 +105,6 @@ public:
      */
     virtual ~IOSystem();
 
-
-public:
-
     // -------------------------------------------------------------------
     /** @brief For backward compatibility
      *  @see Exists(const char*)
@@ -233,7 +230,7 @@ private:
 
 // ----------------------------------------------------------------------------
 AI_FORCE_INLINE
-IOSystem::IOSystem()
+IOSystem::IOSystem() AI_NO_EXCEPT
 : m_pathStack() {
     // empty
 }

include/assimp/LineSplitter.h

@@ -44,11 +44,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief LineSplitter, a helper class to iterate through all lines
  *    of a file easily. Works with StreamReader.
  */
+#pragma once
 #ifndef INCLUDED_LINE_SPLITTER_H
 #define INCLUDED_LINE_SPLITTER_H
 
 #include <stdexcept>
-
 #include "StreamReader.h"
 #include "ParsingUtils.h"
 
@@ -81,164 +81,205 @@ public:
     /** construct from existing stream reader
     note: trim is *always* assumed true if skyp_empty_lines==true
     */
-    LineSplitter(StreamReaderLE& stream, bool skip_empty_lines = true, bool trim = true)
+    LineSplitter(StreamReaderLE& stream, bool skip_empty_lines = true, bool trim = true);
-    : idx( 0 )
-    , stream(stream)
-    , swallow()
-    , skip_empty_lines(skip_empty_lines)
-    , trim(trim) {
-        cur.reserve(1024);
-        operator++();
 
-        idx = 0;
+    ~LineSplitter();
-    }
-
-    ~LineSplitter() {
-        // empty
-    }
-
-public:
 
     // -----------------------------------------
     /** pseudo-iterator increment */
-    LineSplitter& operator++() {
+    LineSplitter& operator++();
-        if(swallow) {
-            swallow = false;
-            return *this;
-        }
-        if (!*this) {
-            throw std::logic_error("End of file, no more lines to be retrieved.");
-        }
-        char s;
-        cur.clear();
-        while(stream.GetRemainingSize() && (s = stream.GetI1(),1)) {
-            if (s == '\n' || s == '\r') {
-                if (skip_empty_lines) {
-                    while (stream.GetRemainingSize() && ((s = stream.GetI1()) == ' ' || s == '\r' || s == '\n'));
-                    if (stream.GetRemainingSize()) {
-                        stream.IncPtr(-1);
-                    }
-                }
-                else {
-                    // skip both potential line terminators but don't read past this line.
-                    if (stream.GetRemainingSize() && (s == '\r' && stream.GetI1() != '\n')) {
-                        stream.IncPtr(-1);
-                    }
-                    if (trim) {
-                        while (stream.GetRemainingSize() && ((s = stream.GetI1()) == ' ' || s == '\t'));
-                        if (stream.GetRemainingSize()) {
-                            stream.IncPtr(-1);
-                        }
-                    }
-                }
-                break;
-            }
-            cur += s;
-        }
-        ++idx;
-        return *this;
-    }
 
     // -----------------------------------------
-    LineSplitter& operator++(int) {
+    LineSplitter& operator++(int);
-        return ++(*this);
-    }
 
     // -----------------------------------------
     /** get a pointer to the beginning of a particular token */
-    const char* operator[] (size_t idx) const {
+    const char* operator[] (size_t idx) const;
-        const char* s = operator->()->c_str();
-
-        SkipSpaces(&s);
-        for(size_t i = 0; i < idx; ++i) {
-
-            for(;!IsSpace(*s); ++s) {
-                if(IsLineEnd(*s)) {
-                    throw std::range_error("Token index out of range, EOL reached");
-                }
-            }
-            SkipSpaces(&s);
-        }
-        return s;
-    }
 
     // -----------------------------------------
     /** extract the start positions of N tokens from the current line*/
     template <size_t N>
-    void get_tokens(const char* (&tokens)[N]) const {
+    void get_tokens(const char* (&tokens)[N]) const;
-        const char* s = operator->()->c_str();
-
-        SkipSpaces(&s);
-        for(size_t i = 0; i < N; ++i) {
-            if(IsLineEnd(*s)) {
-
-                throw std::range_error("Token count out of range, EOL reached");
-
-            }
-            tokens[i] = s;
-
-            for(;*s && !IsSpace(*s); ++s);
-            SkipSpaces(&s);
-        }
-    }
 
     // -----------------------------------------
     /** member access */
-    const std::string* operator -> () const {
+    const std::string* operator -> () const;
-        return &cur;
-    }
 
-    std::string operator* () const {
+    std::string operator* () const;
-        return cur;
-    }
 
     // -----------------------------------------
     /** boolean context */
-    operator bool() const {
+    operator bool() const;
-        return stream.GetRemainingSize()>0;
-    }
 
     // -----------------------------------------
     /** line indices are zero-based, empty lines are included */
-    operator line_idx() const {
+    operator line_idx() const;
-        return idx;
-    }
 
-    line_idx get_index() const {
+    line_idx get_index() const;
-        return idx;
-    }
 
     // -----------------------------------------
     /** access the underlying stream object */
-    StreamReaderLE& get_stream() {
+    StreamReaderLE& get_stream();
-        return stream;
-    }
 
     // -----------------------------------------
     /** !strcmp((*this)->substr(0,strlen(check)),check) */
-    bool match_start(const char* check) {
+    bool match_start(const char* check);
-        const size_t len = strlen(check);
-
-        return len <= cur.length() && std::equal(check,check+len,cur.begin());
-    }
-
 
     // -----------------------------------------
     /** swallow the next call to ++, return the previous value. */
-    void swallow_next_increment() {
+    void swallow_next_increment();
-        swallow = true;
+
-    }
+    LineSplitter( const LineSplitter & ) = delete;
+    LineSplitter(LineSplitter &&) = delete;
+    LineSplitter &operator = ( const LineSplitter & ) = delete;
 
 private:
-    LineSplitter( const LineSplitter & );
+    line_idx mIdx;
-    LineSplitter &operator = ( const LineSplitter & );
+    std::string mCur;
-
+    StreamReaderLE& mStream;
-private:
+    bool mSwallow, mSkip_empty_lines, mTrim;
-    line_idx idx;
-    std::string cur;
-    StreamReaderLE& stream;
-    bool swallow, skip_empty_lines, trim;
 };
 
+inline
+LineSplitter::LineSplitter(StreamReaderLE& stream, bool skip_empty_lines, bool trim )
+: mIdx(0)
+, mCur()
+, mStream(stream)
+, mSwallow()
+, mSkip_empty_lines(skip_empty_lines)
+, mTrim(trim) {
+    mCur.reserve(1024);
+    operator++();
+    mIdx = 0;
 }
+
+inline
+LineSplitter::~LineSplitter() {
+    // empty
+}
+
+inline
+LineSplitter& LineSplitter::operator++() {
+    if (mSwallow) {
+        mSwallow = false;
+        return *this;
+    }
+
+    if (!*this) {
+        throw std::logic_error("End of file, no more lines to be retrieved.");
+    }
+
+    char s;
+    mCur.clear();
+    while (mStream.GetRemainingSize() && (s = mStream.GetI1(), 1)) {
+        if (s == '\n' || s == '\r') {
+            if (mSkip_empty_lines) {
+                while (mStream.GetRemainingSize() && ((s = mStream.GetI1()) == ' ' || s == '\r' || s == '\n'));
+                if (mStream.GetRemainingSize()) {
+                    mStream.IncPtr(-1);
+                }
+            } else {
+                // skip both potential line terminators but don't read past this line.
+                if (mStream.GetRemainingSize() && (s == '\r' && mStream.GetI1() != '\n')) {
+                    mStream.IncPtr(-1);
+                }
+                if (mTrim) {
+                    while (mStream.GetRemainingSize() && ((s = mStream.GetI1()) == ' ' || s == '\t'));
+                    if (mStream.GetRemainingSize()) {
+                        mStream.IncPtr(-1);
+                    }
+                }
+            }
+            break;
+        }
+        mCur += s;
+    }
+    ++mIdx;
+
+    return *this;
+}
+
+inline
+LineSplitter &LineSplitter::operator++(int) {
+    return ++(*this);
+}
+
+inline
+const char *LineSplitter::operator[] (size_t idx) const {
+    const char* s = operator->()->c_str();
+
+    SkipSpaces(&s);
+    for (size_t i = 0; i < idx; ++i) {
+
+        for (; !IsSpace(*s); ++s) {
+            if (IsLineEnd(*s)) {
+                throw std::range_error("Token index out of range, EOL reached");
+            }
+        }
+        SkipSpaces(&s);
+    }
+    return s;
+}
+
+template <size_t N>
+inline
+void LineSplitter::get_tokens(const char* (&tokens)[N]) const {
+    const char* s = operator->()->c_str();
+
+    SkipSpaces(&s);
+    for (size_t i = 0; i < N; ++i) {
+        if (IsLineEnd(*s)) {
+            throw std::range_error("Token count out of range, EOL reached");
+        }
+        tokens[i] = s;
+
+        for (; *s && !IsSpace(*s); ++s);
+        SkipSpaces(&s);
+    }
+}
+
+inline
+const std::string* LineSplitter::operator -> () const {
+    return &mCur;
+}
+
+inline
+std::string LineSplitter::operator* () const {
+    return mCur;
+}
+
+inline
+LineSplitter::operator bool() const {
+    return mStream.GetRemainingSize() > 0;
+}
+
+inline
+LineSplitter::operator line_idx() const {
+    return mIdx;
+}
+
+inline
+LineSplitter::line_idx LineSplitter::get_index() const {
+    return mIdx;
+}
+
+inline
+StreamReaderLE &LineSplitter::get_stream() {
+    return mStream;
+}
+
+inline
+bool LineSplitter::match_start(const char* check) {
+    const size_t len = ::strlen(check);
+
+    return len <= mCur.length() && std::equal(check, check + len, mCur.begin());
+}
+
+inline
+void LineSplitter::swallow_next_increment() {
+    mSwallow = true;
+}
+
+} // Namespace Assimp
+
 #endif // INCLUDED_LINE_SPLITTER_H

include/assimp/LogStream.hpp

@@ -65,7 +65,7 @@ class ASSIMP_API LogStream
 {
 protected:
     /** @brief  Default constructor */
-    LogStream();
+    LogStream() AI_NO_EXCEPT;
 
 public:
     /** @brief  Virtual destructor  */
@@ -91,12 +91,12 @@ public:
      *  @return New LogStream instance.  */
     static LogStream* createDefaultStream(aiDefaultLogStream stream,
         const char* name = "AssimpLog.txt",
-        IOSystem* io = NULL);
+        IOSystem* io = nullptr );
 
 }; // !class LogStream
 
 inline
-LogStream::LogStream() {
+LogStream::LogStream() AI_NO_EXCEPT {
     // empty
 }
 

include/assimp/Logger.hpp

@@ -161,7 +161,7 @@ protected:
     /**
      *  Default constructor
      */
-    Logger();
+    Logger() AI_NO_EXCEPT;
 
     /**
      *  Construction with a given log severity
@@ -215,8 +215,9 @@ protected:
 // ----------------------------------------------------------------------------------
 //  Default constructor
 inline
-Logger::Logger() {
+Logger::Logger() AI_NO_EXCEPT
-    setLogSeverity(NORMAL);
+: m_Severity(NORMAL) {
+    // empty
 }
 
 // ----------------------------------------------------------------------------------
@@ -229,8 +230,9 @@ Logger::~Logger() {
 // ----------------------------------------------------------------------------------
 // Construction with given logging severity
 inline
-Logger::Logger(LogSeverity severity) {
+Logger::Logger(LogSeverity severity)
-    setLogSeverity(severity);
+: m_Severity(severity) {
+    // empty
 }
 
 // ----------------------------------------------------------------------------------

include/assimp/ProgressHandler.hpp

@@ -63,7 +63,7 @@ class ASSIMP_API ProgressHandler
 {
 protected:
     /** @brief  Default constructor */
-    ProgressHandler () {
+    ProgressHandler () AI_NO_EXCEPT  {
     }
 public:
     /** @brief  Virtual destructor  */

include/assimp/SGSpatialSort.h

@@ -111,26 +111,34 @@ protected:
 
     // -------------------------------------------------------------------
     /** An entry in a spatially sorted position array. Consists of a
-     *  vertex index, its position and its precalculated distance from
+     *  vertex index, its position and its pre-calculated distance from
      *  the reference plane */
     // -------------------------------------------------------------------
-    struct Entry
+    struct Entry {
-    {
         unsigned int mIndex;    ///< The vertex referred by this entry
         aiVector3D mPosition;   ///< Position
         uint32_t mSmoothGroups;
         float mDistance;        ///< Distance of this vertex to the sorting plane
 
-        Entry() { /** intentionally not initialized.*/ }
+        Entry() AI_NO_EXCEPT
-        Entry( unsigned int pIndex, const aiVector3D& pPosition, float pDistance,uint32_t pSG)
+        : mIndex(0)
-        :
+        , mPosition()
-            mIndex( pIndex),
+        , mSmoothGroups(0)
-            mPosition( pPosition),
+        , mDistance(0.0f) {
-            mSmoothGroups (pSG),
+            // empty
-            mDistance( pDistance)
+        }
-            {   }
 
-        bool operator < (const Entry& e) const { return mDistance < e.mDistance; }
+        Entry( unsigned int pIndex, const aiVector3D& pPosition, float pDistance,uint32_t pSG)
+        : mIndex( pIndex)
+        , mPosition( pPosition)
+        , mSmoothGroups(pSG)
+        , mDistance( pDistance) {
+            // empty
+        }
+
+        bool operator < (const Entry& e) const {
+            return mDistance < e.mDistance;
+        }
     };
 
     // all positions, sorted by distance to the sorting plane

include/assimp/SmoothingGroups.h

@@ -52,12 +52,10 @@ http://www.jalix.org/ressources/graphics/3DS/_unofficials/3ds-unofficial.txt */
 
 // ---------------------------------------------------------------------------
 /** Helper structure representing a face with smoothing groups assigned */
-struct FaceWithSmoothingGroup
+struct FaceWithSmoothingGroup {
-{
+    FaceWithSmoothingGroup() AI_NO_EXCEPT
-    FaceWithSmoothingGroup()
+    : mIndices()
-        : mIndices(),
+    , iSmoothGroup(0) {
-        iSmoothGroup(0)
-    {
         // in debug builds set all indices to a common magic value
 #ifdef ASSIMP_BUILD_DEBUG
         this->mIndices[0] = 0xffffffff;

include/assimp/SpatialSort.h

@@ -153,7 +153,7 @@ protected:
         aiVector3D mPosition; ///< Position
         ai_real mDistance; ///< Distance of this vertex to the sorting plane
 
-        Entry()
+        Entry() AI_NO_EXCEPT
         : mIndex( 999999999 ), mPosition(), mDistance( 99999. ) {
             // empty        
         }

include/assimp/StreamReader.h

@@ -67,16 +67,13 @@ namespace Assimp {
  *  XXX switch from unsigned int for size types to size_t? or ptrdiff_t?*/
 // --------------------------------------------------------------------------------------------
 template <bool SwapEndianess = false, bool RuntimeSwitch = false>
-class StreamReader
+class StreamReader {
-{
 public:
     // FIXME: use these data types throughout the whole library,
     // then change them to 64 bit values :-)
+    using diff = int;
+    using pos  = unsigned int;
 
-    typedef int diff;
-    typedef unsigned int pos;
-
-public:
     // ---------------------------------------------------------------------
     /** Construction from a given stream with a well-defined endianness.
      *
@@ -111,8 +108,6 @@ public:
         delete[] buffer;
     }
 
-public:
-
     // deprecated, use overloaded operator>> instead
 
     // ---------------------------------------------------------------------
@@ -176,7 +171,6 @@ public:
         return Get<uint64_t>();
     }
 
-public:
     // ---------------------------------------------------------------------
     /** Get the remaining stream size (to the end of the stream) */
     unsigned int GetRemainingSize() const {

include/assimp/anim.h

@@ -70,7 +70,7 @@ struct aiVectorKey
 #ifdef __cplusplus
 
     /// @brief  The default constructor.
-    aiVectorKey() 
+    aiVectorKey() AI_NO_EXCEPT
     : mTime( 0.0 )
     , mValue() {
         // empty
@@ -116,7 +116,7 @@ struct aiQuatKey
     C_STRUCT aiQuaternion mValue;
 
 #ifdef __cplusplus
-    aiQuatKey()
+    aiQuatKey() AI_NO_EXCEPT
     : mTime( 0.0 )
     , mValue() {
         // empty
@@ -163,7 +163,7 @@ struct aiMeshKey
 
 #ifdef __cplusplus
 
-    aiMeshKey()
+    aiMeshKey() AI_NO_EXCEPT
     : mTime(0.0)
     , mValue(0)
     {
@@ -210,10 +210,10 @@ struct aiMeshMorphKey
     /** The number of values and weights */
     unsigned int mNumValuesAndWeights;
 #ifdef __cplusplus
-	aiMeshMorphKey()
+	aiMeshMorphKey() AI_NO_EXCEPT
 		: mTime(0.0)
-		, mValues(NULL)
+		, mValues(nullptr)
-		, mWeights(NULL)
+		, mWeights(nullptr)
 		, mNumValuesAndWeights(0)
 	{
 
@@ -324,13 +324,13 @@ struct aiNodeAnim {
     C_ENUM aiAnimBehaviour mPostState;
 
 #ifdef __cplusplus
-    aiNodeAnim() 
+    aiNodeAnim() AI_NO_EXCEPT
     : mNumPositionKeys( 0 )
-    , mPositionKeys( NULL )
+    , mPositionKeys( nullptr )
     , mNumRotationKeys( 0 )
-    , mRotationKeys( NULL )
+    , mRotationKeys( nullptr )
     , mNumScalingKeys( 0 )
-    , mScalingKeys( NULL )
+    , mScalingKeys( nullptr )
     , mPreState( aiAnimBehaviour_DEFAULT )
     , mPostState( aiAnimBehaviour_DEFAULT ) {
          // empty
@@ -366,7 +366,7 @@ struct aiMeshAnim
 
 #ifdef __cplusplus
 
-    aiMeshAnim()
+    aiMeshAnim() AI_NO_EXCEPT
         : mNumKeys()
         , mKeys()
     {}
@@ -397,7 +397,7 @@ struct aiMeshMorphAnim
 
 #ifdef __cplusplus
 
-    aiMeshMorphAnim()
+    aiMeshMorphAnim() AI_NO_EXCEPT
         : mNumKeys()
         , mKeys()
     {}
@@ -451,15 +451,15 @@ struct aiAnimation {
     C_STRUCT aiMeshMorphAnim **mMorphMeshChannels;
 
 #ifdef __cplusplus
-    aiAnimation()
+    aiAnimation() AI_NO_EXCEPT
     : mDuration(-1.)
     , mTicksPerSecond(0.)
     , mNumChannels(0)
-    , mChannels(NULL)
+    , mChannels(nullptr)
     , mNumMeshChannels(0)
-    , mMeshChannels(NULL)
+    , mMeshChannels(nullptr)
     , mNumMorphMeshChannels(0)
-    , mMorphMeshChannels(NULL) {
+    , mMorphMeshChannels(nullptr) {
         // empty
     }
 

include/assimp/camera.h

@@ -174,7 +174,7 @@ struct aiCamera
 
 #ifdef __cplusplus
 
-    aiCamera()
+    aiCamera() AI_NO_EXCEPT
         : mUp               (0.f,1.f,0.f)
         , mLookAt           (0.f,0.f,1.f)
         , mHorizontalFOV    (0.25f * (float)AI_MATH_PI)

include/assimp/color4.h

@@ -59,7 +59,7 @@ template <typename TReal>
 class aiColor4t
 {
 public:
-    aiColor4t () : r(), g(), b(), a() {}
+    aiColor4t() AI_NO_EXCEPT : r(), g(), b(), a() {}
     aiColor4t (TReal _r, TReal _g, TReal _b, TReal _a)
         : r(_r), g(_g), b(_b), a(_a) {}
     explicit aiColor4t (TReal _r) : r(_r), g(_r), b(_r), a(_r) {}

include/assimp/defs.h

@@ -289,4 +289,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #define AI_MAX_ALLOC(type) ((256U * 1024 * 1024) / sizeof(type))
 
+#ifndef _MSC_VER
+#  define AI_NO_EXCEPT noexcept
+#else
+#  if (_MSC_VER == 1915 )
+#    define AI_NO_EXCEPT noexcept
+#  else
+#    define AI_NO_EXCEPT
+#  endif
+#endif
+
 #endif // !! AI_DEFINES_H_INC

include/assimp/fast_atof.h

@@ -195,7 +195,7 @@ uint64_t strtoul10_64( const char* in, const char** out=0, unsigned int* max_ino
             break;
         }
 
-        const uint64_t new_value = ( value * 10 ) + ( *in - '0' );
+        const uint64_t new_value = ( value * (uint64_t) 10 ) + ( (uint64_t) ( *in - '0' ) );
 
         // numeric overflow, we rely on you
         if ( new_value < value ) {

include/assimp/light.h

@@ -237,7 +237,7 @@ struct aiLight
 
 #ifdef __cplusplus
 
-    aiLight()
+    aiLight() AI_NO_EXCEPT
         :   mType                 (aiLightSource_UNDEFINED)
         ,   mAttenuationConstant  (0.f)
         ,   mAttenuationLinear    (1.f)

include/assimp/material.h

@@ -483,7 +483,7 @@ struct aiUVTransform
 
 
 #ifdef __cplusplus
-    aiUVTransform()
+    aiUVTransform() AI_NO_EXCEPT
         :   mTranslation (0.0,0.0)
         ,   mScaling    (1.0,1.0)
         ,   mRotation   (0.0)
@@ -607,7 +607,7 @@ struct aiMaterialProperty
 
 #ifdef __cplusplus
 
-    aiMaterialProperty()
+    aiMaterialProperty() AI_NO_EXCEPT
     : mSemantic( 0 )
     , mIndex( 0 )
     , mDataLength( 0 )

include/assimp/matrix3x3.h

@@ -69,7 +69,7 @@ class aiMatrix3x3t
 {
 public:
 
-    aiMatrix3x3t () :
+    aiMatrix3x3t() AI_NO_EXCEPT :
         a1(static_cast<TReal>(1.0f)), a2(), a3(),
         b1(), b2(static_cast<TReal>(1.0f)), b3(),
         c1(), c2(), c3(static_cast<TReal>(1.0f)) {}

include/assimp/matrix4x4.h

@@ -71,7 +71,7 @@ class aiMatrix4x4t
 public:
 
     /** set to identity */
-    aiMatrix4x4t ();
+    aiMatrix4x4t() AI_NO_EXCEPT;
 
     /** construction from single values */
     aiMatrix4x4t (  TReal _a1, TReal _a2, TReal _a3, TReal _a4,

include/assimp/matrix4x4.inl

@@ -60,7 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-aiMatrix4x4t<TReal> ::aiMatrix4x4t () :
+aiMatrix4x4t<TReal>::aiMatrix4x4t() AI_NO_EXCEPT :
     a1(1.0f), a2(), a3(), a4(),
     b1(), b2(1.0f), b3(), b4(),
     c1(), c2(), c3(1.0f), c4(),
@@ -71,7 +71,7 @@ aiMatrix4x4t<TReal> ::aiMatrix4x4t () :
 
 // ----------------------------------------------------------------------------------------
 template <typename TReal>
-aiMatrix4x4t<TReal> ::aiMatrix4x4t (TReal _a1, TReal _a2, TReal _a3, TReal _a4,
+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) :

include/assimp/mesh.h

@@ -136,10 +136,10 @@ struct aiFace
 #ifdef __cplusplus
 
     //! Default constructor
-    aiFace()
+    aiFace() AI_NO_EXCEPT
-      : mNumIndices( 0 )
+    : mNumIndices( 0 )
-      , mIndices( NULL )
+    , mIndices( nullptr ) {
-    {
+        // empty
     }
 
     //! Default destructor. Delete the index array
@@ -150,47 +150,56 @@ struct aiFace
 
     //! Copy constructor. Copy the index array
     aiFace( const aiFace& o)
-      : mIndices( NULL )
+    : mNumIndices(0)
-    {
+    , mIndices( nullptr ) {
         *this = o;
     }
 
     //! Assignment operator. Copy the index array
-    aiFace& operator = ( const aiFace& o)
+    aiFace& operator = ( const aiFace& o) {
-    {
+        if (&o == this) {
-        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 = nullptr;
         }
-        else {
+
-            mIndices = NULL;
-        }
         return *this;
     }
 
     //! Comparison operator. Checks whether the index array
     //! of two faces is identical
-    bool operator== (const aiFace& o) const
+    bool operator== (const aiFace& o) const {
-    {
+        if (mIndices == o.mIndices) {
-        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;
+
+        if (nullptr != mIndices && mNumIndices != o.mNumIndices) {
+            return false;
+        }
+
+        if (nullptr == mIndices) {
+            return false;
+        }
+
+        for (unsigned int i = 0; i < this->mNumIndices; ++i) {
+            if (mIndices[i] != o.mIndices[i]) {
+                return false;
+            }
+        }
+
+        return true;
     }
 
     //! Inverse comparison operator. Checks whether the index
     //! array of two faces is NOT identical
-    bool operator != (const aiFace& o) const
+    bool operator != (const aiFace& o) const {
-    {
         return !(*this == o);
     }
 #endif // __cplusplus
@@ -211,13 +220,13 @@ struct aiVertexWeight {
 #ifdef __cplusplus
 
     //! Default constructor
-    aiVertexWeight()
+    aiVertexWeight() AI_NO_EXCEPT
     : mVertexId(0)
     , mWeight(0.0f) {
         // empty
     }
 
-    //! Initialisation from a given index and vertex weight factor
+    //! Initialization from a given index and vertex weight factor
     //! \param pID ID
     //! \param pWeight Vertex weight factor
     aiVertexWeight( unsigned int pID, float pWeight )
@@ -273,21 +282,21 @@ struct aiBone {
 #ifdef __cplusplus
 
     //! Default constructor
-    aiBone()
+    aiBone() AI_NO_EXCEPT
     : mName()
     , mNumWeights( 0 )
-    , mWeights( nullptr ) {
+    , mWeights( nullptr )
+    , mOffsetMatrix() {
         // empty
     }
 
     //! Copy constructor
     aiBone(const aiBone& other)
-      : mName( other.mName )
+    : mName( other.mName )
-      , mNumWeights( other.mNumWeights )
+    , mNumWeights( other.mNumWeights )
-      , mOffsetMatrix( other.mOffsetMatrix )
+    , mWeights(nullptr)
-    {
+    , mOffsetMatrix( other.mOffsetMatrix ) {
-        if (other.mWeights && other.mNumWeights)
+        if (other.mWeights && other.mNumWeights) {
-        {
             mWeights = new aiVertexWeight[mNumWeights];
             ::memcpy(mWeights,other.mWeights,mNumWeights * sizeof(aiVertexWeight));
         }
@@ -295,8 +304,7 @@ struct aiBone {
 
 
     //! Assignment operator
-    aiBone &operator=(const aiBone& other)
+    aiBone &operator=(const aiBone& other) {
-    {
         if (this == &other) {
             return *this;
         }
@@ -332,8 +340,7 @@ struct aiBone {
         return true;
     }
     //! Destructor - deletes the array of vertex weights
-    ~aiBone()
+    ~aiBone() {
-    {
         delete [] mWeights;
     }
 #endif // __cplusplus
@@ -447,11 +454,13 @@ struct aiAnimMesh
 
 #ifdef __cplusplus
 
-    aiAnimMesh()
+    aiAnimMesh() AI_NO_EXCEPT
-        : mVertices( NULL )
+        : mVertices( nullptr )
-        , mNormals( NULL )
+        , mNormals(nullptr)
-        , mTangents( NULL )
+        , mTangents(nullptr)
-        , mBitangents( NULL )
+        , mBitangents(nullptr)
+        , mColors()
+        , mTextureCoords()
         , mNumVertices( 0 )
         , mWeight( 0.0f )
     {
@@ -706,35 +715,36 @@ struct aiMesh
 #ifdef __cplusplus
 
     //! Default constructor. Initializes all members to 0
-    aiMesh()
+    aiMesh() AI_NO_EXCEPT
-        : mPrimitiveTypes( 0 )
+    : mPrimitiveTypes( 0 )
-        , mNumVertices( 0 )
+    , mNumVertices( 0 )
-        , mNumFaces( 0 )
+    , mNumFaces( 0 )
-        , mVertices( NULL )
+    , mVertices( nullptr )
-        , mNormals( NULL )
+    , mNormals(nullptr)
-        , mTangents( NULL )
+    , mTangents(nullptr)
-        , mBitangents( NULL )
+    , mBitangents(nullptr)
-        , mFaces( NULL )
+    , mColors()
-        , mNumBones( 0 )
+    , mTextureCoords()
-        , mBones( NULL )
+    , mNumUVComponents()
-        , mMaterialIndex( 0 )
+    , mFaces(nullptr)
-        , mNumAnimMeshes( 0 )
+    , mNumBones( 0 )
-        , mAnimMeshes( NULL )
+    , mBones(nullptr)
-        , mMethod( 0 )
+    , mMaterialIndex( 0 )
-    {
+    , mNumAnimMeshes( 0 )
-        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++)
+    , mAnimMeshes(nullptr)
-        {
+    , mMethod( 0 ) {
+        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a ) {
             mNumUVComponents[a] = 0;
-            mTextureCoords[a] = NULL;
+            mTextureCoords[a] = nullptr;
         }
 
-        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++)
+        for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
-            mColors[a] = NULL;
+            mColors[a] = nullptr;
+        }
     }
 
     //! Deletes all storage allocated for the mesh
-    ~aiMesh()
+    ~aiMesh() {
-    {
         delete [] mVertices;
         delete [] mNormals;
         delete [] mTangents;
@@ -767,63 +777,67 @@ struct aiMesh
     //! 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; }
+        { return mVertices != nullptr && 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; }
+        { return mFaces != nullptr && mNumFaces > 0; }
 
     //! Check whether the mesh contains normal vectors
     bool HasNormals() const
-        { return mNormals != NULL && mNumVertices > 0; }
+        { return mNormals != nullptr && 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; }
+        { return mTangents != nullptr && mBitangents != nullptr && 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
+    bool HasVertexColors( unsigned int pIndex) const {
-    {
+        if (pIndex >= AI_MAX_NUMBER_OF_COLOR_SETS) {
-        if( pIndex >= AI_MAX_NUMBER_OF_COLOR_SETS)
             return false;
-        else
+        } else {
-            return mColors[pIndex] != NULL && mNumVertices > 0;
+            return mColors[pIndex] != nullptr && 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
+    bool HasTextureCoords( unsigned int pIndex) const {
-    {
+        if (pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS) {
-        if( pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS)
             return false;
-        else
+        } else {
-            return mTextureCoords[pIndex] != NULL && mNumVertices > 0;
+            return mTextureCoords[pIndex] != nullptr && mNumVertices > 0;
+        }
     }
 
     //! Get the number of UV channels the mesh contains
-    unsigned int GetNumUVChannels() const
+    unsigned int GetNumUVChannels() const {
-    {
+        unsigned int n( 0 );
-        unsigned int n = 0;
+        while (n < AI_MAX_NUMBER_OF_TEXTURECOORDS && mTextureCoords[n]) {
-        while (n < AI_MAX_NUMBER_OF_TEXTURECOORDS && mTextureCoords[n])++n;
+            ++n;
+        }
+
         return n;
     }
 
     //! Get the number of vertex color channels the mesh contains
-    unsigned int GetNumColorChannels() const
+    unsigned int GetNumColorChannels() const {
-    {
+        unsigned int n(0);
-        unsigned int n = 0;
+        while (n < AI_MAX_NUMBER_OF_COLOR_SETS && mColors[n]) {
-        while (n < AI_MAX_NUMBER_OF_COLOR_SETS && mColors[n])++n;
+            ++n;
+        }
         return n;
     }
 
     //! Check whether the mesh contains bones
-    inline bool HasBones() const
+    bool HasBones() const {
-        { return mBones != NULL && mNumBones > 0; }
+        return mBones != nullptr && mNumBones > 0;
+    }
 
 #endif // __cplusplus
 };

include/assimp/metadata.h

@@ -129,7 +129,7 @@ struct aiMetadata {
     /** 
      *  @brief  The default constructor, set all members to zero by default.
      */
-    aiMetadata()
+    aiMetadata() AI_NO_EXCEPT
     : mNumProperties(0)
     , mKeys(nullptr)
     , mValues(nullptr) {
@@ -141,11 +141,11 @@ struct aiMetadata {
     , mKeys( nullptr )
     , mValues( nullptr ) {
         mKeys = new aiString[ mNumProperties ];
-        for ( unsigned int i = 0; i < mNumProperties; ++i ) {
+        for ( size_t i = 0; i < static_cast<size_t>( mNumProperties ); ++i ) {
             mKeys[ i ] = rhs.mKeys[ i ];
         }
         mValues = new aiMetadataEntry[ mNumProperties ];
-        for ( unsigned int i = 0; i < mNumProperties; ++i ) {
+        for ( size_t i = 0; i < static_cast<size_t>(mNumProperties); ++i ) {
             mValues[ i ].mType = rhs.mValues[ i ].mType;
             switch ( rhs.mValues[ i ].mType ) {
             case AI_BOOL:

include/assimp/quaternion.h

@@ -60,7 +60,7 @@ template <typename TReal>
 class aiQuaterniont
 {
 public:
-    aiQuaterniont() : w(1.0), x(), y(), z() {}
+    aiQuaterniont() AI_NO_EXCEPT : w(1.0), x(), y(), z() {}
     aiQuaterniont(TReal pw, TReal px, TReal py, TReal pz)
         : w(pw), x(px), y(py), z(pz) {}
 

include/assimp/texture.h

@@ -131,8 +131,7 @@ struct aiTexel
  * as the texture paths (a single asterisk character followed by the
  * zero-based index of the texture in the aiScene::mTextures array).
  */
-struct aiTexture
+struct aiTexture {
-{
     /** Width of the texture, in pixels
      *
      * If mHeight is zero the texture is compressed in a format
@@ -193,24 +192,26 @@ struct aiTexture
     //! @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
+    bool CheckFormat(const char* s) const {
-    {
+        if (nullptr == s) {
+            return false;
+        }
+
 		return (0 == ::strncmp(achFormatHint, s, sizeof(achFormatHint)));
     }
 
     // Construction
-    aiTexture ()
+    aiTexture() AI_NO_EXCEPT
-        : mWidth  (0)
+    : mWidth(0)
-        , mHeight (0)
+    , mHeight(0)
-        , pcData  (NULL)
+    , pcData(nullptr)
-    {
+    , mFilename() {
         achFormatHint[0] = achFormatHint[1] = 0;
         achFormatHint[2] = achFormatHint[3] = 0;
     }
 
     // Destruction
-    ~aiTexture ()
+    ~aiTexture () {
-    {
         delete[] pcData;
     }
 #endif

include/assimp/types.h

@@ -119,10 +119,9 @@ extern "C" {
 // ----------------------------------------------------------------------------------
 /** Represents a plane in a three-dimensional, euclidean space
 */
-struct aiPlane
+struct aiPlane {
-{
 #ifdef __cplusplus
-    aiPlane () : a(0.f), b(0.f), c(0.f), d(0.f) {}
+    aiPlane () AI_NO_EXCEPT : a(0.f), b(0.f), c(0.f), d(0.f) {}
     aiPlane (ai_real _a, ai_real _b, ai_real _c, ai_real _d)
         : a(_a), b(_b), c(_c), d(_d) {}
 
@@ -137,10 +136,9 @@ struct aiPlane
 // ----------------------------------------------------------------------------------
 /** Represents a ray
 */
-struct aiRay
+struct aiRay {
-{
 #ifdef __cplusplus
-    aiRay () {}
+    aiRay () AI_NO_EXCEPT {}
     aiRay (const aiVector3D& _pos, const aiVector3D& _dir)
         : pos(_pos), dir(_dir) {}
 
@@ -158,7 +156,7 @@ struct aiRay
 struct aiColor3D
 {
 #ifdef __cplusplus
-    aiColor3D () : r(0.0f), g(0.0f), b(0.0f) {}
+    aiColor3D () AI_NO_EXCEPT : r(0.0f), g(0.0f), b(0.0f) {}
     aiColor3D (ai_real _r, ai_real _g, ai_real _b) : r(_r), g(_g), b(_b) {}
     explicit aiColor3D (ai_real _r) : r(_r), g(_r), b(_r) {}
     aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {}
@@ -253,9 +251,8 @@ struct aiString
 {
 #ifdef __cplusplus
     /** Default constructor, the string is set to have zero length */
-    aiString() :
+    aiString() AI_NO_EXCEPT
-        length(0)
+    : length( 0 ) {
-    {
         data[0] = '\0';
 
 #ifdef ASSIMP_BUILD_DEBUG
@@ -305,7 +302,7 @@ struct aiString
     }
 
 
-    /** Assigment operator */
+    /** Assignment operator */
     aiString& operator = (const aiString &rOther) {
         if (this == &rOther) {
             return *this;
@@ -373,7 +370,7 @@ struct aiString
 #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
+     *  logical length of strings containing UTF-8 multi-byte sequences! It's
      *  the number of bytes from the beginning of the string to its end.*/
     size_t length;
 
@@ -479,7 +476,7 @@ struct aiMemoryInfo
 #ifdef __cplusplus
 
     /** Default constructor */
-    aiMemoryInfo()
+    aiMemoryInfo() AI_NO_EXCEPT
         : textures   (0)
         , materials  (0)
         , meshes     (0)

include/assimp/vector3.h

@@ -66,7 +66,7 @@ template <typename TReal>
 class aiVector3t
 {
 public:
-    aiVector3t() : x(), y(), z() {}
+    aiVector3t() AI_NO_EXCEPT : 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) {}

port/PyAssimp/pyassimp/core.py

@@ -35,7 +35,7 @@ class AssimpLib(object):
     """
     Assimp-Singleton
     """
-    load, load_mem, export, release, dll = helper.search_library()
+    load, load_mem, export, export_blob, release, dll = helper.search_library()
 _assimp_lib = AssimpLib()
 
 def make_tuple(ai_obj, type = None):
@@ -352,6 +352,33 @@ def export(scene,
     if exportStatus != 0:
         raise AssimpError('Could not export scene!')
 
+def export_blob(scene,
+                file_type = None,
+                processing = postprocess.aiProcess_Triangulate):
+    '''
+    Export a scene and return a blob in the correct format. On failure throws AssimpError.
+
+    Arguments
+    ---------
+    scene: scene to export.
+    file_type: string of file exporter to use. For example "collada".
+    processing: assimp postprocessing parameters. Verbose keywords are imported
+                from postprocessing, and the parameters can be combined bitwise to
+                generate the final processing value. Note that the default value will
+                triangulate quad faces. Example of generating other possible values:
+                processing = (pyassimp.postprocess.aiProcess_Triangulate |
+                              pyassimp.postprocess.aiProcess_OptimizeMeshes)
+    Returns
+    ---------
+    Pointer to structs.ExportDataBlob
+    '''
+    from ctypes import pointer
+    exportBlobPtr = _assimp_lib.export_blob(pointer(scene), file_type.encode("ascii"), processing)
+
+    if exportBlobPtr == 0:
+        raise AssimpError('Could not export scene to blob!')
+    return exportBlobPtr
+
 def release(scene):
     from ctypes import pointer
     _assimp_lib.release(pointer(scene))

port/PyAssimp/pyassimp/helper.py

@@ -176,6 +176,7 @@ def try_load_functions(library_path, dll):
                           load from filename function,
                           load from memory function,
                           export to filename function,
+                          export to blob function,
                           release function,
                           ctypes handle to assimp library)
     '''
@@ -185,15 +186,17 @@ def try_load_functions(library_path, dll):
         release  = dll.aiReleaseImport
         load_mem = dll.aiImportFileFromMemory
         export   = dll.aiExportScene
+        export2blob = dll.aiExportSceneToBlob
     except AttributeError:
         #OK, this is a library, but it doesn't have the functions we need
         return None
 
     # library found!
-    from .structs import Scene
+    from .structs import Scene, ExportDataBlob
     load.restype = POINTER(Scene)
     load_mem.restype = POINTER(Scene)
-    return (library_path, load, load_mem, export, release, dll)
+    export2blob.restype = POINTER(ExportDataBlob)
+    return (library_path, load, load_mem, export, export2blob, release, dll)
 
 def search_library():
     '''
@@ -203,6 +206,7 @@ def search_library():
     Returns: tuple, (load from filename function,
                      load from memory function,
                      export to filename function,
+                     export to blob function,
                      release function,
                      dll)
     '''

port/PyAssimp/pyassimp/structs.py

@@ -5,7 +5,7 @@ from ctypes import POINTER, c_void_p, c_int, c_uint, c_char, c_float, Structure,
 
 class Vector2D(Structure):
     """
-    See 'aiVector2D.h' for details.
+    See 'vector2.h' for details.
     """ 
 
 
@@ -15,7 +15,7 @@ class Vector2D(Structure):
 
 class Matrix3x3(Structure):
     """
-    See 'aiMatrix3x3.h' for details.
+    See 'matrix3x3.h' for details.
     """ 
 
 
@@ -27,7 +27,7 @@ class Matrix3x3(Structure):
 
 class Texel(Structure):
     """
-    See 'aiTexture.h' for details.
+    See 'texture.h' for details.
     """ 
 
     _fields_ = [
@@ -36,7 +36,7 @@ class Texel(Structure):
 
 class Color4D(Structure):
     """
-    See 'aiColor4D.h' for details.
+    See 'color4.h' for details.
     """ 
 
 
@@ -47,7 +47,7 @@ class Color4D(Structure):
 
 class Plane(Structure):
     """
-    See 'aiTypes.h' for details.
+    See 'types.h' for details.
     """ 
 
     _fields_ = [
@@ -57,7 +57,7 @@ class Plane(Structure):
 
 class Color3D(Structure):
     """
-    See 'aiTypes.h' for details.
+    See 'types.h' for details.
     """ 
 
     _fields_ = [
@@ -67,7 +67,7 @@ class Color3D(Structure):
 
 class String(Structure):
     """
-    See 'aiTypes.h' for details.
+    See 'types.h' for details.
     """ 
 
     MAXLEN = 1024
@@ -84,7 +84,7 @@ class String(Structure):
 
 class MaterialPropertyString(Structure):
     """
-    See 'aiTypes.h' for details.
+    See 'MaterialSystem.cpp' for details.
     
     The size of length is truncated to 4 bytes on 64-bit platforms when used as a
     material property (see MaterialSystem.cpp aiMaterial::AddProperty() for details).
@@ -104,7 +104,7 @@ class MaterialPropertyString(Structure):
 
 class MemoryInfo(Structure):
     """
-    See 'aiTypes.h' for details.
+    See 'types.h' for details.
     """ 
 
     _fields_ = [
@@ -135,7 +135,7 @@ class MemoryInfo(Structure):
 
 class Quaternion(Structure):
     """
-    See 'aiQuaternion.h' for details.
+    See 'quaternion.h' for details.
     """ 
 
 
@@ -146,7 +146,7 @@ class Quaternion(Structure):
 
 class Face(Structure):
     """
-    See 'aiMesh.h' for details.
+    See 'mesh.h' for details.
     """ 
 
     _fields_ = [
@@ -161,7 +161,7 @@ class Face(Structure):
 
 class VertexWeight(Structure):
     """
-    See 'aiMesh.h' for details.
+    See 'mesh.h' for details.
     """ 
 
     _fields_ = [
@@ -175,7 +175,7 @@ class VertexWeight(Structure):
 
 class Matrix4x4(Structure):
     """
-    See 'aiMatrix4x4.h' for details.
+    See 'matrix4x4.h' for details.
     """ 
 
 
@@ -188,7 +188,7 @@ class Matrix4x4(Structure):
 
 class Vector3D(Structure):
     """
-    See 'aiVector3D.h' for details.
+    See 'vector3.h' for details.
     """ 
 
 
@@ -198,7 +198,7 @@ class Vector3D(Structure):
 
 class MeshKey(Structure):
     """
-    See 'aiAnim.h' for details.
+    See 'anim.h' for details.
     """ 
 
     _fields_ = [
@@ -251,7 +251,7 @@ class Metadata(Structure):
 
 class Node(Structure):
     """
-    See 'aiScene.h' for details.
+    See 'scene.h' for details.
     """ 
 
 
@@ -296,7 +296,7 @@ Node._fields_ = [
 
 class Light(Structure):
     """
-    See 'aiLight.h' for details.
+    See 'light.h' for details.
     """ 
 
 
@@ -322,6 +322,13 @@ class Light(Structure):
             #  may be normalized, but it needn't.
             ("mDirection", Vector3D),
             
+            # Up 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.
+            ("mUp", Vector3D),
+
             # Constant light attenuation factor.
             #  The intensity of the light source at a given distance 'd' from
             #  the light's position is
@@ -393,11 +400,14 @@ class Light(Structure):
             #  interpolation between the inner and the outer cone of the
             #  spot light.
             ("mAngleOuterCone", c_float),
+
+            # Size of area light source.
+            ("mSize", Vector2D),
         ]
 
 class Texture(Structure):
     """
-    See 'aiTexture.h' for details.
+    See 'texture.h' for details.
     """ 
 
 
@@ -414,16 +424,25 @@ class Texture(Structure):
             ("mHeight", c_uint),
             
             # A hint from the loader to make it easier for applications
-            #  to determine the type of embedded compressed textures.
+            # to determine the type of embedded textures.
-            # If mHeight != 0 this member is undefined. Otherwise it
+            # 
-            # is set set to '\\0\\0\\0\\0' if the loader has no additional
+            # If mHeight != 0 this member is show how data is packed. Hint will consist of
+            # two parts: channel order and channel bitness (count of the bits for every
+            # color channel). For simple parsing by the viewer it's better to not omit
+            # absent color channel and just use 0 for bitness. For example:
+            # 1. Image contain RGBA and 8 bit per channel, achFormatHint == "rgba8888";
+            # 2. Image contain ARGB and 8 bit per channel, achFormatHint == "argb8888";
+            # 3. Image contain RGB and 5 bit for R and B channels and 6 bit for G channel,
+            #    achFormatHint == "rgba5650";
+            # 4. One color image with B channel and 1 bit for it, achFormatHint == "rgba0010";
+            # If mHeight == 0 then achFormatHint 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'.
-            ("achFormatHint", c_char*4),
+            ("achFormatHint", c_char*9),
             
             # Data of the texture.
             # Points to an array of mWidth
@@ -434,11 +453,15 @@ class Texture(Structure):
             # buffer of size mWidth containing the compressed texture
             # data. Good luck, have fun!
             ("pcData", POINTER(Texel)),
+
+            # Texture original filename
+            # Used to get the texture reference
+            ("mFilename", String),
         ]
 
 class Ray(Structure):
     """
-    See 'aiTypes.h' for details.
+    See 'types.h' for details.
     """ 
 
     _fields_ = [
@@ -448,7 +471,7 @@ class Ray(Structure):
 
 class UVTransform(Structure):
     """
-    See 'aiMaterial.h' for details.
+    See 'material.h' for details.
     """ 
 
     _fields_ = [
@@ -469,7 +492,7 @@ class UVTransform(Structure):
 
 class MaterialProperty(Structure):
     """
-    See 'aiMaterial.h' for details.
+    See 'material.h' for details.
     """ 
 
     _fields_ = [
@@ -505,7 +528,7 @@ class MaterialProperty(Structure):
 
 class Material(Structure):
     """
-    See 'aiMaterial.h' for details.
+    See 'material.h' for details.
     """ 
 
     _fields_ = [
@@ -521,7 +544,7 @@ class Material(Structure):
 
 class Bone(Structure):
     """
-    See 'aiMesh.h' for details.
+    See 'mesh.h' for details.
     """ 
 
     _fields_ = [
@@ -540,9 +563,56 @@ class Bone(Structure):
             ("mOffsetMatrix", Matrix4x4),
         ]
 
+
+class AnimMesh(Structure):
+    """
+    See 'mesh.h' for details.
+    """ 
+
+    AI_MAX_NUMBER_OF_TEXTURECOORDS = 0x8
+    AI_MAX_NUMBER_OF_COLOR_SETS = 0x8
+
+    _fields_ = [
+            # 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)
+            ("mVertices", POINTER(Vector3D)),
+
+            # Replacement for aiMesh::mNormals.
+            ("mNormals", POINTER(Vector3D)),
+
+            # Replacement for aiMesh::mTangents.
+            ("mTangents", POINTER(Vector3D)),
+
+            # Replacement for aiMesh::mBitangents.
+            ("mBitangents", POINTER(Vector3D)),
+
+            # Replacement for aiMesh::mColors
+            ("mColors", POINTER(Color4D) * AI_MAX_NUMBER_OF_COLOR_SETS),
+
+            # Replacement for aiMesh::mTextureCoords
+            ("mTextureCoords", POINTER(Vector3D) * 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.
+            ("mNumVertices", c_uint),
+
+            # Weight of the AnimMesh.
+            ("mWeight", c_float),
+        ]
+
+
 class Mesh(Structure):
     """
-    See 'aiMesh.h' for details.
+    See 'mesh.h' for details.
     """ 
 
     AI_MAX_FACE_INDICES = 0x7fff
@@ -552,8 +622,7 @@ class Mesh(Structure):
     AI_MAX_NUMBER_OF_COLOR_SETS = 0x8
     AI_MAX_NUMBER_OF_TEXTURECOORDS = 0x8
 
-    _fields_ = [
+    _fields_ = [ # Bitwise combination of the members of the
-            # 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
@@ -676,17 +745,23 @@ class Mesh(Structure):
             #   - Vertex animations refer to meshes by their names.
             ("mName", String),
             
-            # NOT CURRENTLY IN USE. The number of attachment meshes
+            # The number of attachment meshes. Note! Currently only works with Collada loader.
             ("mNumAnimMeshes", c_uint),
             
-            # NOT CURRENTLY IN USE. Attachment meshes for this mesh, for vertex-based animation.
+            # Attachment meshes for this mesh, for vertex-based animation.
-            #  Attachment meshes carry replacement data for some of the
+            # Attachment meshes carry replacement data for some of the
-            #  mesh'es vertex components (usually positions, normals).
+            # mesh'es vertex components (usually positions, normals).
+            # Note! Currently only works with Collada loader.
+            ("mAnimMesh", POINTER(POINTER(AnimMesh))),
+
+            # Method of morphing when animeshes are specified.
+            ("mMethod", c_uint),
+
         ]
 
 class Camera(Structure):
     """
-    See 'aiCamera.h' for details.
+    See 'camera.h' for details.
     """ 
 
 
@@ -746,7 +821,7 @@ class Camera(Structure):
 
 class VectorKey(Structure):
     """
-    See 'aiAnim.h' for details.
+    See 'anim.h' for details.
     """ 
 
     _fields_ = [
@@ -759,7 +834,7 @@ class VectorKey(Structure):
 
 class QuatKey(Structure):
     """
-    See 'aiAnim.h' for details.
+    See 'anim.h' for details.
     """ 
 
     _fields_ = [
@@ -770,9 +845,27 @@ class QuatKey(Structure):
             ("mValue", Quaternion),
         ]
 
+class MeshMorphKey(Structure):
+    """
+    See 'anim.h' for details.
+    """ 
+
+    _fields_ = [
+            # The time of this key
+            ("mTime", c_double),
+
+            # The values and weights at the time of this key
+            ("mValues", POINTER(c_uint)),
+            ("mWeights", POINTER(c_double)),
+
+            # The number of values and weights
+            ("mNumValuesAndWeights", c_uint),
+
+        ]
+
 class NodeAnim(Structure):
     """
-    See 'aiAnim.h' for details.
+    See 'anim.h' for details.
     """ 
 
     _fields_ = [
@@ -821,9 +914,48 @@ class NodeAnim(Structure):
             ("mPostState", c_uint),
         ]
 
+class MeshAnim(Structure):
+    """
+    See 'anim.h' for details.
+    """ 
+
+    _fields_ = [
+            # 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 wild-card to select a group
+            #  of meshes with similar animation setup)
+            ("mName", String),
+
+            # Size of the #mKeys array. Must be 1, at least.
+            ("mNumKeys", c_uint),
+
+            # Key frames of the animation. May not be NULL.
+            ("mKeys", POINTER(MeshKey)),
+        ]
+
+class MeshMorphAnim(Structure):
+    """
+    See 'anim.h' for details.
+    """     
+
+    _fields_ = [
+            # 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)
+            ("mName", String),
+
+            # Size of the #mKeys array. Must be 1, at least.
+            ("mNumKeys", c_uint),
+
+            # Key frames of the animation. May not be NULL.
+            ("mKeys", POINTER(MeshMorphKey)),
+        ]
+
+
 class Animation(Structure):
     """
-    See 'aiAnim.h' for details.
+    See 'anim.h' for details.
     """ 
 
     _fields_ = [
@@ -852,8 +984,51 @@ class Animation(Structure):
             
             # The mesh animation channels. Each channel affects a single mesh.
             #  The array is mNumMeshChannels in size.
+            ("mMeshChannels", POINTER(POINTER(MeshAnim))),
+
+            # The number of mesh animation channels. Each channel affects
+            # a single mesh and defines morphing animation.
+            ("mNumMorphMeshChannels", c_uint),
+
+            # The morph mesh animation channels. Each channel affects a single mesh.
+            # The array is mNumMorphMeshChannels in size. 
+            ("mMorphMeshChannels", POINTER(POINTER(MeshMorphAnim))),
+
         ]
 
+class ExportDataBlob(Structure):
+    """
+    See 'cexport.h' for details.
+
+    Note that the '_fields_' definition is outside the class to allow the 'next' field to be recursive
+    """
+    pass
+
+ExportDataBlob._fields_ = [
+            # Size of the data in bytes
+            ("size", c_size_t),
+
+            # The data.
+            ("data", c_void_p),
+
+            # 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.
+            ("name", String),
+
+            # Pointer to the next blob in the chain or NULL if there is none.
+            ("next", POINTER(ExportDataBlob)),
+        ]
+
+
 class Scene(Structure):
     """
     See 'aiScene.h' for details.
@@ -864,6 +1039,7 @@ class Scene(Structure):
     AI_SCENE_FLAGS_VALIDATION_WARNING =  	0x4
     AI_SCENE_FLAGS_NON_VERBOSE_FORMAT =  	0x8
     AI_SCENE_FLAGS_TERRAIN = 0x10
+    AI_SCENE_FLAGS_ALLOW_SHARED = 0x20
 
     _fields_ = [
             # Any combination of the AI_SCENE_FLAGS_XXX flags. By default
@@ -940,6 +1116,9 @@ class Scene(Structure):
             # unit-conversions, versions, vendors or other model-specific data. This
             # can be used to store format-specific metadata as well.
             ("mMetadata", POINTER(Metadata)),
+
+            # Internal data, do not touch
+            ("mPrivate", c_char_p),
         ]
 
 assimp_structs_as_tuple = (Matrix4x4,

scripts/StepImporter/CppGenerator.py

@@ -5,7 +5,7 @@
 # Open Asset Import Library (ASSIMP)
 # ---------------------------------------------------------------------------
 #
-# Copyright (c) 2006-2010, ASSIMP Development Team
+# Copyright (c) 2006-2018, ASSIMP Development Team
 #
 # All rights reserved.
 #
@@ -280,8 +280,3 @@ def work(filename):
 
 if __name__ == "__main__":
     sys.exit(work(sys.argv[1] if len(sys.argv)>1 else 'schema.exp'))
-
-
-
-    
-    

test/CMakeLists.txt

@@ -40,8 +40,9 @@
 cmake_minimum_required( VERSION 2.6 )
 
 INCLUDE_DIRECTORIES(
-	../contrib/gtest/include
+	${Assimp_SOURCE_DIR}/contrib/gtest/include
-	../contrib/gtest/
+	${Assimp_SOURCE_DIR}/contrib/gtest/
+    ${Assimp_SOURCE_DIR}/test/unit
     ${Assimp_SOURCE_DIR}/include
     ${Assimp_SOURCE_DIR}/code
 )
@@ -74,6 +75,7 @@ SET( COMMON
   unit/utProfiler.cpp
   unit/utSharedPPData.cpp
   unit/utStringUtils.cpp
+  unit/Common/utLineSplitter.cpp
 )
 
 SET( IMPORTERS
@@ -115,6 +117,7 @@ SET( IMPORTERS
   unit/utB3DImportExport.cpp
   unit/utMDCImportExport.cpp
   unit/utAssbinImportExport.cpp
+  unit/ImportExport/utCOBImportExport.cpp
 )
 
 SET( MATERIAL

test/models/AMF/test_with_mat.amf

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<amf unit="inch" version="1.1">
+  <metadata type="name">Split Pyramid</metadata>
+  <metadata type="author">John Smith</metadata> 
+  <object id="1">
+    <mesh>
+      <vertices>
+        <vertex><coordinates><x>0</x><y>0</y><z>0</z></coordinates></vertex>
+        <vertex><coordinates><x>1</x><y>0</y><z>0</z></coordinates></vertex>
+        <vertex><coordinates><x>0</x><y>1</y><z>0</z></coordinates></vertex>
+        <vertex><coordinates><x>1</x><y>1</y><z>0</z></coordinates></vertex>
+        <vertex><coordinates><x>0.5</x><y>0.5</y><z>1</z></coordinates></vertex>
+      </vertices>
+      <volume materialid="2">
+        <metadata type="name">Hard side</metadata> 
+        <triangle><v1>2</v1><v2>1</v2><v3>0</v3></triangle>
+        <triangle><v1>0</v1><v2>1</v2><v3>4</v3></triangle>
+        <triangle><v1>4</v1><v2>1</v2><v3>2</v3></triangle>
+        <triangle><v1>0</v1><v2>4</v2><v3>2</v3></triangle>
+      </volume>
+      <volume materialid="3">
+        <metadata type="name">Soft side</metadata> 
+        <triangle><v1>2</v1><v2>3</v2><v3>1</v3></triangle>
+        <triangle><v1>1</v1><v2>3</v2><v3>4</v3></triangle>
+        <triangle><v1>4</v1><v2>3</v2><v3>2</v3></triangle>
+        <triangle><v1>4</v1><v2>2</v2><v3>1</v3></triangle>
+      </volume>
+    </mesh>
+  </object>
+  <material id="2">
+    <metadata type="name">Hard material</metadata>
+    <color><r>0.1</r><g>0.1</g><b>0.1</b></color>
+  </material>
+  <material id="3">
+    <metadata type="name">Soft material</metadata>
+    <color><r>0</r><g>0.9</g><b>0.9</b><a>0.5</a></color>
+  </material>
+</amf>

test/models/ParsingFiles/linesplitter_emptyline_test.txt

@@ -0,0 +1,3 @@
+TEST
+
+the rest

test/models/ParsingFiles/linesplitter_tokenizetest.txt

@@ -0,0 +1,12 @@
+#1= IFCORGANIZATION('GS','Graphisoft','Graphisoft',$,$);
+#5= IFCAPPLICATION(#1,'14.0','ArchiCAD 14.0','ArchiCAD');
+#6= IFCPERSON('','Haefele','Karl-Heinz',$,$,$,$,$);
+#8= IFCORGANIZATION('','KIT / IAI','',$,$);
+#12= IFCPERSONANDORGANIZATION(#6,#8,$);
+#13= IFCOWNERHISTORY(#12,#5,$,.ADDED.,$,$,$,1286451639);
+#14= IFCSIUNIT(*,.LENGTHUNIT.,$,.METRE.);
+#15= IFCSIUNIT(*,.AREAUNIT.,$,.SQUARE_METRE.);
+#16= IFCSIUNIT(*,.VOLUMEUNIT.,$,.CUBIC_METRE.);
+#17= IFCSIUNIT(*,.PLANEANGLEUNIT.,$,.RADIAN.);
+#18= IFCMEASUREWITHUNIT(IFCPLANEANGLEMEASURE(0.017453293),#17);
+

test/unit/Common/utLineSplitter.cpp

@@ -0,0 +1,71 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+#include "UnitTestPCH.h"
+
+#include <assimp/LineSplitter.h>
+#include <assimp/DefaultIOSystem.h>
+#include <string>
+
+using namespace Assimp;
+
+class utLineSplitter : public ::testing::Test {
+    // empty
+};
+
+TEST_F(utLineSplitter, tokenizetest) {
+    DefaultIOSystem fs;
+    IOStream* file = fs.Open(ASSIMP_TEST_MODELS_DIR"/ParsingFiles/linesplitter_tokenizetest.txt", "rb");
+
+    StreamReaderLE stream(file);
+    LineSplitter myLineSplitter(stream);
+}
+
+TEST_F( utLineSplitter, issue212Test) {
+    DefaultIOSystem fs;
+    IOStream* file = fs.Open(ASSIMP_TEST_MODELS_DIR"/ParsingFiles/linesplitter_emptyline_test.txt", "rb");
+
+    StreamReaderLE stream(file);
+    LineSplitter myLineSplitter(stream);
+    myLineSplitter++;
+    EXPECT_THROW( myLineSplitter++, std::logic_error );
+}

test/unit/ImportExport/utCOBImportExport.cpp

@@ -0,0 +1,64 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#include "UnitTestPCH.h"
+#include "SceneDiffer.h"
+#include "AbstractImportExportBase.h"
+
+#include <assimp/Importer.hpp>
+#include <assimp/postprocess.h>
+
+using namespace Assimp;
+
+class utCOBImportExport : public AbstractImportExportBase {
+public:
+    virtual bool importerTest() {
+        Assimp::Importer importer;
+        const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/COB/molecule.cob", aiProcess_ValidateDataStructure);
+        return nullptr != scene;
+    }
+};
+
+TEST_F(utCOBImportExport, importAMFFromFileTest) {
+    EXPECT_TRUE(importerTest());
+}

test/unit/utAMFImportExport.cpp

@@ -59,6 +59,14 @@ public:
     }
 };
 
-TEST_F( utAMFImportExport, importACFromFileTest ) {
+TEST_F( utAMFImportExport, importAMFFromFileTest ) {
     EXPECT_TRUE( importerTest() );
 }
+
+
+
+TEST_F(utAMFImportExport, importAMFWithMatFromFileTest) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/AMF/test_with_mat.amf", aiProcess_ValidateDataStructure);
+    EXPECT_NE(nullptr, scene);
+}

test/unit/utSceneCombiner.cpp

@@ -73,7 +73,7 @@ TEST_F( utSceneCombiner, MergeMeshes_ValidNames_Test ) {
     EXPECT_EQ( "mesh_1.mesh_2.mesh_3", outName );
 }
 
-TEST_F( utSceneCombiner, CopySceneWithNullptr_NoException ) {
+TEST_F( utSceneCombiner, CopySceneWithNullptr_AI_NO_EXCEPTion ) {
     EXPECT_NO_THROW( SceneCombiner::CopyScene( nullptr, nullptr ) );
     EXPECT_NO_THROW( SceneCombiner::CopySceneFlat( nullptr, nullptr ) );
 }

test/unit/utglTF2ImportExport.cpp

@@ -101,6 +101,24 @@ TEST_F( utglTF2ImportExport, importBinaryglTF2FromFileTest ) {
     EXPECT_TRUE( binaryImporterTest() );
 }
 
+#ifndef ASSIMP_BUILD_NO_EXPORT
+TEST_F(utglTF2ImportExport, importglTF2AndExportToOBJ) {
+    Assimp::Importer importer;
+    Assimp::Exporter exporter;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/glTF2/BoxTextured-glTF/BoxTextured.gltf", aiProcess_ValidateDataStructure);
+    EXPECT_NE(nullptr, scene);
+    EXPECT_EQ(aiReturn_SUCCESS, exporter.Export(scene, "obj", ASSIMP_TEST_MODELS_DIR "/glTF2/BoxTextured-glTF/BoxTextured_out.obj"));
+}
+
+TEST_F(utglTF2ImportExport, importglTF2EmbeddedAndExportToOBJ) {
+    Assimp::Importer importer;
+    Assimp::Exporter exporter;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/glTF2/BoxTextured-glTF-Embedded/BoxTextured.gltf", aiProcess_ValidateDataStructure);
+    EXPECT_NE(nullptr, scene);
+    EXPECT_EQ(aiReturn_SUCCESS, exporter.Export(scene, "obj", ASSIMP_TEST_MODELS_DIR "/glTF2/BoxTextured-glTF-Embedded/BoxTextured_out.obj"));
+}
+#endif // ASSIMP_BUILD_NO_EXPORT
+
 TEST_F(utglTF2ImportExport, importglTF2PrimitiveModePointsWithoutIndices) {
     Assimp::Importer importer;
     //Points without indices

tools/assimp_cmd/Main.cpp

@@ -466,6 +466,9 @@ int ProcessStandardArguments(
 		else if (! strcmp( param, "-sbc") || ! strcmp( param, "--split-by-bone-count")) {
 			fill.ppFlags |= aiProcess_SplitByBoneCount;
 		}
+		else if (!strcmp(param, "-embtex") || ! strcmp(param, "--embed-textures")) {
+			fill.ppFlags |= aiProcess_EmbedTextures;
+		}
 		else if (! strncmp( param, "-c",2) || ! strncmp( param, "--config=",9)) {
 			const unsigned int ofs = (params[i][1] == '-' ? 9 : 2);