diff --git a/.travis.yml b/.travis.yml index 8b00b4cc7..8fe39d59c 100644 --- a/.travis.yml +++ b/.travis.yml @@ -70,6 +70,6 @@ addons: project: name: "assimp/assimp" notification_email: kim.kulling@googlemail.com - build_command_prepend: "cmake . -DASSIMP_ENABLE_BOOST_WORKAROUND=YES" + build_command_prepend: "cmake ./" build_command: "make -j4" branch_pattern: coverity_scan diff --git a/code/C4DImporter.cpp b/code/C4DImporter.cpp index 665d74633..6e5b7d39b 100644 --- a/code/C4DImporter.cpp +++ b/code/C4DImporter.cpp @@ -2,7 +2,7 @@ Open Asset Import Library (assimp) ---------------------------------------------------------------------- -Copyright (c) 2006-2012, assimp team +Copyright (c) 2006-2019, assimp team All rights reserved. Redistribution and use of this software in source and binary forms, @@ -68,8 +68,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace melange; // overload this function and fill in your own unique data -void GetWriterInfo(int &id, String &appname) -{ +void GetWriterInfo(int &id, String &appname) { id = 2424226; appname = "Open Asset Import Library"; } @@ -78,7 +77,10 @@ using namespace Assimp; using namespace Assimp::Formatter; namespace Assimp { - template<> const std::string LogFunctions::log_prefix = "C4D: "; + template<> const char* LogFunctions::Prefix() { + static auto prefix = "C4D: "; + return prefix; + } } static const aiImporterDesc desc = { @@ -97,47 +99,44 @@ static const aiImporterDesc desc = { // ------------------------------------------------------------------------------------------------ C4DImporter::C4DImporter() -{} +: BaseImporter() { + // empty +} // ------------------------------------------------------------------------------------------------ -C4DImporter::~C4DImporter() -{} +C4DImporter::~C4DImporter() { + // empty +} // ------------------------------------------------------------------------------------------------ -bool C4DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const -{ +bool C4DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const { const std::string& extension = GetExtension(pFile); if (extension == "c4d") { return true; - } - - else if ((!extension.length() || checkSig) && pIOHandler) { + } else if ((!extension.length() || checkSig) && pIOHandler) { // TODO } + return false; } // ------------------------------------------------------------------------------------------------ -const aiImporterDesc* C4DImporter::GetInfo () const -{ +const aiImporterDesc* C4DImporter::GetInfo () const { return &desc; } // ------------------------------------------------------------------------------------------------ -void C4DImporter::SetupProperties(const Importer* /*pImp*/) -{ +void C4DImporter::SetupProperties(const Importer* /*pImp*/) { // nothing to be done for the moment } // ------------------------------------------------------------------------------------------------ // Imports the given file into the given scene structure. -void C4DImporter::InternReadFile( const std::string& pFile, - aiScene* pScene, IOSystem* pIOHandler) -{ +void C4DImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) { std::unique_ptr file( pIOHandler->Open( pFile)); - if( file.get() == NULL) { + if( file.get() == nullptr ) { ThrowException("failed to open file " + pFile); } @@ -151,7 +150,7 @@ void C4DImporter::InternReadFile( const std::string& pFile, // open document first BaseDocument* doc = LoadDocument(f, SCENEFILTER_OBJECTS | SCENEFILTER_MATERIALS); - if(doc == NULL) { + if(doc == nullptr ) { ThrowException("failed to read document " + pFile); } @@ -160,11 +159,10 @@ void C4DImporter::InternReadFile( const std::string& pFile, // first convert all materials ReadMaterials(doc->GetFirstMaterial()); - // process C4D scenegraph recursively + // process C4D scene-graph recursively try { RecurseHierarchy(doc->GetFirstObject(), pScene->mRootNode); - } - catch(...) { + } catch(...) { for(aiMesh* mesh : meshes) { delete mesh; } @@ -201,8 +199,7 @@ void C4DImporter::InternReadFile( const std::string& pFile, // ------------------------------------------------------------------------------------------------ -bool C4DImporter::ReadShader(aiMaterial* out, melange::BaseShader* shader) -{ +bool C4DImporter::ReadShader(aiMaterial* out, melange::BaseShader* shader) { // based on Melange sample code (C4DImportExport.cpp) while(shader) { if(shader->GetType() == Xlayer) { @@ -220,15 +217,12 @@ bool C4DImporter::ReadShader(aiMaterial* out, melange::BaseShader* shader) // Ignore the actual layer blending - models for real-time rendering should not // use them in a non-trivial way. Just try to find textures that we can apply // to the model. - while (lsl) - { - if (lsl->GetType() == TypeFolder) - { + while (lsl) { + if (lsl->GetType() == TypeFolder) { BlendFolder* const folder = dynamic_cast(lsl); LayerShaderLayer *subLsl = dynamic_cast(folder->m_Children.GetObject(0)); - while (subLsl) - { + while (subLsl) { if (subLsl->GetType() == TypeShader) { BlendShader* const shader = dynamic_cast(subLsl); if(ReadShader(out, static_cast(shader->m_pLink->GetLink()))) { @@ -238,8 +232,7 @@ bool C4DImporter::ReadShader(aiMaterial* out, melange::BaseShader* shader) subLsl = subLsl->GetNext(); } - } - else if (lsl->GetType() == TypeShader) { + } else if (lsl->GetType() == TypeShader) { BlendShader* const shader = dynamic_cast(lsl); if(ReadShader(out, static_cast(shader->m_pLink->GetLink()))) { return true; @@ -248,33 +241,27 @@ bool C4DImporter::ReadShader(aiMaterial* out, melange::BaseShader* shader) lsl = lsl->GetNext(); } - } - else if ( shader->GetType() == Xbitmap ) - { + } else if ( shader->GetType() == Xbitmap ) { aiString path; shader->GetFileName().GetString().GetCString(path.data, MAXLEN-1); path.length = ::strlen(path.data); out->AddProperty(&path, AI_MATKEY_TEXTURE_DIFFUSE(0)); return true; - } - else { + } else { LogWarn("ignoring shader type: " + std::string(GetObjectTypeName(shader->GetType()))); } shader = shader->GetNext(); } + return false; } - // ------------------------------------------------------------------------------------------------ -void C4DImporter::ReadMaterials(melange::BaseMaterial* mat) -{ +void C4DImporter::ReadMaterials(melange::BaseMaterial* mat) { // based on Melange sample code - while (mat) - { + while (mat) { const String& name = mat->GetName(); - if (mat->GetType() == Mmaterial) - { + if (mat->GetType() == Mmaterial) { aiMaterial* out = new aiMaterial(); material_mapping[mat] = static_cast(materials.size()); materials.push_back(out); @@ -286,8 +273,7 @@ void C4DImporter::ReadMaterials(melange::BaseMaterial* mat) Material& m = dynamic_cast(*mat); - if (m.GetChannelState(CHANNEL_COLOR)) - { + if (m.GetChannelState(CHANNEL_COLOR)) { GeData data; mat->GetParameter(MATERIAL_COLOR_COLOR, data); Vector color = data.GetVector(); @@ -307,9 +293,7 @@ void C4DImporter::ReadMaterials(melange::BaseMaterial* mat) if(shader) { ReadShader(out, shader); } - } - else - { + } else { LogWarn("ignoring plugin material: " + std::string(GetObjectTypeName(mat->GetType()))); } mat = mat->GetNext(); @@ -317,14 +301,12 @@ void C4DImporter::ReadMaterials(melange::BaseMaterial* mat) } // ------------------------------------------------------------------------------------------------ -void C4DImporter::RecurseHierarchy(BaseObject* object, aiNode* parent) -{ - ai_assert(parent != NULL); +void C4DImporter::RecurseHierarchy(BaseObject* object, aiNode* parent) { + ai_assert(parent != nullptr ); std::vector nodes; // based on Melange sample code - while (object) - { + while (object) { const String& name = object->GetName(); const LONG type = object->GetType(); const Matrix& ml = object->GetMl(); @@ -356,26 +338,20 @@ void C4DImporter::RecurseHierarchy(BaseObject* object, aiNode* parent) nodes.push_back(nd); GeData data; - if (type == Ocamera) - { + if (type == Ocamera) { object->GetParameter(CAMERAOBJECT_FOV, data); // TODO: read camera - } - else if (type == Olight) - { + } else if (type == Olight) { // TODO: read light - } - else if (type == Opolygon) - { + } else if (type == Opolygon) { aiMesh* const mesh = ReadMesh(object); - if(mesh != NULL) { + if(mesh != nullptr) { nd->mNumMeshes = 1; nd->mMeshes = new unsigned int[1]; nd->mMeshes[0] = static_cast(meshes.size()); meshes.push_back(mesh); } - } - else { + } else { LogWarn("ignoring object: " + std::string(GetObjectTypeName(type))); } @@ -389,28 +365,27 @@ void C4DImporter::RecurseHierarchy(BaseObject* object, aiNode* parent) std::copy(nodes.begin(), nodes.end(), parent->mChildren); } - // ------------------------------------------------------------------------------------------------ -aiMesh* C4DImporter::ReadMesh(BaseObject* object) -{ - ai_assert(object != NULL && object->GetType() == Opolygon); +aiMesh* C4DImporter::ReadMesh(BaseObject* object) { + ai_assert(object != nullptr); + ai_assert( object->GetType() == Opolygon ); // based on Melange sample code PolygonObject* const polyObject = dynamic_cast(object); - ai_assert(polyObject != NULL); + ai_assert(polyObject != nullptr); const LONG pointCount = polyObject->GetPointCount(); const LONG polyCount = polyObject->GetPolygonCount(); if(!polyObject || !pointCount) { LogWarn("ignoring mesh with zero vertices or faces"); - return NULL; + return nullptr; } const Vector* points = polyObject->GetPointR(); - ai_assert(points != NULL); + ai_assert(points != nullptr); const CPolygon* polys = polyObject->GetPolygonR(); - ai_assert(polys != NULL); + ai_assert(polys != nullptr); std::unique_ptr mesh(new aiMesh()); mesh->mNumFaces = static_cast(polyCount); @@ -443,14 +418,14 @@ aiMesh* C4DImporter::ReadMesh(BaseObject* object) // check if there are normals, tangents or UVW coordinates BaseTag* tag = object->GetTag(Tnormal); - NormalTag* normals_src = NULL; + NormalTag* normals_src = nullptr; if(tag) { normals_src = dynamic_cast(tag); normals = mesh->mNormals = new aiVector3D[mesh->mNumVertices](); } tag = object->GetTag(Ttangent); - TangentTag* tangents_src = NULL; + TangentTag* tangents_src = nullptr; if(tag) { tangents_src = dynamic_cast(tag); tangents = mesh->mTangents = new aiVector3D[mesh->mNumVertices](); @@ -458,15 +433,14 @@ aiMesh* C4DImporter::ReadMesh(BaseObject* object) } tag = object->GetTag(Tuvw); - UVWTag* uvs_src = NULL; + UVWTag* uvs_src = nullptr; if(tag) { uvs_src = dynamic_cast(tag); uvs = mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices](); } // copy vertices and extra channels over and populate faces - for (LONG i = 0; i < polyCount; ++i, ++face) - { + for (LONG i = 0; i < polyCount; ++i, ++face) { ai_assert(polys[i].a < pointCount && polys[i].a >= 0); const Vector& pointA = points[polys[i].a]; verts->x = pointA.x; @@ -489,8 +463,7 @@ aiMesh* C4DImporter::ReadMesh(BaseObject* object) ++verts; // TODO: do we also need to handle lines or points with similar checks? - if (polys[i].c != polys[i].d) - { + if (polys[i].c != polys[i].d) { ai_assert(polys[i].d < pointCount && polys[i].d >= 0); face->mNumIndices = 4; @@ -500,8 +473,7 @@ aiMesh* C4DImporter::ReadMesh(BaseObject* object) verts->y = pointD.y; verts->z = pointD.z; ++verts; - } - else { + } else { face->mNumIndices = 3; } face->mIndices = new unsigned int[face->mNumIndices]; @@ -513,8 +485,7 @@ aiMesh* C4DImporter::ReadMesh(BaseObject* object) if (normals_src) { if(i >= normals_src->GetDataCount()) { LogError("unexpected number of normals, ignoring"); - } - else { + } else { ConstNormalHandle normal_handle = normals_src->GetDataAddressR(); NormalStruct nor; NormalTag::Get(normal_handle, i, nor); @@ -616,26 +587,25 @@ aiMesh* C4DImporter::ReadMesh(BaseObject* object) } mesh->mMaterialIndex = ResolveMaterial(polyObject); + return mesh.release(); } - // ------------------------------------------------------------------------------------------------ -unsigned int C4DImporter::ResolveMaterial(PolygonObject* obj) -{ - ai_assert(obj != NULL); +unsigned int C4DImporter::ResolveMaterial(PolygonObject* obj) { + ai_assert(obj != nullptr); const unsigned int mat_count = static_cast(materials.size()); BaseTag* tag = obj->GetTag(Ttexture); - if(tag == NULL) { + if(tag == nullptr) { return mat_count; } TextureTag& ttag = dynamic_cast(*tag); BaseMaterial* const mat = ttag.GetMaterial(); - ai_assert(mat != NULL); + ai_assert(mat != nullptr); const MaterialMap::const_iterator it = material_mapping.find(mat); if(it == material_mapping.end()) { @@ -643,6 +613,7 @@ unsigned int C4DImporter::ResolveMaterial(PolygonObject* obj) } ai_assert((*it).second < mat_count); + return (*it).second; } diff --git a/code/C4DImporter.h b/code/C4DImporter.h index 2f67d90f3..f3b1351f6 100644 --- a/code/C4DImporter.h +++ b/code/C4DImporter.h @@ -2,7 +2,7 @@ Open Asset Import Library (assimp) ---------------------------------------------------------------------- -Copyright (c) 2006-2012, assimp team +Copyright (c) 2006-2019, assimp team All rights reserved. Redistribution and use of this software in source and binary forms, @@ -48,6 +48,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include + +// Forward declarations struct aiNode; struct aiMesh; struct aiMaterial; @@ -61,8 +63,7 @@ namespace melange { class BaseShader; } -namespace Assimp { - +namespace Assimp { // TinyFormatter.h namespace Formatter { template class basic_formatter; @@ -75,17 +76,10 @@ namespace Assimp { * * Note that Melange is not free software. */ // ------------------------------------------------------------------------------------------- -class C4DImporter : public BaseImporter, public LogFunctions -{ +class C4DImporter : public BaseImporter, public LogFunctions { public: - C4DImporter(); ~C4DImporter(); - - -public: - - // -------------------- bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const; @@ -119,5 +113,5 @@ private: }; // !class C4DImporter } // end of namespace Assimp -#endif // INCLUDED_AI_CINEMA_4D_LOADER_H +#endif // INCLUDED_AI_CINEMA_4D_LOADER_H