v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix static-code-analysis findings.

pull/2151/head
kimkulling 2018-09-21 16:07:09 +02:00
parent 0795ebda46
commit f818a909e5
55 changed files with 646 additions and 13122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
code/3DSHelper.h
View File

@ -66,7 +66,7 @@ namespace D3DS {
*/ */
class Discreet3DS { class Discreet3DS {
private: private:
Discreet3DS() { Discreet3DS() noexcept {
// empty // empty
} }
@ -328,19 +328,17 @@ struct Face : public FaceWithSmoothingGroup
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Helper structure representing a texture */ /** Helper structure representing a texture */
struct Texture struct Texture {
{
//! Default constructor //! Default constructor
Texture() Texture() noexcept
: 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(); mTextureBlend = get_qnan();
} }
@ -394,7 +392,7 @@ struct Material
//! Move constructor. This is explicitly written because MSVC doesn't support defaulting it //! Move constructor. This is explicitly written because MSVC doesn't support defaulting it
Material(Material &&other) Material(Material &&other) noexcept
: mName(std::move(other.mName)) : mName(std::move(other.mName))
, mDiffuse(std::move(other.mDiffuse)) , mDiffuse(std::move(other.mDiffuse))
, mSpecularExponent(std::move(other.mSpecularExponent)) , mSpecularExponent(std::move(other.mSpecularExponent))
@ -418,7 +416,7 @@ struct Material
} }
Material &operator=(Material &&other) { Material &operator=(Material &&other) noexcept {
if (this == &other) { if (this == &other) {
return *this; return *this;
} }
@ -447,7 +445,7 @@ struct Material
} }
~Material() {} virtual ~Material() {}
//! Name of the material //! Name of the material

238
code/AMFImporter.hpp
View File

@ -63,8 +63,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Header files, stdlib. // Header files, stdlib.
#include <set> #include <set>
namespace Assimp namespace Assimp {
{
/// \class AMFImporter /// \class AMFImporter
/// Class that holding scene graph which include: geometry, metadata, materials etc. /// 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> /// new - <texmap> and children <utex1>, <utex2>, <utex3>, <vtex1>, <vtex2>, <vtex3>
/// old - <map> and children <u1>, <u2>, <u3>, <v1>, <v2>, <v3> /// old - <map> and children <u1>, <u2>, <u3>, <v1>, <v2>, <v3>
/// ///
class AMFImporter : public BaseImporter class AMFImporter : public BaseImporter {
{
/***********************************************/
/******************** Types ********************/
/***********************************************/
private: 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. /// Clear all temporary data.
void Clear(); void Clear();
@ -200,7 +149,6 @@ private:
/************* Functions: find set *************/ /************* 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). /// Find specified node element in node elements list ( \ref mNodeElement_List).
/// \param [in] pID - ID(name) of requested node element. /// \param [in] pID - ID(name) of requested node element.
/// \param [in] pType - type of node element. /// \param [in] pType - type of node element.
@ -208,7 +156,6 @@ private:
/// \return true - if the node element is found, else - false. /// \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; 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. /// Find requested aiNode in node list.
/// \param [in] pID - ID(name) of requested node. /// \param [in] pID - ID(name) of requested node.
/// \param [in] pNodeList - list of nodes where to find the 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. /// \return true - if the node is found, else - false.
bool Find_ConvertedNode(const std::string& pID, std::list<aiNode*>& pNodeList, aiNode** pNode) const; 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. /// Find material in list for converted materials. Use at postprocessing step.
/// \param [in] pID - material ID. /// \param [in] pID - material ID.
/// \param [out] pConvertedMaterial - pointer to found converted material (\ref SPP_Material). /// \param [out] pConvertedMaterial - pointer to found converted material (\ref SPP_Material).
/// \return true - if the material is found, else - false. /// \return true - if the material is found, else - false.
bool Find_ConvertedMaterial(const std::string& pID, const SPP_Material** pConvertedMaterial) const; 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_R - ID of source "red" texture.
/// \param [in] pID_G - ID of source "green" texture. /// \param [in] pID_G - ID of source "green" texture.
/// \param [in] pID_B - ID of source "blue" 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, 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; 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. /// Get data stored in <vertices> and place it to arrays.
/// \param [in] pNodeElement - reference to node element which kept <object> data. /// \param [in] pNodeElement - reference to node element which kept <object> data.
/// \param [in] pVertexCoordinateArray - reference to vertices coordinates kept in <vertices>. /// \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, void PostprocessHelper_CreateMeshDataArray(const CAMFImporter_NodeElement_Mesh& pNodeElement, std::vector<aiVector3D>& pVertexCoordinateArray,
std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray) const; 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 /// 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 /// 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. /// to converted textures list.
@ -260,27 +200,23 @@ private:
/// \return index of the texture in array of the converted textures. /// \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); 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). /// 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 /// \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. /// processing.
/// \param [out] pOutputList_Separated - output list of the faces lists. Separated faces list by used texture IDs. Will be cleared before 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); 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. /// 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 [in] pMetadataList - reference to list with collected metadata.
/// \param [out] pSceneNode - scene node in which metadata will be added. /// \param [out] pSceneNode - scene node in which metadata will be added.
void Postprocess_AddMetadata(const std::list<CAMFImporter_NodeElement_Metadata*>& pMetadataList, aiNode& pSceneNode) const; 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>. /// To create aiMesh and aiNode for it from <object>.
/// \param [in] pNodeElement - reference to node element which kept <object> data. /// \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] pMeshList - reference to a list with all aiMesh of the scene.
/// \param [out] pSceneNode - pointer to place where new aiNode will be created. /// \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); 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>. /// Create mesh for every <volume> in <mesh>.
/// \param [in] pNodeElement - reference to node element which kept <mesh> data. /// \param [in] pNodeElement - reference to node element which kept <mesh> data.
/// \param [in] pVertexCoordinateArray - reference to vertices coordinates for all <volume>'s. /// \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, const std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray, const CAMFImporter_NodeElement_Color* pObjectColor,
std::list<aiMesh*>& pMeshList, aiNode& pSceneNode); 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. /// Convert material from \ref CAMFImporter_NodeElement_Material to \ref SPP_Material.
/// \param [in] pMaterial - source CAMFImporter_NodeElement_Material. /// \param [in] pMaterial - source CAMFImporter_NodeElement_Material.
void Postprocess_BuildMaterial(const CAMFImporter_NodeElement_Material& pMaterial); 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>. /// Create and add to aiNode's list new part of scene graph defined by <constellation>.
/// \param [in] pConstellation - reference to <constellation> node. /// \param [in] pConstellation - reference to <constellation> node.
/// \param [out] pNodeList - reference to aiNode's list. /// \param [out] pNodeList - reference to aiNode's list.
void Postprocess_BuildConstellation(CAMFImporter_NodeElement_Constellation& pConstellation, std::list<aiNode*>& pNodeList) const; 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. /// Build Assimp scene graph in aiScene from collected data.
/// \param [out] pScene - pointer to aiScene where tree will be built. /// \param [out] pScene - pointer to aiScene where tree will be built.
void Postprocess_BuildScene(aiScene* pScene); 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. /// Call that function when close tag of node not found and exception must be raised.
/// E.g.: /// E.g.:
/// <amf> /// <amf>
@ -324,19 +253,16 @@ private:
/// \param [in] pNode - node name in which exception happened. /// \param [in] pNode - node name in which exception happened.
void Throw_CloseNotFound(const std::string& pNode); 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. /// Call that function when attribute name is incorrect and exception must be raised.
/// \param [in] pAttrName - attribute name. /// \param [in] pAttrName - attribute name.
/// \throw DeadlyImportError. /// \throw DeadlyImportError.
void Throw_IncorrectAttr(const std::string& pAttrName); 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. /// Call that function when attribute value is incorrect and exception must be raised.
/// \param [in] pAttrName - attribute name. /// \param [in] pAttrName - attribute name.
/// \throw DeadlyImportError. /// \throw DeadlyImportError.
void Throw_IncorrectAttrValue(const std::string& pAttrName); 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. /// 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.: /// E.g.:
/// <object> /// <object>
@ -348,204 +274,158 @@ private:
/// \param [in] pDescription - message about error. E.g. what the node defined while exception raised. /// \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); 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. /// 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. /// \param [in] pID - ID of of element which not found.
/// \throw DeadlyImportError. /// \throw DeadlyImportError.
void Throw_ID_NotFound(const std::string& pID) const; 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. /// Check if current node have children: <node>...</node>. If not then exception will throwed.
void XML_CheckNode_MustHaveChildren(); void XML_CheckNode_MustHaveChildren();
/// \fn bool XML_CheckNode_NameEqual(const std::string& pNodeName)
/// Check if current node name is equal to pNodeName. /// Check if current node name is equal to pNodeName.
/// \param [in] pNodeName - name for checking. /// \param [in] pNodeName - name for checking.
/// return true if current node name is equal to pNodeName, else - false. /// return true if current node name is equal to pNodeName, else - false.
bool XML_CheckNode_NameEqual(const std::string& pNodeName) { return mReader->getNodeName() == pNodeName; } 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. /// 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. /// \param [in] pParentNodeName - parent node name. Used for reporting.
void XML_CheckNode_SkipUnsupported(const std::string& pParentNodeName); 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. /// 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. /// \param [in] pNodeName - requested node name.
/// return true - if node is found, else - false. /// return true - if node is found, else - false.
bool XML_SearchNode(const std::string& pNodeName); bool XML_SearchNode(const std::string& pNodeName);
/// \fn bool XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx)
/// Read attribute value. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \return read data. /// \return read data.
bool XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx); bool XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx);
/// \fn float XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx)
/// Read attribute value. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \return read data. /// \return read data.
float XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx); float XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx);
/// \fn uint32_t XML_ReadNode_GetAttrVal_AsU32(const int pAttrIdx)
/// Read attribute value. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \return read data. /// \return read data.
uint32_t XML_ReadNode_GetAttrVal_AsU32(const int pAttrIdx); uint32_t XML_ReadNode_GetAttrVal_AsU32(const int pAttrIdx);
/// \fn float XML_ReadNode_GetVal_AsFloat()
/// Read node value. /// Read node value.
/// \return read data. /// \return read data.
float XML_ReadNode_GetVal_AsFloat(); float XML_ReadNode_GetVal_AsFloat();
/// \fn uint32_t XML_ReadNode_GetVal_AsU32()
/// Read node value. /// Read node value.
/// \return read data. /// \return read data.
uint32_t XML_ReadNode_GetVal_AsU32(); uint32_t XML_ReadNode_GetVal_AsU32();
/// \fn void XML_ReadNode_GetVal_AsString(std::string& pValue)
/// Read node value. /// Read node value.
/// \return read data. /// \return read data.
void XML_ReadNode_GetVal_AsString(std::string& pValue); 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. /// 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. /// \param [in] pNode - new current node.
void ParseHelper_Node_Enter(CAMFImporter_NodeElement* pNode); 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. /// This function must be called when exiting from grouping node. \ref ParseHelper_Group_Begin.
void ParseHelper_Node_Exit(); 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 /// 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". /// must be converted to right form - "0.xxx".
/// \param [in] pInStr - pointer to input string which can contain incorrect form of values. /// \param [in] pInStr - pointer to input string which can contain incorrect form of values.
/// \param [out[ pOutString - output string with right form of values. /// \param [out[ pOutString - output string with right form of values.
void ParseHelper_FixTruncatedFloatString(const char* pInStr, std::string& pOutString); 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. /// Decode Base64-encoded data.
/// \param [in] pInputBase64 - reference to input Base64-encoded string. /// \param [in] pInputBase64 - reference to input Base64-encoded string.
/// \param [out] pOutputData - reference to output array for decoded data. /// \param [out] pOutputData - reference to output array for decoded data.
void ParseHelper_Decode_Base64(const std::string& pInputBase64, std::vector<uint8_t>& pOutputData) const; void ParseHelper_Decode_Base64(const std::string& pInputBase64, std::vector<uint8_t>& pOutputData) const;
/// \fn void ParseNode_Root()
/// Parse <AMF> node of the file. /// Parse <AMF> node of the file.
void ParseNode_Root(); void ParseNode_Root();
/******** Functions: top nodes *********/
/// \fn void ParseNode_Constellation()
/// Parse <constellation> node of the file. /// Parse <constellation> node of the file.
void ParseNode_Constellation(); void ParseNode_Constellation();
/// \fn void ParseNode_Constellation()
/// Parse <instance> node of the file. /// Parse <instance> node of the file.
void ParseNode_Instance(); void ParseNode_Instance();
/// \fn void ParseNode_Material()
/// Parse <material> node of the file. /// Parse <material> node of the file.
void ParseNode_Material(); void ParseNode_Material();
/// \fn void ParseNode_Metadata()
/// Parse <metadata> node. /// Parse <metadata> node.
void ParseNode_Metadata(); void ParseNode_Metadata();
/// \fn void ParseNode_Object()
/// Parse <object> node of the file. /// Parse <object> node of the file.
void ParseNode_Object(); void ParseNode_Object();
/// \fn void ParseNode_Texture()
/// Parse <texture> node of the file. /// Parse <texture> node of the file.
void ParseNode_Texture(); void ParseNode_Texture();
/******** Functions: geometry nodes *********/
/// \fn void ParseNode_Coordinates()
/// Parse <coordinates> node of the file. /// Parse <coordinates> node of the file.
void ParseNode_Coordinates(); void ParseNode_Coordinates();
/// \fn void ParseNode_Edge()
/// Parse <edge> node of the file. /// Parse <edge> node of the file.
void ParseNode_Edge(); void ParseNode_Edge();
/// \fn void ParseNode_Mesh()
/// Parse <mesh> node of the file. /// Parse <mesh> node of the file.
void ParseNode_Mesh(); void ParseNode_Mesh();
/// \fn void ParseNode_Triangle()
/// Parse <triangle> node of the file. /// Parse <triangle> node of the file.
void ParseNode_Triangle(); void ParseNode_Triangle();
/// \fn void ParseNode_Vertex()
/// Parse <vertex> node of the file. /// Parse <vertex> node of the file.
void ParseNode_Vertex(); void ParseNode_Vertex();
/// \fn void ParseNode_Vertices()
/// Parse <vertices> node of the file. /// Parse <vertices> node of the file.
void ParseNode_Vertices(); void ParseNode_Vertices();
/// \fn void ParseNode_Volume()
/// Parse <volume> node of the file. /// Parse <volume> node of the file.
void ParseNode_Volume(); void ParseNode_Volume();
/******** Functions: material nodes *********/
/// \fn void ParseNode_Color()
/// Parse <color> node of the file. /// Parse <color> node of the file.
void ParseNode_Color(); void ParseNode_Color();
/// \fn void ParseNode_TexMap(const bool pUseOldName = false)
/// Parse <texmap> of <map> node of the file. /// 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>. /// \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); void ParseNode_TexMap(const bool pUseOldName = false);
public: public:
/// \fn AMFImporter()
/// Default constructor. /// Default constructor.
AMFImporter() AMFImporter() noexcept
: mNodeElement_Cur(nullptr), mReader(nullptr) : mNodeElement_Cur(nullptr)
{} , mReader(nullptr) {
// empty
}
/// \fn ~AMFImporter()
/// Default destructor. /// Default destructor.
~AMFImporter(); ~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. /// 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] pFile - name of file to be parsed.
/// \param [in] pIOHandler - pointer to IO helper object. /// \param [in] pIOHandler - pointer to IO helper object.
void ParseFile(const std::string& pFile, IOSystem* pIOHandler); void ParseFile(const std::string& pFile, IOSystem* pIOHandler);
/***********************************************/
/********* Functions: BaseImporter set *********/
/***********************************************/
bool CanRead(const std::string& pFile, IOSystem* pIOHandler, bool pCheckSig) const; bool CanRead(const std::string& pFile, IOSystem* pIOHandler, bool pCheckSig) const;
void GetExtensionList(std::set<std::string>& pExtensionList); void GetExtensionList(std::set<std::string>& pExtensionList);
void InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler); void InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler);
const aiImporterDesc* GetInfo ()const; 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 }// namespace Assimp

98
code/AMFImporter_Material.cpp
View File

@ -68,10 +68,9 @@ namespace Assimp
// Multi elements - No. // Multi elements - No.
// Red, Greed, Blue and Alpha (transparency) component of a color in sRGB space, values ranging from 0 to 1. The // 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. // 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>. // Read attributes for node <color>.
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
@ -98,15 +97,19 @@ CAMFImporter_NodeElement* ne;
MACRO_NODECHECK_LOOPEND("color"); MACRO_NODECHECK_LOOPEND("color");
ParseHelper_Node_Exit(); ParseHelper_Node_Exit();
// check that all components was defined // 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 else
{ {
mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
}// if(!mReader->isEmptyElement()) else }
als.Composed = false; als.Composed = false;
mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph. 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. // An available material.
// Multi elements - Yes. // Multi elements - Yes.
// Parent element - <amf>. // 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>. // Read attributes for node <color>.
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
@ -131,9 +133,11 @@ CAMFImporter_NodeElement* ne;
// create new object. // create new object.
ne = new CAMFImporter_NodeElement_Material(mNodeElement_Cur); ne = new CAMFImporter_NodeElement_Material(mNodeElement_Cur);
// and assign read data
// and assign read data
((CAMFImporter_NodeElement_Material*)ne)->ID = id; ((CAMFImporter_NodeElement_Material*)ne)->ID = id;
// Check for child nodes
// Check for child nodes
if(!mReader->isEmptyElement()) if(!mReader->isEmptyElement())
{ {
bool col_read = false; bool col_read = false;
@ -154,11 +158,11 @@ CAMFImporter_NodeElement* ne;
if(XML_CheckNode_NameEqual("metadata")) { ParseNode_Metadata(); continue; } if(XML_CheckNode_NameEqual("metadata")) { ParseNode_Metadata(); continue; }
MACRO_NODECHECK_LOOPEND("material"); MACRO_NODECHECK_LOOPEND("material");
ParseHelper_Node_Exit(); ParseHelper_Node_Exit();
}// if(!mReader->isEmptyElement()) }
else else
{ {
mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element 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. 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>. // Parent element - <amf>.
void AMFImporter::ParseNode_Texture() 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>. // Read attributes for node <color>.
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
@ -201,20 +204,34 @@ CAMFImporter_NodeElement* ne;
MACRO_ATTRREAD_LOOPEND; MACRO_ATTRREAD_LOOPEND;
// create new texture object. // 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 CAMFImporter_NodeElement_Texture& als = *((CAMFImporter_NodeElement_Texture*)ne);// alias for convenience
// Check for child nodes // 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 // 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 // copy data
als.ID = id; als.ID = id;
als.Width = width; als.Width = width;
@ -222,8 +239,11 @@ CAMFImporter_NodeElement* ne;
als.Depth = depth; als.Depth = depth;
als.Tiled = tiled; als.Tiled = tiled;
ParseHelper_Decode_Base64(enc64_data, als.Data); 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_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. 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>. // <utex1>, <utex2>, <utex3>, <vtex1>, <vtex2>, <vtex3>. Old name: <u1>, <u2>, <u3>, <v1>, <v2>, <v3>.
// Multi elements - No. // Multi elements - No.
// Texture coordinates for every vertex of triangle. // 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>. // Read attributes for node <color>.
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
@ -257,7 +275,7 @@ CAMFImporter_NodeElement* ne;
MACRO_ATTRREAD_LOOPEND; MACRO_ATTRREAD_LOOPEND;
// create new texture coordinates object. // 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 CAMFImporter_NodeElement_TexMap& als = *((CAMFImporter_NodeElement_TexMap*)ne);// alias for convenience
// check data // check data

84
code/AMFImporter_Node.hpp
View File

@ -62,7 +62,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/// \class CAMFImporter_NodeElement /// \class CAMFImporter_NodeElement
/// Base class for elements of nodes. /// Base class for elements of nodes.
class CAMFImporter_NodeElement { class CAMFImporter_NodeElement {
public: public:
/// Define what data type contain node element. /// Define what data type contain node element.
enum EType { enum EType {
@ -96,15 +95,11 @@ public: /// Destructor, virtual..
// empty // 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: protected:
/// In constructor inheritor must set element type. /// In constructor inheritor must set element type.
@ -200,30 +195,27 @@ struct CAMFImporter_NodeElement_Root : public CAMFImporter_NodeElement
/// \struct CAMFImporter_NodeElement_Color /// \struct CAMFImporter_NodeElement_Color
/// Structure that define object node. /// 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_Color(CAMFImporter_NodeElement* pParent)
: CAMFImporter_NodeElement(ENET_Color, pParent) : CAMFImporter_NodeElement(ENET_Color, pParent)
{} , Composed( false )
, Color_Composed{""}
};// struct CAMFImporter_NodeElement_Color , Color()
, Profile() {
// empty
}
};
/// \struct CAMFImporter_NodeElement_Material /// \struct CAMFImporter_NodeElement_Material
/// Structure that define material node. /// 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) /// \fn CAMFImporter_NodeElement_Material(CAMFImporter_NodeElement* pParent)
/// Constructor. /// Constructor.
/// \param [in] pParent - pointer to parent node. /// \param [in] pParent - pointer to parent node.
@ -339,43 +331,39 @@ struct CAMFImporter_NodeElement_Coordinates : public CAMFImporter_NodeElement
/// \struct CAMFImporter_NodeElement_TexMap /// \struct CAMFImporter_NodeElement_TexMap
/// Structure that define texture coordinates node. /// 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. aiVector3D TextureCoordinate[3];///< Texture coordinates.
std::string TextureID_R;///< Texture ID for red color component. std::string TextureID_R;///< Texture ID for red color component.
std::string TextureID_G;///< Texture ID for green 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_B;///< Texture ID for blue color component.
std::string TextureID_A;///< Texture ID for alpha color component. std::string TextureID_A;///< Texture ID for alpha color component.
/****************** Functions ******************/
/// \fn CAMFImporter_NodeElement_TexMap(CAMFImporter_NodeElement* pParent)
/// Constructor. /// Constructor.
/// \param [in] pParent - pointer to parent node. /// \param [in] pParent - pointer to parent node.
CAMFImporter_NodeElement_TexMap(CAMFImporter_NodeElement* pParent) 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 /// \struct CAMFImporter_NodeElement_Triangle
/// Structure that define triangle node. /// 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. size_t V[3];///< Triangle vertices.
/****************** Functions ******************/
/// \fn CAMFImporter_NodeElement_Triangle(CAMFImporter_NodeElement* pParent)
/// Constructor. /// Constructor.
/// \param [in] pParent - pointer to parent node. /// \param [in] pParent - pointer to parent node.
CAMFImporter_NodeElement_Triangle(CAMFImporter_NodeElement* pParent) CAMFImporter_NodeElement_Triangle(CAMFImporter_NodeElement* pParent)
: CAMFImporter_NodeElement(ENET_Triangle, pParent) : CAMFImporter_NodeElement(ENET_Triangle, pParent)
{} , V{}{
// empty
}
};// struct CAMFImporter_NodeElement_Triangle };// struct CAMFImporter_NodeElement_Triangle

77
code/ASEParser.h
View File

@ -85,7 +85,7 @@ struct Material : public D3DS::Material
//! Move constructor. This is explicitly written because MSVC doesn't support defaulting it //! Move constructor. This is explicitly written because MSVC doesn't support defaulting it
Material(Material &&other) Material(Material &&other) noexcept
: D3DS::Material(std::move(other)) : D3DS::Material(std::move(other))
, avSubMaterials(std::move(other.avSubMaterials)) , avSubMaterials(std::move(other.avSubMaterials))
, pcInstance(std::move(other.pcInstance)) , pcInstance(std::move(other.pcInstance))
@ -95,7 +95,7 @@ struct Material : public D3DS::Material
} }
Material &operator=(Material &&other) { Material &operator=(Material &&other) noexcept {
if (this == &other) { if (this == &other) {
return *this; return *this;
} }
@ -127,19 +127,14 @@ struct Material : public D3DS::Material
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Helper structure to represent an ASE file face */ /** Helper structure to represent an ASE file face */
struct Face : public FaceWithSmoothingGroup struct Face : public FaceWithSmoothingGroup {
{
//! Default constructor. Initializes everything with 0 //! Default constructor. Initializes everything with 0
Face() Face() noexcept
{ : amUVIndices{0}
mColorIndices[0] = mColorIndices[1] = mColorIndices[2] = 0; , mColorIndices{0}
for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i) , iMaterial(DEFAULT_MATINDEX)
{ , iFace(0) {
amUVIndices[i][0] = amUVIndices[i][1] = amUVIndices[i][2] = 0; // empty
}
iMaterial = DEFAULT_MATINDEX;
iFace = 0;
} }
//! special value to indicate that no material index has //! special value to indicate that no material index has
@ -147,8 +142,6 @@ struct Face : public FaceWithSmoothingGroup
//! will replace this value later. //! will replace this value later.
static const unsigned int DEFAULT_MATINDEX = 0xFFFFFFFF; static const unsigned int DEFAULT_MATINDEX = 0xFFFFFFFF;
//! Indices into each list of texture coordinates //! Indices into each list of texture coordinates
unsigned int amUVIndices[AI_MAX_NUMBER_OF_TEXTURECOORDS][3]; unsigned int amUVIndices[AI_MAX_NUMBER_OF_TEXTURECOORDS][3];
@ -204,7 +197,7 @@ struct Animation
TCB = 0x2 TCB = 0x2
} mRotationType, mScalingType, mPositionType; } mRotationType, mScalingType, mPositionType;
Animation() Animation() noexcept
: mRotationType (TRACK) : mRotationType (TRACK)
, mScalingType (TRACK) , mScalingType (TRACK)
, mPositionType (TRACK) , mPositionType (TRACK)
@ -223,14 +216,13 @@ struct Animation
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Helper structure to represent the inheritance information of an ASE node */ /** Helper structure to represent the inheritance information of an ASE node */
struct InheritanceInfo struct InheritanceInfo {
{
//! Default constructor //! Default constructor
InheritanceInfo() InheritanceInfo() noexcept
{ : abInheritPosition{true}
// set the inheritance flag for all axes by default to true , abInheritRotation{true}
for (unsigned int i = 0; i < 3;++i) , abInheritScaling{true} {
abInheritPosition[i] = abInheritRotation[i] = abInheritScaling[i] = true; // empty
} }
//! Inherit the parent's position?, axis order is x,y,z //! Inherit the parent's position?, axis order is x,y,z
@ -291,24 +283,23 @@ struct BaseNode
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Helper structure to represent an ASE file mesh */ /** 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 //! Default constructor has been deleted
Mesh() = delete; Mesh() = delete;
//! Construction from an existing name //! Construction from an existing name
explicit Mesh(const std::string &name) explicit Mesh(const std::string &name)
: BaseNode (BaseNode::Mesh, name) : BaseNode( BaseNode::Mesh, name )
, amTexCoords{ }
, mVertexColors()
, mBoneVertices()
, mBones()
, iMaterialIndex(Face::DEFAULT_MATINDEX) , iMaterialIndex(Face::DEFAULT_MATINDEX)
, bSkip (false) , mNumUVComponents{ 2 }
{ , bSkip (false) {
// use 2 texture vertex components by default // empty
for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c)
this->mNumUVComponents[c] = 2;
} }
//! List of all texture coordinate sets //! List of all texture coordinate sets
std::vector<aiVector3D> amTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS]; std::vector<aiVector3D> amTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
@ -396,12 +387,11 @@ struct Camera : public BaseNode
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Helper structure to represent an ASE helper object (dummy) */ /** Helper structure to represent an ASE helper object (dummy) */
struct Dummy : public BaseNode struct Dummy : public BaseNode {
{
//! Constructor //! Constructor
Dummy() Dummy() noexcept
: BaseNode (BaseNode::Dummy, "DUMMY") : BaseNode (BaseNode::Dummy, "DUMMY") {
{ // empty
} }
}; };
@ -416,12 +406,11 @@ struct Dummy : public BaseNode
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
/** \brief Class to parse ASE files /** \brief Class to parse ASE files
*/ */
class Parser class Parser {
{
private: private:
Parser() noexcept {
Parser() {} // empty
}
public: public:

2
code/BaseImporter.cpp
View File

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

2
code/BaseProcess.cpp
View File

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

8
code/BaseProcess.h
View File

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

4
code/COBLoader.cpp
View File

@ -137,9 +137,7 @@ void COBImporter::SetupProperties(const Importer* /*pImp*/)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Imports the given file into the given scene structure. // 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; COB::Scene scene;
std::unique_ptr<StreamReaderLE> stream(new StreamReaderLE( pIOHandler->Open(pFile,"rb")) ); std::unique_ptr<StreamReaderLE> stream(new StreamReaderLE( pIOHandler->Open(pFile,"rb")) );

2
code/EmbedTexturesProcess.cpp
View File

@ -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.seekg(0, std::ios::beg);
file.read(reinterpret_cast<char*>(imageContent), imageSize); file.read(reinterpret_cast<char*>(imageContent), imageSize);

4
code/Importer.h
View File

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

39
code/LWOAnimation.h
View File

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

14
code/LWOFileData.h
View File

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

2
code/LimitBoneWeightsProcess.h
View File

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

4
code/MD3Loader.h
View File

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

14
code/MD5Parser.h
View File

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

34
code/MDCFileData.h
View File

@ -118,23 +118,23 @@ struct Surface
uint32_t ulOffsetFrameBaseFrames ; uint32_t ulOffsetFrameBaseFrames ;
uint32_t ulOffsetFrameCompFrames ; uint32_t ulOffsetFrameCompFrames ;
uint32_t ulOffsetEnd; uint32_t ulOffsetEnd;
Surface() Surface() noexcept
: ulIdent(), : ulIdent()
ulFlags(), , ucName{ 0 }
ulNumCompFrames(), , ulFlags()
ulNumBaseFrames(), , ulNumCompFrames()
ulNumShaders(), , ulNumBaseFrames()
ulNumVertices(), , ulNumShaders()
ulNumTriangles(), , ulNumVertices()
ulOffsetTriangles(), , ulNumTriangles()
ulOffsetShaders(), , ulOffsetTriangles()
ulOffsetTexCoords(), , ulOffsetShaders()
ulOffsetBaseVerts(), , ulOffsetTexCoords()
ulOffsetCompVerts(), , ulOffsetBaseVerts()
ulOffsetFrameBaseFrames(), , ulOffsetCompVerts()
ulOffsetFrameCompFrames(), , ulOffsetFrameBaseFrames()
ulOffsetEnd() , ulOffsetFrameCompFrames()
{ , ulOffsetEnd() {
ucName[AI_MDC_MAXQPATH-1] = '\0'; ucName[AI_MDC_MAXQPATH-1] = '\0';
} }
} PACK_STRUCT; } PACK_STRUCT;

39
code/MDLFileData.h
View File

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

18
code/OptimizeMeshes.h
View File

@ -67,20 +67,22 @@ namespace Assimp {
class OptimizeMeshesProcess : public BaseProcess class OptimizeMeshesProcess : public BaseProcess
{ {
public: public:
/// @brief The class constructor.
OptimizeMeshesProcess(); OptimizeMeshesProcess();
/// @brief The class destcructor,
~OptimizeMeshesProcess(); ~OptimizeMeshesProcess();
/** @brief Internal utility to store additional mesh info /** @brief Internal utility to store additional mesh info
*/ */
struct MeshInfo struct MeshInfo {
{ MeshInfo() noexcept
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 //! Number of times this mesh is referenced
unsigned int instance_cnt; unsigned int instance_cnt;

32
code/PlyParser.h
View File

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

41
code/SMDLoader.h
View File

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

4
code/ScenePrivate.h
View File

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

33
code/TextureTransform.h
View File

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

118
code/XFileHelper.h
View File

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

3
contrib/irrXML/irrArray.h
View File

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

6
include/assimp/BaseImporter.h
View File

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

5
include/assimp/ByteSwapper.h
View File

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

24
include/assimp/DefaultIOStream.h
View File

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

4
include/assimp/IOStream.hpp
View File

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

7
include/assimp/IOSystem.hpp
View File

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

6
include/assimp/LogStream.hpp
View File

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

12
include/assimp/Logger.hpp
View File

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

2
include/assimp/ProgressHandler.hpp
View File

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

32
include/assimp/SGSpatialSort.h
View File

@ -111,26 +111,34 @@ protected:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** An entry in a spatially sorted position array. Consists of a /** 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 */ * the reference plane */
// ------------------------------------------------------------------- // -------------------------------------------------------------------
struct Entry struct Entry {
{
unsigned int mIndex; ///< The vertex referred by this entry unsigned int mIndex; ///< The vertex referred by this entry
aiVector3D mPosition; ///< Position aiVector3D mPosition; ///< Position
uint32_t mSmoothGroups; uint32_t mSmoothGroups;
float mDistance; ///< Distance of this vertex to the sorting plane float mDistance; ///< Distance of this vertex to the sorting plane
Entry() { /** intentionally not initialized.*/ } Entry() noexcept
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 // all positions, sorted by distance to the sorting plane

10
include/assimp/SmoothingGroups.h
View File

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

2
include/assimp/SpatialSort.h
View File

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

32
include/assimp/anim.h
View File

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

2
include/assimp/camera.h
View File

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

2
include/assimp/color4.h
View File

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

2
include/assimp/fast_atof.h
View File

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

2
include/assimp/light.h
View File

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

4
include/assimp/material.h
View File

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

2
include/assimp/matrix3x3.h
View File

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

2
include/assimp/matrix4x4.h
View File

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

4
include/assimp/matrix4x4.inl
View File

@ -60,7 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
aiMatrix4x4t<TReal> ::aiMatrix4x4t () : aiMatrix4x4t<TReal>::aiMatrix4x4t() noexcept :
a1(1.0f), a2(), a3(), a4(), a1(1.0f), a2(), a3(), a4(),
b1(), b2(1.0f), b3(), b4(), b1(), b2(1.0f), b3(), b4(),
c1(), c2(), c3(1.0f), c4(), c1(), c2(), c3(1.0f), c4(),
@ -71,7 +71,7 @@ aiMatrix4x4t<TReal> ::aiMatrix4x4t () :
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> 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 _b1, TReal _b2, TReal _b3, TReal _b4,
TReal _c1, TReal _c2, TReal _c3, TReal _c4, TReal _c1, TReal _c2, TReal _c3, TReal _c4,
TReal _d1, TReal _d2, TReal _d3, TReal _d4) : TReal _d1, TReal _d2, TReal _d3, TReal _d4) :

190
include/assimp/mesh.h
View File

@ -136,10 +136,10 @@ struct aiFace
#ifdef __cplusplus #ifdef __cplusplus
//! Default constructor //! Default constructor
aiFace() aiFace() noexcept
: mNumIndices( 0 ) : mNumIndices( 0 )
, mIndices( NULL ) , mIndices( nullptr ) {
{ // empty
} }
//! Default destructor. Delete the index array //! Default destructor. Delete the index array
@ -150,47 +150,56 @@ struct aiFace
//! Copy constructor. Copy the index array //! Copy constructor. Copy the index array
aiFace( const aiFace& o) aiFace( const aiFace& o)
: mIndices( NULL ) : mNumIndices(0)
{ , mIndices( nullptr ) {
*this = o; *this = o;
} }
//! Assignment operator. Copy the index array //! Assignment operator. Copy the index array
aiFace& operator = ( const aiFace& o) aiFace& operator = ( const aiFace& o) {
{ if (&o == this) {
if (&o == this)
return *this; return *this;
}
delete[] mIndices; delete[] mIndices;
mNumIndices = o.mNumIndices; mNumIndices = o.mNumIndices;
if (mNumIndices) { if (mNumIndices) {
mIndices = new unsigned int[mNumIndices]; mIndices = new unsigned int[mNumIndices];
::memcpy( mIndices, o.mIndices, mNumIndices * sizeof( unsigned int)); ::memcpy( mIndices, o.mIndices, mNumIndices * sizeof( unsigned int));
} else {
mIndices = nullptr;
} }
else {
mIndices = NULL;
}
return *this; return *this;
} }
//! Comparison operator. Checks whether the index array //! Comparison operator. Checks whether the index array
//! of two faces is identical //! 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 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 //! Inverse comparison operator. Checks whether the index
//! array of two faces is NOT identical //! array of two faces is NOT identical
bool operator != (const aiFace& o) const bool operator != (const aiFace& o) const {
{
return !(*this == o); return !(*this == o);
} }
#endif // __cplusplus #endif // __cplusplus
@ -211,13 +220,13 @@ struct aiVertexWeight {
#ifdef __cplusplus #ifdef __cplusplus
//! Default constructor //! Default constructor
aiVertexWeight() aiVertexWeight() noexcept
: mVertexId(0) : mVertexId(0)
, mWeight(0.0f) { , mWeight(0.0f) {
// empty // empty
} }
//! Initialisation from a given index and vertex weight factor //! Initialization from a given index and vertex weight factor
//! \param pID ID //! \param pID ID
//! \param pWeight Vertex weight factor //! \param pWeight Vertex weight factor
aiVertexWeight( unsigned int pID, float pWeight ) aiVertexWeight( unsigned int pID, float pWeight )
@ -273,21 +282,21 @@ struct aiBone {
#ifdef __cplusplus #ifdef __cplusplus
//! Default constructor //! Default constructor
aiBone() aiBone() noexcept
: mName() : mName()
, mNumWeights( 0 ) , mNumWeights( 0 )
, mWeights( nullptr ) { , mWeights( nullptr )
, mOffsetMatrix() {
// empty // empty
} }
//! Copy constructor //! Copy constructor
aiBone(const aiBone& other) 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]; mWeights = new aiVertexWeight[mNumWeights];
::memcpy(mWeights,other.mWeights,mNumWeights * sizeof(aiVertexWeight)); ::memcpy(mWeights,other.mWeights,mNumWeights * sizeof(aiVertexWeight));
} }
@ -295,8 +304,7 @@ struct aiBone {
//! Assignment operator //! Assignment operator
aiBone &operator=(const aiBone& other) aiBone &operator=(const aiBone& other) {
{
if (this == &other) { if (this == &other) {
return *this; return *this;
} }
@ -332,8 +340,7 @@ struct aiBone {
return true; return true;
} }
//! Destructor - deletes the array of vertex weights //! Destructor - deletes the array of vertex weights
~aiBone() ~aiBone() {
{
delete [] mWeights; delete [] mWeights;
} }
#endif // __cplusplus #endif // __cplusplus
@ -447,11 +454,13 @@ struct aiAnimMesh
#ifdef __cplusplus #ifdef __cplusplus
aiAnimMesh() aiAnimMesh() noexcept
: mVertices( NULL ) : mVertices( nullptr )
, mNormals( NULL ) , mNormals(nullptr)
, mTangents( NULL ) , mTangents(nullptr)
, mBitangents( NULL ) , mBitangents(nullptr)
, mColors()
, mTextureCoords()
, mNumVertices( 0 ) , mNumVertices( 0 )
, mWeight( 0.0f ) , mWeight( 0.0f )
{ {
@ -706,35 +715,36 @@ struct aiMesh
#ifdef __cplusplus #ifdef __cplusplus
//! Default constructor. Initializes all members to 0 //! Default constructor. Initializes all members to 0
aiMesh() aiMesh() noexcept
: 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; 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 //! Deletes all storage allocated for the mesh
~aiMesh() ~aiMesh() {
{
delete [] mVertices; delete [] mVertices;
delete [] mNormals; delete [] mNormals;
delete [] mTangents; delete [] mTangents;
@ -767,63 +777,67 @@ struct aiMesh
//! Check whether the mesh contains positions. Provided no special //! Check whether the mesh contains positions. Provided no special
//! scene flags are set, this will always be true //! scene flags are set, this will always be true
bool HasPositions() const bool HasPositions() const
{ return mVertices != NULL && mNumVertices > 0; } { return mVertices != nullptr && mNumVertices > 0; }
//! Check whether the mesh contains faces. If no special scene flags //! Check whether the mesh contains faces. If no special scene flags
//! are set this should always return true //! are set this should always return true
bool HasFaces() const bool HasFaces() const
{ return mFaces != NULL && mNumFaces > 0; } { return mFaces != nullptr && mNumFaces > 0; }
//! Check whether the mesh contains normal vectors //! Check whether the mesh contains normal vectors
bool HasNormals() const bool HasNormals() const
{ return mNormals != NULL && mNumVertices > 0; } { return mNormals != nullptr && mNumVertices > 0; }
//! Check whether the mesh contains tangent and bitangent vectors //! Check whether the mesh contains tangent and bitangent vectors
//! It is not possible that it contains tangents and no bitangents //! It is not possible that it contains tangents and no bitangents
//! (or the other way round). The existence of one of them //! (or the other way round). The existence of one of them
//! implies that the second is there, too. //! implies that the second is there, too.
bool HasTangentsAndBitangents() const 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 //! Check whether the mesh contains a vertex color set
//! \param pIndex Index of the 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; 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 //! Check whether the mesh contains a texture coordinate set
//! \param pIndex Index of the texture coordinates 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; 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 //! 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; return n;
} }
//! Get the number of vertex color channels the mesh contains //! 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; return n;
} }
//! Check whether the mesh contains bones //! 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 #endif // __cplusplus
}; };

6
include/assimp/metadata.h
View File

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

2
include/assimp/quaternion.h
View File

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

24
include/assimp/texture.h
View File

@ -131,8 +131,7 @@ struct aiTexel
* as the texture paths (a single asterisk character followed by the * as the texture paths (a single asterisk character followed by the
* zero-based index of the texture in the aiScene::mTextures array). * zero-based index of the texture in the aiScene::mTextures array).
*/ */
struct aiTexture struct aiTexture {
{
/** Width of the texture, in pixels /** Width of the texture, in pixels
* *
* If mHeight is zero the texture is compressed in a format * If mHeight is zero the texture is compressed in a format
@ -193,24 +192,27 @@ struct aiTexture
//! @param s Input string. 3 characters are maximally processed. //! @param s Input string. 3 characters are maximally processed.
//! Example values: "jpg", "png" //! Example values: "jpg", "png"
//! @return true if the given string matches the format hint //! @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))); return (0 == ::strncmp(achFormatHint, s, sizeof(achFormatHint)));
} }
// Construction // Construction
aiTexture () aiTexture() noexcept
: mWidth (0) : mWidth(0)
, mHeight (0) , mHeight(0)
, pcData (NULL) , achFormatHint{ 0 }
{ , pcData(nullptr)
, mFilename() {
achFormatHint[0] = achFormatHint[1] = 0; achFormatHint[0] = achFormatHint[1] = 0;
achFormatHint[2] = achFormatHint[3] = 0; achFormatHint[2] = achFormatHint[3] = 0;
} }
// Destruction // Destruction
~aiTexture () ~aiTexture () {
{
delete[] pcData; delete[] pcData;
} }
#endif #endif

19
include/assimp/types.h
View File

@ -122,7 +122,8 @@ extern "C" {
struct aiPlane struct aiPlane
{ {
#ifdef __cplusplus #ifdef __cplusplus
aiPlane () : a(0.f), b(0.f), c(0.f), d(0.f) {} aiPlane () noexcept : 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) aiPlane (ai_real _a, ai_real _b, ai_real _c, ai_real _d)
: a(_a), b(_b), c(_c), d(_d) {} : a(_a), b(_b), c(_c), d(_d) {}
@ -140,7 +141,7 @@ struct aiPlane
struct aiRay struct aiRay
{ {
#ifdef __cplusplus #ifdef __cplusplus
aiRay () {} aiRay () noexcept {}
aiRay (const aiVector3D& _pos, const aiVector3D& _dir) aiRay (const aiVector3D& _pos, const aiVector3D& _dir)
: pos(_pos), dir(_dir) {} : pos(_pos), dir(_dir) {}
@ -158,7 +159,7 @@ struct aiRay
struct aiColor3D struct aiColor3D
{ {
#ifdef __cplusplus #ifdef __cplusplus
aiColor3D () : r(0.0f), g(0.0f), b(0.0f) {} aiColor3D () noexcept : 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) {} 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) {} explicit aiColor3D (ai_real _r) : r(_r), g(_r), b(_r) {}
aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {} aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {}
@ -253,9 +254,9 @@ struct aiString
{ {
#ifdef __cplusplus #ifdef __cplusplus
/** Default constructor, the string is set to have zero length */ /** Default constructor, the string is set to have zero length */
aiString() : aiString() noexcept
length(0) : length( 0 )
{ , data {0} {
data[0] = '\0'; data[0] = '\0';
#ifdef ASSIMP_BUILD_DEBUG #ifdef ASSIMP_BUILD_DEBUG
@ -305,7 +306,7 @@ struct aiString
} }
/** Assigment operator */ /** Assignment operator */
aiString& operator = (const aiString &rOther) { aiString& operator = (const aiString &rOther) {
if (this == &rOther) { if (this == &rOther) {
return *this; return *this;
@ -373,7 +374,7 @@ struct aiString
#endif // !__cplusplus #endif // !__cplusplus
/** Binary length of the string excluding the terminal 0. This is NOT the /** 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.*/ * the number of bytes from the beginning of the string to its end.*/
size_t length; size_t length;
@ -479,7 +480,7 @@ struct aiMemoryInfo
#ifdef __cplusplus #ifdef __cplusplus
/** Default constructor */ /** Default constructor */
aiMemoryInfo() aiMemoryInfo() noexcept
: textures (0) : textures (0)
, materials (0) , materials (0)
, meshes (0) , meshes (0)

2
include/assimp/vector3.h
View File

@ -66,7 +66,7 @@ template <typename TReal>
class aiVector3t class aiVector3t
{ {
public: public:
aiVector3t() : x(), y(), z() {} aiVector3t() noexcept : x(), y(), z() {}
aiVector3t(TReal _x, TReal _y, TReal _z) : x(_x), y(_y), z(_z) {} aiVector3t(TReal _x, TReal _y, TReal _z) : x(_x), y(_y), z(_z) {}
explicit aiVector3t (TReal _xyz ) : x(_xyz), y(_xyz), z(_xyz) {} explicit aiVector3t (TReal _xyz ) : x(_xyz), y(_xyz), z(_xyz) {}
aiVector3t( const aiVector3t& o ) : x(o.x), y(o.y), z(o.z) {} aiVector3t( const aiVector3t& o ) : x(o.x), y(o.y), z(o.z) {}

7
scripts/StepImporter/CppGenerator.py
View File

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

12401
scripts/StepImporter/schema_ifc4.exp
View File

File diff suppressed because it is too large Load Diff

1
test/CMakeLists.txt
View File

@ -117,6 +117,7 @@ SET( IMPORTERS
unit/utB3DImportExport.cpp unit/utB3DImportExport.cpp
unit/utMDCImportExport.cpp unit/utMDCImportExport.cpp
unit/utAssbinImportExport.cpp unit/utAssbinImportExport.cpp
unit/ImportExport/utCOBImportExport.cpp
) )
SET( MATERIAL SET( MATERIAL

10
test/unit/utAMFImportExport.cpp
View File

@ -59,6 +59,14 @@ public:
} }
}; };
TEST_F( utAMFImportExport, importACFromFileTest ) { TEST_F( utAMFImportExport, importAMFFromFileTest ) {
EXPECT_TRUE( importerTest() ); 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);
}