From a521b23ab5ca49ddfd0ce0e3fbd0704725287417 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20Aumu=CC=88ller?= Date: Sat, 14 Oct 2023 14:49:41 +0200 Subject: [PATCH 01/16] link to external minizip with full path This let's cmake create config files that allow linking to minizip even when in an unrelated prefix. This can happen with package managers that install every package into their own prefix, such as [Spack](https://spack.io). --- code/CMakeLists.txt | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/code/CMakeLists.txt b/code/CMakeLists.txt index 0fe2291f8..3be1004a7 100644 --- a/code/CMakeLists.txt +++ b/code/CMakeLists.txt @@ -1380,7 +1380,12 @@ ENDIF() IF(NOT ASSIMP_HUNTER_ENABLED) if (UNZIP_FOUND) INCLUDE_DIRECTORIES(${UNZIP_INCLUDE_DIRS}) - TARGET_LINK_LIBRARIES(assimp ${UNZIP_LIBRARIES}) + # TODO if cmake required version has been updated to >3.12.0, collapse this to the second case only + if(${CMAKE_VERSION} VERSION_LESS "3.12.0") + TARGET_LINK_LIBRARIES(assimp ${UNZIP_LIBRARIES}) + else() + TARGET_LINK_LIBRARIES(assimp ${UNZIP_LINK_LIBRARIES}) + endif() else () INCLUDE_DIRECTORIES("../") endif () From 46b19cc6a4cc4129d996614591e91c2cf165d5f5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?T=C3=A1rcio=20Vin=C3=ADcius?= Date: Sun, 15 Oct 2023 17:48:38 -0300 Subject: [PATCH 02/16] utf8 header not found --- code/CMakeLists.txt | 2 +- samples/SimpleTexturedDirectx11/CMakeLists.txt | 1 + .../SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp | 1 + samples/SimpleTexturedOpenGL/CMakeLists.txt | 1 + .../SimpleTexturedOpenGL/src/model_loading.cpp | 1 + 5 files changed, 5 insertions(+), 1 deletion(-) diff --git a/code/CMakeLists.txt b/code/CMakeLists.txt index 3be1004a7..9b0b964c0 100644 --- a/code/CMakeLists.txt +++ b/code/CMakeLists.txt @@ -923,7 +923,7 @@ IF(ASSIMP_HUNTER_ENABLED) hunter_add_package(utf8) find_package(utf8cpp CONFIG REQUIRED) ELSE() - # utf8 is header-only, so Assimp doesn't need to do anything. + INCLUDE_DIRECTORIES("../contrib/utf8cpp/source") ENDIF() # polyclipping diff --git a/samples/SimpleTexturedDirectx11/CMakeLists.txt b/samples/SimpleTexturedDirectx11/CMakeLists.txt index de83734ba..f64923179 100644 --- a/samples/SimpleTexturedDirectx11/CMakeLists.txt +++ b/samples/SimpleTexturedDirectx11/CMakeLists.txt @@ -19,6 +19,7 @@ INCLUDE_DIRECTORIES( ${Assimp_SOURCE_DIR}/include ${Assimp_SOURCE_DIR}/code ${SAMPLES_SHARED_CODE_DIR} + ${Assimp_SOURCE_DIR}/contrib/utf8cpp/source ) LINK_DIRECTORIES( diff --git a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp index 4da5820a1..ec031a594 100644 --- a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp +++ b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp @@ -23,6 +23,7 @@ #include #include #include +#include #include "ModelLoader.h" #include "SafeRelease.hpp" diff --git a/samples/SimpleTexturedOpenGL/CMakeLists.txt b/samples/SimpleTexturedOpenGL/CMakeLists.txt index 70837e87c..a10a15101 100644 --- a/samples/SimpleTexturedOpenGL/CMakeLists.txt +++ b/samples/SimpleTexturedOpenGL/CMakeLists.txt @@ -21,6 +21,7 @@ INCLUDE_DIRECTORIES( ${OPENGL_INCLUDE_DIR} ${GLUT_INCLUDE_DIR} ${SAMPLES_SHARED_CODE_DIR} + ${Assimp_SOURCE_DIR}/contrib/utf8cpp/source ) LINK_DIRECTORIES( diff --git a/samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/src/model_loading.cpp b/samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/src/model_loading.cpp index 7d730a630..f6d3097fe 100644 --- a/samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/src/model_loading.cpp +++ b/samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/src/model_loading.cpp @@ -17,6 +17,7 @@ #include #include #include +#include #ifdef _MSC_VER #pragma warning(disable: 4100) // Disable warning 'unreferenced formal parameter' From 28ab0a094a66474f0379d004671c3d6a26457c38 Mon Sep 17 00:00:00 2001 From: julianknodt Date: Sun, 15 Oct 2023 22:03:31 -0700 Subject: [PATCH 03/16] Fix incorrect deg->radian conversion It seems that rotation matrices later expect radians. This conversion breaks it, and was validated on the conversion of `cesium_man.glb` --> `cesium_man.fbx` --- code/AssetLib/FBX/FBXConverter.cpp | 21 +++++++++++---------- code/AssetLib/FBX/FBXExporter.cpp | 10 ++++------ 2 files changed, 15 insertions(+), 16 deletions(-) diff --git a/code/AssetLib/FBX/FBXConverter.cpp b/code/AssetLib/FBX/FBXConverter.cpp index 498da43ca..3538e84a8 100644 --- a/code/AssetLib/FBX/FBXConverter.cpp +++ b/code/AssetLib/FBX/FBXConverter.cpp @@ -577,16 +577,17 @@ void FBXConverter::GetRotationMatrix(Model::RotOrder mode, const aiVector3D &rot bool is_id[3] = { true, true, true }; aiMatrix4x4 temp[3]; - if (std::fabs(rotation.z) > angle_epsilon) { - aiMatrix4x4::RotationZ(AI_DEG_TO_RAD(rotation.z), temp[2]); + const auto rot = AI_DEG_TO_RAD(rotation); + if (std::fabs(rot.z) > angle_epsilon) { + aiMatrix4x4::RotationZ(rot.z, temp[2]); is_id[2] = false; } - if (std::fabs(rotation.y) > angle_epsilon) { - aiMatrix4x4::RotationY(AI_DEG_TO_RAD(rotation.y), temp[1]); + if (std::fabs(rot.y) > angle_epsilon) { + aiMatrix4x4::RotationY(rot.y, temp[1]); is_id[1] = false; } - if (std::fabs(rotation.x) > angle_epsilon) { - aiMatrix4x4::RotationX(AI_DEG_TO_RAD(rotation.x), temp[0]); + if (std::fabs(rot.x) > angle_epsilon) { + aiMatrix4x4::RotationX(rot.x, temp[0]); is_id[0] = false; } @@ -3225,7 +3226,6 @@ aiNodeAnim* FBXConverter::GenerateSimpleNodeAnim(const std::string& name, aiVector3D defTranslate = PropertyGet(props, "Lcl Translation", aiVector3D(0.f, 0.f, 0.f)); aiVector3D defRotation = PropertyGet(props, "Lcl Rotation", aiVector3D(0.f, 0.f, 0.f)); aiVector3D defScale = PropertyGet(props, "Lcl Scaling", aiVector3D(1.f, 1.f, 1.f)); - aiQuaternion defQuat = EulerToQuaternion(defRotation, rotOrder); aiVectorKey* outTranslations = new aiVectorKey[keyCount]; aiQuatKey* outRotations = new aiQuatKey[keyCount]; @@ -3241,8 +3241,9 @@ aiNodeAnim* FBXConverter::GenerateSimpleNodeAnim(const std::string& name, } if (keyframeLists[TransformationComp_Rotation].size() > 0) { - InterpolateKeys(outRotations, keytimes, keyframeLists[TransformationComp_Rotation], defRotation, maxTime, minTime, rotOrder); + InterpolateKeys(outRotations, keytimes, keyframeLists[TransformationComp_Rotation], AI_DEG_TO_RAD(defRotation), maxTime, minTime, rotOrder); } else { + aiQuaternion defQuat = EulerToQuaternion(AI_DEG_TO_RAD(defRotation), rotOrder); for (size_t i = 0; i < keyCount; ++i) { outRotations[i].mTime = CONVERT_FBX_TIME(keytimes[i]) * anim_fps; outRotations[i].mValue = defQuat; @@ -3264,7 +3265,7 @@ aiNodeAnim* FBXConverter::GenerateSimpleNodeAnim(const std::string& name, const aiVector3D& preRotation = PropertyGet(props, "PreRotation", ok); if (ok && preRotation.SquareLength() > zero_epsilon) { - const aiQuaternion preQuat = EulerToQuaternion(preRotation, Model::RotOrder_EulerXYZ); + const aiQuaternion preQuat = EulerToQuaternion(AI_DEG_TO_RAD(preRotation), Model::RotOrder_EulerXYZ); for (size_t i = 0; i < keyCount; ++i) { outRotations[i].mValue = preQuat * outRotations[i].mValue; } @@ -3272,7 +3273,7 @@ aiNodeAnim* FBXConverter::GenerateSimpleNodeAnim(const std::string& name, const aiVector3D& postRotation = PropertyGet(props, "PostRotation", ok); if (ok && postRotation.SquareLength() > zero_epsilon) { - const aiQuaternion postQuat = EulerToQuaternion(postRotation, Model::RotOrder_EulerXYZ); + const aiQuaternion postQuat = EulerToQuaternion(AI_DEG_TO_RAD(postRotation), Model::RotOrder_EulerXYZ); for (size_t i = 0; i < keyCount; ++i) { outRotations[i].mValue = outRotations[i].mValue * postQuat; } diff --git a/code/AssetLib/FBX/FBXExporter.cpp b/code/AssetLib/FBX/FBXExporter.cpp index 9da713e5d..2ea505618 100644 --- a/code/AssetLib/FBX/FBXExporter.cpp +++ b/code/AssetLib/FBX/FBXExporter.cpp @@ -74,8 +74,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // https://code.blender.org/2013/08/fbx-binary-file-format-specification/ // https://wiki.blender.org/index.php/User:Mont29/Foundation/FBX_File_Structure -const ai_real DEG = ai_real( 57.29577951308232087679815481 ); // degrees per radian - using namespace Assimp; using namespace Assimp::FBX; @@ -2434,7 +2432,7 @@ void FBXExporter::WriteObjects () aiMatrix4x4 m(k.mValue.GetMatrix()); aiVector3D qs, qr, qt; m.Decompose(qs, qr, qt); - qr *= DEG; + qr = AI_RAD_TO_DEG(qr); xval.push_back(qr.x); yval.push_back(qr.y); zval.push_back(qr.z); @@ -2515,9 +2513,10 @@ void FBXExporter::WriteModelNode( ); } if (r != zero) { + r = AI_RAD_TO_DEG(r); p.AddP70( "Lcl Rotation", "Lcl Rotation", "", "A", - double(DEG*r.x), double(DEG*r.y), double(DEG*r.z) + double(r.x), double(r.y), double(r.z) ); } if (s != one) { @@ -2601,8 +2600,7 @@ void FBXExporter::WriteModelNodes( transform_chain.emplace_back(elem->first, t); break; case 'r': // rotation - r *= float(DEG); - transform_chain.emplace_back(elem->first, r); + transform_chain.emplace_back(elem->first, AI_RAD_TO_DEG(r)); break; case 's': // scale transform_chain.emplace_back(elem->first, s); From 0b0ec713f67d75bfd26317cc3e064acc518fe209 Mon Sep 17 00:00:00 2001 From: Kim Kulling Date: Thu, 9 Nov 2023 22:28:15 +0100 Subject: [PATCH 04/16] Fix empty mesh handling --- code/AssetLib/3DS/3DSLoader.cpp | 4 - code/AssetLib/3DS/3DSLoader.h | 3 +- code/AssetLib/FBX/FBXImporter.cpp | 2 +- code/AssetLib/IQM/IQMImporter.cpp | 7 - code/AssetLib/Obj/ObjFileImporter.cpp | 6 +- code/AssetLib/XGL/XGLLoader.cpp | 206 +++++++++++++------------- code/AssetLib/XGL/XGLLoader.h | 30 ++-- code/Common/Compression.cpp | 6 +- contrib/zlib/zconf.h.included | 19 ++- 9 files changed, 145 insertions(+), 138 deletions(-) diff --git a/code/AssetLib/3DS/3DSLoader.cpp b/code/AssetLib/3DS/3DSLoader.cpp index aa29956df..fc8758c2b 100644 --- a/code/AssetLib/3DS/3DSLoader.cpp +++ b/code/AssetLib/3DS/3DSLoader.cpp @@ -103,10 +103,6 @@ Discreet3DSImporter::Discreet3DSImporter() : // empty } -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -Discreet3DSImporter::~Discreet3DSImporter() = default; - // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool Discreet3DSImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { diff --git a/code/AssetLib/3DS/3DSLoader.h b/code/AssetLib/3DS/3DSLoader.h index 6bd73f412..c579507e0 100644 --- a/code/AssetLib/3DS/3DSLoader.h +++ b/code/AssetLib/3DS/3DSLoader.h @@ -59,7 +59,6 @@ struct aiNode; namespace Assimp { - using namespace D3DS; // --------------------------------------------------------------------------------- @@ -68,7 +67,7 @@ using namespace D3DS; class Discreet3DSImporter : public BaseImporter { public: Discreet3DSImporter(); - ~Discreet3DSImporter() override; + ~Discreet3DSImporter() override = default; // ------------------------------------------------------------------- /** Returns whether the class can handle the format of the given file. diff --git a/code/AssetLib/FBX/FBXImporter.cpp b/code/AssetLib/FBX/FBXImporter.cpp index 56e0f38e9..32631996e 100644 --- a/code/AssetLib/FBX/FBXImporter.cpp +++ b/code/AssetLib/FBX/FBXImporter.cpp @@ -95,7 +95,7 @@ FBXImporter::FBXImporter() = default; // Returns whether the class can handle the format of the given file. bool FBXImporter::CanRead(const std::string & pFile, IOSystem * pIOHandler, bool /*checkSig*/) const { // at least ASCII-FBX files usually have a 'FBX' somewhere in their head - static const char *tokens[] = { "fbx" }; + static const char *tokens[] = { " \n\r\n " }; return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); } diff --git a/code/AssetLib/IQM/IQMImporter.cpp b/code/AssetLib/IQM/IQMImporter.cpp index 139b490d8..392ed1193 100644 --- a/code/AssetLib/IQM/IQMImporter.cpp +++ b/code/AssetLib/IQM/IQMImporter.cpp @@ -100,13 +100,6 @@ bool IQMImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool c if (!pIOHandler) { return true; } - /* - * don't use CheckMagicToken because that checks with swapped bytes too, leading to false - * positives. This magic is not uint32_t, but char[4], so memcmp is the best way - - const char* tokens[] = {"3DMO", "3dmo"}; - return CheckMagicToken(pIOHandler,pFile,tokens,2,0,4); - */ std::unique_ptr pStream(pIOHandler->Open(pFile, "rb")); unsigned char data[15]; if (!pStream || 15 != pStream->Read(data, 1, 15)) { diff --git a/code/AssetLib/Obj/ObjFileImporter.cpp b/code/AssetLib/Obj/ObjFileImporter.cpp index 173ef2074..73924f86a 100644 --- a/code/AssetLib/Obj/ObjFileImporter.cpp +++ b/code/AssetLib/Obj/ObjFileImporter.cpp @@ -78,7 +78,9 @@ using namespace std; ObjFileImporter::ObjFileImporter() : m_Buffer(), m_pRootObject(nullptr), - m_strAbsPath(std::string(1, DefaultIOSystem().getOsSeparator())) {} + m_strAbsPath(std::string(1, DefaultIOSystem().getOsSeparator())) { + // empty +} // ------------------------------------------------------------------------------------------------ // Destructor. @@ -102,7 +104,7 @@ const aiImporterDesc *ObjFileImporter::GetInfo() const { // Obj-file import implementation void ObjFileImporter::InternReadFile(const std::string &file, aiScene *pScene, IOSystem *pIOHandler) { // Read file into memory - static const std::string mode = "rb"; + static constexpr char mode[] = "rb"; auto streamCloser = [&](IOStream *pStream) { pIOHandler->Close(pStream); }; diff --git a/code/AssetLib/XGL/XGLLoader.cpp b/code/AssetLib/XGL/XGLLoader.cpp index 04e303370..1d3cf9eb4 100644 --- a/code/AssetLib/XGL/XGLLoader.cpp +++ b/code/AssetLib/XGL/XGLLoader.cpp @@ -3,7 +3,7 @@ Open Asset Import Library (assimp) --------------------------------------------------------------------------- -Copyright (c) 2006-2022, assimp team +Copyright (c) 2006-2023, assimp team All rights reserved. @@ -56,62 +56,43 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -//#include -//#include -using namespace Assimp; +namespace Assimp { -namespace Assimp { // this has to be in here because LogFunctions is in ::Assimp +static constexpr uint32_t ErrorId = ~0u; template <> const char *LogFunctions::Prefix() { return "XGL: "; } -} // namespace Assimp - -static const aiImporterDesc desc = { - "XGL Importer", - "", - "", - "", - aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportCompressedFlavour, - 0, - 0, - 0, - 0, - "xgl zgl" -}; +static constexpr aiImporterDesc desc = { + "XGL Importer", "", "", "", + aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportCompressedFlavour, + 0, 0, 0, 0, "xgl zgl"}; // ------------------------------------------------------------------------------------------------ -// Constructor to be privately used by Importer -XGLImporter::XGLImporter() : - mXmlParser(nullptr), - m_scene(nullptr) { +XGLImporter::XGLImporter() : mXmlParser(nullptr), m_scene(nullptr) { // empty } // ------------------------------------------------------------------------------------------------ -// Destructor, private as well XGLImporter::~XGLImporter() { delete mXmlParser; } // ------------------------------------------------------------------------------------------------ -// Returns whether the class can handle the format of the given file. bool XGLImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { static const char *tokens[] = { "", "", "" }; return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); } // ------------------------------------------------------------------------------------------------ -// Get a list of all file extensions which are handled by this class const aiImporterDesc *XGLImporter::GetInfo() const { return &desc; } // ------------------------------------------------------------------------------------------------ -// Imports the given file into the given scene structure. void XGLImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) { #ifndef ASSIMP_BUILD_NO_COMPRESSED_XGL std::vector uncompressed; @@ -159,7 +140,7 @@ void XGLImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy std::vector &meshes = scope.meshes_linear; std::vector &materials = scope.materials_linear; - if (!meshes.size() || !materials.size()) { + if (meshes.empty() || materials.empty()) { ThrowException("failed to extract data from XGL file, no meshes loaded"); } @@ -199,9 +180,10 @@ void XGLImporter::ReadWorld(XmlNode &node, TempScope &scope) { } aiNode *const nd = ReadObject(node, scope); - if (!nd) { + if (nd == nullptr) { ThrowException("failure reading "); } + if (nd->mName.length == 0) { nd->mName.Set("WORLD"); } @@ -254,15 +236,19 @@ aiNode *XGLImporter::ReadObject(XmlNode &node, TempScope &scope) { const std::string &s = ai_stdStrToLower(child.name()); if (s == "mesh") { const size_t prev = scope.meshes_linear.size(); - bool empty; - if (ReadMesh(child, scope, empty)) { + if (ReadMesh(child, scope)) { const size_t newc = scope.meshes_linear.size(); for (size_t i = 0; i < newc - prev; ++i) { meshes.push_back(static_cast(i + prev)); } + } else { + printf("skipping empty mesh\n"); } } else if (s == "mat") { - ReadMaterial(child, scope); + const uint32_t matId = ReadMaterial(child, scope); + if (matId == ErrorId) { + ThrowException("Invalid material id detected."); + } } else if (s == "object") { children.push_back(ReadObject(child, scope)); } else if (s == "objectref") { @@ -438,18 +424,25 @@ aiMesh *XGLImporter::ToOutputMesh(const TempMaterialMesh &m) { return mesh.release(); } -// ------------------------------------------------------------------------------------------------ -bool XGLImporter::ReadMesh(XmlNode &node, TempScope &scope, bool &empty) { - TempMesh t; +// ------------------------------------------------------------------------------------------------ +inline static unsigned int generateMeshId(unsigned int meshId, bool nor, bool uv) { + unsigned int currentMeshId = meshId | ((nor ? 1 : 0) << 31) | ((uv ? 1 : 0) << 30); + return currentMeshId; +} + +// ------------------------------------------------------------------------------------------------ +bool XGLImporter::ReadMesh(XmlNode &node, TempScope &scope) { + TempMesh t; + uint32_t matId = 99999; + bool mesh_created = false; std::map bymat; const unsigned int mesh_id = ReadIDAttr(node); - bool empty_mesh = true; for (XmlNode &child : node.children()) { const std::string &s = ai_stdStrToLower(child.name()); if (s == "mat") { - ReadMaterial(child, scope); + matId = ReadMaterial(child, scope); } else if (s == "p") { pugi::xml_attribute attr = child.attribute("ID"); if (attr.empty()) { @@ -477,66 +470,41 @@ bool XGLImporter::ReadMesh(XmlNode &node, TempScope &scope, bool &empty) { } else if (s == "f" || s == "l" || s == "p") { const unsigned int vcount = s == "f" ? 3 : (s == "l" ? 2 : 1); - unsigned int mid = ~0u; - TempFace tf[3]; + unsigned int meshId = ErrorId; + TempFace tempFace[3] = {}; bool has[3] = { false }; - for (XmlNode &sub_child : child.children()) { - const std::string &scn = ai_stdStrToLower(sub_child.name()); - if (scn == "fv1" || scn == "lv1" || scn == "pv1") { - ReadFaceVertex(sub_child, t, tf[0]); - has[0] = true; - } else if (scn == "fv2" || scn == "lv2") { - ReadFaceVertex(sub_child, t, tf[1]); - has[1] = true; - } else if (scn == "fv3") { - ReadFaceVertex(sub_child, t, tf[2]); - has[2] = true; - } else if (scn == "mat") { - if (mid != ~0u) { - LogWarn("only one material tag allowed per "); - } - mid = ResolveMaterialRef(sub_child, scope); - } else if (scn == "matref") { - if (mid != ~0u) { - LogWarn("only one material tag allowed per "); - } - mid = ResolveMaterialRef(sub_child, scope); - } - } - if (has[0] || has[1] || has[2]) { - empty_mesh = false; - } - - if (mid == ~0u) { + meshId = ReadVertices(child, t, tempFace, has, meshId, scope); + if (meshId == ErrorId) { ThrowException("missing material index"); } - bool nor = false; - bool uv = false; + bool nor = false, uv = false; for (unsigned int i = 0; i < vcount; ++i) { if (!has[i]) { ThrowException("missing face vertex data"); } - nor = nor || tf[i].has_normal; - uv = uv || tf[i].has_uv; + nor = nor || tempFace[i].has_normal; + uv = uv || tempFace[i].has_uv; } - if (mid >= (1 << 30)) { + if (meshId >= (1 << 30)) { LogWarn("material indices exhausted, this may cause errors in the output"); } - unsigned int meshId = mid | ((nor ? 1 : 0) << 31) | ((uv ? 1 : 0) << 30); + const unsigned int currentMeshId = generateMeshId(meshId, nor, uv); - TempMaterialMesh &mesh = bymat[meshId]; - mesh.matid = mid; + // Generate the temp mesh + TempMaterialMesh &mesh = bymat[currentMeshId]; + mesh.matid = meshId; + mesh_created = true; for (unsigned int i = 0; i < vcount; ++i) { - mesh.positions.push_back(tf[i].pos); + mesh.positions.push_back(tempFace[i].pos); if (nor) { - mesh.normals.push_back(tf[i].normal); + mesh.normals.push_back(tempFace[i].normal); } if (uv) { - mesh.uvs.push_back(tf[i].uv); + mesh.uvs.push_back(tempFace[i].uv); } mesh.pflags |= 1 << (vcount - 1); @@ -546,25 +514,59 @@ bool XGLImporter::ReadMesh(XmlNode &node, TempScope &scope, bool &empty) { } } - // finally extract output meshes and add them to the scope - using pairt = std::pair; - for (const pairt &p : bymat) { - aiMesh *const m = ToOutputMesh(p.second); - scope.meshes_linear.push_back(m); - - // if this is a definition, keep it on the stack - if (mesh_id != ~0u) { - scope.meshes.insert(std::pair(mesh_id, m)); - } - } - if (empty_mesh) { - LogWarn("Mesh is empty, skipping."); - empty = empty_mesh; - return false; + if (!mesh_created) { + TempMaterialMesh &mesh = bymat[mesh_id]; + mesh.matid = matId; } + // finally extract output meshes and add them to the scope + AppendOutputMeshes(bymat, scope, mesh_id); + // no id == not a reference, insert this mesh right *here* - return mesh_id == ~0u; + return mesh_id == ErrorId; +} + +// ---------------------------------------------------------------------------------------------- +void XGLImporter::AppendOutputMeshes(std::map bymat, TempScope &scope, + const unsigned int mesh_id) { + using pairt = std::pair; + for (const pairt &p : bymat) { + aiMesh *const m = ToOutputMesh(p.second); + scope.meshes_linear.push_back(m); + + // if this is a definition, keep it on the stack + if (mesh_id != ErrorId) { + scope.meshes.insert(std::pair(mesh_id, m)); + } + } +} + +// ---------------------------------------------------------------------------------------------- +unsigned int XGLImporter::ReadVertices(XmlNode &child, TempMesh t, TempFace *tf, bool *has, unsigned int mid, TempScope &scope) { + for (XmlNode &sub_child : child.children()) { + const std::string &scn = ai_stdStrToLower(sub_child.name()); + if (scn == "fv1" || scn == "lv1" || scn == "pv1") { + ReadFaceVertex(sub_child, t, tf[0]); + has[0] = true; + } else if (scn == "fv2" || scn == "lv2") { + ReadFaceVertex(sub_child, t, tf[1]); + has[1] = true; + } else if (scn == "fv3") { + ReadFaceVertex(sub_child, t, tf[2]); + has[2] = true; + } else if (scn == "mat") { + if (mid != ErrorId) { + LogWarn("only one material tag allowed per "); + } + mid = ResolveMaterialRef(sub_child, scope); + } else if (scn == "matref") { + if (mid != ErrorId) { + LogWarn("only one material tag allowed per "); + } + mid = ResolveMaterialRef(sub_child, scope); + } + } + return mid; } // ---------------------------------------------------------------------------------------------- @@ -598,10 +600,10 @@ unsigned int XGLImporter::ResolveMaterialRef(XmlNode &node, TempScope &scope) { } // ------------------------------------------------------------------------------------------------ -void XGLImporter::ReadMaterial(XmlNode &node, TempScope &scope) { +unsigned int XGLImporter::ReadMaterial(XmlNode &node, TempScope &scope) { const unsigned int mat_id = ReadIDAttr(node); - auto *mat(new aiMaterial); + auto *mat = new aiMaterial; for (XmlNode &child : node.children()) { const std::string &s = ai_stdStrToLower(child.name()); if (s == "amb") { @@ -627,6 +629,8 @@ void XGLImporter::ReadMaterial(XmlNode &node, TempScope &scope) { scope.materials[mat_id] = mat; scope.materials_linear.push_back(mat); + + return mat_id; } // ---------------------------------------------------------------------------------------------- @@ -683,7 +687,7 @@ unsigned int XGLImporter::ReadIDAttr(XmlNode &node) { } } - return ~0u; + return ErrorId; } // ------------------------------------------------------------------------------------------------ @@ -712,14 +716,14 @@ unsigned int XGLImporter::ReadIndexFromText(XmlNode &node) { const char *s = v.c_str(); if (!SkipSpaces(&s)) { LogError("unexpected EOL, failed to parse index element"); - return ~0u; + return ErrorId; } - const char *se; + const char *se = nullptr; const unsigned int t = strtoul10(s, &se); if (se == s) { LogError("failed to read index"); - return ~0u; + return ErrorId; } return t; @@ -786,4 +790,6 @@ aiColor3D XGLImporter::ReadCol3(XmlNode &node) { return aiColor3D(v.x, v.y, v.z); } +} // namespace Assimp + #endif // ASSIMP_BUILD_NO_XGL_IMPORTER diff --git a/code/AssetLib/XGL/XGLLoader.h b/code/AssetLib/XGL/XGLLoader.h index ae7ccddc2..2f0f14200 100644 --- a/code/AssetLib/XGL/XGLLoader.h +++ b/code/AssetLib/XGL/XGLLoader.h @@ -69,12 +69,14 @@ namespace Assimp { */ class XGLImporter : public BaseImporter, public LogFunctions { public: + /// @brief The class constructor. XGLImporter(); + + /// @brief The class destructor. ~XGLImporter() override; - // ------------------------------------------------------------------- - /** Returns whether the class can handle the format of the given file. - * See BaseImporter::CanRead() for details. */ + /// @brief Returns whether the class can handle the format of the given file. + /// @see BaseImporter::CanRead() for details. */ bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const override; @@ -92,10 +94,7 @@ protected: private: struct TempScope { - TempScope() : - light() { - // empty - } + TempScope() : light() {} ~TempScope() { for (aiMesh *m : meshes_linear) { @@ -145,9 +144,7 @@ private: }; struct TempMaterialMesh { - TempMaterialMesh() : - pflags(), - matid() { + TempMaterialMesh() : pflags(), matid() { // empty } @@ -160,9 +157,7 @@ private: }; struct TempFace { - TempFace() : - has_uv(), - has_normal() { + TempFace() : has_uv(), has_normal() { // empty } @@ -175,26 +170,25 @@ private: private: void Cleanup(); - std::string GetElementName(); bool ReadElement(); bool ReadElementUpToClosing(const char *closetag); bool SkipToText(); unsigned int ReadIDAttr(XmlNode &node); - void ReadWorld(XmlNode &node, TempScope &scope); void ReadLighting(XmlNode &node, TempScope &scope); aiLight *ReadDirectionalLight(XmlNode &node); aiNode *ReadObject(XmlNode &node, TempScope &scope); - bool ReadMesh(XmlNode &node, TempScope &scope, bool &empty); - void ReadMaterial(XmlNode &node, TempScope &scope); + bool ReadMesh(XmlNode &node, TempScope &scope); + void AppendOutputMeshes(std::map bymat, TempScope &scope, const unsigned int mesh_id); + unsigned int ReadVertices(XmlNode &child, TempMesh t, TempFace *tf, bool *has, unsigned int mid, TempScope &scope); + unsigned int ReadMaterial(XmlNode &node, TempScope &scope); aiVector2D ReadVec2(XmlNode &node); aiVector3D ReadVec3(XmlNode &node); aiColor3D ReadCol3(XmlNode &node); aiMatrix4x4 ReadTrafo(XmlNode &node); unsigned int ReadIndexFromText(XmlNode &node); float ReadFloat(XmlNode &node); - aiMesh *ToOutputMesh(const TempMaterialMesh &m); void ReadFaceVertex(XmlNode &node, const TempMesh &t, TempFace &out); unsigned int ResolveMaterialRef(XmlNode &node, TempScope &scope); diff --git a/code/Common/Compression.cpp b/code/Common/Compression.cpp index 3bf306dee..a6a7be7e4 100644 --- a/code/Common/Compression.cpp +++ b/code/Common/Compression.cpp @@ -66,6 +66,10 @@ Compression::Compression() : Compression::~Compression() { ai_assert(mImpl != nullptr); + if (mImpl->mOpen) { + close(); + } + delete mImpl; } @@ -124,7 +128,7 @@ static int getFlushMode(Compression::FlushMode flush) { return z_flush; } -constexpr size_t MYBLOCK = 32786; +static constexpr size_t MYBLOCK = 32786; size_t Compression::decompress(const void *data, size_t in, std::vector &uncompressed) { ai_assert(mImpl != nullptr); diff --git a/contrib/zlib/zconf.h.included b/contrib/zlib/zconf.h.included index 352f552b8..2271dc5f5 100644 --- a/contrib/zlib/zconf.h.included +++ b/contrib/zlib/zconf.h.included @@ -40,6 +40,9 @@ # define crc32 z_crc32 # define crc32_combine z_crc32_combine # define crc32_combine64 z_crc32_combine64 +# define crc32_combine_gen z_crc32_combine_gen +# define crc32_combine_gen64 z_crc32_combine_gen64 +# define crc32_combine_op z_crc32_combine_op # define crc32_z z_crc32_z # define deflate z_deflate # define deflateBound z_deflateBound @@ -351,6 +354,9 @@ # ifdef FAR # undef FAR # endif +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif # include /* No need for _export, use ZLIB.DEF instead. */ /* For complete Windows compatibility, use WINAPI, not __stdcall. */ @@ -469,11 +475,18 @@ typedef uLong FAR uLongf; # undef _LARGEFILE64_SOURCE #endif -#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H) -# define Z_HAVE_UNISTD_H +#ifndef Z_HAVE_UNISTD_H +# ifdef __WATCOMC__ +# define Z_HAVE_UNISTD_H +# endif +#endif +#ifndef Z_HAVE_UNISTD_H +# if defined(_LARGEFILE64_SOURCE) && !defined(_WIN32) +# define Z_HAVE_UNISTD_H +# endif #endif #ifndef Z_SOLO -# if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) +# if defined(Z_HAVE_UNISTD_H) # include /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ # ifdef VMS # include /* for off_t */ From aa3abb3c06493e10ed46a0f800ed44cce7b05b3b Mon Sep 17 00:00:00 2001 From: Kim Kulling Date: Thu, 9 Nov 2023 22:42:24 +0100 Subject: [PATCH 05/16] Fix warning: remove printf --- code/AssetLib/XGL/XGLLoader.cpp | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/code/AssetLib/XGL/XGLLoader.cpp b/code/AssetLib/XGL/XGLLoader.cpp index 1d3cf9eb4..4c66d33b4 100644 --- a/code/AssetLib/XGL/XGLLoader.cpp +++ b/code/AssetLib/XGL/XGLLoader.cpp @@ -241,9 +241,7 @@ aiNode *XGLImporter::ReadObject(XmlNode &node, TempScope &scope) { for (size_t i = 0; i < newc - prev; ++i) { meshes.push_back(static_cast(i + prev)); } - } else { - printf("skipping empty mesh\n"); - } + } } else if (s == "mat") { const uint32_t matId = ReadMaterial(child, scope); if (matId == ErrorId) { From 8cf2d6e588aa1ebadcad75b28dcb1568c6627a91 Mon Sep 17 00:00:00 2001 From: Kim Kulling Date: Sat, 11 Nov 2023 09:59:42 +0100 Subject: [PATCH 06/16] Refactoring: Some cleanups --- code/AssetLib/3DS/3DSLoader.cpp | 2 +- code/AssetLib/3MF/D3MFImporter.cpp | 2 +- code/AssetLib/AC/ACLoader.cpp | 2 +- code/AssetLib/AMF/AMFImporter.cpp | 2 +- code/AssetLib/AMF/AMFImporter.hpp | 103 +++--- code/AssetLib/ASE/ASELoader.cpp | 2 +- code/AssetLib/Assbin/AssbinLoader.cpp | 2 +- code/AssetLib/B3D/B3DImporter.cpp | 2 +- code/AssetLib/BVH/BVHLoader.cpp | 2 +- code/AssetLib/Blender/BlenderLoader.cpp | 7 +- code/AssetLib/COB/COBLoader.cpp | 12 +- code/AssetLib/COB/COBLoader.h | 16 +- code/AssetLib/CSM/CSMLoader.cpp | 15 +- code/AssetLib/CSM/CSMLoader.h | 7 +- code/AssetLib/Collada/ColladaLoader.cpp | 6 +- code/AssetLib/Collada/ColladaLoader.h | 2 +- code/AssetLib/DXF/DXFLoader.cpp | 4 +- code/AssetLib/FBX/FBXImporter.cpp | 29 +- code/AssetLib/FBX/FBXImporter.h | 2 +- code/AssetLib/HMP/HMPLoader.cpp | 2 +- code/AssetLib/IFC/IFCLoader.cpp | 2 +- code/AssetLib/IQM/IQMImporter.cpp | 3 +- code/AssetLib/Irr/IRRLoader.cpp | 2 +- code/AssetLib/Irr/IRRMeshLoader.cpp | 2 +- code/AssetLib/LWO/LWOBLoader.cpp | 387 ++++++++++------------ code/AssetLib/LWS/LWSLoader.cpp | 6 +- code/AssetLib/LWS/LWSLoader.h | 2 +- code/AssetLib/M3D/M3DImporter.cpp | 2 +- code/AssetLib/MD2/MD2Loader.cpp | 11 +- code/AssetLib/MD2/MD2Loader.h | 2 +- code/AssetLib/MD3/MD3Loader.cpp | 2 +- code/AssetLib/MD5/MD5Loader.cpp | 6 +- code/AssetLib/MD5/MD5Loader.h | 2 +- code/AssetLib/MDC/MDCLoader.cpp | 6 +- code/AssetLib/MDC/MDCLoader.h | 2 +- code/AssetLib/MDL/MDLLoader.cpp | 6 +- code/AssetLib/MDL/MDLLoader.h | 11 +- code/AssetLib/MMD/MMDImporter.cpp | 6 +- code/AssetLib/MMD/MMDImporter.h | 26 +- code/AssetLib/MS3D/MS3DLoader.cpp | 5 +- code/AssetLib/MS3D/MS3DLoader.h | 3 +- code/AssetLib/NDO/NDOLoader.cpp | 12 +- code/AssetLib/NDO/NDOLoader.h | 4 +- code/AssetLib/NFF/NFFLoader.cpp | 35 +- code/AssetLib/NFF/NFFLoader.h | 4 +- code/AssetLib/OFF/OFFLoader.cpp | 243 +++++++------- code/AssetLib/OFF/OFFLoader.h | 4 +- code/AssetLib/Obj/ObjFileImporter.cpp | 7 +- code/AssetLib/Ogre/OgreImporter.cpp | 2 +- code/AssetLib/OpenGEX/OpenGEXImporter.cpp | 72 ++-- code/AssetLib/Ply/PlyLoader.cpp | 54 ++- code/AssetLib/Ply/PlyLoader.h | 2 +- code/AssetLib/Q3BSP/Q3BSPFileImporter.cpp | 9 +- code/AssetLib/Q3BSP/Q3BSPFileImporter.h | 1 + code/AssetLib/Q3D/Q3DLoader.cpp | 25 +- code/AssetLib/Raw/RawLoader.cpp | 14 +- code/AssetLib/Raw/RawLoader.h | 4 +- code/AssetLib/SIB/SIBImporter.cpp | 17 +- code/AssetLib/SIB/SIBImporter.h | 4 +- code/AssetLib/Unreal/UnrealLoader.cpp | 2 +- code/AssetLib/glTF/glTFImporter.cpp | 6 +- code/AssetLib/glTF2/glTF2Importer.cpp | 2 +- include/assimp/BaseImporter.h | 4 + include/assimp/ParsingUtils.h | 1 - 64 files changed, 557 insertions(+), 686 deletions(-) diff --git a/code/AssetLib/3DS/3DSLoader.cpp b/code/AssetLib/3DS/3DSLoader.cpp index fc8758c2b..bec77ff23 100644 --- a/code/AssetLib/3DS/3DSLoader.cpp +++ b/code/AssetLib/3DS/3DSLoader.cpp @@ -56,7 +56,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Discreet 3DS Importer", "", "", diff --git a/code/AssetLib/3MF/D3MFImporter.cpp b/code/AssetLib/3MF/D3MFImporter.cpp index 5d9644fa5..add33bb79 100644 --- a/code/AssetLib/3MF/D3MFImporter.cpp +++ b/code/AssetLib/3MF/D3MFImporter.cpp @@ -68,7 +68,7 @@ namespace Assimp { using namespace D3MF; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "3mf Importer", "", "", diff --git a/code/AssetLib/AC/ACLoader.cpp b/code/AssetLib/AC/ACLoader.cpp index e93fba5f0..4c6c48737 100644 --- a/code/AssetLib/AC/ACLoader.cpp +++ b/code/AssetLib/AC/ACLoader.cpp @@ -62,7 +62,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "AC3D Importer", "", "", diff --git a/code/AssetLib/AMF/AMFImporter.cpp b/code/AssetLib/AMF/AMFImporter.cpp index ff581b492..eabdb35e1 100644 --- a/code/AssetLib/AMF/AMFImporter.cpp +++ b/code/AssetLib/AMF/AMFImporter.cpp @@ -53,7 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. namespace Assimp { -const aiImporterDesc AMFImporter::Description = { +static constexpr aiImporterDesc Description = { "Additive manufacturing file format(AMF) Importer", "smalcom", "", diff --git a/code/AssetLib/AMF/AMFImporter.hpp b/code/AssetLib/AMF/AMFImporter.hpp index 27f733043..fbaf4fc6d 100644 --- a/code/AssetLib/AMF/AMFImporter.hpp +++ b/code/AssetLib/AMF/AMFImporter.hpp @@ -98,8 +98,12 @@ namespace Assimp { /// old - and children , , , , , /// class AMFImporter : public BaseImporter { -private: - struct SPP_Material; // forward declaration + using AMFMetaDataArray = std::vector; + using MeshArray = std::vector; + using NodeArray = std::vector; + +public: + struct SPP_Material; /// Data type for post-processing step. More suitable container for part of material's composition. struct SPP_Composite { @@ -107,22 +111,6 @@ private: std::string Formula; ///< Formula for calculating ratio of \ref Material. }; - /// \struct SPP_Material - /// Data type for post-processing step. More suitable container for material. - struct SPP_Material { - std::string ID; ///< Material ID. - std::list Metadata; ///< Metadata of material. - AMFColor *Color; ///< Color of material. - std::list Composition; ///< List of child materials if current material is composition of few another. - - /// Return color calculated for specified coordinate. - /// \param [in] pX - "x" coordinate. - /// \param [in] pY - "y" coordinate. - /// \param [in] pZ - "z" coordinate. - /// \return calculated color. - aiColor4D GetColor(const float pX, const float pY, const float pZ) const; - }; - /// Data type for post-processing step. More suitable container for texture. struct SPP_Texture { std::string ID; @@ -139,10 +127,52 @@ private: const AMFTexMap *TexMap; ///< Face texture mapping data. Equal to nullptr if texture mapping is not set for the face. }; - using AMFMetaDataArray = std::vector; - using MeshArray = std::vector; - using NodeArray = std::vector; + /// Data type for post-processing step. More suitable container for material. + struct SPP_Material { + std::string ID; ///< Material ID. + std::list Metadata; ///< Metadata of material. + AMFColor *Color; ///< Color of material. + std::list Composition; ///< List of child materials if current material is composition of few another. + /// Return color calculated for specified coordinate. + /// \param [in] pX - "x" coordinate. + /// \param [in] pY - "y" coordinate. + /// \param [in] pZ - "z" coordinate. + /// \return calculated color. + aiColor4D GetColor(const float pX, const float pY, const float pZ) const; + }; + + /// Default constructor. + AMFImporter() AI_NO_EXCEPT; + + /// Default destructor. + ~AMFImporter() override; + + /// 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 thrown if trouble will found. + /// \param [in] pFile - name of file to be parsed. + /// \param [in] pIOHandler - pointer to IO helper object. + void ParseFile(const std::string &pFile, IOSystem *pIOHandler); + void ParseHelper_Node_Enter(AMFNodeElementBase *child); + void ParseHelper_Node_Exit(); + bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool pCheckSig) const override; + void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override; + const aiImporterDesc *GetInfo() const override; + bool Find_NodeElement(const std::string &pID, const AMFNodeElementBase::EType pType, AMFNodeElementBase **pNodeElement) const; + bool Find_ConvertedNode(const std::string &pID, NodeArray &nodeArray, aiNode **pNode) const; + bool Find_ConvertedMaterial(const std::string &pID, const SPP_Material **pConvertedMaterial) const; + AI_WONT_RETURN void Throw_CloseNotFound(const std::string &nodeName) AI_WONT_RETURN_SUFFIX; + AI_WONT_RETURN void Throw_IncorrectAttr(const std::string &nodeName, const std::string &pAttrName) AI_WONT_RETURN_SUFFIX; + AI_WONT_RETURN void Throw_IncorrectAttrValue(const std::string &nodeName, const std::string &pAttrName) AI_WONT_RETURN_SUFFIX; + AI_WONT_RETURN void Throw_MoreThanOnceDefined(const std::string &nodeName, const std::string &pNodeType, const std::string &pDescription) AI_WONT_RETURN_SUFFIX; + AI_WONT_RETURN void Throw_ID_NotFound(const std::string &pID) const AI_WONT_RETURN_SUFFIX; + void XML_CheckNode_MustHaveChildren(pugi::xml_node &node); + bool XML_SearchNode(const std::string &nodeName); + void ParseHelper_FixTruncatedFloatString(const char *pInStr, std::string &pOutString); + AMFImporter(const AMFImporter &pScene) = delete; + AMFImporter &operator=(const AMFImporter &pScene) = delete; + +private: /// Clear all temporary data. void Clear(); @@ -262,40 +292,9 @@ private: /// \param [in] pUseOldName - if true then use old name of node(and children) - , instead of new name - . void ParseNode_TexMap(XmlNode &node, const bool pUseOldName = false); -public: - /// Default constructor. - AMFImporter() AI_NO_EXCEPT; - /// Default destructor. - ~AMFImporter() override; - - /// 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 thrown if trouble will found. - /// \param [in] pFile - name of file to be parsed. - /// \param [in] pIOHandler - pointer to IO helper object. - void ParseFile(const std::string &pFile, IOSystem *pIOHandler); - void ParseHelper_Node_Enter(AMFNodeElementBase *child); - void ParseHelper_Node_Exit(); - bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool pCheckSig) const override; - void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override; - const aiImporterDesc *GetInfo() const override; - bool Find_NodeElement(const std::string &pID, const AMFNodeElementBase::EType pType, AMFNodeElementBase **pNodeElement) const; - bool Find_ConvertedNode(const std::string &pID, NodeArray &nodeArray, aiNode **pNode) const; - bool Find_ConvertedMaterial(const std::string &pID, const SPP_Material **pConvertedMaterial) const; - AI_WONT_RETURN void Throw_CloseNotFound(const std::string &nodeName) AI_WONT_RETURN_SUFFIX; - AI_WONT_RETURN void Throw_IncorrectAttr(const std::string &nodeName, const std::string &pAttrName) AI_WONT_RETURN_SUFFIX; - AI_WONT_RETURN void Throw_IncorrectAttrValue(const std::string &nodeName, const std::string &pAttrName) AI_WONT_RETURN_SUFFIX; - AI_WONT_RETURN void Throw_MoreThanOnceDefined(const std::string &nodeName, const std::string &pNodeType, const std::string &pDescription) AI_WONT_RETURN_SUFFIX; - AI_WONT_RETURN void Throw_ID_NotFound(const std::string &pID) const AI_WONT_RETURN_SUFFIX; - void XML_CheckNode_MustHaveChildren(pugi::xml_node &node); - bool XML_SearchNode(const std::string &nodeName); - void ParseHelper_FixTruncatedFloatString(const char *pInStr, std::string &pOutString); - AMFImporter(const AMFImporter &pScene) = delete; - AMFImporter &operator=(const AMFImporter &pScene) = delete; private: - static const aiImporterDesc Description; - AMFNodeElementBase *mNodeElement_Cur; ///< Current element. std::list mNodeElement_List; ///< All elements of scene graph. XmlParser *mXmlParser; diff --git a/code/AssetLib/ASE/ASELoader.cpp b/code/AssetLib/ASE/ASELoader.cpp index 4617c9ed4..db34b8ac4 100644 --- a/code/AssetLib/ASE/ASELoader.cpp +++ b/code/AssetLib/ASE/ASELoader.cpp @@ -66,7 +66,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; using namespace Assimp::ASE; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "ASE Importer", "", "", diff --git a/code/AssetLib/Assbin/AssbinLoader.cpp b/code/AssetLib/Assbin/AssbinLoader.cpp index f7b35636c..6995ea976 100644 --- a/code/AssetLib/Assbin/AssbinLoader.cpp +++ b/code/AssetLib/Assbin/AssbinLoader.cpp @@ -65,7 +65,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Assimp Binary Importer", "Gargaj / Conspiracy", "", diff --git a/code/AssetLib/B3D/B3DImporter.cpp b/code/AssetLib/B3D/B3DImporter.cpp index bf8145798..6e0b8a85b 100644 --- a/code/AssetLib/B3D/B3DImporter.cpp +++ b/code/AssetLib/B3D/B3DImporter.cpp @@ -62,7 +62,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; using namespace std; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "BlitzBasic 3D Importer", "", "", diff --git a/code/AssetLib/BVH/BVHLoader.cpp b/code/AssetLib/BVH/BVHLoader.cpp index d92887c9e..990eef8c7 100644 --- a/code/AssetLib/BVH/BVHLoader.cpp +++ b/code/AssetLib/BVH/BVHLoader.cpp @@ -58,7 +58,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; using namespace Assimp::Formatter; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "BVH Importer (MoCap)", "", "", diff --git a/code/AssetLib/Blender/BlenderLoader.cpp b/code/AssetLib/Blender/BlenderLoader.cpp index 5c6e7bc5b..35b35f08d 100644 --- a/code/AssetLib/Blender/BlenderLoader.cpp +++ b/code/AssetLib/Blender/BlenderLoader.cpp @@ -69,11 +69,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // zlib is needed for compressed blend files #ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND #include "Common/Compression.h" -/* #ifdef ASSIMP_BUILD_NO_OWN_ZLIB -# include -# else -# include "../contrib/zlib/zlib.h" -# endif*/ #endif namespace Assimp { @@ -89,7 +84,7 @@ using namespace Assimp; using namespace Assimp::Blender; using namespace Assimp::Formatter; -static const aiImporterDesc blenderDesc = { +static constexpr aiImporterDesc blenderDesc = { "Blender 3D Importer (http://www.blender3d.org)", "", "", diff --git a/code/AssetLib/COB/COBLoader.cpp b/code/AssetLib/COB/COBLoader.cpp index 20df53f75..dc0199263 100644 --- a/code/AssetLib/COB/COBLoader.cpp +++ b/code/AssetLib/COB/COBLoader.cpp @@ -65,7 +65,7 @@ using namespace Assimp; using namespace Assimp::COB; using namespace Assimp::Formatter; -static const float units[] = { +static constexpr float units[] = { 1000.f, 100.f, 1.f, @@ -76,7 +76,7 @@ static const float units[] = { 1.f / 1609.344f }; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "TrueSpace Object Importer", "", "", @@ -89,14 +89,6 @@ static const aiImporterDesc desc = { "cob scn" }; -// ------------------------------------------------------------------------------------------------ -// Constructor to be privately used by Importer -COBImporter::COBImporter() = default; - -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -COBImporter::~COBImporter() = default; - // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool COBImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { diff --git a/code/AssetLib/COB/COBLoader.h b/code/AssetLib/COB/COBLoader.h index e6eb96dc1..a9755f5d7 100644 --- a/code/AssetLib/COB/COBLoader.h +++ b/code/AssetLib/COB/COBLoader.h @@ -56,16 +56,16 @@ class LineSplitter; // TinyFormatter.h namespace Formatter { -template -class basic_formatter; -typedef class basic_formatter, std::allocator> format; + template + class basic_formatter; + typedef class basic_formatter, std::allocator> format; } // namespace Formatter // COBScene.h namespace COB { -struct ChunkInfo; -struct Node; -struct Scene; + struct ChunkInfo; + struct Node; + struct Scene; } // namespace COB // ------------------------------------------------------------------------------------------- @@ -75,8 +75,8 @@ struct Scene; // ------------------------------------------------------------------------------------------- class COBImporter : public BaseImporter { public: - COBImporter(); - ~COBImporter() override; + COBImporter() = default; + ~COBImporter() override = default; // -------------------- bool CanRead(const std::string &pFile, IOSystem *pIOHandler, diff --git a/code/AssetLib/CSM/CSMLoader.cpp b/code/AssetLib/CSM/CSMLoader.cpp index db152f453..20f2343f5 100644 --- a/code/AssetLib/CSM/CSMLoader.cpp +++ b/code/AssetLib/CSM/CSMLoader.cpp @@ -44,9 +44,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. /** @file CSMLoader.cpp * Implementation of the CSM importer class. */ - - - #ifndef ASSIMP_BUILD_NO_CSM_IMPORTER #include "CSMLoader.h" @@ -63,7 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "CharacterStudio Motion Importer (MoCap)", "", "", @@ -79,13 +76,9 @@ static const aiImporterDesc desc = { // ------------------------------------------------------------------------------------------------ // Constructor to be privately used by Importer -CSMImporter::CSMImporter() -: noSkeletonMesh() -{} - -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -CSMImporter::~CSMImporter() = default; +CSMImporter::CSMImporter() : noSkeletonMesh(){ + // empty +} // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. diff --git a/code/AssetLib/CSM/CSMLoader.h b/code/AssetLib/CSM/CSMLoader.h index e9c4cd5ee..fc9017d17 100644 --- a/code/AssetLib/CSM/CSMLoader.h +++ b/code/AssetLib/CSM/CSMLoader.h @@ -61,7 +61,7 @@ namespace Assimp { class CSMImporter : public BaseImporter { public: CSMImporter(); - ~CSMImporter() override; + ~CSMImporter() override = default; // ------------------------------------------------------------------- bool CanRead(const std::string &pFile, IOSystem *pIOHandler, @@ -81,9 +81,8 @@ protected: private: bool noSkeletonMesh; -}; // end of class CSMImporter +}; -} // end of namespace Assimp +} // namespace Assimp #endif // AI_AC3DIMPORTER_H_INC - diff --git a/code/AssetLib/Collada/ColladaLoader.cpp b/code/AssetLib/Collada/ColladaLoader.cpp index e1f19a5ed..41e529de0 100644 --- a/code/AssetLib/Collada/ColladaLoader.cpp +++ b/code/AssetLib/Collada/ColladaLoader.cpp @@ -64,7 +64,7 @@ namespace Assimp { using namespace Assimp::Formatter; using namespace Assimp::Collada; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Collada Importer", "", "", @@ -101,10 +101,6 @@ ColladaLoader::ColladaLoader() : // empty } -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -ColladaLoader::~ColladaLoader() = default; - // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool ColladaLoader::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { diff --git a/code/AssetLib/Collada/ColladaLoader.h b/code/AssetLib/Collada/ColladaLoader.h index 74b5c06b7..3cea7f531 100644 --- a/code/AssetLib/Collada/ColladaLoader.h +++ b/code/AssetLib/Collada/ColladaLoader.h @@ -86,7 +86,7 @@ public: ColladaLoader(); /// The class destructor. - ~ColladaLoader() override; + ~ColladaLoader() override = default; /// Returns whether the class can handle the format of the given file. /// @see BaseImporter::CanRead() for more details. diff --git a/code/AssetLib/DXF/DXFLoader.cpp b/code/AssetLib/DXF/DXFLoader.cpp index dae665388..f69cdfce2 100644 --- a/code/AssetLib/DXF/DXFLoader.cpp +++ b/code/AssetLib/DXF/DXFLoader.cpp @@ -70,7 +70,7 @@ static const aiColor4D AI_DXF_DEFAULT_COLOR(aiColor4D(0.6f, 0.6f, 0.6f, 0.6f)); // color indices for DXF - 16 are supported, the table is // taken directly from the DXF spec. -static aiColor4D g_aclrDxfIndexColors[] = { +static const aiColor4D g_aclrDxfIndexColors[] = { aiColor4D(0.6f, 0.6f, 0.6f, 1.0f), aiColor4D (1.0f, 0.0f, 0.0f, 1.0f), // red aiColor4D (0.0f, 1.0f, 0.0f, 1.0f), // green @@ -97,7 +97,7 @@ static const int GroupCode_XComp = 10; static const int GroupCode_YComp = 20; static const int GroupCode_ZComp = 30; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Drawing Interchange Format (DXF) Importer", "", "", diff --git a/code/AssetLib/FBX/FBXImporter.cpp b/code/AssetLib/FBX/FBXImporter.cpp index 32631996e..afd4b11c1 100644 --- a/code/AssetLib/FBX/FBXImporter.cpp +++ b/code/AssetLib/FBX/FBXImporter.cpp @@ -72,25 +72,20 @@ using namespace Assimp::Formatter; using namespace Assimp::FBX; namespace { - -static const aiImporterDesc desc = { - "Autodesk FBX Importer", - "", - "", - "", - aiImporterFlags_SupportTextFlavour, - 0, - 0, - 0, - 0, - "fbx" -}; + static constexpr aiImporterDesc desc = { + "Autodesk FBX Importer", + "", + "", + "", + aiImporterFlags_SupportTextFlavour, + 0, + 0, + 0, + 0, + "fbx" + }; } -// ------------------------------------------------------------------------------------------------ -// Constructor to be privately used by #Importer -FBXImporter::FBXImporter() = default; - // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool FBXImporter::CanRead(const std::string & pFile, IOSystem * pIOHandler, bool /*checkSig*/) const { diff --git a/code/AssetLib/FBX/FBXImporter.h b/code/AssetLib/FBX/FBXImporter.h index 9acabaddd..d12b45969 100644 --- a/code/AssetLib/FBX/FBXImporter.h +++ b/code/AssetLib/FBX/FBXImporter.h @@ -70,7 +70,7 @@ typedef class basic_formatter, std::allocator class FBXImporter : public BaseImporter, public LogFunctions { public: /// @brief The class constructor. - FBXImporter(); + FBXImporter() = default; /// @brief The class destructor, default implementation. ~FBXImporter() override = default; diff --git a/code/AssetLib/HMP/HMPLoader.cpp b/code/AssetLib/HMP/HMPLoader.cpp index 431783a6a..5ccb2b474 100644 --- a/code/AssetLib/HMP/HMPLoader.cpp +++ b/code/AssetLib/HMP/HMPLoader.cpp @@ -57,7 +57,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "3D GameStudio Heightmap (HMP) Importer", "", "", diff --git a/code/AssetLib/IFC/IFCLoader.cpp b/code/AssetLib/IFC/IFCLoader.cpp index 990986b62..c919d9982 100644 --- a/code/AssetLib/IFC/IFCLoader.cpp +++ b/code/AssetLib/IFC/IFCLoader.cpp @@ -103,7 +103,7 @@ void ConvertUnit(const ::Assimp::STEP::EXPRESS::DataType &dt, ConversionData &co } // namespace -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Industry Foundation Classes (IFC) Importer", "", "", diff --git a/code/AssetLib/IQM/IQMImporter.cpp b/code/AssetLib/IQM/IQMImporter.cpp index 392ed1193..432c12113 100644 --- a/code/AssetLib/IQM/IQMImporter.cpp +++ b/code/AssetLib/IQM/IQMImporter.cpp @@ -59,7 +59,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // http://sauerbraten.org/iqm/ // https://github.com/lsalzman/iqm - inline void swap_block( uint32_t *block, size_t size ){ (void)block; // suppress 'unreferenced formal parameter' MSVC warning size >>= 2; @@ -67,7 +66,7 @@ inline void swap_block( uint32_t *block, size_t size ){ AI_SWAP4( block[ i ] ); } -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Inter-Quake Model Importer", "", "", diff --git a/code/AssetLib/Irr/IRRLoader.cpp b/code/AssetLib/Irr/IRRLoader.cpp index f841cd876..99e053892 100644 --- a/code/AssetLib/Irr/IRRLoader.cpp +++ b/code/AssetLib/Irr/IRRLoader.cpp @@ -66,7 +66,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Irrlicht Scene Reader", "", "", diff --git a/code/AssetLib/Irr/IRRMeshLoader.cpp b/code/AssetLib/Irr/IRRMeshLoader.cpp index 8161a2997..b35a95c12 100644 --- a/code/AssetLib/Irr/IRRMeshLoader.cpp +++ b/code/AssetLib/Irr/IRRMeshLoader.cpp @@ -56,7 +56,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Irrlicht Mesh Reader", "", "", diff --git a/code/AssetLib/LWO/LWOBLoader.cpp b/code/AssetLib/LWO/LWOBLoader.cpp index e49adcf98..4a9792b79 100644 --- a/code/AssetLib/LWO/LWOBLoader.cpp +++ b/code/AssetLib/LWO/LWOBLoader.cpp @@ -51,64 +51,56 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "LWOLoader.h" using namespace Assimp; - // ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWOBFile() -{ +void LWOImporter::LoadLWOBFile() { LE_NCONST uint8_t* const end = mFileBuffer + fileSize; bool running = true; - while (running) - { - if (mFileBuffer + sizeof(IFF::ChunkHeader) > end)break; + while (running) { + if (mFileBuffer + sizeof(IFF::ChunkHeader) > end) + break; const IFF::ChunkHeader head = IFF::LoadChunk(mFileBuffer); - if (mFileBuffer + head.length > end) - { + if (mFileBuffer + head.length > end) { throw DeadlyImportError("LWOB: Invalid chunk length"); } uint8_t* const next = mFileBuffer+head.length; - switch (head.type) - { + switch (head.type) { // vertex list - case AI_LWO_PNTS: - { + case AI_LWO_PNTS: { if (!mCurLayer->mTempPoints.empty()) ASSIMP_LOG_WARN("LWO: PNTS chunk encountered twice"); - else LoadLWOPoints(head.length); - break; - } - // face list - case AI_LWO_POLS: - { + else + LoadLWOPoints(head.length); + } break; + case AI_LWO_POLS: { // face list + if (!mCurLayer->mFaces.empty()) + ASSIMP_LOG_WARN("LWO: POLS chunk encountered twice"); + else + LoadLWOBPolygons(head.length); + } break; + + case AI_LWO_SRFS: // list of tags + { + if (!mTags->empty()) + ASSIMP_LOG_WARN("LWO: SRFS chunk encountered twice"); + else + LoadLWOTags(head.length); + } break; - if (!mCurLayer->mFaces.empty()) - ASSIMP_LOG_WARN("LWO: POLS chunk encountered twice"); - else LoadLWOBPolygons(head.length); - break; - } - // list of tags - case AI_LWO_SRFS: - { - if (!mTags->empty()) - ASSIMP_LOG_WARN("LWO: SRFS chunk encountered twice"); - else LoadLWOTags(head.length); - break; - } + case AI_LWO_SURF: // surface chunk + { + LoadLWOBSurface(head.length); + } break; - // surface chunk - case AI_LWO_SURF: - { - LoadLWOBSurface(head.length); + default: break; - } } mFileBuffer = next; } } // ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWOBPolygons(unsigned int length) -{ +void LWOImporter::LoadLWOBPolygons(unsigned int length) { // first find out how many faces and vertices we'll finally need LE_NCONST uint16_t* const end = (LE_NCONST uint16_t*)(mFileBuffer+length); LE_NCONST uint16_t* cursor = (LE_NCONST uint16_t*)mFileBuffer; @@ -123,8 +115,7 @@ void LWOImporter::LoadLWOBPolygons(unsigned int length) CountVertsAndFacesLWOB(iNumVertices,iNumFaces,cursor,end); // allocate the output array and copy face indices - if (iNumFaces) - { + if (iNumFaces) { cursor = (LE_NCONST uint16_t*)mFileBuffer; mCurLayer->mFaces.resize(iNumFaces); @@ -135,10 +126,8 @@ void LWOImporter::LoadLWOBPolygons(unsigned int length) // ------------------------------------------------------------------------------------------------ void LWOImporter::CountVertsAndFacesLWOB(unsigned int& verts, unsigned int& faces, - LE_NCONST uint16_t*& cursor, const uint16_t* const end, unsigned int max) -{ - while (cursor < end && max--) - { + LE_NCONST uint16_t*& cursor, const uint16_t* const end, unsigned int max) { + while (cursor < end && max--) { uint16_t numIndices; // must have 2 shorts left for numIndices and surface if (end - cursor < 2) { @@ -154,8 +143,7 @@ void LWOImporter::CountVertsAndFacesLWOB(unsigned int& verts, unsigned int& face cursor += numIndices; int16_t surface; ::memcpy(&surface, cursor++, 2); - if (surface < 0) - { + if (surface < 0) { // there are detail polygons ::memcpy(&numIndices, cursor++, 2); CountVertsAndFacesLWOB(verts,faces,cursor,end,numIndices); @@ -167,18 +155,14 @@ void LWOImporter::CountVertsAndFacesLWOB(unsigned int& verts, unsigned int& face void LWOImporter::CopyFaceIndicesLWOB(FaceList::iterator& it, LE_NCONST uint16_t*& cursor, const uint16_t* const end, - unsigned int max) -{ - while (cursor < end && max--) - { + unsigned int max) { + while (cursor < end && max--) { LWO::Face& face = *it;++it; uint16_t numIndices; ::memcpy(&numIndices, cursor++, 2); face.mNumIndices = numIndices; - if(face.mNumIndices) - { - if (cursor + face.mNumIndices >= end) - { + if(face.mNumIndices) { + if (cursor + face.mNumIndices >= end) { break; } face.mIndices = new unsigned int[face.mNumIndices]; @@ -187,8 +171,7 @@ void LWOImporter::CopyFaceIndicesLWOB(FaceList::iterator& it, uint16_t index; ::memcpy(&index, cursor++, 2); mi = index; - if (mi > mCurLayer->mTempPoints.size()) - { + if (mi > mCurLayer->mTempPoints.size()) { ASSIMP_LOG_WARN("LWOB: face index is out of range"); mi = (unsigned int)mCurLayer->mTempPoints.size()-1; } @@ -198,15 +181,13 @@ void LWOImporter::CopyFaceIndicesLWOB(FaceList::iterator& it, } int16_t surface; ::memcpy(&surface, cursor++, 2); - if (surface < 0) - { + if (surface < 0) { surface = -surface; // there are detail polygons. uint16_t numPolygons; ::memcpy(&numPolygons, cursor++, 2); - if (cursor < end) - { + if (cursor < end) { CopyFaceIndicesLWOB(it,cursor,end,numPolygons); } } @@ -215,8 +196,7 @@ void LWOImporter::CopyFaceIndicesLWOB(FaceList::iterator& it, } // ------------------------------------------------------------------------------------------------ -LWO::Texture* LWOImporter::SetupNewTextureLWOB(LWO::TextureList& list,unsigned int size) -{ +LWO::Texture* LWOImporter::SetupNewTextureLWOB(LWO::TextureList& list,unsigned int size) { list.emplace_back(); LWO::Texture* tex = &list.back(); @@ -224,8 +204,7 @@ LWO::Texture* LWOImporter::SetupNewTextureLWOB(LWO::TextureList& list,unsigned i GetS0(type,size); const char* s = type.c_str(); - if(strstr(s, "Image Map")) - { + if(strstr(s, "Image Map")) { // Determine mapping type if(strstr(s, "Planar")) tex->mapMode = LWO::Texture::Planar; @@ -237,9 +216,7 @@ LWO::Texture* LWOImporter::SetupNewTextureLWOB(LWO::TextureList& list,unsigned i tex->mapMode = LWO::Texture::Cubic; else if(strstr(s, "Front")) tex->mapMode = LWO::Texture::FrontProjection; - } - else - { + } else { // procedural or gradient, not supported ASSIMP_LOG_ERROR("LWOB: Unsupported legacy texture: ", type); } @@ -248,8 +225,7 @@ LWO::Texture* LWOImporter::SetupNewTextureLWOB(LWO::TextureList& list,unsigned i } // ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWOBSurface(unsigned int size) -{ +void LWOImporter::LoadLWOBSurface(unsigned int size) { LE_NCONST uint8_t* const end = mFileBuffer + size; mSurfaces->push_back( LWO::Surface () ); @@ -277,148 +253,147 @@ void LWOImporter::LoadLWOBSurface(unsigned int size) } uint8_t* const next = mFileBuffer+head.length; - switch (head.type) - { - // diffuse color - case AI_LWO_COLR: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,COLR,3); - surf.mColor.r = GetU1() / 255.0f; - surf.mColor.g = GetU1() / 255.0f; - surf.mColor.b = GetU1() / 255.0f; - break; - } - // diffuse strength ... - case AI_LWO_DIFF: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,DIFF,2); - surf.mDiffuseValue = GetU2() / 255.0f; - break; - } - // specular strength ... - case AI_LWO_SPEC: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,SPEC,2); - surf.mSpecularValue = GetU2() / 255.0f; - break; - } - // luminosity ... - case AI_LWO_LUMI: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,LUMI,2); - surf.mLuminosity = GetU2() / 255.0f; - break; - } - // transparency - case AI_LWO_TRAN: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,TRAN,2); - surf.mTransparency = GetU2() / 255.0f; - break; - } - // surface flags - case AI_LWO_FLAG: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,FLAG,2); - uint16_t flag = GetU2(); - if (flag & 0x4 ) surf.mMaximumSmoothAngle = 1.56207f; - if (flag & 0x8 ) surf.mColorHighlights = 1.f; - if (flag & 0x100) surf.bDoubleSided = true; - break; - } - // maximum smoothing angle - case AI_LWO_SMAN: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,SMAN,4); - surf.mMaximumSmoothAngle = std::fabs( GetF4() ); - break; - } - // glossiness - case AI_LWO_GLOS: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,GLOS,2); - surf.mGlossiness = (float)GetU2(); - break; - } - // color texture - case AI_LWO_CTEX: - { - pTex = SetupNewTextureLWOB(surf.mColorTextures, - head.length); - break; - } - // diffuse texture - case AI_LWO_DTEX: - { - pTex = SetupNewTextureLWOB(surf.mDiffuseTextures, - head.length); - break; - } - // specular texture - case AI_LWO_STEX: - { - pTex = SetupNewTextureLWOB(surf.mSpecularTextures, - head.length); - break; - } - // bump texture - case AI_LWO_BTEX: - { - pTex = SetupNewTextureLWOB(surf.mBumpTextures, - head.length); - break; - } - // transparency texture - case AI_LWO_TTEX: - { - pTex = SetupNewTextureLWOB(surf.mOpacityTextures, - head.length); - break; - } - // texture path - case AI_LWO_TIMG: - { - if (pTex) { - GetS0(pTex->mFileName,head.length); - } else { - ASSIMP_LOG_WARN("LWOB: Unexpected TIMG chunk"); + switch (head.type) { + // diffuse color + case AI_LWO_COLR: + { + AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,COLR,3); + surf.mColor.r = GetU1() / 255.0f; + surf.mColor.g = GetU1() / 255.0f; + surf.mColor.b = GetU1() / 255.0f; + break; } - break; - } - // texture strength - case AI_LWO_TVAL: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,TVAL,1); - if (pTex) { - pTex->mStrength = (float)GetU1()/ 255.f; - } else { - ASSIMP_LOG_ERROR("LWOB: Unexpected TVAL chunk"); + // diffuse strength ... + case AI_LWO_DIFF: + { + AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,DIFF,2); + surf.mDiffuseValue = GetU2() / 255.0f; + break; } - break; - } - // texture flags - case AI_LWO_TFLG: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,TFLG,2); - - if (nullptr != pTex) { - const uint16_t s = GetU2(); - if (s & 1) - pTex->majorAxis = LWO::Texture::AXIS_X; - else if (s & 2) - pTex->majorAxis = LWO::Texture::AXIS_Y; - else if (s & 4) - pTex->majorAxis = LWO::Texture::AXIS_Z; - - if (s & 16) { - ASSIMP_LOG_WARN("LWOB: Ignoring \'negate\' flag on texture"); + // specular strength ... + case AI_LWO_SPEC: + { + AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,SPEC,2); + surf.mSpecularValue = GetU2() / 255.0f; + break; + } + // luminosity ... + case AI_LWO_LUMI: + { + AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,LUMI,2); + surf.mLuminosity = GetU2() / 255.0f; + break; + } + // transparency + case AI_LWO_TRAN: + { + AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,TRAN,2); + surf.mTransparency = GetU2() / 255.0f; + break; + } + // surface flags + case AI_LWO_FLAG: + { + AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,FLAG,2); + uint16_t flag = GetU2(); + if (flag & 0x4 ) surf.mMaximumSmoothAngle = 1.56207f; + if (flag & 0x8 ) surf.mColorHighlights = 1.f; + if (flag & 0x100) surf.bDoubleSided = true; + break; + } + // maximum smoothing angle + case AI_LWO_SMAN: + { + AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,SMAN,4); + surf.mMaximumSmoothAngle = std::fabs( GetF4() ); + break; + } + // glossiness + case AI_LWO_GLOS: + { + AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,GLOS,2); + surf.mGlossiness = (float)GetU2(); + break; + } + // color texture + case AI_LWO_CTEX: + { + pTex = SetupNewTextureLWOB(surf.mColorTextures, + head.length); + break; + } + // diffuse texture + case AI_LWO_DTEX: + { + pTex = SetupNewTextureLWOB(surf.mDiffuseTextures, + head.length); + break; + } + // specular texture + case AI_LWO_STEX: + { + pTex = SetupNewTextureLWOB(surf.mSpecularTextures, + head.length); + break; + } + // bump texture + case AI_LWO_BTEX: + { + pTex = SetupNewTextureLWOB(surf.mBumpTextures, + head.length); + break; + } + // transparency texture + case AI_LWO_TTEX: + { + pTex = SetupNewTextureLWOB(surf.mOpacityTextures, + head.length); + break; + } + // texture path + case AI_LWO_TIMG: + { + if (pTex) { + GetS0(pTex->mFileName,head.length); + } else { + ASSIMP_LOG_WARN("LWOB: Unexpected TIMG chunk"); } + break; } - else { - ASSIMP_LOG_WARN("LWOB: Unexpected TFLG chunk"); + // texture strength + case AI_LWO_TVAL: + { + AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,TVAL,1); + if (pTex) { + pTex->mStrength = (float)GetU1()/ 255.f; + } else { + ASSIMP_LOG_ERROR("LWOB: Unexpected TVAL chunk"); + } + break; + } + // texture flags + case AI_LWO_TFLG: + { + AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,TFLG,2); + + if (nullptr != pTex) { + const uint16_t s = GetU2(); + if (s & 1) + pTex->majorAxis = LWO::Texture::AXIS_X; + else if (s & 2) + pTex->majorAxis = LWO::Texture::AXIS_Y; + else if (s & 4) + pTex->majorAxis = LWO::Texture::AXIS_Z; + + if (s & 16) { + ASSIMP_LOG_WARN("LWOB: Ignoring \'negate\' flag on texture"); + } + } + else { + ASSIMP_LOG_WARN("LWOB: Unexpected TFLG chunk"); + } + break; } - break; - } } mFileBuffer = next; } diff --git a/code/AssetLib/LWS/LWSLoader.cpp b/code/AssetLib/LWS/LWSLoader.cpp index c41ff9cac..dec834495 100644 --- a/code/AssetLib/LWS/LWSLoader.cpp +++ b/code/AssetLib/LWS/LWSLoader.cpp @@ -63,7 +63,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "LightWave Scene Importer", "", "", @@ -139,10 +139,6 @@ LWSImporter::LWSImporter() : // nothing to do here } -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -LWSImporter::~LWSImporter() = default; - // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool LWSImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { diff --git a/code/AssetLib/LWS/LWSLoader.h b/code/AssetLib/LWS/LWSLoader.h index 3df9fe9d9..4e92ef0d5 100644 --- a/code/AssetLib/LWS/LWSLoader.h +++ b/code/AssetLib/LWS/LWSLoader.h @@ -174,7 +174,7 @@ struct NodeDesc { class LWSImporter : public BaseImporter { public: LWSImporter(); - ~LWSImporter() override; + ~LWSImporter() override = default; // ------------------------------------------------------------------- // Check whether we can read a specific file diff --git a/code/AssetLib/M3D/M3DImporter.cpp b/code/AssetLib/M3D/M3DImporter.cpp index 895b2bf70..71f416139 100644 --- a/code/AssetLib/M3D/M3DImporter.cpp +++ b/code/AssetLib/M3D/M3DImporter.cpp @@ -85,7 +85,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. are listed in aiScene->mRootNode->children, but all without meshes */ -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Model 3D Importer", "", "", diff --git a/code/AssetLib/MD2/MD2Loader.cpp b/code/AssetLib/MD2/MD2Loader.cpp index ee7dbc6a6..596d26414 100644 --- a/code/AssetLib/MD2/MD2Loader.cpp +++ b/code/AssetLib/MD2/MD2Loader.cpp @@ -5,8 +5,6 @@ Open Asset Import Library (assimp) Copyright (c) 2006-2022, assimp team - - All rights reserved. Redistribution and use of this software in source and binary forms, @@ -41,7 +39,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --------------------------------------------------------------------------- */ - #ifndef ASSIMP_BUILD_NO_MD2_IMPORTER /** @file Implementation of the MD2 importer class */ @@ -65,7 +62,7 @@ using namespace Assimp::MD2; # define ARRAYSIZE(_array) (int(sizeof(_array) / sizeof(_array[0]))) #endif -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Quake II Mesh Importer", "", "", @@ -79,7 +76,7 @@ static const aiImporterDesc desc = { }; // ------------------------------------------------------------------------------------------------ -// Helper function to lookup a normal in Quake 2's precalculated table +// Helper function to lookup a normal in Quake 2's pre-calculated table void MD2::LookupNormalIndex(uint8_t iNormalIndex,aiVector3D& vOut) { // make sure the normal index has a valid value @@ -100,10 +97,6 @@ MD2Importer::MD2Importer() fileSize() {} -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -MD2Importer::~MD2Importer() = default; - // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool MD2Importer::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const diff --git a/code/AssetLib/MD2/MD2Loader.h b/code/AssetLib/MD2/MD2Loader.h index a49ccb2fd..bab026ea0 100644 --- a/code/AssetLib/MD2/MD2Loader.h +++ b/code/AssetLib/MD2/MD2Loader.h @@ -63,7 +63,7 @@ using namespace MD2; class MD2Importer : public BaseImporter { public: MD2Importer(); - ~MD2Importer() override; + ~MD2Importer() override = default; // ------------------------------------------------------------------- /** Returns whether the class can handle the format of the given file. diff --git a/code/AssetLib/MD3/MD3Loader.cpp b/code/AssetLib/MD3/MD3Loader.cpp index fcb8d0c35..e743889e3 100644 --- a/code/AssetLib/MD3/MD3Loader.cpp +++ b/code/AssetLib/MD3/MD3Loader.cpp @@ -70,7 +70,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Quake III Mesh Importer", "", "", diff --git a/code/AssetLib/MD5/MD5Loader.cpp b/code/AssetLib/MD5/MD5Loader.cpp index 4236f32e9..697e758fb 100644 --- a/code/AssetLib/MD5/MD5Loader.cpp +++ b/code/AssetLib/MD5/MD5Loader.cpp @@ -64,7 +64,7 @@ using namespace Assimp; // Minimum weight value. Weights inside [-n ... n] are ignored #define AI_MD5_WEIGHT_EPSILON Math::getEpsilon() -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Doom 3 / MD5 Mesh Importer", "", "", @@ -92,10 +92,6 @@ MD5Importer::MD5Importer() : // empty } -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -MD5Importer::~MD5Importer() = default; - // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool MD5Importer::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { diff --git a/code/AssetLib/MD5/MD5Loader.h b/code/AssetLib/MD5/MD5Loader.h index 63fb1c36b..c213c04e6 100644 --- a/code/AssetLib/MD5/MD5Loader.h +++ b/code/AssetLib/MD5/MD5Loader.h @@ -65,7 +65,7 @@ using namespace Assimp::MD5; class MD5Importer : public BaseImporter { public: MD5Importer(); - ~MD5Importer() override; + ~MD5Importer() override = default; // ------------------------------------------------------------------- /** Returns whether the class can handle the format of the given file. diff --git a/code/AssetLib/MDC/MDCLoader.cpp b/code/AssetLib/MDC/MDCLoader.cpp index 10ea618b9..87247adec 100644 --- a/code/AssetLib/MDC/MDCLoader.cpp +++ b/code/AssetLib/MDC/MDCLoader.cpp @@ -60,7 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; using namespace Assimp::MDC; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Return To Castle Wolfenstein Mesh Importer", "", "", @@ -103,10 +103,6 @@ MDCImporter::MDCImporter() : // empty } -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -MDCImporter::~MDCImporter() = default; - // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool MDCImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { diff --git a/code/AssetLib/MDC/MDCLoader.h b/code/AssetLib/MDC/MDCLoader.h index 6e67cd12f..a1f8d9fc9 100644 --- a/code/AssetLib/MDC/MDCLoader.h +++ b/code/AssetLib/MDC/MDCLoader.h @@ -62,7 +62,7 @@ using namespace MDC; class MDCImporter : public BaseImporter { public: MDCImporter(); - ~MDCImporter() override; + ~MDCImporter() override = default; // ------------------------------------------------------------------- /** Returns whether the class can handle the format of the given file. diff --git a/code/AssetLib/MDL/MDLLoader.cpp b/code/AssetLib/MDL/MDLLoader.cpp index 7b2ec7115..2b14fe980 100644 --- a/code/AssetLib/MDL/MDLLoader.cpp +++ b/code/AssetLib/MDL/MDLLoader.cpp @@ -65,7 +65,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Quake Mesh / 3D GameStudio Mesh Importer", "", "", @@ -96,10 +96,6 @@ MDLImporter::MDLImporter() : // empty } -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -MDLImporter::~MDLImporter() = default; - // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool MDLImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { diff --git a/code/AssetLib/MDL/MDLLoader.h b/code/AssetLib/MDL/MDLLoader.h index 44ff21e3e..333f7c8b1 100644 --- a/code/AssetLib/MDL/MDLLoader.h +++ b/code/AssetLib/MDL/MDLLoader.h @@ -39,10 +39,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------- */ - -/** @file MDLLoader.h - * @brief Declaration of the loader for MDL files - */ +/// @file MDLLoader.h +/// @brief Declaration of the loader for MDL files #pragma once #ifndef AI_MDLLOADER_H_INCLUDED #define AI_MDLLOADER_H_INCLUDED @@ -83,11 +81,10 @@ using namespace MDL; * them all with a single 1000-line function-beast. However, it has been * split into several code paths to make the code easier to read and maintain. */ -class MDLImporter : public BaseImporter -{ +class MDLImporter : public BaseImporter { public: MDLImporter(); - ~MDLImporter() override; + ~MDLImporter() override = default; // ------------------------------------------------------------------- /** Returns whether the class can handle the format of the given file. diff --git a/code/AssetLib/MMD/MMDImporter.cpp b/code/AssetLib/MMD/MMDImporter.cpp index 0905ce1e0..b96d45c98 100644 --- a/code/AssetLib/MMD/MMDImporter.cpp +++ b/code/AssetLib/MMD/MMDImporter.cpp @@ -57,7 +57,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -static const aiImporterDesc desc = { "MMD Importer", +static constexpr aiImporterDesc desc = { "MMD Importer", "", "", "surfaces supported?", @@ -81,10 +81,6 @@ MMDImporter::MMDImporter() : m_strAbsPath = io.getOsSeparator(); } -// ------------------------------------------------------------------------------------------------ -// Destructor. -MMDImporter::~MMDImporter() = default; - // ------------------------------------------------------------------------------------------------ // Returns true, if file is an pmx file. bool MMDImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, diff --git a/code/AssetLib/MMD/MMDImporter.h b/code/AssetLib/MMD/MMDImporter.h index 36f384829..1f584bf12 100644 --- a/code/AssetLib/MMD/MMDImporter.h +++ b/code/AssetLib/MMD/MMDImporter.h @@ -50,46 +50,34 @@ struct aiMesh; namespace Assimp { // ------------------------------------------------------------------------------------------------ -/// \class MMDImporter -/// \brief Imports MMD a pmx/pmd/vmd file +/// @class MMDImporter +/// @brief Imports MMD a pmx/pmd/vmd file // ------------------------------------------------------------------------------------------------ class MMDImporter : public BaseImporter { public: - /// \brief Default constructor + /// @brief Default constructor MMDImporter(); - /// \brief Destructor - ~MMDImporter() override; + /// @brief Destructor + ~MMDImporter() override = default; public: - /// \brief Returns whether the class can handle the format of the given file. - /// \remark See BaseImporter::CanRead() for details. + /// @brief Returns whether the class can handle the format of the given file. + /// @remark See BaseImporter::CanRead() for details. bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const override; private: - //! \brief Appends the supported extension. const aiImporterDesc* GetInfo() const override; - - //! \brief File import implementation. void InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) override; - - //! \brief Create the data from imported content. void CreateDataFromImport(const pmx::PmxModel* pModel, aiScene* pScene); - - //! \brief Create the mesh aiMesh* CreateMesh(const pmx::PmxModel* pModel, const int indexStart, const int indexCount); - - //! \brief Create the material aiMaterial* CreateMaterial(const pmx::PmxMaterial* pMat, const pmx::PmxModel* pModel); private: - //! Data buffer std::vector m_Buffer; - //! Absolute pathname of model in file system std::string m_strAbsPath; }; -// ------------------------------------------------------------------------------------------------ } // Namespace Assimp diff --git a/code/AssetLib/MS3D/MS3DLoader.cpp b/code/AssetLib/MS3D/MS3DLoader.cpp index d4dd2be75..e0f0f8b5a 100644 --- a/code/AssetLib/MS3D/MS3DLoader.cpp +++ b/code/AssetLib/MS3D/MS3DLoader.cpp @@ -60,7 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Milkshape 3D Importer", "", "", @@ -84,9 +84,6 @@ MS3DImporter::MS3DImporter() : mScene() {} -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -MS3DImporter::~MS3DImporter() = default; // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool MS3DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const diff --git a/code/AssetLib/MS3D/MS3DLoader.h b/code/AssetLib/MS3D/MS3DLoader.h index 4bd417566..3e25f1f59 100644 --- a/code/AssetLib/MS3D/MS3DLoader.h +++ b/code/AssetLib/MS3D/MS3DLoader.h @@ -48,6 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include + struct aiNode; namespace Assimp { @@ -58,7 +59,7 @@ namespace Assimp { class MS3DImporter : public BaseImporter { public: MS3DImporter(); - ~MS3DImporter() override; + ~MS3DImporter() override = default; // ------------------------------------------------------------------- /** Returns whether the class can handle the format of the given file. diff --git a/code/AssetLib/NDO/NDOLoader.cpp b/code/AssetLib/NDO/NDOLoader.cpp index edccc1624..405438dfc 100644 --- a/code/AssetLib/NDO/NDOLoader.cpp +++ b/code/AssetLib/NDO/NDOLoader.cpp @@ -43,8 +43,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * Implementation of the NDO importer class. */ - #ifndef ASSIMP_BUILD_NO_NDO_IMPORTER + #include "NDOLoader.h" #include #include @@ -56,7 +56,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Nendo Mesh Importer", "", "", @@ -69,14 +69,6 @@ static const aiImporterDesc desc = { "ndo" }; -// ------------------------------------------------------------------------------------------------ -// Constructor to be privately used by Importer -NDOImporter::NDOImporter() = default; - -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -NDOImporter::~NDOImporter() = default; - // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool NDOImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const diff --git a/code/AssetLib/NDO/NDOLoader.h b/code/AssetLib/NDO/NDOLoader.h index 61dd93981..c4f127851 100644 --- a/code/AssetLib/NDO/NDOLoader.h +++ b/code/AssetLib/NDO/NDOLoader.h @@ -65,8 +65,8 @@ class Importer; */ class NDOImporter : public BaseImporter { public: - NDOImporter(); - ~NDOImporter() override; + NDOImporter() = default; + ~NDOImporter() override = default; //! Represents a single edge struct Edge { diff --git a/code/AssetLib/NFF/NFFLoader.cpp b/code/AssetLib/NFF/NFFLoader.cpp index ce7007155..78adc27bd 100644 --- a/code/AssetLib/NFF/NFFLoader.cpp +++ b/code/AssetLib/NFF/NFFLoader.cpp @@ -56,9 +56,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -using namespace Assimp; +namespace Assimp { -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Neutral File Format Importer", "", "", @@ -71,14 +71,6 @@ static const aiImporterDesc desc = { "enff nff" }; -// ------------------------------------------------------------------------------------------------ -// Constructor to be privately used by Importer -NFFImporter::NFFImporter() = default; - -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -NFFImporter::~NFFImporter() = default; - // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool NFFImporter::CanRead(const std::string & pFile, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const { @@ -94,7 +86,7 @@ const aiImporterDesc *NFFImporter::GetInfo() const { // ------------------------------------------------------------------------------------------------ #define AI_NFF_PARSE_FLOAT(f) \ SkipSpaces(&sz); \ - if (!::IsLineEnd(*sz)) sz = fast_atoreal_move(sz, (ai_real &)f); + if (!IsLineEnd(*sz)) sz = fast_atoreal_move(sz, (ai_real &)f); // ------------------------------------------------------------------------------------------------ #define AI_NFF_PARSE_TRIPLE(v) \ @@ -338,8 +330,8 @@ void NFFImporter::InternReadFile(const std::string &pFile, break; } - // read the numbr of vertices - unsigned int num = ::strtoul10(sz, &sz); + // read the number of vertices + unsigned int num = strtoul10(sz, &sz); // temporary storage std::vector tempColors; @@ -365,7 +357,7 @@ void NFFImporter::InternReadFile(const std::string &pFile, // color definition if (TokenMatch(sz, "0x", 2)) { hasColor = true; - unsigned int numIdx = ::strtoul16(sz, &sz); + unsigned int numIdx = strtoul16(sz, &sz); aiColor4D clr; clr.a = 1.f; @@ -403,15 +395,16 @@ void NFFImporter::InternReadFile(const std::string &pFile, } AI_NFF2_GET_NEXT_TOKEN(); - if (!num) throw DeadlyImportError("NFF2: There are zero vertices"); - num = ::strtoul10(sz, &sz); + if (!num) + throw DeadlyImportError("NFF2: There are zero vertices"); + num = strtoul10(sz, &sz); std::vector tempIdx; tempIdx.reserve(10); for (unsigned int i = 0; i < num; ++i) { AI_NFF2_GET_NEXT_TOKEN(); SkipSpaces(line, &sz); - unsigned int numIdx = ::strtoul10(sz, &sz); + unsigned int numIdx = strtoul10(sz, &sz); // read all faces indices if (numIdx) { @@ -421,7 +414,7 @@ void NFFImporter::InternReadFile(const std::string &pFile, for (unsigned int a = 0; a < numIdx; ++a) { SkipSpaces(sz, &sz); - unsigned int m = ::strtoul10(sz, &sz); + unsigned int m = strtoul10(sz, &sz); if (m >= (unsigned int)tempPositions.size()) { ASSIMP_LOG_ERROR("NFF2: Vertex index overflow"); m = 0; @@ -446,7 +439,7 @@ void NFFImporter::InternReadFile(const std::string &pFile, if (TokenMatch(sz, "0x", 2)) { hasColor = true; const char *sz2 = sz; - numIdx = ::strtoul16(sz, &sz); + numIdx = strtoul16(sz, &sz); const unsigned int diff = (unsigned int)(sz - sz2); // 0xRRGGBB @@ -518,7 +511,7 @@ void NFFImporter::InternReadFile(const std::string &pFile, // Material ID? else if (!materialTable.empty() && TokenMatch(sz, "matid", 5)) { SkipSpaces(&sz); - matIdx = ::strtoul10(sz, &sz); + matIdx = strtoul10(sz, &sz); if (matIdx >= materialTable.size()) { ASSIMP_LOG_ERROR("NFF2: Material index overflow."); matIdx = 0; @@ -1165,4 +1158,6 @@ void NFFImporter::InternReadFile(const std::string &pFile, pScene->mRootNode = root; } +} // namespace Assimp + #endif // !! ASSIMP_BUILD_NO_NFF_IMPORTER diff --git a/code/AssetLib/NFF/NFFLoader.h b/code/AssetLib/NFF/NFFLoader.h index 7fd094306..b402aec84 100644 --- a/code/AssetLib/NFF/NFFLoader.h +++ b/code/AssetLib/NFF/NFFLoader.h @@ -63,8 +63,8 @@ namespace Assimp { */ class NFFImporter : public BaseImporter { public: - NFFImporter(); - ~NFFImporter() override; + NFFImporter() = default; + ~NFFImporter() override = default; // ------------------------------------------------------------------- /** Returns whether the class can handle the format of the given file. diff --git a/code/AssetLib/OFF/OFFLoader.cpp b/code/AssetLib/OFF/OFFLoader.cpp index f50afb57b..ce8dfc2d4 100644 --- a/code/AssetLib/OFF/OFFLoader.cpp +++ b/code/AssetLib/OFF/OFFLoader.cpp @@ -43,7 +43,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * @brief Implementation of the OFF importer class */ - #ifndef ASSIMP_BUILD_NO_OFF_IMPORTER // internal headers @@ -56,9 +55,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -using namespace Assimp; +namespace Assimp { -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "OFF Importer", "", "", @@ -71,99 +70,92 @@ static const aiImporterDesc desc = { "off" }; -// ------------------------------------------------------------------------------------------------ -// Constructor to be privately used by Importer -OFFImporter::OFFImporter() = default; - -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -OFFImporter::~OFFImporter() = default; - // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. -bool OFFImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const -{ - static const char* tokens[] = { "off" }; - return SearchFileHeaderForToken(pIOHandler,pFile,tokens,AI_COUNT_OF(tokens),3); +bool OFFImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { + static const char *tokens[] = { "off" }; + return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens), 3); } // ------------------------------------------------------------------------------------------------ -const aiImporterDesc* OFFImporter::GetInfo () const -{ +const aiImporterDesc *OFFImporter::GetInfo() const { return &desc; } - // skip blank space, lines and comments -static void NextToken(const char **car, const char* end) { - SkipSpacesAndLineEnd(car); - while (*car < end && (**car == '#' || **car == '\n' || **car == '\r')) { - SkipLine(car); +static void NextToken(const char **car, const char *end) { SkipSpacesAndLineEnd(car); - } + while (*car < end && (**car == '#' || **car == '\n' || **car == '\r')) { + SkipLine(car); + SkipSpacesAndLineEnd(car); + } } // ------------------------------------------------------------------------------------------------ // Imports the given file into the given scene structure. -void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) { - std::unique_ptr file( pIOHandler->Open( pFile, "rb")); +void OFFImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) { + std::unique_ptr file(pIOHandler->Open(pFile, "rb")); // Check whether we can read from the file if (file == nullptr) { - throw DeadlyImportError("Failed to open OFF file ", pFile, "."); + throw DeadlyImportError("Failed to open OFF file ", pFile, "."); } // allocate storage and copy the contents of the file to a memory buffer std::vector mBuffer2; - TextFileToBuffer(file.get(),mBuffer2); - const char* buffer = &mBuffer2[0]; + TextFileToBuffer(file.get(), mBuffer2); + const char *buffer = &mBuffer2[0]; // Proper OFF header parser. We only implement normal loading for now. bool hasTexCoord = false, hasNormals = false, hasColors = false; bool hasHomogenous = false, hasDimension = false; unsigned int dimensions = 3; - const char* car = buffer; - const char* end = buffer + mBuffer2.size(); + const char *car = buffer; + const char *end = buffer + mBuffer2.size(); NextToken(&car, end); if (car < end - 2 && car[0] == 'S' && car[1] == 'T') { - hasTexCoord = true; car += 2; + hasTexCoord = true; + car += 2; } if (car < end - 1 && car[0] == 'C') { - hasColors = true; car++; + hasColors = true; + car++; } - if (car < end- 1 && car[0] == 'N') { - hasNormals = true; car++; + if (car < end - 1 && car[0] == 'N') { + hasNormals = true; + car++; } if (car < end - 1 && car[0] == '4') { - hasHomogenous = true; car++; + hasHomogenous = true; + car++; } if (car < end - 1 && car[0] == 'n') { - hasDimension = true; car++; + hasDimension = true; + car++; } if (car < end - 3 && car[0] == 'O' && car[1] == 'F' && car[2] == 'F') { car += 3; - NextToken(&car, end); + NextToken(&car, end); } else { - // in case there is no OFF header (which is allowed by the - // specification...), then we might have unintentionally read an - // additional dimension from the primitive count fields - dimensions = 3; - hasHomogenous = false; - NextToken(&car, end); + // in case there is no OFF header (which is allowed by the + // specification...), then we might have unintentionally read an + // additional dimension from the primitive count fields + dimensions = 3; + hasHomogenous = false; + NextToken(&car, end); - // at this point the next token should be an integer number - if (car >= end - 1 || *car < '0' || *car > '9') { - throw DeadlyImportError("OFF: Header is invalid"); - } + // at this point the next token should be an integer number + if (car >= end - 1 || *car < '0' || *car > '9') { + throw DeadlyImportError("OFF: Header is invalid"); + } } if (hasDimension) { dimensions = strtoul10(car, &car); - NextToken(&car, end); + NextToken(&car, end); } if (dimensions > 3) { - throw DeadlyImportError - ("OFF: Number of vertex coordinates higher than 3 unsupported"); + throw DeadlyImportError("OFF: Number of vertex coordinates higher than 3 unsupported"); } NextToken(&car, end); @@ -171,7 +163,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS NextToken(&car, end); const unsigned int numFaces = strtoul10(car, &car); NextToken(&car, end); - strtoul10(car, &car); // skip edge count + strtoul10(car, &car); // skip edge count NextToken(&car, end); if (!numVertices) { @@ -182,13 +174,13 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS } pScene->mNumMeshes = 1; - pScene->mMeshes = new aiMesh*[ pScene->mNumMeshes ]; + pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]; - aiMesh* mesh = new aiMesh(); + aiMesh *mesh = new aiMesh(); pScene->mMeshes[0] = mesh; mesh->mNumFaces = numFaces; - aiFace* faces = new aiFace[mesh->mNumFaces]; + aiFace *faces = new aiFace[mesh->mNumFaces]; mesh->mFaces = faces; mesh->mNumVertices = numVertices; @@ -206,100 +198,101 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS // now read all vertex lines for (unsigned int i = 0; i < numVertices; ++i) { - if(!GetNextLine(buffer, line)) { + if (!GetNextLine(buffer, line)) { ASSIMP_LOG_ERROR("OFF: The number of verts in the header is incorrect"); break; } - aiVector3D& v = mesh->mVertices[i]; + aiVector3D &v = mesh->mVertices[i]; sz = line; - // helper array to write a for loop over possible dimension values - ai_real* vec[3] = {&v.x, &v.y, &v.z}; + // helper array to write a for loop over possible dimension values + ai_real *vec[3] = { &v.x, &v.y, &v.z }; - // stop at dimensions: this allows loading 1D or 2D coordinate vertices - for (unsigned int dim = 0; dim < dimensions; ++dim ) { - SkipSpaces(&sz); - sz = fast_atoreal_move(sz, *vec[dim]); - } + // stop at dimensions: this allows loading 1D or 2D coordinate vertices + for (unsigned int dim = 0; dim < dimensions; ++dim) { + SkipSpaces(&sz); + sz = fast_atoreal_move(sz, *vec[dim]); + } - // if has homogeneous coordinate, divide others by this one - if (hasHomogenous) { - SkipSpaces(&sz); - ai_real w = 1.; - sz = fast_atoreal_move(sz, w); - for (unsigned int dim = 0; dim < dimensions; ++dim ) { - *(vec[dim]) /= w; - } - } + // if has homogeneous coordinate, divide others by this one + if (hasHomogenous) { + SkipSpaces(&sz); + ai_real w = 1.; + sz = fast_atoreal_move(sz, w); + for (unsigned int dim = 0; dim < dimensions; ++dim) { + *(vec[dim]) /= w; + } + } - // read optional normals - if (hasNormals) { - aiVector3D& n = mesh->mNormals[i]; - SkipSpaces(&sz); - sz = fast_atoreal_move(sz,(ai_real&)n.x); - SkipSpaces(&sz); - sz = fast_atoreal_move(sz,(ai_real&)n.y); - SkipSpaces(&sz); - fast_atoreal_move(sz,(ai_real&)n.z); - } + // read optional normals + if (hasNormals) { + aiVector3D &n = mesh->mNormals[i]; + SkipSpaces(&sz); + sz = fast_atoreal_move(sz, (ai_real &)n.x); + SkipSpaces(&sz); + sz = fast_atoreal_move(sz, (ai_real &)n.y); + SkipSpaces(&sz); + fast_atoreal_move(sz, (ai_real &)n.z); + } - // reading colors is a pain because the specification says it can be - // integers or floats, and any number of them between 1 and 4 included, - // until the next comment or end of line - // in theory should be testing type ! - if (hasColors) { - aiColor4D& c = mesh->mColors[0][i]; - SkipSpaces(&sz); - sz = fast_atoreal_move(sz,(ai_real&)c.r); + // reading colors is a pain because the specification says it can be + // integers or floats, and any number of them between 1 and 4 included, + // until the next comment or end of line + // in theory should be testing type ! + if (hasColors) { + aiColor4D &c = mesh->mColors[0][i]; + SkipSpaces(&sz); + sz = fast_atoreal_move(sz, (ai_real &)c.r); if (*sz != '#' && *sz != '\n' && *sz != '\r') { - SkipSpaces(&sz); - sz = fast_atoreal_move(sz,(ai_real&)c.g); + SkipSpaces(&sz); + sz = fast_atoreal_move(sz, (ai_real &)c.g); } else { - c.g = 0.; - } + c.g = 0.; + } if (*sz != '#' && *sz != '\n' && *sz != '\r') { - SkipSpaces(&sz); - sz = fast_atoreal_move(sz,(ai_real&)c.b); + SkipSpaces(&sz); + sz = fast_atoreal_move(sz, (ai_real &)c.b); } else { - c.b = 0.; - } + c.b = 0.; + } if (*sz != '#' && *sz != '\n' && *sz != '\r') { - SkipSpaces(&sz); - sz = fast_atoreal_move(sz,(ai_real&)c.a); + SkipSpaces(&sz); + sz = fast_atoreal_move(sz, (ai_real &)c.a); } else { - c.a = 1.; - } - } + c.a = 1.; + } + } if (hasTexCoord) { - aiVector3D& t = mesh->mTextureCoords[0][i]; - SkipSpaces(&sz); - sz = fast_atoreal_move(sz,(ai_real&)t.x); - SkipSpaces(&sz); - fast_atoreal_move(sz,(ai_real&)t.y); - } + aiVector3D &t = mesh->mTextureCoords[0][i]; + SkipSpaces(&sz); + sz = fast_atoreal_move(sz, (ai_real &)t.x); + SkipSpaces(&sz); + fast_atoreal_move(sz, (ai_real &)t.y); + } } // load faces with their indices faces = mesh->mFaces; - for (unsigned int i = 0; i < numFaces; ) { - if(!GetNextLine(buffer,line)) { + for (unsigned int i = 0; i < numFaces;) { + if (!GetNextLine(buffer, line)) { ASSIMP_LOG_ERROR("OFF: The number of faces in the header is incorrect"); throw DeadlyImportError("OFF: The number of faces in the header is incorrect"); } unsigned int idx; - sz = line; SkipSpaces(&sz); - idx = strtoul10(sz,&sz); - if(!idx || idx > 9) { - ASSIMP_LOG_ERROR("OFF: Faces with zero indices aren't allowed"); + sz = line; + SkipSpaces(&sz); + idx = strtoul10(sz, &sz); + if (!idx || idx > 9) { + ASSIMP_LOG_ERROR("OFF: Faces with zero indices aren't allowed"); --mesh->mNumFaces; ++i; continue; - } - faces->mNumIndices = idx; + } + faces->mNumIndices = idx; faces->mIndices = new unsigned int[faces->mNumIndices]; - for (unsigned int m = 0; m < faces->mNumIndices;++m) { + for (unsigned int m = 0; m < faces->mNumIndices; ++m) { SkipSpaces(&sz); - idx = strtoul10(sz,&sz); + idx = strtoul10(sz, &sz); if (idx >= numVertices) { ASSIMP_LOG_ERROR("OFF: Vertex index is out of range"); idx = numVertices - 1; @@ -314,20 +307,22 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS pScene->mRootNode = new aiNode(); pScene->mRootNode->mName.Set(""); pScene->mRootNode->mNumMeshes = 1; - pScene->mRootNode->mMeshes = new unsigned int [pScene->mRootNode->mNumMeshes]; + pScene->mRootNode->mMeshes = new unsigned int[pScene->mRootNode->mNumMeshes]; pScene->mRootNode->mMeshes[0] = 0; // generate a default material pScene->mNumMaterials = 1; - pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials]; - aiMaterial* pcMat = new aiMaterial(); + pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials]; + aiMaterial *pcMat = new aiMaterial(); - aiColor4D clr( ai_real( 0.6 ), ai_real( 0.6 ), ai_real( 0.6 ), ai_real( 1.0 ) ); - pcMat->AddProperty(&clr,1,AI_MATKEY_COLOR_DIFFUSE); + aiColor4D clr(ai_real(0.6), ai_real(0.6), ai_real(0.6), ai_real(1.0)); + pcMat->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE); pScene->mMaterials[0] = pcMat; const int twosided = 1; pcMat->AddProperty(&twosided, 1, AI_MATKEY_TWOSIDED); } +} // namespace Assimp + #endif // !! ASSIMP_BUILD_NO_OFF_IMPORTER diff --git a/code/AssetLib/OFF/OFFLoader.h b/code/AssetLib/OFF/OFFLoader.h index 04bb7f481..b8577e507 100644 --- a/code/AssetLib/OFF/OFFLoader.h +++ b/code/AssetLib/OFF/OFFLoader.h @@ -57,8 +57,8 @@ namespace Assimp { */ class OFFImporter : public BaseImporter { public: - OFFImporter(); - ~OFFImporter() override; + OFFImporter() = default; + ~OFFImporter() override = default; // ------------------------------------------------------------------- /** Returns whether the class can handle the format of the given file. diff --git a/code/AssetLib/Obj/ObjFileImporter.cpp b/code/AssetLib/Obj/ObjFileImporter.cpp index 73924f86a..339e90b06 100644 --- a/code/AssetLib/Obj/ObjFileImporter.cpp +++ b/code/AssetLib/Obj/ObjFileImporter.cpp @@ -54,7 +54,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Wavefront Object Importer", "", "", @@ -103,6 +103,11 @@ const aiImporterDesc *ObjFileImporter::GetInfo() const { // ------------------------------------------------------------------------------------------------ // Obj-file import implementation void ObjFileImporter::InternReadFile(const std::string &file, aiScene *pScene, IOSystem *pIOHandler) { + if (m_pRootObject != nullptr) { + delete m_pRootObject; + m_pRootObject = nullptr; + } + // Read file into memory static constexpr char mode[] = "rb"; auto streamCloser = [&](IOStream *pStream) { diff --git a/code/AssetLib/Ogre/OgreImporter.cpp b/code/AssetLib/Ogre/OgreImporter.cpp index 860aed727..5bf6901a0 100644 --- a/code/AssetLib/Ogre/OgreImporter.cpp +++ b/code/AssetLib/Ogre/OgreImporter.cpp @@ -48,7 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Ogre3D Mesh Importer", "", "", diff --git a/code/AssetLib/OpenGEX/OpenGEXImporter.cpp b/code/AssetLib/OpenGEX/OpenGEXImporter.cpp index 16268ead5..735f56755 100644 --- a/code/AssetLib/OpenGEX/OpenGEXImporter.cpp +++ b/code/AssetLib/OpenGEX/OpenGEXImporter.cpp @@ -52,7 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Open Game Engine Exchange", "", "", @@ -66,42 +66,42 @@ static const aiImporterDesc desc = { }; namespace Grammar { - static const char* MetricType = "Metric"; - static const char *Metric_DistanceType = "distance"; - static const char *Metric_AngleType = "angle"; - static const char *Metric_TimeType = "time"; - static const char *Metric_UpType = "up"; - static const char *NameType = "Name"; - static const char *ObjectRefType = "ObjectRef"; - static const char *MaterialRefType = "MaterialRef"; - static const char *MetricKeyType = "key"; - static const char *GeometryNodeType = "GeometryNode"; - static const char *CameraNodeType = "CameraNode"; - static const char *LightNodeType = "LightNode"; - static const char *GeometryObjectType = "GeometryObject"; - static const char *CameraObjectType = "CameraObject"; - static const char *LightObjectType = "LightObject"; - static const char *TransformType = "Transform"; - static const char *MeshType = "Mesh"; - static const char *VertexArrayType = "VertexArray"; - static const char *IndexArrayType = "IndexArray"; - static const char *MaterialType = "Material"; - static const char *ColorType = "Color"; - static const char *ParamType = "Param"; - static const char *TextureType = "Texture"; - static const char *AttenType = "Atten"; + static constexpr char MetricType[] = "Metric"; + static constexpr char Metric_DistanceType[] = "distance"; + static constexpr char Metric_AngleType[] = "angle"; + static constexpr char Metric_TimeType[] = "time"; + static constexpr char Metric_UpType[] = "up"; + static constexpr char NameType[] = "Name"; + static constexpr char ObjectRefType[] = "ObjectRef"; + static constexpr char MaterialRefType[] = "MaterialRef"; + static constexpr char MetricKeyType[] = "key"; + static constexpr char GeometryNodeType[] = "GeometryNode"; + static constexpr char CameraNodeType[] = "CameraNode"; + static constexpr char LightNodeType[] = "LightNode"; + static constexpr char GeometryObjectType[] = "GeometryObject"; + static constexpr char CameraObjectType[] = "CameraObject"; + static constexpr char LightObjectType[] = "LightObject"; + static constexpr char TransformType[] = "Transform"; + static constexpr char MeshType[] = "Mesh"; + static constexpr char VertexArrayType[] = "VertexArray"; + static constexpr char IndexArrayType[] = "IndexArray"; + static constexpr char MaterialType[] = "Material"; + static constexpr char ColorType[] = "Color"; + static constexpr char ParamType[] = "Param"; + static constexpr char TextureType[] = "Texture"; + static constexpr char AttenType[] = "Atten"; - static const char *DiffuseColorToken = "diffuse"; - static const char *SpecularColorToken = "specular"; - static const char *EmissionColorToken = "emission"; + static constexpr char DiffuseColorToken[] = "diffuse"; + static constexpr char SpecularColorToken[] = "specular"; + static constexpr char EmissionColorToken[] = "emission"; - static const char *DiffuseTextureToken = "diffuse"; - static const char *DiffuseSpecularTextureToken = "specular"; - static const char *SpecularPowerTextureToken = "specular_power"; - static const char *EmissionTextureToken = "emission"; - static const char *OpacyTextureToken = "opacity"; - static const char *TransparencyTextureToken = "transparency"; - static const char *NormalTextureToken = "normal"; + static constexpr char DiffuseTextureToken[] = "diffuse"; + static constexpr char DiffuseSpecularTextureToken[] = "specular"; + static constexpr char SpecularPowerTextureToken[] = "specular_power"; + static constexpr char EmissionTextureToken[] = "emission"; + static constexpr char OpacyTextureToken[] = "opacity"; + static constexpr char TransparencyTextureToken[] = "transparency"; + static constexpr char NormalTextureToken[] = "normal"; enum TokenType { NoneType = -1, @@ -139,7 +139,7 @@ namespace Grammar { return false; } - int idx(-1); + int idx = -1; for (size_t i = 0; i < 4; i++) { if (ValidMetricToken[i] == token) { idx = (int)i; diff --git a/code/AssetLib/Ply/PlyLoader.cpp b/code/AssetLib/Ply/PlyLoader.cpp index 783c7f1c6..a747ba5cd 100644 --- a/code/AssetLib/Ply/PlyLoader.cpp +++ b/code/AssetLib/Ply/PlyLoader.cpp @@ -53,9 +53,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -using namespace ::Assimp; +namespace Assimp { -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Stanford Polygon Library (PLY) Importer", "", "", @@ -71,16 +71,16 @@ static const aiImporterDesc desc = { // ------------------------------------------------------------------------------------------------ // Internal stuff namespace { -// ------------------------------------------------------------------------------------------------ -// Checks that property index is within range -template -inline const T &GetProperty(const std::vector &props, int idx) { - if (static_cast(idx) >= props.size()) { - throw DeadlyImportError("Invalid .ply file: Property index is out of range."); - } + // ------------------------------------------------------------------------------------------------ + // Checks that property index is within range + template + inline const T &GetProperty(const std::vector &props, int idx) { + if (static_cast(idx) >= props.size()) { + throw DeadlyImportError("Invalid .ply file: Property index is out of range."); + } - return props[idx]; -} + return props[idx]; + } } // namespace // ------------------------------------------------------------------------------------------------ @@ -92,10 +92,6 @@ PLYImporter::PLYImporter() : // empty } -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -PLYImporter::~PLYImporter() = default; - // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool PLYImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { @@ -215,7 +211,7 @@ void PLYImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy throw DeadlyImportError("Invalid .ply file: Missing format specification"); } - //free the file buffer + // free the file buffer streamedBuffer.close(); if (mGeneratedMesh == nullptr) { @@ -376,7 +372,7 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn haveNormal = true; } - //Colors + // Colors aiColor4D cOut; bool haveColor = false; if (0xFFFFFFFF != aiColors[0]) { @@ -415,7 +411,7 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn haveColor = true; } - //Texture coordinates + // Texture coordinates aiVector3D tOut; tOut.z = 0; bool haveTextureCoords = false; @@ -431,7 +427,7 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn haveTextureCoords = true; } - //create aiMesh if needed + // create aiMesh if needed if (nullptr == mGeneratedMesh) { mGeneratedMesh = new aiMesh(); mGeneratedMesh->mMaterialIndex = 0; @@ -512,8 +508,8 @@ void PLYImporter::LoadFace(const PLY::Element *pcElement, const PLY::ElementInst bool bIsTriStrip = false; // index of the material index property - //unsigned int iMaterialIndex = 0xFFFFFFFF; - //PLY::EDataType eType2 = EDT_Char; + // unsigned int iMaterialIndex = 0xFFFFFFFF; + // PLY::EDataType eType2 = EDT_Char; // texture coordinates unsigned int iTextureCoord = 0xFFFFFFFF; @@ -595,7 +591,7 @@ void PLYImporter::LoadFace(const PLY::Element *pcElement, const PLY::ElementInst if (0xFFFFFFFF != iTextureCoord) { const unsigned int iNum = (unsigned int)GetProperty(instElement->alProperties, iTextureCoord).avList.size(); - //should be 6 coords + // should be 6 coords std::vector::const_iterator p = GetProperty(instElement->alProperties, iTextureCoord).avList.begin(); @@ -625,7 +621,7 @@ void PLYImporter::LoadFace(const PLY::Element *pcElement, const PLY::ElementInst // a value of -1 indicates a restart of the strip bool flip = false; const std::vector &quak = GetProperty(instElement->alProperties, iProperty).avList; - //pvOut->reserve(pvOut->size() + quak.size() + (quak.size()>>2u)); //Limits memory consumption + // pvOut->reserve(pvOut->size() + quak.size() + (quak.size()>>2u)); //Limits memory consumption int aiTable[2] = { -1, -1 }; for (std::vector::const_iterator a = quak.begin(); a != quak.end(); ++a) { @@ -863,7 +859,7 @@ void PLYImporter::LoadMaterial(std::vector *pvOut, std::string &de const int two_sided = 1; pcHelper->AddProperty(&two_sided, 1, AI_MATKEY_TWOSIDED); - //default texture + // default texture if (!defaultTexture.empty()) { const aiString name(defaultTexture.c_str()); pcHelper->AddProperty(&name, _AI_MATKEY_TEXTURE_BASE, aiTextureType_DIFFUSE, 0); @@ -873,7 +869,7 @@ void PLYImporter::LoadMaterial(std::vector *pvOut, std::string &de pcHelper->AddProperty(&two_sided, 1, AI_MATKEY_TWOSIDED); } - //set to wireframe, so when using this material info we can switch to points rendering + // set to wireframe, so when using this material info we can switch to points rendering if (pointsOnly) { const int wireframe = 1; pcHelper->AddProperty(&wireframe, 1, AI_MATKEY_ENABLE_WIREFRAME); @@ -890,7 +886,7 @@ void PLYImporter::LoadMaterial(std::vector *pvOut, std::string &de int iMode = (int)aiShadingMode_Gouraud; pcHelper->AddProperty(&iMode, 1, AI_MATKEY_SHADING_MODEL); - //generate white material most 3D engine just multiply ambient / diffuse color with actual ambient / light color + // generate white material most 3D engine just multiply ambient / diffuse color with actual ambient / light color aiColor3D clr; clr.b = clr.g = clr.r = 1.0f; pcHelper->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE); @@ -906,13 +902,13 @@ void PLYImporter::LoadMaterial(std::vector *pvOut, std::string &de pcHelper->AddProperty(&two_sided, 1, AI_MATKEY_TWOSIDED); } - //default texture + // default texture if (!defaultTexture.empty()) { const aiString name(defaultTexture.c_str()); pcHelper->AddProperty(&name, _AI_MATKEY_TEXTURE_BASE, aiTextureType_DIFFUSE, 0); } - //set to wireframe, so when using this material info we can switch to points rendering + // set to wireframe, so when using this material info we can switch to points rendering if (pointsOnly) { const int wireframe = 1; pcHelper->AddProperty(&wireframe, 1, AI_MATKEY_ENABLE_WIREFRAME); @@ -922,4 +918,6 @@ void PLYImporter::LoadMaterial(std::vector *pvOut, std::string &de } } +} // namespace Assimp + #endif // !! ASSIMP_BUILD_NO_PLY_IMPORTER diff --git a/code/AssetLib/Ply/PlyLoader.h b/code/AssetLib/Ply/PlyLoader.h index e29da1db6..f85445f91 100644 --- a/code/AssetLib/Ply/PlyLoader.h +++ b/code/AssetLib/Ply/PlyLoader.h @@ -65,7 +65,7 @@ using namespace PLY; class PLYImporter : public BaseImporter { public: PLYImporter(); - ~PLYImporter() override; + ~PLYImporter() override = default; // ------------------------------------------------------------------- /** Returns whether the class can handle the format of the given file. diff --git a/code/AssetLib/Q3BSP/Q3BSPFileImporter.cpp b/code/AssetLib/Q3BSP/Q3BSPFileImporter.cpp index 924949eeb..30b1bf053 100644 --- a/code/AssetLib/Q3BSP/Q3BSPFileImporter.cpp +++ b/code/AssetLib/Q3BSP/Q3BSPFileImporter.cpp @@ -65,7 +65,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Quake III BSP Importer", "", "", @@ -146,7 +146,11 @@ Q3BSPFileImporter::Q3BSPFileImporter() : // ------------------------------------------------------------------------------------------------ // Destructor. Q3BSPFileImporter::~Q3BSPFileImporter() { - // Clear face-to-material map + clear(); +} + +// ------------------------------------------------------------------------------------------------ +void Q3BSPFileImporter::clear() { for (FaceMap::iterator it = m_MaterialLookupMap.begin(); it != m_MaterialLookupMap.end(); ++it) { const std::string &matName = it->first; if (!matName.empty()) { @@ -173,6 +177,7 @@ const aiImporterDesc *Q3BSPFileImporter::GetInfo() const { // ------------------------------------------------------------------------------------------------ // Import method. void Q3BSPFileImporter::InternReadFile(const std::string &rFile, aiScene *scene, IOSystem *ioHandler) { + clear(); ZipArchiveIOSystem Archive(ioHandler, rFile); if (!Archive.isOpen()) { throw DeadlyImportError("Failed to open file ", rFile, "."); diff --git a/code/AssetLib/Q3BSP/Q3BSPFileImporter.h b/code/AssetLib/Q3BSP/Q3BSPFileImporter.h index fdcfff876..63d6edb21 100644 --- a/code/AssetLib/Q3BSP/Q3BSPFileImporter.h +++ b/code/AssetLib/Q3BSP/Q3BSPFileImporter.h @@ -81,6 +81,7 @@ protected: using FaceMapIt = std::map* >::iterator; using FaceMapConstIt = std::map*>::const_iterator; + void clear(); const aiImporterDesc* GetInfo () const override; void InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) override; void separateMapName( const std::string &rImportName, std::string &rArchiveName, std::string &rMapName ); diff --git a/code/AssetLib/Q3D/Q3DLoader.cpp b/code/AssetLib/Q3D/Q3DLoader.cpp index 22d1065de..b599ad8f2 100644 --- a/code/AssetLib/Q3D/Q3DLoader.cpp +++ b/code/AssetLib/Q3D/Q3DLoader.cpp @@ -55,9 +55,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -using namespace Assimp; +namespace Assimp { -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Quick3D Importer", "", "", @@ -127,7 +127,7 @@ void Q3DImporter::InternReadFile(const std::string &pFile, std::vector materials; try { materials.reserve(numMats); - } catch(const std::bad_alloc&) { + } catch (const std::bad_alloc &) { ASSIMP_LOG_ERROR("Invalid alloc for materials."); throw DeadlyImportError("Invalid Quick3D-file, material allocation failed."); } @@ -135,7 +135,7 @@ void Q3DImporter::InternReadFile(const std::string &pFile, std::vector meshes; try { meshes.reserve(numMeshes); - } catch(const std::bad_alloc&) { + } catch (const std::bad_alloc &) { ASSIMP_LOG_ERROR("Invalid alloc for meshes."); throw DeadlyImportError("Invalid Quick3D-file, mesh allocation failed."); } @@ -237,7 +237,6 @@ void Q3DImporter::InternReadFile(const std::string &pFile, if (minor > '0' && major == '3') stream.IncPtr(mesh.faces.size()); } - // stream.IncPtr(4); // unknown value here } break; // materials chunk @@ -275,8 +274,6 @@ void Q3DImporter::InternReadFile(const std::string &pFile, // read the transparency mat.transparency = stream.GetF4(); - // unknown value here - // stream.IncPtr(4); // FIX: it could be the texture index ... mat.texIdx = (unsigned int)stream.GetI4(); } @@ -425,7 +422,8 @@ outer: pScene->mMeshes = new aiMesh *[pScene->mNumMaterials]; for (unsigned int i = 0, real = 0; i < (unsigned int)materials.size(); ++i) { - if (fidx[i].empty()) continue; + if (fidx[i].empty()) + continue; // Allocate a mesh and a material aiMesh *mesh = pScene->mMeshes[real] = new aiMesh(); @@ -548,14 +546,9 @@ outer: // Now we need to attach the meshes to the root node of the scene pScene->mRootNode->mNumMeshes = pScene->mNumMeshes; pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes]; - for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) + for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) { pScene->mRootNode->mMeshes[i] = i; - - /*pScene->mRootNode->mTransformation *= aiMatrix4x4( - 1.f, 0.f, 0.f, 0.f, - 0.f, -1.f,0.f, 0.f, - 0.f, 0.f, 1.f, 0.f, - 0.f, 0.f, 0.f, 1.f);*/ + } // Add cameras and light sources to the scene root node pScene->mRootNode->mNumChildren = pScene->mNumLights + pScene->mNumCameras; @@ -577,4 +570,6 @@ outer: } } +} // namespace Assimp + #endif // !! ASSIMP_BUILD_NO_Q3D_IMPORTER diff --git a/code/AssetLib/Raw/RawLoader.cpp b/code/AssetLib/Raw/RawLoader.cpp index 1791a5c52..4c5f852b0 100644 --- a/code/AssetLib/Raw/RawLoader.cpp +++ b/code/AssetLib/Raw/RawLoader.cpp @@ -55,9 +55,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -using namespace Assimp; +namespace Assimp { -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Raw Importer", "", "", @@ -70,14 +70,6 @@ static const aiImporterDesc desc = { "raw" }; -// ------------------------------------------------------------------------------------------------ -// Constructor to be privately used by Importer -RAWImporter::RAWImporter() = default; - -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -RAWImporter::~RAWImporter() = default; - // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool RAWImporter::CanRead(const std::string &filename, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const { @@ -295,4 +287,6 @@ void RAWImporter::InternReadFile(const std::string &pFile, } } +} // namespace Assimp + #endif // !! ASSIMP_BUILD_NO_RAW_IMPORTER diff --git a/code/AssetLib/Raw/RawLoader.h b/code/AssetLib/Raw/RawLoader.h index 54314f728..83e4a9f1f 100644 --- a/code/AssetLib/Raw/RawLoader.h +++ b/code/AssetLib/Raw/RawLoader.h @@ -57,8 +57,8 @@ namespace Assimp { */ class RAWImporter : public BaseImporter { public: - RAWImporter(); - ~RAWImporter() override; + RAWImporter() = default; + ~RAWImporter() override = default; // ------------------------------------------------------------------- /** Returns whether the class can handle the format of the given file. diff --git a/code/AssetLib/SIB/SIBImporter.cpp b/code/AssetLib/SIB/SIBImporter.cpp index 9f299180b..26b1c5227 100644 --- a/code/AssetLib/SIB/SIBImporter.cpp +++ b/code/AssetLib/SIB/SIBImporter.cpp @@ -69,9 +69,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include -using namespace Assimp; +namespace Assimp { -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Silo SIB Importer", "Richard Mitton (http://www.codersnotes.com/about)", "", @@ -94,7 +94,7 @@ enum { N }; -typedef std::pair SIBPair; +using SIBPair = std::pair; struct SIBEdge { uint32_t faceA, faceB; @@ -199,15 +199,6 @@ static aiString ReadString(StreamReaderLE *stream, uint32_t numWChars) { return result; } - -// ------------------------------------------------------------------------------------------------ -// Constructor to be privately used by Importer -SIBImporter::SIBImporter() = default; - -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -SIBImporter::~SIBImporter() = default; - // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool SIBImporter::CanRead(const std::string &filename, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const { @@ -882,4 +873,6 @@ void SIBImporter::InternReadFile(const std::string &pFile, } } +} // namespace Assimp + #endif // !! ASSIMP_BUILD_NO_SIB_IMPORTER diff --git a/code/AssetLib/SIB/SIBImporter.h b/code/AssetLib/SIB/SIBImporter.h index 2b197ddca..903c36561 100644 --- a/code/AssetLib/SIB/SIBImporter.h +++ b/code/AssetLib/SIB/SIBImporter.h @@ -57,8 +57,8 @@ namespace Assimp { */ class ASSIMP_API SIBImporter : public BaseImporter { public: - SIBImporter(); - ~SIBImporter() override; + SIBImporter() = default; + ~SIBImporter() override = default; // ------------------------------------------------------------------- /** Returns whether the class can handle the format of the given file. diff --git a/code/AssetLib/Unreal/UnrealLoader.cpp b/code/AssetLib/Unreal/UnrealLoader.cpp index f2b0ab118..7d7b4dc76 100644 --- a/code/AssetLib/Unreal/UnrealLoader.cpp +++ b/code/AssetLib/Unreal/UnrealLoader.cpp @@ -152,7 +152,7 @@ inline void DecompressVertex(aiVector3D &v, int32_t in) { } // end namespace Unreal -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Unreal Mesh Importer", "", "", diff --git a/code/AssetLib/glTF/glTFImporter.cpp b/code/AssetLib/glTF/glTFImporter.cpp index 110a2a52f..cd8b7762d 100644 --- a/code/AssetLib/glTF/glTFImporter.cpp +++ b/code/AssetLib/glTF/glTFImporter.cpp @@ -62,11 +62,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using namespace Assimp; using namespace glTF; -// -// glTFImporter -// - -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "glTF Importer", "", "", diff --git a/code/AssetLib/glTF2/glTF2Importer.cpp b/code/AssetLib/glTF2/glTF2Importer.cpp index 0fed11cef..4bdbe39f1 100644 --- a/code/AssetLib/glTF2/glTF2Importer.cpp +++ b/code/AssetLib/glTF2/glTF2Importer.cpp @@ -82,7 +82,7 @@ struct Tangent { // glTF2Importer // -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "glTF2 Importer", "", "", diff --git a/include/assimp/BaseImporter.h b/include/assimp/BaseImporter.h index d0b173171..f9df32b32 100644 --- a/include/assimp/BaseImporter.h +++ b/include/assimp/BaseImporter.h @@ -63,6 +63,7 @@ struct aiImporterDesc; namespace Assimp { +// Forward declarations class Importer; class IOSystem; class BaseProcess; @@ -73,6 +74,9 @@ class IOStream; #define AI_MAKE_MAGIC(string) ((uint32_t)((string[0] << 24) + \ (string[1] << 16) + (string[2] << 8) + string[3])) +using UByteBuffer = std::vector; +using ByteBuffer = std::vector; + // --------------------------------------------------------------------------- /** FOR IMPORTER PLUGINS ONLY: The BaseImporter defines a common interface * for all importer worker classes. diff --git a/include/assimp/ParsingUtils.h b/include/assimp/ParsingUtils.h index b08f23227..7e7fb161c 100644 --- a/include/assimp/ParsingUtils.h +++ b/include/assimp/ParsingUtils.h @@ -70,7 +70,6 @@ namespace Assimp { static const unsigned int BufferSize = 4096; - // --------------------------------------------------------------------------------- template AI_FORCE_INLINE bool IsUpper(char_t in) { From 4535e37fc65d57f7848d6b1bce08f400e52fa7c5 Mon Sep 17 00:00:00 2001 From: Kim Kulling Date: Sat, 11 Nov 2023 21:13:47 +0100 Subject: [PATCH 07/16] Fix namespaces. --- code/AssetLib/3DS/3DSConverter.cpp | 10 +++-- code/AssetLib/3DS/3DSExporter.h | 6 +-- code/AssetLib/3DS/3DSLoader.cpp | 4 +- code/AssetLib/3MF/D3MFImporter.cpp | 4 -- code/AssetLib/3MF/D3MFImporter.h | 4 +- code/AssetLib/3MF/D3MFOpcPackage.cpp | 10 ++--- code/AssetLib/3MF/XmlSerializer.cpp | 6 +-- code/AssetLib/AC/ACLoader.cpp | 4 +- code/AssetLib/ASE/ASELoader.cpp | 4 +- code/AssetLib/ASE/ASEParser.cpp | 4 +- code/AssetLib/B3D/B3DImporter.cpp | 20 +++++----- code/AssetLib/BVH/BVHLoader.cpp | 48 +++++++++++------------ code/AssetLib/COB/COBLoader.cpp | 4 +- code/AssetLib/SMD/SMDLoader.cpp | 6 ++- code/AssetLib/STL/STLLoader.cpp | 41 +++++++++---------- code/AssetLib/Terragen/TerragenLoader.cpp | 10 ++--- code/AssetLib/Terragen/TerragenLoader.h | 2 +- code/AssetLib/Unreal/UnrealLoader.cpp | 14 ++++--- code/AssetLib/X/XFileImporter.cpp | 2 +- code/AssetLib/XGL/XGLLoader.cpp | 12 +++++- code/AssetLib/XGL/XGLLoader.h | 2 + include/assimp/vector3.h | 2 + 22 files changed, 121 insertions(+), 98 deletions(-) diff --git a/code/AssetLib/3DS/3DSConverter.cpp b/code/AssetLib/3DS/3DSConverter.cpp index b4f625b76..b99e9f798 100644 --- a/code/AssetLib/3DS/3DSConverter.cpp +++ b/code/AssetLib/3DS/3DSConverter.cpp @@ -52,9 +52,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -using namespace Assimp; +namespace Assimp { -static const unsigned int NotSet = 0xcdcdcdcd; +static constexpr unsigned int NotSet = 0xcdcdcdcd; // ------------------------------------------------------------------------------------------------ // Setup final material indices, generae a default material if necessary @@ -68,7 +68,7 @@ void Discreet3DSImporter::ReplaceDefaultMaterial() { unsigned int idx(NotSet); for (unsigned int i = 0; i < mScene->mMaterials.size(); ++i) { std::string s = mScene->mMaterials[i].mName; - for (char & it : s) { + for (char &it : s) { it = static_cast(::tolower(static_cast(it))); } @@ -262,7 +262,7 @@ void Discreet3DSImporter::ConvertMaterial(D3DS::Material &oldMat, unsigned int iWire = 1; mat.AddProperty((int *)&iWire, 1, AI_MATKEY_ENABLE_WIREFRAME); } - [[fallthrough]]; + [[fallthrough]]; case D3DS::Discreet3DS::Gouraud: eShading = aiShadingMode_Gouraud; @@ -805,4 +805,6 @@ void Discreet3DSImporter::ConvertScene(aiScene *pcOut) { } } +} // namespace Assimp + #endif // !! ASSIMP_BUILD_NO_3DS_IMPORTER diff --git a/code/AssetLib/3DS/3DSExporter.h b/code/AssetLib/3DS/3DSExporter.h index 82ec3512f..66e91e10d 100644 --- a/code/AssetLib/3DS/3DSExporter.h +++ b/code/AssetLib/3DS/3DSExporter.h @@ -4,7 +4,6 @@ Open Asset Import Library (assimp) Copyright (c) 2006-2022, assimp team - All rights reserved. Redistribution and use of this software in source and binary forms, @@ -57,8 +56,7 @@ struct aiNode; struct aiMaterial; struct aiMesh; -namespace Assimp -{ +namespace Assimp { // ------------------------------------------------------------------------------------------------ /** @@ -88,7 +86,7 @@ private: std::map trafos; - typedef std::multimap MeshesByNodeMap; + using MeshesByNodeMap = std::multimap; MeshesByNodeMap meshes; }; diff --git a/code/AssetLib/3DS/3DSLoader.cpp b/code/AssetLib/3DS/3DSLoader.cpp index bec77ff23..a2dcc32ac 100644 --- a/code/AssetLib/3DS/3DSLoader.cpp +++ b/code/AssetLib/3DS/3DSLoader.cpp @@ -54,7 +54,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -using namespace Assimp; +namespace Assimp { static constexpr aiImporterDesc desc = { "Discreet 3DS Importer", @@ -1335,4 +1335,6 @@ void Discreet3DSImporter::ParseColorChunk(aiColor3D *out, bool acceptPercent) { (void)bGamma; } +} // namespace Assimp + #endif // !! ASSIMP_BUILD_NO_3DS_IMPORTER diff --git a/code/AssetLib/3MF/D3MFImporter.cpp b/code/AssetLib/3MF/D3MFImporter.cpp index add33bb79..e8529064c 100644 --- a/code/AssetLib/3MF/D3MFImporter.cpp +++ b/code/AssetLib/3MF/D3MFImporter.cpp @@ -81,10 +81,6 @@ static constexpr aiImporterDesc desc = { "3mf" }; -D3MFImporter::D3MFImporter() = default; - -D3MFImporter::~D3MFImporter() = default; - bool D3MFImporter::CanRead(const std::string &filename, IOSystem *pIOHandler, bool /*checkSig*/) const { if (!ZipArchiveIOSystem::isZipArchive(pIOHandler, filename)) { return false; diff --git a/code/AssetLib/3MF/D3MFImporter.h b/code/AssetLib/3MF/D3MFImporter.h index a39ae790f..9ae68acb0 100644 --- a/code/AssetLib/3MF/D3MFImporter.h +++ b/code/AssetLib/3MF/D3MFImporter.h @@ -56,10 +56,10 @@ namespace Assimp { class D3MFImporter : public BaseImporter { public: /// @brief The default class constructor. - D3MFImporter(); + D3MFImporter() = default; /// @brief The class destructor. - ~D3MFImporter() override; + ~D3MFImporter() override = default; /// @brief Performs the data format detection. /// @param pFile The filename to check. diff --git a/code/AssetLib/3MF/D3MFOpcPackage.cpp b/code/AssetLib/3MF/D3MFOpcPackage.cpp index 934305d49..a173b1c6a 100644 --- a/code/AssetLib/3MF/D3MFOpcPackage.cpp +++ b/code/AssetLib/3MF/D3MFOpcPackage.cpp @@ -68,7 +68,7 @@ using OpcPackageRelationshipPtr = std::shared_ptr; class OpcPackageRelationshipReader { public: OpcPackageRelationshipReader(XmlParser &parser) : - m_relationShips() { + mRelations() { XmlNode root = parser.getRootNode(); ParseRootNode(root); } @@ -108,13 +108,13 @@ public: relPtr->type = currentNode.attribute(XmlTag::RELS_ATTRIB_TYPE).as_string(); relPtr->target = currentNode.attribute(XmlTag::RELS_ATTRIB_TARGET).as_string(); if (validateRels(relPtr)) { - m_relationShips.push_back(relPtr); + mRelations.push_back(relPtr); } } } } - std::vector m_relationShips; + std::vector mRelations; }; static bool IsEmbeddedTexture( const std::string &filename ) { @@ -217,11 +217,11 @@ std::string D3MFOpcPackage::ReadPackageRootRelationship(IOStream *stream) { OpcPackageRelationshipReader reader(xmlParser); - auto itr = std::find_if(reader.m_relationShips.begin(), reader.m_relationShips.end(), [](const OpcPackageRelationshipPtr &rel) { + auto itr = std::find_if(reader.mRelations.begin(), reader.mRelations.end(), [](const OpcPackageRelationshipPtr &rel) { return rel->type == XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE; }); - if (itr == reader.m_relationShips.end()) { + if (itr == reader.mRelations.end()) { throw DeadlyImportError("Cannot find ", XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE); } diff --git a/code/AssetLib/3MF/XmlSerializer.cpp b/code/AssetLib/3MF/XmlSerializer.cpp index c77111728..5fcdc0ccc 100644 --- a/code/AssetLib/3MF/XmlSerializer.cpp +++ b/code/AssetLib/3MF/XmlSerializer.cpp @@ -49,12 +49,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. namespace Assimp { namespace D3MF { -static const int IdNotSet = -1; +static constexpr int IdNotSet = -1; namespace { -static const size_t ColRGBA_Len = 9; -static const size_t ColRGB_Len = 7; +static constexpr size_t ColRGBA_Len = 9; +static constexpr size_t ColRGB_Len = 7; // format of the color string: #RRGGBBAA or #RRGGBB (3MF Core chapter 5.1.1) bool validateColorString(const char *color) { diff --git a/code/AssetLib/AC/ACLoader.cpp b/code/AssetLib/AC/ACLoader.cpp index 4c6c48737..1bb77c441 100644 --- a/code/AssetLib/AC/ACLoader.cpp +++ b/code/AssetLib/AC/ACLoader.cpp @@ -60,7 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -using namespace Assimp; +namespace Assimp { static constexpr aiImporterDesc desc = { "AC3D Importer", @@ -862,4 +862,6 @@ void AC3DImporter::InternReadFile(const std::string &pFile, } } +} // namespace Assimp + #endif //!defined ASSIMP_BUILD_NO_AC_IMPORTER diff --git a/code/AssetLib/ASE/ASELoader.cpp b/code/AssetLib/ASE/ASELoader.cpp index db34b8ac4..94e213fb3 100644 --- a/code/AssetLib/ASE/ASELoader.cpp +++ b/code/AssetLib/ASE/ASELoader.cpp @@ -63,7 +63,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // utilities #include -using namespace Assimp; +namespace Assimp { using namespace Assimp::ASE; static constexpr aiImporterDesc desc = { @@ -1262,6 +1262,8 @@ bool ASEImporter::GenerateNormals(ASE::Mesh &mesh) { return false; } +} + #endif // ASSIMP_BUILD_NO_3DS_IMPORTER #endif // !! ASSIMP_BUILD_NO_BASE_IMPORTER diff --git a/code/AssetLib/ASE/ASEParser.cpp b/code/AssetLib/ASE/ASEParser.cpp index c43eb42ff..90f462598 100644 --- a/code/AssetLib/ASE/ASEParser.cpp +++ b/code/AssetLib/ASE/ASEParser.cpp @@ -53,7 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -using namespace Assimp; +namespace Assimp { using namespace Assimp::ASE; // ------------------------------------------------------------------------------------------------ @@ -1864,6 +1864,8 @@ void Parser::ParseLV4MeshLong(unsigned int &iOut) { iOut = strtoul10(filePtr, &filePtr); } +} + #endif // ASSIMP_BUILD_NO_3DS_IMPORTER #endif // !! ASSIMP_BUILD_NO_BASE_IMPORTER diff --git a/code/AssetLib/B3D/B3DImporter.cpp b/code/AssetLib/B3D/B3DImporter.cpp index 6e0b8a85b..670f3de53 100644 --- a/code/AssetLib/B3D/B3DImporter.cpp +++ b/code/AssetLib/B3D/B3DImporter.cpp @@ -59,7 +59,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include -using namespace Assimp; +namespace Assimp { using namespace std; static constexpr aiImporterDesc desc = { @@ -79,9 +79,9 @@ static constexpr aiImporterDesc desc = { #pragma warning(disable : 4018) #endif -//#define DEBUG_B3D +// #define DEBUG_B3D -template +template void DeleteAllBarePointers(std::vector &x) { for (auto p : x) { delete p; @@ -329,7 +329,7 @@ void B3DImporter::ReadBRUS() { mat->AddProperty(&i, 1, AI_MATKEY_TWOSIDED); } - //Textures + // Textures for (int i = 0; i < n_texs; ++i) { int texid = ReadInt(); if (texid < -1 || (texid >= 0 && texid >= static_cast(_textures.size()))) { @@ -372,7 +372,7 @@ void B3DImporter::ReadVRTS() { } if (_vflags & 2) { - ReadQuat(); //skip v 4bytes... + ReadQuat(); // skip v 4bytes... } for (int j = 0; j < _tcsets; ++j) { @@ -704,22 +704,22 @@ void B3DImporter::ReadBB3D(aiScene *scene) { } } - //nodes + // nodes scene->mRootNode = _nodes[0]; _nodes.clear(); // node ownership now belongs to scene - //material + // material if (!_materials.size()) { _materials.emplace_back(std::unique_ptr(new aiMaterial)); } scene->mNumMaterials = static_cast(_materials.size()); scene->mMaterials = unique_to_array(_materials); - //meshes + // meshes scene->mNumMeshes = static_cast(_meshes.size()); scene->mMeshes = unique_to_array(_meshes); - //animations + // animations if (_animations.size() == 1 && _nodeAnims.size()) { aiAnimation *anim = _animations.back().get(); @@ -738,4 +738,6 @@ void B3DImporter::ReadBB3D(aiScene *scene) { flip.Execute(scene); } +} // namespace Assimp + #endif // !! ASSIMP_BUILD_NO_B3D_IMPORTER diff --git a/code/AssetLib/BVH/BVHLoader.cpp b/code/AssetLib/BVH/BVHLoader.cpp index 990eef8c7..4d2cfde15 100644 --- a/code/AssetLib/BVH/BVHLoader.cpp +++ b/code/AssetLib/BVH/BVHLoader.cpp @@ -55,7 +55,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -using namespace Assimp; +namespace Assimp { + using namespace Assimp::Formatter; static constexpr aiImporterDesc desc = { @@ -73,8 +74,8 @@ static constexpr aiImporterDesc desc = { // ------------------------------------------------------------------------------------------------ // Aborts the file reading with an exception -template -AI_WONT_RETURN void BVHLoader::ThrowException(T&&... args) { +template +AI_WONT_RETURN void BVHLoader::ThrowException(T &&...args) { throw DeadlyImportError(mFileName, ":", mLine, " - ", args...); } @@ -426,7 +427,7 @@ void BVHLoader::CreateAnimation(aiScene *pScene) { nodeAnim->mNodeName.Set(nodeName); std::map channelMap; - //Build map of channels + // Build map of channels for (unsigned int channel = 0; channel < node.mChannels.size(); ++channel) { channelMap[node.mChannels[channel]] = channel; } @@ -441,7 +442,7 @@ void BVHLoader::CreateAnimation(aiScene *pScene) { // Now compute all translations for (BVHLoader::ChannelType channel = Channel_PositionX; channel <= Channel_PositionZ; channel = (BVHLoader::ChannelType)(channel + 1)) { - //Find channel in node + // Find channel in node std::map::iterator mapIter = channelMap.find(channel); if (mapIter == channelMap.end()) @@ -485,30 +486,27 @@ void BVHLoader::CreateAnimation(aiScene *pScene) { for (unsigned int fr = 0; fr < mAnimNumFrames; ++fr) { aiMatrix4x4 temp; aiMatrix3x3 rotMatrix; - for (unsigned int channelIdx = 0; channelIdx < node.mChannels.size(); ++ channelIdx) { - switch (node.mChannels[channelIdx]) { - case Channel_RotationX: - { + for (unsigned int channelIdx = 0; channelIdx < node.mChannels.size(); ++channelIdx) { + switch (node.mChannels[channelIdx]) { + case Channel_RotationX: { const float angle = node.mChannelValues[fr * node.mChannels.size() + channelIdx] * float(AI_MATH_PI) / 180.0f; - aiMatrix4x4::RotationX( angle, temp); rotMatrix *= aiMatrix3x3( temp); - } - break; - case Channel_RotationY: - { + aiMatrix4x4::RotationX(angle, temp); + rotMatrix *= aiMatrix3x3(temp); + } break; + case Channel_RotationY: { const float angle = node.mChannelValues[fr * node.mChannels.size() + channelIdx] * float(AI_MATH_PI) / 180.0f; - aiMatrix4x4::RotationY( angle, temp); rotMatrix *= aiMatrix3x3( temp); - } - break; - case Channel_RotationZ: - { + aiMatrix4x4::RotationY(angle, temp); + rotMatrix *= aiMatrix3x3(temp); + } break; + case Channel_RotationZ: { const float angle = node.mChannelValues[fr * node.mChannels.size() + channelIdx] * float(AI_MATH_PI) / 180.0f; - aiMatrix4x4::RotationZ( angle, temp); rotMatrix *= aiMatrix3x3( temp); - } - break; + aiMatrix4x4::RotationZ(angle, temp); + rotMatrix *= aiMatrix3x3(temp); + } break; default: break; - } - } + } + } rotkey->mTime = double(fr); rotkey->mValue = aiQuaternion(rotMatrix); ++rotkey; @@ -525,4 +523,6 @@ void BVHLoader::CreateAnimation(aiScene *pScene) { } } +} // namespace Assimp + #endif // !! ASSIMP_BUILD_NO_BVH_IMPORTER diff --git a/code/AssetLib/COB/COBLoader.cpp b/code/AssetLib/COB/COBLoader.cpp index dc0199263..9a6e32f6d 100644 --- a/code/AssetLib/COB/COBLoader.cpp +++ b/code/AssetLib/COB/COBLoader.cpp @@ -61,7 +61,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include -using namespace Assimp; +namespace Assimp { using namespace Assimp::COB; using namespace Assimp::Formatter; @@ -1164,4 +1164,6 @@ void COBImporter::ReadUnit_Binary(COB::Scene &out, StreamReaderLE &reader, const ASSIMP_LOG_WARN("`Unit` chunk ", nfo.id, " is a child of ", nfo.parent_id, " which does not exist"); } +} + #endif // ASSIMP_BUILD_NO_COB_IMPORTER diff --git a/code/AssetLib/SMD/SMDLoader.cpp b/code/AssetLib/SMD/SMDLoader.cpp index 9af871cee..4b63dd9d0 100644 --- a/code/AssetLib/SMD/SMDLoader.cpp +++ b/code/AssetLib/SMD/SMDLoader.cpp @@ -64,9 +64,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define strtok_s strtok_r #endif -using namespace Assimp; +namespace Assimp { -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Valve SMD Importer", "", "", @@ -1077,4 +1077,6 @@ void SMDImporter::ParseVertex(const char* szCurrent, SMDI_PARSE_RETURN; } +} + #endif // !! ASSIMP_BUILD_NO_SMD_IMPORTER diff --git a/code/AssetLib/STL/STLLoader.cpp b/code/AssetLib/STL/STLLoader.cpp index 9c0fb4f59..269ee1467 100644 --- a/code/AssetLib/STL/STLLoader.cpp +++ b/code/AssetLib/STL/STLLoader.cpp @@ -52,11 +52,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -using namespace Assimp; +namespace Assimp { namespace { -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Stereolithography (STL) Importer", "", "", @@ -129,7 +129,7 @@ STLImporter::STLImporter() : mBuffer(), mFileSize(0), mScene() { - // empty + // empty } // ------------------------------------------------------------------------------------------------ @@ -250,13 +250,13 @@ void STLImporter::LoadASCIIFile(aiNode *root) { sz += 5; // skip the "solid" SkipSpaces(&sz); const char *szMe = sz; - while (!::IsSpaceOrNewLine(*sz)) { + while (!IsSpaceOrNewLine(*sz)) { sz++; } size_t temp = (size_t)(sz - szMe); // setup the name of the node - if ( temp ) { + if (temp) { if (temp >= MAXLEN) { throw DeadlyImportError("STL: Node name too long"); } @@ -303,7 +303,7 @@ void STLImporter::LoadASCIIFile(aiNode *root) { normalBuffer.emplace_back(vn); normalBuffer.emplace_back(vn); } - } else if (!strncmp(sz, "vertex", 6) && ::IsSpaceOrNewLine(*(sz + 6))) { // vertex 1.50000 1.50000 0.00000 + } else if (!strncmp(sz, "vertex", 6) && IsSpaceOrNewLine(*(sz + 6))) { // vertex 1.50000 1.50000 0.00000 if (faceVertexCounter >= 3) { ASSIMP_LOG_ERROR("STL: a facet with more than 3 vertices has been found"); ++sz; @@ -325,14 +325,14 @@ void STLImporter::LoadASCIIFile(aiNode *root) { } else if (!::strncmp(sz, "endsolid", 8)) { do { ++sz; - } while (!::IsLineEnd(*sz)); + } while (!IsLineEnd(*sz)); SkipSpacesAndLineEnd(&sz); // finished! break; } else { // else skip the whole identifier do { ++sz; - } while (!::IsSpaceOrNewLine(*sz)); + } while (!IsSpaceOrNewLine(*sz)); } } @@ -349,14 +349,14 @@ void STLImporter::LoadASCIIFile(aiNode *root) { throw DeadlyImportError("Normal buffer size does not match position buffer size"); } - // only process positionbuffer when filled, else exception when accessing with index operator + // only process position buffer when filled, else exception when accessing with index operator // see line 353: only warning is triggered - // see line 373(now): access to empty positionbuffer with index operator forced exception + // see line 373(now): access to empty position buffer with index operator forced exception if (!positionBuffer.empty()) { pMesh->mNumFaces = static_cast(positionBuffer.size() / 3); pMesh->mNumVertices = static_cast(positionBuffer.size()); pMesh->mVertices = new aiVector3D[pMesh->mNumVertices]; - for (size_t i=0; imNumVertices; ++i ) { + for (size_t i = 0; i < pMesh->mNumVertices; ++i) { pMesh->mVertices[i].x = positionBuffer[i].x; pMesh->mVertices[i].y = positionBuffer[i].y; pMesh->mVertices[i].z = positionBuffer[i].z; @@ -366,7 +366,7 @@ void STLImporter::LoadASCIIFile(aiNode *root) { // also only process normalBuffer when filled, else exception when accessing with index operator if (!normalBuffer.empty()) { pMesh->mNormals = new aiVector3D[pMesh->mNumVertices]; - for (size_t i=0; imNumVertices; ++i ) { + for (size_t i = 0; i < pMesh->mNumVertices; ++i) { pMesh->mNormals[i].x = normalBuffer[i].x; pMesh->mNormals[i].y = normalBuffer[i].y; pMesh->mNormals[i].z = normalBuffer[i].z; @@ -450,9 +450,8 @@ bool STLImporter::LoadBinaryFile() { aiVector3D *vp = pMesh->mVertices = new aiVector3D[pMesh->mNumVertices]; aiVector3D *vn = pMesh->mNormals = new aiVector3D[pMesh->mNumVertices]; - typedef aiVector3t aiVector3F; - aiVector3F *theVec; - aiVector3F theVec3F; + aiVector3f *theVec; + aiVector3f theVec3F; for (unsigned int i = 0; i < pMesh->mNumFaces; ++i) { // NOTE: Blender sometimes writes empty normals ... this is not @@ -460,8 +459,8 @@ bool STLImporter::LoadBinaryFile() { // There's one normal for the face in the STL; use it three times // for vertex normals - theVec = (aiVector3F *)sz; - ::memcpy(&theVec3F, theVec, sizeof(aiVector3F)); + theVec = (aiVector3f *)sz; + ::memcpy(&theVec3F, theVec, sizeof(aiVector3f)); vn->x = theVec3F.x; vn->y = theVec3F.y; vn->z = theVec3F.z; @@ -471,7 +470,7 @@ bool STLImporter::LoadBinaryFile() { vn += 3; // vertex 1 - ::memcpy(&theVec3F, theVec, sizeof(aiVector3F)); + ::memcpy(&theVec3F, theVec, sizeof(aiVector3f)); vp->x = theVec3F.x; vp->y = theVec3F.y; vp->z = theVec3F.z; @@ -479,7 +478,7 @@ bool STLImporter::LoadBinaryFile() { ++vp; // vertex 2 - ::memcpy(&theVec3F, theVec, sizeof(aiVector3F)); + ::memcpy(&theVec3F, theVec, sizeof(aiVector3f)); vp->x = theVec3F.x; vp->y = theVec3F.y; vp->z = theVec3F.z; @@ -487,7 +486,7 @@ bool STLImporter::LoadBinaryFile() { ++vp; // vertex 3 - ::memcpy(&theVec3F, theVec, sizeof(aiVector3F)); + ::memcpy(&theVec3F, theVec, sizeof(aiVector3f)); vp->x = theVec3F.x; vp->y = theVec3F.y; vp->z = theVec3F.z; @@ -570,4 +569,6 @@ void STLImporter::pushMeshesToNode(std::vector &meshIndices, aiNod meshIndices.clear(); } +} // namespace Assimp + #endif // !! ASSIMP_BUILD_NO_STL_IMPORTER diff --git a/code/AssetLib/Terragen/TerragenLoader.cpp b/code/AssetLib/Terragen/TerragenLoader.cpp index 738ad8e27..b1870414c 100644 --- a/code/AssetLib/Terragen/TerragenLoader.cpp +++ b/code/AssetLib/Terragen/TerragenLoader.cpp @@ -51,9 +51,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -using namespace Assimp; +namespace Assimp { -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Terragen Heightmap Importer", "", "", @@ -73,10 +73,6 @@ TerragenImporter::TerragenImporter() : // empty } -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -TerragenImporter::~TerragenImporter() = default; - // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool TerragenImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { @@ -244,4 +240,6 @@ void TerragenImporter::InternReadFile(const std::string &pFile, pScene->mFlags |= AI_SCENE_FLAGS_TERRAIN; } +} // namespace Assimp + #endif // !! ASSIMP_BUILD_NO_TERRAGEN_IMPORTER diff --git a/code/AssetLib/Terragen/TerragenLoader.h b/code/AssetLib/Terragen/TerragenLoader.h index cb9ff9166..0c7b686e9 100644 --- a/code/AssetLib/Terragen/TerragenLoader.h +++ b/code/AssetLib/Terragen/TerragenLoader.h @@ -73,7 +73,7 @@ namespace Assimp { class TerragenImporter : public BaseImporter { public: TerragenImporter(); - ~TerragenImporter() override; + ~TerragenImporter() override = default; // ------------------------------------------------------------------- bool CanRead(const std::string &pFile, IOSystem *pIOHandler, diff --git a/code/AssetLib/Unreal/UnrealLoader.cpp b/code/AssetLib/Unreal/UnrealLoader.cpp index 7d7b4dc76..5f622da42 100644 --- a/code/AssetLib/Unreal/UnrealLoader.cpp +++ b/code/AssetLib/Unreal/UnrealLoader.cpp @@ -63,7 +63,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -using namespace Assimp; +namespace Assimp { namespace Unreal { @@ -178,7 +178,7 @@ UnrealImporter::~UnrealImporter() = default; // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. -bool UnrealImporter::CanRead(const std::string & filename, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const { +bool UnrealImporter::CanRead(const std::string &filename, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const { return SimpleExtensionCheck(filename, "3d", "uc"); } @@ -336,12 +336,12 @@ void UnrealImporter::InternReadFile(const std::string &pFile, tempTextures.emplace_back(); std::pair &me = tempTextures.back(); for (; !IsLineEnd(*data); ++data) { - if (!::ASSIMP_strincmp(data, "NAME=", 5)) { + if (!ASSIMP_strincmp(data, "NAME=", 5)) { const char *d = data += 5; for (; !IsSpaceOrNewLine(*data); ++data) ; me.first = std::string(d, (size_t)(data - d)); - } else if (!::ASSIMP_strincmp(data, "FILE=", 5)) { + } else if (!ASSIMP_strincmp(data, "FILE=", 5)) { const char *d = data += 5; for (; !IsSpaceOrNewLine(*data); ++data) ; @@ -363,10 +363,10 @@ void UnrealImporter::InternReadFile(const std::string &pFile, std::pair &me = textures.back(); for (; !IsLineEnd(*data); ++data) { - if (!::ASSIMP_strincmp(data, "NUM=", 4)) { + if (!ASSIMP_strincmp(data, "NUM=", 4)) { data += 4; me.first = strtoul10(data, &data); - } else if (!::ASSIMP_strincmp(data, "TEXTURE=", 8)) { + } else if (!ASSIMP_strincmp(data, "TEXTURE=", 8)) { data += 8; const char *d = data; for (; !IsSpaceOrNewLine(*data); ++data) @@ -516,4 +516,6 @@ void UnrealImporter::InternReadFile(const std::string &pFile, flipper.Execute(pScene); } +} // namespace Assimp + #endif // !! ASSIMP_BUILD_NO_3D_IMPORTER diff --git a/code/AssetLib/X/XFileImporter.cpp b/code/AssetLib/X/XFileImporter.cpp index 271812859..00f44b34b 100644 --- a/code/AssetLib/X/XFileImporter.cpp +++ b/code/AssetLib/X/XFileImporter.cpp @@ -61,7 +61,7 @@ namespace Assimp { using namespace Assimp::Formatter; -static const aiImporterDesc desc = { +static constexpr aiImporterDesc desc = { "Direct3D XFile Importer", "", "", diff --git a/code/AssetLib/XGL/XGLLoader.cpp b/code/AssetLib/XGL/XGLLoader.cpp index 4c66d33b4..9efd5d628 100644 --- a/code/AssetLib/XGL/XGLLoader.cpp +++ b/code/AssetLib/XGL/XGLLoader.cpp @@ -78,7 +78,7 @@ XGLImporter::XGLImporter() : mXmlParser(nullptr), m_scene(nullptr) { // ------------------------------------------------------------------------------------------------ XGLImporter::~XGLImporter() { - delete mXmlParser; + clear(); } // ------------------------------------------------------------------------------------------------ @@ -94,7 +94,8 @@ const aiImporterDesc *XGLImporter::GetInfo() const { // ------------------------------------------------------------------------------------------------ void XGLImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) { - #ifndef ASSIMP_BUILD_NO_COMPRESSED_XGL + clear(); +#ifndef ASSIMP_BUILD_NO_COMPRESSED_XGL std::vector uncompressed; #endif @@ -165,6 +166,13 @@ void XGLImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy scope.dismiss(); } +// ------------------------------------------------------------------------------------------------ +void XGLImporter::clear() { + delete mXmlParser; + mXmlParser = nullptr; +} + + // ------------------------------------------------------------------------------------------------ void XGLImporter::ReadWorld(XmlNode &node, TempScope &scope) { for (XmlNode ¤tNode : node.children()) { diff --git a/code/AssetLib/XGL/XGLLoader.h b/code/AssetLib/XGL/XGLLoader.h index 2f0f14200..f620561d1 100644 --- a/code/AssetLib/XGL/XGLLoader.h +++ b/code/AssetLib/XGL/XGLLoader.h @@ -81,6 +81,8 @@ public: bool checkSig) const override; protected: + void clear(); + // ------------------------------------------------------------------- /** Return importer meta information. * See #BaseImporter::GetInfo for the details */ diff --git a/include/assimp/vector3.h b/include/assimp/vector3.h index 5d0962b6a..eb940e7f9 100644 --- a/include/assimp/vector3.h +++ b/include/assimp/vector3.h @@ -151,6 +151,8 @@ public: typedef aiVector3t aiVector3D; +typedef aiVector3t aiVector3f; +typedef aiVector3t aiVector3d; #else From 9efbbe0a691b75ebcde87b92f99aeeb0edbe822d Mon Sep 17 00:00:00 2001 From: julianknodt Date: Mon, 16 Oct 2023 22:37:35 -0700 Subject: [PATCH 08/16] Read int from uvwsrc Previously was reading a uint, which always failed. Since the output was never checked, this seemed to work, and works fine for most models since they only use UV channel 0. --- code/AssetLib/glTF2/glTF2Exporter.cpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/code/AssetLib/glTF2/glTF2Exporter.cpp b/code/AssetLib/glTF2/glTF2Exporter.cpp index 614ce763c..18a6ae2f4 100644 --- a/code/AssetLib/glTF2/glTF2Exporter.cpp +++ b/code/AssetLib/glTF2/glTF2Exporter.cpp @@ -559,7 +559,11 @@ void glTF2Exporter::GetMatTex(const aiMaterial &mat, Ref &texture, unsi aiString tex; // Read texcoord (UV map index) - mat.Get(AI_MATKEY_UVWSRC(tt, slot), texCoord); + // Note: must be an int to be successful. + int tmp = 0; + const auto ok = mat.Get(AI_MATKEY_UVWSRC(tt, slot), tmp); + if (ok == aiReturn_SUCCESS) texCoord = tmp; + if (mat.Get(AI_MATKEY_TEXTURE(tt, slot), tex) == AI_SUCCESS) { std::string path = tex.C_Str(); From f0e7448fdc99c35655de6ea4a534718dbed90a2d Mon Sep 17 00:00:00 2001 From: Kim Kulling Date: Tue, 14 Nov 2023 21:58:39 +0100 Subject: [PATCH 09/16] Remove double delete --- code/AssetLib/3MF/D3MFOpcPackage.cpp | 3 --- 1 file changed, 3 deletions(-) diff --git a/code/AssetLib/3MF/D3MFOpcPackage.cpp b/code/AssetLib/3MF/D3MFOpcPackage.cpp index a173b1c6a..e772d8b7e 100644 --- a/code/AssetLib/3MF/D3MFOpcPackage.cpp +++ b/code/AssetLib/3MF/D3MFOpcPackage.cpp @@ -186,9 +186,6 @@ D3MFOpcPackage::D3MFOpcPackage(IOSystem *pIOHandler, const std::string &rFile) : D3MFOpcPackage::~D3MFOpcPackage() { mZipArchive->Close(mRootStream); delete mZipArchive; - for (auto tex : mEmbeddedTextures) { - delete tex; - } } IOStream *D3MFOpcPackage::RootStream() const { From 8648c2af45444348cd6a680baff0f19f7b839c81 Mon Sep 17 00:00:00 2001 From: copycd Date: Mon, 23 Oct 2023 20:55:02 +0900 Subject: [PATCH 10/16] fix mesh-name error. --- code/AssetLib/Obj/ObjFileParser.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/code/AssetLib/Obj/ObjFileParser.cpp b/code/AssetLib/Obj/ObjFileParser.cpp index 09602e882..acb3f074c 100644 --- a/code/AssetLib/Obj/ObjFileParser.cpp +++ b/code/AssetLib/Obj/ObjFileParser.cpp @@ -605,7 +605,8 @@ void ObjFileParser::getMaterialDesc() { } if (needsNewMesh(strName)) { - createMesh(strName); + auto newMeshName = m_pModel->mActiveGroup.empty() ? strName : m_pModel->mActiveGroup; + createMesh(newMeshName); } m_pModel->mCurrentMesh->m_uiMaterialIndex = getMaterialIndex(strName); From 2235518b3cbd42531581edc7646c61dbe1fef31e Mon Sep 17 00:00:00 2001 From: Wojciech Matyjewicz Date: Mon, 23 Oct 2023 10:48:59 +0200 Subject: [PATCH 11/16] Fix parsing in . The regression was introduced in 904f17f. Since all the cases are now fully handled at the child level, visiting the whole subtree is changed into iteration over the children. --- code/AssetLib/Collada/ColladaParser.cpp | 34 ++++++++++++------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/code/AssetLib/Collada/ColladaParser.cpp b/code/AssetLib/Collada/ColladaParser.cpp index fcadd08a7..a139f63b3 100644 --- a/code/AssetLib/Collada/ColladaParser.cpp +++ b/code/AssetLib/Collada/ColladaParser.cpp @@ -1274,9 +1274,7 @@ void ColladaParser::ReadEffectParam(XmlNode &node, Collada::EffectParam &pParam) return; } - XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); - XmlNode currentNode; - while (xmlIt.getNext(currentNode)) { + for (XmlNode ¤tNode : node.children()) { const std::string ¤tName = currentNode.name(); if (currentName == "surface") { // image ID given inside tags @@ -1289,22 +1287,24 @@ void ColladaParser::ReadEffectParam(XmlNode &node, Collada::EffectParam &pParam) } } else if (currentName == "sampler2D" && (FV_1_4_n == mFormat || FV_1_3_n == mFormat)) { // surface ID is given inside tags - const char *content = currentNode.value(); - pParam.mType = Param_Sampler; - pParam.mReference = content; + XmlNode source = currentNode.child("source"); + if (source) { + std::string v; + XmlParser::getValueAsString(source, v); + pParam.mType = Param_Sampler; + pParam.mReference = v.c_str(); + } } else if (currentName == "sampler2D") { // surface ID is given inside tags - std::string url; - XmlParser::getStdStrAttribute(currentNode, "url", url); - if (url[0] != '#') { - throw DeadlyImportError("Unsupported URL format in instance_image"); - } - pParam.mType = Param_Sampler; - pParam.mReference = url.c_str() + 1; - } else if (currentName == "source") { - const char *source = currentNode.child_value(); - if (nullptr != source) { - pParam.mReference = source; + XmlNode instance_image = currentNode.child("instance_image"); + if (instance_image) { + std::string url; + XmlParser::getStdStrAttribute(instance_image, "url", url); + if (url[0] != '#') { + throw DeadlyImportError("Unsupported URL format in instance_image"); + } + pParam.mType = Param_Sampler; + pParam.mReference = url.c_str() + 1; } } } From 069e19487c0fd9bd1311c69577307af0694ca02c Mon Sep 17 00:00:00 2001 From: Wojciech Matyjewicz Date: Mon, 23 Oct 2023 10:50:52 +0200 Subject: [PATCH 12/16] Fix parsing in . The regression was introduced in 21678df. --- code/AssetLib/Collada/ColladaParser.cpp | 60 ++++++++++++------------- 1 file changed, 30 insertions(+), 30 deletions(-) diff --git a/code/AssetLib/Collada/ColladaParser.cpp b/code/AssetLib/Collada/ColladaParser.cpp index a139f63b3..7ccb22fec 100644 --- a/code/AssetLib/Collada/ColladaParser.cpp +++ b/code/AssetLib/Collada/ColladaParser.cpp @@ -814,38 +814,38 @@ void ColladaParser::ReadImage(XmlNode &node, Collada::Image &pImage) { if (!pImage.mFileName.length()) { pImage.mFileName = "unknown_texture"; } - } - } else if (mFormat == FV_1_5_n) { - std::string value; - XmlNode refChild = currentNode.child("ref"); - XmlNode hexChild = currentNode.child("hex"); - if (refChild) { - // element content is filename - hopefully - if (XmlParser::getValueAsString(refChild, value)) { - aiString filepath(value); - UriDecodePath(filepath); - pImage.mFileName = filepath.C_Str(); - } - } else if (hexChild && !pImage.mFileName.length()) { - // embedded image. get format - pImage.mEmbeddedFormat = hexChild.attribute("format").as_string(); - if (pImage.mEmbeddedFormat.empty()) { - ASSIMP_LOG_WARN("Collada: Unknown image file format"); - } + } else if (mFormat == FV_1_5_n) { + std::string value; + XmlNode refChild = currentNode.child("ref"); + XmlNode hexChild = currentNode.child("hex"); + if (refChild) { + // element content is filename - hopefully + if (XmlParser::getValueAsString(refChild, value)) { + aiString filepath(value); + UriDecodePath(filepath); + pImage.mFileName = filepath.C_Str(); + } + } else if (hexChild && !pImage.mFileName.length()) { + // embedded image. get format + pImage.mEmbeddedFormat = hexChild.attribute("format").as_string(); + if (pImage.mEmbeddedFormat.empty()) { + ASSIMP_LOG_WARN("Collada: Unknown image file format"); + } - XmlParser::getValueAsString(hexChild, value); - const char *data = value.c_str(); - // hexadecimal-encoded binary octets. First of all, find the - // required buffer size to reserve enough storage. - const char *cur = data; - while (!IsSpaceOrNewLine(*cur)) { - ++cur; - } + XmlParser::getValueAsString(hexChild, value); + const char *data = value.c_str(); + // hexadecimal-encoded binary octets. First of all, find the + // required buffer size to reserve enough storage. + const char *cur = data; + while (!IsSpaceOrNewLine(*cur)) { + ++cur; + } - const unsigned int size = (unsigned int)(cur - data) * 2; - pImage.mImageData.resize(size); - for (unsigned int i = 0; i < size; ++i) { - pImage.mImageData[i] = HexOctetToDecimal(data + (i << 1)); + const unsigned int size = (unsigned int)(cur - data) * 2; + pImage.mImageData.resize(size); + for (unsigned int i = 0; i < size; ++i) { + pImage.mImageData[i] = HexOctetToDecimal(data + (i << 1)); + } } } } From 6004290dde2995a19ec5005baaaba07cfebfeb3a Mon Sep 17 00:00:00 2001 From: Florian Born <44984048+FlorianBorn71@users.noreply.github.com> Date: Thu, 2 Nov 2023 16:18:29 +0100 Subject: [PATCH 13/16] Use the correct allocator for deleting objects in case of duplicate animation Ids --- code/AssetLib/FBX/FBXDocument.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/code/AssetLib/FBX/FBXDocument.cpp b/code/AssetLib/FBX/FBXDocument.cpp index 657f30f8c..ee4a6632b 100644 --- a/code/AssetLib/FBX/FBXDocument.cpp +++ b/code/AssetLib/FBX/FBXDocument.cpp @@ -390,7 +390,7 @@ void Document::ReadObjects() { const auto foundObject = objects.find(id); if(foundObject != objects.end()) { DOMWarning("encountered duplicate object id, ignoring first occurrence",el.second); - delete foundObject->second; + delete_LazyObject(foundObject->second); } objects[id] = new_LazyObject(id, *el.second, *this); From aae93691b9923e13af089a2a092fdd75bbfab489 Mon Sep 17 00:00:00 2001 From: Alexandre Avenel Date: Sat, 4 Nov 2023 09:59:13 +0100 Subject: [PATCH 14/16] Fix container overflow in MMD parser Using reserve, buffer size is not updated. Since data is directly inserted and not using push_pack, this can lead to a container overflow. --- code/AssetLib/MMD/MMDPmxParser.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/code/AssetLib/MMD/MMDPmxParser.cpp b/code/AssetLib/MMD/MMDPmxParser.cpp index ca37ba199..42e835c66 100644 --- a/code/AssetLib/MMD/MMDPmxParser.cpp +++ b/code/AssetLib/MMD/MMDPmxParser.cpp @@ -93,7 +93,7 @@ namespace pmx { return std::string(); } - buffer.reserve(size); + buffer.resize(size); stream->read((char*) buffer.data(), size); if (encoding == 0) { From bfe8745b9032ca0fc0d23101f1951288265398cc Mon Sep 17 00:00:00 2001 From: Alexandre Avenel Date: Sat, 4 Nov 2023 10:09:18 +0100 Subject: [PATCH 15/16] Add as unit-test an invalid PLY model triggering heap-buffer-overflow ==23896==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x12f9daec1827 at pc 0x7ffcad83699c bp 0x00c61574c910 sp 0x00c61574c910 READ of size 1 at 0x12f9daec1827 thread T0 ==23896==WARNING: Failed to use and restart external symbolizer! #0 0x7ffcad83699b in Assimp::IOStreamBuffer::getNextLine C:\Users\aavenel\Dev\assimp\include\assimp\IOStreamBuffer.h:299 #1 0x7ffcad83ce69 in Assimp::PLY::DOM::ParseHeader C:\Users\aavenel\Dev\assimp\code\AssetLib\Ply\PlyParser.cpp:428 #2 0x7ffcad83d58e in Assimp::PLY::DOM::ParseInstanceBinary C:\Users\aavenel\Dev\assimp\code\AssetLib\Ply\PlyParser.cpp:498 #3 0x7ffcad83302a in Assimp::PLYImporter::InternReadFile C:\Users\aavenel\Dev\assimp\code\AssetLib\Ply\PlyLoader.cpp:189 #4 0x7ffcad4f2f48 in Assimp::BaseImporter::ReadFile C:\Users\aavenel\Dev\assimp\code\Common\BaseImporter.cpp:135 #5 0x7ffcad51ee46 in Assimp::Importer::ReadFile C:\Users\aavenel\Dev\assimp\code\Common\Importer.cpp:709 #6 0x7ff7dd8f9f1a in ImportModel C:\Users\aavenel\Dev\assimp\tools\assimp_cmd\Main.cpp:307 #7 0x7ff7dd8fdf9e in Assimp_Info C:\Users\aavenel\Dev\assimp\tools\assimp_cmd\Info.cpp:344 #8 0x7ff7dd8fc04f in main C:\Users\aavenel\Dev\assimp\tools\assimp_cmd\Main.cpp:222 #9 0x7ff7dd9030eb in __scrt_common_main_seh D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:288 #10 0x7ffd39e57343 in BaseThreadInitThunk+0x13 (C:\WINDOWS\System32\KERNEL32.DLL+0x180017343) #11 0x7ffd3a2626b0 in RtlUserThreadStart+0x20 (C:\WINDOWS\SYSTEM32\ntdll.dll+0x1800526b0) --- ...h-30d6d0f7c529b3b66b4131700b7a4580cd7082df.ply | Bin 0 -> 159 bytes test/unit/utPLYImportExport.cpp | 7 +++++++ 2 files changed, 7 insertions(+) create mode 100644 test/models/invalid/crash-30d6d0f7c529b3b66b4131700b7a4580cd7082df.ply diff --git a/test/models/invalid/crash-30d6d0f7c529b3b66b4131700b7a4580cd7082df.ply b/test/models/invalid/crash-30d6d0f7c529b3b66b4131700b7a4580cd7082df.ply new file mode 100644 index 0000000000000000000000000000000000000000..948f5bcf98fb1d2df3bd6201ac1938b2985f5a93 GIT binary patch literal 159 zcmXTOspLw_FUn0UQAo_CDU Pgh2#|!vf=g7$5)u^LZ== literal 0 HcmV?d00001 diff --git a/test/unit/utPLYImportExport.cpp b/test/unit/utPLYImportExport.cpp index 1f733c0e7..13c90fc47 100644 --- a/test/unit/utPLYImportExport.cpp +++ b/test/unit/utPLYImportExport.cpp @@ -196,3 +196,10 @@ TEST_F(utPLYImportExport, parseErrorTest) { const aiScene *scene = importer.ReadFileFromMemory(test_file, strlen(test_file), 0); EXPECT_NE(nullptr, scene); } + +// This file is invalid, we just want to ensure that the importer is not crashing +TEST_F(utPLYImportExport, parseInvalid) { + Assimp::Importer importer; + const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/invalid/crash-30d6d0f7c529b3b66b4131700b7a4580cd7082df.ply", 0); + EXPECT_EQ(nullptr, scene); +} From e4e2c63e0c2c449cd69fb9a3269e865eb83c241d Mon Sep 17 00:00:00 2001 From: Alexandre Avenel Date: Sat, 4 Nov 2023 10:28:19 +0100 Subject: [PATCH 16/16] Fix heap-buffer overflow in PLY parser --- code/AssetLib/Ply/PlyParser.cpp | 3 ++- include/assimp/IOStreamBuffer.h | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/code/AssetLib/Ply/PlyParser.cpp b/code/AssetLib/Ply/PlyParser.cpp index 6edba71fc..662da805e 100644 --- a/code/AssetLib/Ply/PlyParser.cpp +++ b/code/AssetLib/Ply/PlyParser.cpp @@ -425,7 +425,8 @@ bool PLY::DOM::ParseHeader(IOStreamBuffer &streamBuffer, std::vector break; } else { // ignore unknown header elements - streamBuffer.getNextLine(buffer); + if (!streamBuffer.getNextLine(buffer)) + return false; } } diff --git a/include/assimp/IOStreamBuffer.h b/include/assimp/IOStreamBuffer.h index fae480e71..47db35a95 100644 --- a/include/assimp/IOStreamBuffer.h +++ b/include/assimp/IOStreamBuffer.h @@ -287,7 +287,7 @@ static AI_FORCE_INLINE bool isEndOfCache(size_t pos, size_t cacheSize) { template AI_FORCE_INLINE bool IOStreamBuffer::getNextLine(std::vector &buffer) { buffer.resize(m_cacheSize); - if (isEndOfCache(m_cachePos, m_cacheSize) || 0 == m_filePos) { + if (m_cachePos >= m_cacheSize || 0 == m_filePos) { if (!readNextBlock()) { return false; }