diff options
Diffstat (limited to 'src/mesh/assimp-master/code/AssetLib/Obj')
10 files changed, 0 insertions, 3750 deletions
diff --git a/src/mesh/assimp-master/code/AssetLib/Obj/ObjExporter.cpp b/src/mesh/assimp-master/code/AssetLib/Obj/ObjExporter.cpp deleted file mode 100644 index 882f3a9..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Obj/ObjExporter.cpp +++ /dev/null @@ -1,414 +0,0 @@ -/* -Open Asset Import Library (assimp) ----------------------------------------------------------------------- - -Copyright (c) 2006-2020, assimp team - - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ - -#ifndef ASSIMP_BUILD_NO_EXPORT -#ifndef ASSIMP_BUILD_NO_OBJ_EXPORTER - -#include "ObjExporter.h" -#include <assimp/Exceptional.h> -#include <assimp/StringComparison.h> -#include <assimp/version.h> -#include <assimp/IOSystem.hpp> -#include <assimp/Exporter.hpp> -#include <assimp/material.h> -#include <assimp/scene.h> -#include <memory> - -using namespace Assimp; - -namespace Assimp { - -// ------------------------------------------------------------------------------------------------ -// Worker function for exporting a scene to Wavefront OBJ. Prototyped and registered in Exporter.cpp -void ExportSceneObj(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/) { - // invoke the exporter - ObjExporter exporter(pFile, pScene); - - if (exporter.mOutput.fail() || exporter.mOutputMat.fail()) { - throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile)); - } - - // we're still here - export successfully completed. Write both the main OBJ file and the material script - { - std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt")); - if (outfile == nullptr) { - throw DeadlyExportError("could not open output .obj file: " + std::string(pFile)); - } - outfile->Write( exporter.mOutput.str().c_str(), static_cast<size_t>(exporter.mOutput.tellp()),1); - } - { - std::unique_ptr<IOStream> outfile (pIOSystem->Open(exporter.GetMaterialLibFileName(),"wt")); - if (outfile == nullptr) { - throw DeadlyExportError("could not open output .mtl file: " + std::string(exporter.GetMaterialLibFileName())); - } - outfile->Write( exporter.mOutputMat.str().c_str(), static_cast<size_t>(exporter.mOutputMat.tellp()),1); - } -} - -// ------------------------------------------------------------------------------------------------ -// Worker function for exporting a scene to Wavefront OBJ without the material file. Prototyped and registered in Exporter.cpp -void ExportSceneObjNoMtl(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* ) { - // invoke the exporter - ObjExporter exporter(pFile, pScene, true); - - if (exporter.mOutput.fail() || exporter.mOutputMat.fail()) { - throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile)); - } - - // we're still here - export successfully completed. Write both the main OBJ file and the material script - { - std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt")); - if (outfile == nullptr) { - throw DeadlyExportError("could not open output .obj file: " + std::string(pFile)); - } - outfile->Write( exporter.mOutput.str().c_str(), static_cast<size_t>(exporter.mOutput.tellp()),1); - } - - -} - -} // end of namespace Assimp - -static const std::string MaterialExt = ".mtl"; - -// ------------------------------------------------------------------------------------------------ -ObjExporter::ObjExporter(const char* _filename, const aiScene* pScene, bool noMtl) -: filename(_filename) -, pScene(pScene) -, vn() -, vt() -, vp() -, useVc(false) -, mVnMap() -, mVtMap() -, mVpMap() -, mMeshes() -, endl("\n") { - // make sure that all formatting happens using the standard, C locale and not the user's current locale - const std::locale& l = std::locale("C"); - mOutput.imbue(l); - mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION); - mOutputMat.imbue(l); - mOutputMat.precision(ASSIMP_AI_REAL_TEXT_PRECISION); - - WriteGeometryFile(noMtl); - if ( !noMtl ) { - WriteMaterialFile(); - } -} - -// ------------------------------------------------------------------------------------------------ -ObjExporter::~ObjExporter() { - // empty -} - -// ------------------------------------------------------------------------------------------------ -std::string ObjExporter::GetMaterialLibName() { - // within the Obj file, we use just the relative file name with the path stripped - const std::string& s = GetMaterialLibFileName(); - std::string::size_type il = s.find_last_of("/\\"); - if (il != std::string::npos) { - return s.substr(il + 1); - } - - return s; -} - -// ------------------------------------------------------------------------------------------------ -std::string ObjExporter::GetMaterialLibFileName() { - // Remove existing .obj file extension so that the final material file name will be fileName.mtl and not fileName.obj.mtl - size_t lastdot = filename.find_last_of('.'); - if ( lastdot != std::string::npos ) { - return filename.substr( 0, lastdot ) + MaterialExt; - } - - return filename + MaterialExt; -} - -// ------------------------------------------------------------------------------------------------ -void ObjExporter::WriteHeader(std::ostringstream& out) { - out << "# File produced by Open Asset Import Library (http://www.assimp.sf.net)" << endl; - out << "# (assimp v" << aiGetVersionMajor() << '.' << aiGetVersionMinor() << '.' - << aiGetVersionRevision() << ")" << endl << endl; -} - -// ------------------------------------------------------------------------------------------------ -std::string ObjExporter::GetMaterialName(unsigned int index) { - const aiMaterial* const mat = pScene->mMaterials[index]; - if ( nullptr == mat ) { - static const std::string EmptyStr; - return EmptyStr; - } - - aiString s; - if(AI_SUCCESS == mat->Get(AI_MATKEY_NAME,s)) { - return std::string(s.data,s.length); - } - - char number[ sizeof(unsigned int) * 3 + 1 ]; - ASSIMP_itoa10(number,index); - return "$Material_" + std::string(number); -} - -// ------------------------------------------------------------------------------------------------ -void ObjExporter::WriteMaterialFile() { - WriteHeader(mOutputMat); - - for(unsigned int i = 0; i < pScene->mNumMaterials; ++i) { - const aiMaterial* const mat = pScene->mMaterials[i]; - - int illum = 1; - mOutputMat << "newmtl " << GetMaterialName(i) << endl; - - aiColor4D c; - if(AI_SUCCESS == mat->Get(AI_MATKEY_COLOR_DIFFUSE,c)) { - mOutputMat << "Kd " << c.r << " " << c.g << " " << c.b << endl; - } - if(AI_SUCCESS == mat->Get(AI_MATKEY_COLOR_AMBIENT,c)) { - mOutputMat << "Ka " << c.r << " " << c.g << " " << c.b << endl; - } - if(AI_SUCCESS == mat->Get(AI_MATKEY_COLOR_SPECULAR,c)) { - mOutputMat << "Ks " << c.r << " " << c.g << " " << c.b << endl; - } - if(AI_SUCCESS == mat->Get(AI_MATKEY_COLOR_EMISSIVE,c)) { - mOutputMat << "Ke " << c.r << " " << c.g << " " << c.b << endl; - } - if(AI_SUCCESS == mat->Get(AI_MATKEY_COLOR_TRANSPARENT,c)) { - mOutputMat << "Tf " << c.r << " " << c.g << " " << c.b << endl; - } - - ai_real o; - if(AI_SUCCESS == mat->Get(AI_MATKEY_OPACITY,o)) { - mOutputMat << "d " << o << endl; - } - if(AI_SUCCESS == mat->Get(AI_MATKEY_REFRACTI,o)) { - mOutputMat << "Ni " << o << endl; - } - - if(AI_SUCCESS == mat->Get(AI_MATKEY_SHININESS,o) && o) { - mOutputMat << "Ns " << o << endl; - illum = 2; - } - - mOutputMat << "illum " << illum << endl; - - aiString s; - if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_DIFFUSE(0),s)) { - mOutputMat << "map_Kd " << s.data << endl; - } - if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_AMBIENT(0),s)) { - mOutputMat << "map_Ka " << s.data << endl; - } - if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_SPECULAR(0),s)) { - mOutputMat << "map_Ks " << s.data << endl; - } - if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_SHININESS(0),s)) { - mOutputMat << "map_Ns " << s.data << endl; - } - if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_OPACITY(0),s)) { - mOutputMat << "map_d " << s.data << endl; - } - if(AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_HEIGHT(0),s) || AI_SUCCESS == mat->Get(AI_MATKEY_TEXTURE_NORMALS(0),s)) { - // implementations seem to vary here, so write both variants - mOutputMat << "bump " << s.data << endl; - mOutputMat << "map_bump " << s.data << endl; - } - - mOutputMat << endl; - } -} - -void ObjExporter::WriteGeometryFile(bool noMtl) { - WriteHeader(mOutput); - if (!noMtl) - mOutput << "mtllib " << GetMaterialLibName() << endl << endl; - - // collect mesh geometry - aiMatrix4x4 mBase; - AddNode(pScene->mRootNode, mBase); - - // write vertex positions with colors, if any - mVpMap.getKeys( vp ); - if ( !useVc ) { - mOutput << "# " << vp.size() << " vertex positions" << endl; - for ( const vertexData& v : vp ) { - mOutput << "v " << v.vp.x << " " << v.vp.y << " " << v.vp.z << endl; - } - } else { - mOutput << "# " << vp.size() << " vertex positions and colors" << endl; - for ( const vertexData& v : vp ) { - mOutput << "v " << v.vp.x << " " << v.vp.y << " " << v.vp.z << " " << v.vc.r << " " << v.vc.g << " " << v.vc.b << endl; - } - } - mOutput << endl; - - // write uv coordinates - mVtMap.getKeys(vt); - mOutput << "# " << vt.size() << " UV coordinates" << endl; - for(const aiVector3D& v : vt) { - mOutput << "vt " << v.x << " " << v.y << " " << v.z << endl; - } - mOutput << endl; - - // write vertex normals - mVnMap.getKeys(vn); - mOutput << "# " << vn.size() << " vertex normals" << endl; - for(const aiVector3D& v : vn) { - mOutput << "vn " << v.x << " " << v.y << " " << v.z << endl; - } - mOutput << endl; - - // now write all mesh instances - for(const MeshInstance& m : mMeshes) { - mOutput << "# Mesh \'" << m.name << "\' with " << m.faces.size() << " faces" << endl; - if (!m.name.empty()) { - mOutput << "g " << m.name << endl; - } - if ( !noMtl ) { - mOutput << "usemtl " << m.matname << endl; - } - - for(const Face& f : m.faces) { - mOutput << f.kind << ' '; - for(const FaceVertex& fv : f.indices) { - mOutput << ' ' << fv.vp; - - if (f.kind != 'p') { - if (fv.vt || f.kind == 'f') { - mOutput << '/'; - } - if (fv.vt) { - mOutput << fv.vt; - } - if (f.kind == 'f' && fv.vn) { - mOutput << '/' << fv.vn; - } - } - } - - mOutput << endl; - } - mOutput << endl; - } -} - -// ------------------------------------------------------------------------------------------------ -void ObjExporter::AddMesh(const aiString& name, const aiMesh* m, const aiMatrix4x4& mat) { - mMeshes.push_back(MeshInstance() ); - MeshInstance& mesh = mMeshes.back(); - - if ( nullptr != m->mColors[ 0 ] ) { - useVc = true; - } - - mesh.name = std::string( name.data, name.length ); - mesh.matname = GetMaterialName(m->mMaterialIndex); - - mesh.faces.resize(m->mNumFaces); - - for(unsigned int i = 0; i < m->mNumFaces; ++i) { - const aiFace& f = m->mFaces[i]; - - Face& face = mesh.faces[i]; - switch (f.mNumIndices) { - case 1: - face.kind = 'p'; - break; - case 2: - face.kind = 'l'; - break; - default: - face.kind = 'f'; - } - face.indices.resize(f.mNumIndices); - - for(unsigned int a = 0; a < f.mNumIndices; ++a) { - const unsigned int idx = f.mIndices[a]; - - aiVector3D vert = mat * m->mVertices[idx]; - - if ( nullptr != m->mColors[ 0 ] ) { - aiColor4D col4 = m->mColors[ 0 ][ idx ]; - face.indices[a].vp = mVpMap.getIndex({vert, aiColor3D(col4.r, col4.g, col4.b)}); - } else { - face.indices[a].vp = mVpMap.getIndex({vert, aiColor3D(0,0,0)}); - } - - if (m->mNormals) { - aiVector3D norm = aiMatrix3x3(mat) * m->mNormals[idx]; - face.indices[a].vn = mVnMap.getIndex(norm); - } else { - face.indices[a].vn = 0; - } - - if ( m->mTextureCoords[ 0 ] ) { - face.indices[a].vt = mVtMap.getIndex(m->mTextureCoords[0][idx]); - } else { - face.indices[a].vt = 0; - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -void ObjExporter::AddNode(const aiNode* nd, const aiMatrix4x4& mParent) { - const aiMatrix4x4& mAbs = mParent * nd->mTransformation; - - aiMesh *cm( nullptr ); - for(unsigned int i = 0; i < nd->mNumMeshes; ++i) { - cm = pScene->mMeshes[nd->mMeshes[i]]; - if (nullptr != cm) { - AddMesh(cm->mName, pScene->mMeshes[nd->mMeshes[i]], mAbs); - } else { - AddMesh(nd->mName, pScene->mMeshes[nd->mMeshes[i]], mAbs); - } - } - - for(unsigned int i = 0; i < nd->mNumChildren; ++i) { - AddNode(nd->mChildren[i], mAbs); - } -} - -// ------------------------------------------------------------------------------------------------ - -#endif // ASSIMP_BUILD_NO_OBJ_EXPORTER -#endif // ASSIMP_BUILD_NO_EXPORT diff --git a/src/mesh/assimp-master/code/AssetLib/Obj/ObjExporter.h b/src/mesh/assimp-master/code/AssetLib/Obj/ObjExporter.h deleted file mode 100644 index a64f38f..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Obj/ObjExporter.h +++ /dev/null @@ -1,190 +0,0 @@ -/* -Open Asset Import Library (assimp) ----------------------------------------------------------------------- - -Copyright (c) 2006-2020, assimp team - - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ - -/** @file ObjExporter.h - * Declares the exporter class to write a scene to a Collada file - */ -#ifndef AI_OBJEXPORTER_H_INC -#define AI_OBJEXPORTER_H_INC - -#include <assimp/types.h> -#include <sstream> -#include <vector> -#include <map> - -struct aiScene; -struct aiNode; -struct aiMesh; - -namespace Assimp { - -// ------------------------------------------------------------------------------------------------ -/** Helper class to export a given scene to an OBJ file. */ -// ------------------------------------------------------------------------------------------------ -class ObjExporter { -public: - /// Constructor for a specific scene to export - ObjExporter(const char* filename, const aiScene* pScene, bool noMtl=false); - ~ObjExporter(); - std::string GetMaterialLibName(); - std::string GetMaterialLibFileName(); - - /// public string-streams to write all output into - std::ostringstream mOutput, mOutputMat; - -private: - // intermediate data structures - struct FaceVertex { - FaceVertex() - : vp() - , vn() - , vt() { - // empty - } - - // one-based, 0 means: 'does not exist' - unsigned int vp, vn, vt; - }; - - struct Face { - char kind; - std::vector<FaceVertex> indices; - }; - - struct MeshInstance { - std::string name, matname; - std::vector<Face> faces; - }; - - void WriteHeader(std::ostringstream& out); - void WriteMaterialFile(); - void WriteGeometryFile(bool noMtl=false); - std::string GetMaterialName(unsigned int index); - void AddMesh(const aiString& name, const aiMesh* m, const aiMatrix4x4& mat); - void AddNode(const aiNode* nd, const aiMatrix4x4& mParent); - -private: - std::string filename; - const aiScene* const pScene; - - struct vertexData { - aiVector3D vp; - aiColor3D vc; // OBJ does not support 4D color - }; - - std::vector<aiVector3D> vn, vt; - std::vector<aiColor4D> vc; - std::vector<vertexData> vp; - bool useVc; - - struct vertexDataCompare { - bool operator() ( const vertexData& a, const vertexData& b ) const { - // position - if (a.vp.x < b.vp.x) return true; - if (a.vp.x > b.vp.x) return false; - if (a.vp.y < b.vp.y) return true; - if (a.vp.y > b.vp.y) return false; - if (a.vp.z < b.vp.z) return true; - if (a.vp.z > b.vp.z) return false; - - // color - if (a.vc.r < b.vc.r) return true; - if (a.vc.r > b.vc.r) return false; - if (a.vc.g < b.vc.g) return true; - if (a.vc.g > b.vc.g) return false; - if (a.vc.b < b.vc.b) return true; - if (a.vc.b > b.vc.b) return false; - return false; - } - }; - - struct aiVectorCompare { - bool operator() (const aiVector3D& a, const aiVector3D& b) const { - if(a.x < b.x) return true; - if(a.x > b.x) return false; - if(a.y < b.y) return true; - if(a.y > b.y) return false; - if(a.z < b.z) return true; - return false; - } - }; - - template <class T, class Compare = std::less<T>> - class indexMap { - int mNextIndex; - typedef std::map<T, int, Compare> dataType; - dataType vecMap; - - public: - indexMap() - : mNextIndex(1) { - // empty - } - - int getIndex(const T& key) { - typename dataType::iterator vertIt = vecMap.find(key); - // vertex already exists, so reference it - if(vertIt != vecMap.end()){ - return vertIt->second; - } - return vecMap[key] = mNextIndex++; - }; - - void getKeys( std::vector<T>& keys ) { - keys.resize(vecMap.size()); - for(typename dataType::iterator it = vecMap.begin(); it != vecMap.end(); ++it){ - keys[it->second-1] = it->first; - } - }; - }; - - indexMap<aiVector3D, aiVectorCompare> mVnMap, mVtMap; - indexMap<vertexData, vertexDataCompare> mVpMap; - std::vector<MeshInstance> mMeshes; - - // this endl() doesn't flush() the stream - const std::string endl; -}; - -} - -#endif diff --git a/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileData.h b/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileData.h deleted file mode 100644 index 3d504d0..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileData.h +++ /dev/null @@ -1,344 +0,0 @@ -/* -Open Asset Import Library (assimp) ----------------------------------------------------------------------- - -Copyright (c) 2006-2020, assimp team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ - -#pragma once -#ifndef OBJ_FILEDATA_H_INC -#define OBJ_FILEDATA_H_INC - -#include <assimp/mesh.h> -#include <assimp/types.h> -#include <map> -#include <vector> - -namespace Assimp { -namespace ObjFile { - -struct Object; -struct Face; -struct Material; - -// ------------------------------------------------------------------------------------------------ -//! \struct Face -//! \brief Data structure for a simple obj-face, describes discredit,l.ation and materials -// ------------------------------------------------------------------------------------------------ -struct Face { - using IndexArray = std::vector<unsigned int>; - - //! Primitive type - aiPrimitiveType m_PrimitiveType; - //! Vertex indices - IndexArray m_vertices; - //! Normal indices - IndexArray m_normals; - //! Texture coordinates indices - IndexArray m_texturCoords; - //! Pointer to assigned material - Material *m_pMaterial; - - //! \brief Default constructor - Face(aiPrimitiveType pt = aiPrimitiveType_POLYGON) : - m_PrimitiveType(pt), m_vertices(), m_normals(), m_texturCoords(), m_pMaterial(0L) { - // empty - } - - //! \brief Destructor - ~Face() { - // empty - } -}; - -// ------------------------------------------------------------------------------------------------ -//! \struct Object -//! \brief Stores all objects of an obj-file object definition -// ------------------------------------------------------------------------------------------------ -struct Object { - enum ObjectType { - ObjType, - GroupType - }; - - //! Object name - std::string m_strObjName; - //! Transformation matrix, stored in OpenGL format - aiMatrix4x4 m_Transformation; - //! All sub-objects referenced by this object - std::vector<Object *> m_SubObjects; - /// Assigned meshes - std::vector<unsigned int> m_Meshes; - - //! \brief Default constructor - Object() = default; - - //! \brief Destructor - ~Object() { - for (std::vector<Object *>::iterator it = m_SubObjects.begin(); it != m_SubObjects.end(); ++it) { - delete *it; - } - } -}; - -// ------------------------------------------------------------------------------------------------ -//! \struct Material -//! \brief Data structure to store all material specific data -// ------------------------------------------------------------------------------------------------ -struct Material { - //! Name of material description - aiString MaterialName; - //! Texture names - aiString texture; - aiString textureSpecular; - aiString textureAmbient; - aiString textureEmissive; - aiString textureBump; - aiString textureNormal; - aiString textureReflection[6]; - aiString textureSpecularity; - aiString textureOpacity; - aiString textureDisp; - aiString textureRoughness; - aiString textureMetallic; - aiString textureSheen; - aiString textureRMA; - - enum TextureType { - TextureDiffuseType = 0, - TextureSpecularType, - TextureAmbientType, - TextureEmissiveType, - TextureBumpType, - TextureNormalType, - TextureReflectionSphereType, - TextureReflectionCubeTopType, - TextureReflectionCubeBottomType, - TextureReflectionCubeFrontType, - TextureReflectionCubeBackType, - TextureReflectionCubeLeftType, - TextureReflectionCubeRightType, - TextureSpecularityType, - TextureOpacityType, - TextureDispType, - TextureRoughnessType, - TextureMetallicType, - TextureSheenType, - TextureRMAType, - TextureTypeCount - }; - bool clamp[TextureTypeCount]; - - //! Ambient color - aiColor3D ambient; - //! Diffuse color - aiColor3D diffuse; - //! Specular color - aiColor3D specular; - //! Emissive color - aiColor3D emissive; - //! Alpha value - ai_real alpha; - //! Shineness factor - ai_real shineness; - //! Illumination model - int illumination_model; - //! Index of refraction - ai_real ior; - //! Transparency color - aiColor3D transparent; - - //! PBR Roughness - ai_real roughness; - //! PBR Metallic - ai_real metallic; - //! PBR Metallic - aiColor3D sheen; - //! PBR Clearcoat Thickness - ai_real clearcoat_thickness; - //! PBR Clearcoat Rougness - ai_real clearcoat_roughness; - //! PBR Anisotropy - ai_real anisotropy; - - //! bump map multipler (normal map scalar)(-bm) - ai_real bump_multiplier; - - //! Constructor - Material() : - diffuse(ai_real(0.6), ai_real(0.6), ai_real(0.6)), - alpha(ai_real(1.0)), - shineness(ai_real(0.0)), - illumination_model(1), - ior(ai_real(1.0)), - transparent(ai_real(1.0), ai_real(1.0), ai_real(1.0)), - roughness(ai_real(1.0)), - metallic(ai_real(0.0)), - sheen(ai_real(1.0), ai_real(1.0), ai_real(1.0)), - clearcoat_thickness(ai_real(0.0)), - clearcoat_roughness(ai_real(0.0)), - anisotropy(ai_real(0.0)), - bump_multiplier(ai_real(1.0)) { - std::fill_n(clamp, static_cast<unsigned int>(TextureTypeCount), false); - } - - // Destructor - ~Material() = default; -}; - -// ------------------------------------------------------------------------------------------------ -//! \struct Mesh -//! \brief Data structure to store a mesh -// ------------------------------------------------------------------------------------------------ -struct Mesh { - static const unsigned int NoMaterial = ~0u; - /// The name for the mesh - std::string m_name; - /// Array with pointer to all stored faces - std::vector<Face *> m_Faces; - /// Assigned material - Material *m_pMaterial; - /// Number of stored indices. - unsigned int m_uiNumIndices; - /// Number of UV - unsigned int m_uiUVCoordinates[AI_MAX_NUMBER_OF_TEXTURECOORDS]; - /// Material index. - unsigned int m_uiMaterialIndex; - /// True, if normals are stored. - bool m_hasNormals; - /// True, if vertex colors are stored. - bool m_hasVertexColors; - - /// Constructor - explicit Mesh(const std::string &name) : - m_name(name), - m_pMaterial(nullptr), - m_uiNumIndices(0), - m_uiMaterialIndex(NoMaterial), - m_hasNormals(false) { - memset(m_uiUVCoordinates, 0, sizeof(unsigned int) * AI_MAX_NUMBER_OF_TEXTURECOORDS); - } - - /// Destructor - ~Mesh() { - for (std::vector<Face *>::iterator it = m_Faces.begin(); - it != m_Faces.end(); ++it) { - delete *it; - } - } -}; - -// ------------------------------------------------------------------------------------------------ -//! \struct Model -//! \brief Data structure to store all obj-specific model data -// ------------------------------------------------------------------------------------------------ -struct Model { - using GroupMap = std::map<std::string, std::vector<unsigned int> *>; - using GroupMapIt = std::map<std::string, std::vector<unsigned int> *>::iterator; - using ConstGroupMapIt = std::map<std::string, std::vector<unsigned int> *>::const_iterator; - - //! Model name - std::string m_ModelName; - //! List ob assigned objects - std::vector<Object *> m_Objects; - //! Pointer to current object - ObjFile::Object *m_pCurrent; - //! Pointer to current material - ObjFile::Material *m_pCurrentMaterial; - //! Pointer to default material - ObjFile::Material *m_pDefaultMaterial; - //! Vector with all generated materials - std::vector<std::string> m_MaterialLib; - //! Vector with all generated vertices - std::vector<aiVector3D> m_Vertices; - //! vector with all generated normals - std::vector<aiVector3D> m_Normals; - //! vector with all vertex colors - std::vector<aiVector3D> m_VertexColors; - //! Group map - GroupMap m_Groups; - //! Group to face id assignment - std::vector<unsigned int> *m_pGroupFaceIDs; - //! Active group - std::string m_strActiveGroup; - //! Vector with generated texture coordinates - std::vector<aiVector3D> m_TextureCoord; - //! Maximum dimension of texture coordinates - unsigned int m_TextureCoordDim; - //! Current mesh instance - Mesh *m_pCurrentMesh; - //! Vector with stored meshes - std::vector<Mesh *> m_Meshes; - //! Material map - std::map<std::string, Material *> m_MaterialMap; - - //! \brief The default class constructor - Model() : - m_ModelName(), - m_pCurrent(nullptr), - m_pCurrentMaterial(nullptr), - m_pDefaultMaterial(nullptr), - m_pGroupFaceIDs(nullptr), - m_strActiveGroup(), - m_TextureCoordDim(0), - m_pCurrentMesh(nullptr) { - // empty - } - - //! \brief The class destructor - ~Model() { - for (auto & it : m_Objects) { - delete it; - } - for (auto & Meshe : m_Meshes) { - delete Meshe; - } - for (auto & Group : m_Groups) { - delete Group.second; - } - for (auto & it : m_MaterialMap) { - delete it.second; - } - } -}; - -// ------------------------------------------------------------------------------------------------ - -} // Namespace ObjFile -} // Namespace Assimp - -#endif // OBJ_FILEDATA_H_INC diff --git a/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileImporter.cpp b/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileImporter.cpp deleted file mode 100644 index 68fdb21..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileImporter.cpp +++ /dev/null @@ -1,783 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (assimp) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2020, assimp team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -#ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER - -#include "ObjFileImporter.h" -#include "ObjFileData.h" -#include "ObjFileParser.h" -#include <assimp/DefaultIOSystem.h> -#include <assimp/IOStreamBuffer.h> -#include <assimp/ai_assert.h> -#include <assimp/importerdesc.h> -#include <assimp/scene.h> -#include <assimp/DefaultLogger.hpp> -#include <assimp/Importer.hpp> -#include <assimp/ObjMaterial.h> -#include <memory> - -static const aiImporterDesc desc = { - "Wavefront Object Importer", - "", - "", - "surfaces not supported", - aiImporterFlags_SupportTextFlavour, - 0, - 0, - 0, - 0, - "obj" -}; - -static const unsigned int ObjMinSize = 16; - -namespace Assimp { - -using namespace std; - -// ------------------------------------------------------------------------------------------------ -// Default constructor -ObjFileImporter::ObjFileImporter() : - m_Buffer(), - m_pRootObject(nullptr), - m_strAbsPath(std::string(1, DefaultIOSystem().getOsSeparator())) {} - -// ------------------------------------------------------------------------------------------------ -// Destructor. -ObjFileImporter::~ObjFileImporter() { - delete m_pRootObject; - m_pRootObject = nullptr; -} - -// ------------------------------------------------------------------------------------------------ -// Returns true if file is an obj file. -bool ObjFileImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { - static const char *tokens[] = { "mtllib", "usemtl", "v ", "vt ", "vn ", "o ", "g ", "s ", "f " }; - return BaseImporter::SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens), 200, false, true); -} - -// ------------------------------------------------------------------------------------------------ -const aiImporterDesc *ObjFileImporter::GetInfo() const { - return &desc; -} - -// ------------------------------------------------------------------------------------------------ -// 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"; - auto streamCloser = [&](IOStream *pStream) { - pIOHandler->Close(pStream); - }; - std::unique_ptr<IOStream, decltype(streamCloser)> fileStream(pIOHandler->Open(file, mode), streamCloser); - if (!fileStream.get()) { - throw DeadlyImportError("Failed to open file ", file, "."); - } - - // Get the file-size and validate it, throwing an exception when fails - size_t fileSize = fileStream->FileSize(); - if (fileSize < ObjMinSize) { - throw DeadlyImportError("OBJ-file is too small."); - } - - IOStreamBuffer<char> streamedBuffer; - streamedBuffer.open(fileStream.get()); - - // Allocate buffer and read file into it - //TextFileToBuffer( fileStream.get(),m_Buffer); - - // Get the model name - std::string modelName, folderName; - std::string::size_type pos = file.find_last_of("\\/"); - if (pos != std::string::npos) { - modelName = file.substr(pos + 1, file.size() - pos - 1); - folderName = file.substr(0, pos); - if (!folderName.empty()) { - pIOHandler->PushDirectory(folderName); - } - } else { - modelName = file; - } - - // parse the file into a temporary representation - ObjFileParser parser(streamedBuffer, modelName, pIOHandler, m_progress, file); - - // And create the proper return structures out of it - CreateDataFromImport(parser.GetModel(), pScene); - - streamedBuffer.close(); - - // Clean up allocated storage for the next import - m_Buffer.clear(); - - // Pop directory stack - if (pIOHandler->StackSize() > 0) { - pIOHandler->PopDirectory(); - } -} - -// ------------------------------------------------------------------------------------------------ -// Create the data from parsed obj-file -void ObjFileImporter::CreateDataFromImport(const ObjFile::Model *pModel, aiScene *pScene) { - if (nullptr == pModel) { - return; - } - - // Create the root node of the scene - pScene->mRootNode = new aiNode; - if (!pModel->m_ModelName.empty()) { - // Set the name of the scene - pScene->mRootNode->mName.Set(pModel->m_ModelName); - } else { - // This is a fatal error, so break down the application - ai_assert(false); - } - - if (!pModel->m_Objects.empty()) { - - unsigned int meshCount = 0; - unsigned int childCount = 0; - - for (auto object : pModel->m_Objects) { - if (object) { - ++childCount; - meshCount += (unsigned int)object->m_Meshes.size(); - } - } - - // Allocate space for the child nodes on the root node - pScene->mRootNode->mChildren = new aiNode *[childCount]; - - // Create nodes for the whole scene - std::vector<aiMesh *> MeshArray; - MeshArray.reserve(meshCount); - for (size_t index = 0; index < pModel->m_Objects.size(); ++index) { - createNodes(pModel, pModel->m_Objects[index], pScene->mRootNode, pScene, MeshArray); - } - - ai_assert(pScene->mRootNode->mNumChildren == childCount); - - // Create mesh pointer buffer for this scene - if (pScene->mNumMeshes > 0) { - pScene->mMeshes = new aiMesh *[MeshArray.size()]; - for (size_t index = 0; index < MeshArray.size(); ++index) { - pScene->mMeshes[index] = MeshArray[index]; - } - } - - // Create all materials - createMaterials(pModel, pScene); - } else { - if (pModel->m_Vertices.empty()) { - return; - } - - std::unique_ptr<aiMesh> mesh(new aiMesh); - mesh->mPrimitiveTypes = aiPrimitiveType_POINT; - unsigned int n = (unsigned int)pModel->m_Vertices.size(); - mesh->mNumVertices = n; - - mesh->mVertices = new aiVector3D[n]; - memcpy(mesh->mVertices, pModel->m_Vertices.data(), n * sizeof(aiVector3D)); - - if (!pModel->m_Normals.empty()) { - mesh->mNormals = new aiVector3D[n]; - if (pModel->m_Normals.size() < n) { - throw DeadlyImportError("OBJ: vertex normal index out of range"); - } - memcpy(mesh->mNormals, pModel->m_Normals.data(), n * sizeof(aiVector3D)); - } - - if (!pModel->m_VertexColors.empty()) { - mesh->mColors[0] = new aiColor4D[mesh->mNumVertices]; - for (unsigned int i = 0; i < n; ++i) { - if (i < pModel->m_VertexColors.size()) { - const aiVector3D &color = pModel->m_VertexColors[i]; - mesh->mColors[0][i] = aiColor4D(color.x, color.y, color.z, 1.0); - } else { - throw DeadlyImportError("OBJ: vertex color index out of range"); - } - } - } - - pScene->mRootNode->mNumMeshes = 1; - pScene->mRootNode->mMeshes = new unsigned int[1]; - pScene->mRootNode->mMeshes[0] = 0; - pScene->mMeshes = new aiMesh *[1]; - pScene->mNumMeshes = 1; - pScene->mMeshes[0] = mesh.release(); - } -} - -// ------------------------------------------------------------------------------------------------ -// Creates all nodes of the model -aiNode *ObjFileImporter::createNodes(const ObjFile::Model *pModel, const ObjFile::Object *pObject, - aiNode *pParent, aiScene *pScene, - std::vector<aiMesh *> &MeshArray) { - ai_assert(nullptr != pModel); - if (nullptr == pObject) { - return nullptr; - } - - // Store older mesh size to be able to computes mesh offsets for new mesh instances - const size_t oldMeshSize = MeshArray.size(); - aiNode *pNode = new aiNode; - - pNode->mName = pObject->m_strObjName; - - // If we have a parent node, store it - ai_assert(nullptr != pParent); - appendChildToParentNode(pParent, pNode); - - for (size_t i = 0; i < pObject->m_Meshes.size(); ++i) { - unsigned int meshId = pObject->m_Meshes[i]; - aiMesh *pMesh = createTopology(pModel, pObject, meshId); - if (pMesh) { - if (pMesh->mNumFaces > 0) { - MeshArray.push_back(pMesh); - } else { - delete pMesh; - } - } - } - - // Create all nodes from the sub-objects stored in the current object - if (!pObject->m_SubObjects.empty()) { - size_t numChilds = pObject->m_SubObjects.size(); - pNode->mNumChildren = static_cast<unsigned int>(numChilds); - pNode->mChildren = new aiNode *[numChilds]; - pNode->mNumMeshes = 1; - pNode->mMeshes = new unsigned int[1]; - } - - // Set mesh instances into scene- and node-instances - const size_t meshSizeDiff = MeshArray.size() - oldMeshSize; - if (meshSizeDiff > 0) { - pNode->mMeshes = new unsigned int[meshSizeDiff]; - pNode->mNumMeshes = static_cast<unsigned int>(meshSizeDiff); - size_t index = 0; - for (size_t i = oldMeshSize; i < MeshArray.size(); ++i) { - pNode->mMeshes[index] = pScene->mNumMeshes; - pScene->mNumMeshes++; - ++index; - } - } - - return pNode; -} - -// ------------------------------------------------------------------------------------------------ -// Create topology data -aiMesh *ObjFileImporter::createTopology(const ObjFile::Model *pModel, const ObjFile::Object *pData, unsigned int meshIndex) { - // Checking preconditions - ai_assert(nullptr != pModel); - - if (nullptr == pData) { - return nullptr; - } - - // Create faces - ObjFile::Mesh *pObjMesh = pModel->m_Meshes[meshIndex]; - if (!pObjMesh) { - return nullptr; - } - - if (pObjMesh->m_Faces.empty()) { - return nullptr; - } - - std::unique_ptr<aiMesh> pMesh(new aiMesh); - if (!pObjMesh->m_name.empty()) { - pMesh->mName.Set(pObjMesh->m_name); - } - - for (size_t index = 0; index < pObjMesh->m_Faces.size(); index++) { - ObjFile::Face *const inp = pObjMesh->m_Faces[index]; - ai_assert(nullptr != inp); - - if (inp->m_PrimitiveType == aiPrimitiveType_LINE) { - pMesh->mNumFaces += static_cast<unsigned int>(inp->m_vertices.size() - 1); - pMesh->mPrimitiveTypes |= aiPrimitiveType_LINE; - } else if (inp->m_PrimitiveType == aiPrimitiveType_POINT) { - pMesh->mNumFaces += static_cast<unsigned int>(inp->m_vertices.size()); - pMesh->mPrimitiveTypes |= aiPrimitiveType_POINT; - } else { - ++pMesh->mNumFaces; - if (inp->m_vertices.size() > 3) { - pMesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON; - } else { - pMesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE; - } - } - } - - unsigned int uiIdxCount(0u); - if (pMesh->mNumFaces > 0) { - pMesh->mFaces = new aiFace[pMesh->mNumFaces]; - if (pObjMesh->m_uiMaterialIndex != ObjFile::Mesh::NoMaterial) { - pMesh->mMaterialIndex = pObjMesh->m_uiMaterialIndex; - } - - unsigned int outIndex(0); - - // Copy all data from all stored meshes - for (auto &face : pObjMesh->m_Faces) { - ObjFile::Face *const inp = face; - if (inp->m_PrimitiveType == aiPrimitiveType_LINE) { - for (size_t i = 0; i < inp->m_vertices.size() - 1; ++i) { - aiFace &f = pMesh->mFaces[outIndex++]; - uiIdxCount += f.mNumIndices = 2; - f.mIndices = new unsigned int[2]; - } - continue; - } else if (inp->m_PrimitiveType == aiPrimitiveType_POINT) { - for (size_t i = 0; i < inp->m_vertices.size(); ++i) { - aiFace &f = pMesh->mFaces[outIndex++]; - uiIdxCount += f.mNumIndices = 1; - f.mIndices = new unsigned int[1]; - } - continue; - } - - aiFace *pFace = &pMesh->mFaces[outIndex++]; - const unsigned int uiNumIndices = (unsigned int)face->m_vertices.size(); - uiIdxCount += pFace->mNumIndices = (unsigned int)uiNumIndices; - if (pFace->mNumIndices > 0) { - pFace->mIndices = new unsigned int[uiNumIndices]; - } - } - } - - // Create mesh vertices - createVertexArray(pModel, pData, meshIndex, pMesh.get(), uiIdxCount); - - return pMesh.release(); -} - -// ------------------------------------------------------------------------------------------------ -// Creates a vertex array -void ObjFileImporter::createVertexArray(const ObjFile::Model *pModel, - const ObjFile::Object *pCurrentObject, - unsigned int uiMeshIndex, - aiMesh *pMesh, - unsigned int numIndices) { - // Checking preconditions - ai_assert(nullptr != pCurrentObject); - - // Break, if no faces are stored in object - if (pCurrentObject->m_Meshes.empty()) - return; - - // Get current mesh - ObjFile::Mesh *pObjMesh = pModel->m_Meshes[uiMeshIndex]; - if (nullptr == pObjMesh || pObjMesh->m_uiNumIndices < 1) { - return; - } - - // Copy vertices of this mesh instance - pMesh->mNumVertices = numIndices; - if (pMesh->mNumVertices == 0) { - throw DeadlyImportError("OBJ: no vertices"); - } else if (pMesh->mNumVertices > AI_MAX_VERTICES) { - throw DeadlyImportError("OBJ: Too many vertices"); - } - pMesh->mVertices = new aiVector3D[pMesh->mNumVertices]; - - // Allocate buffer for normal vectors - if (!pModel->m_Normals.empty() && pObjMesh->m_hasNormals) - pMesh->mNormals = new aiVector3D[pMesh->mNumVertices]; - - // Allocate buffer for vertex-color vectors - if (!pModel->m_VertexColors.empty()) - pMesh->mColors[0] = new aiColor4D[pMesh->mNumVertices]; - - // Allocate buffer for texture coordinates - if (!pModel->m_TextureCoord.empty() && pObjMesh->m_uiUVCoordinates[0]) { - pMesh->mNumUVComponents[0] = pModel->m_TextureCoordDim; - pMesh->mTextureCoords[0] = new aiVector3D[pMesh->mNumVertices]; - } - - // Copy vertices, normals and textures into aiMesh instance - bool normalsok = true, uvok = true; - unsigned int newIndex = 0, outIndex = 0; - for (auto sourceFace : pObjMesh->m_Faces) { - // Copy all index arrays - for (size_t vertexIndex = 0, outVertexIndex = 0; vertexIndex < sourceFace->m_vertices.size(); vertexIndex++) { - const unsigned int vertex = sourceFace->m_vertices.at(vertexIndex); - if (vertex >= pModel->m_Vertices.size()) { - throw DeadlyImportError("OBJ: vertex index out of range"); - } - - if (pMesh->mNumVertices <= newIndex) { - throw DeadlyImportError("OBJ: bad vertex index"); - } - - pMesh->mVertices[newIndex] = pModel->m_Vertices[vertex]; - - // Copy all normals - if (normalsok && !pModel->m_Normals.empty() && vertexIndex < sourceFace->m_normals.size()) { - const unsigned int normal = sourceFace->m_normals.at(vertexIndex); - if (normal >= pModel->m_Normals.size()) { - normalsok = false; - } else { - pMesh->mNormals[newIndex] = pModel->m_Normals[normal]; - } - } - - // Copy all vertex colors - if (vertex < pModel->m_VertexColors.size()) { - const aiVector3D &color = pModel->m_VertexColors[vertex]; - pMesh->mColors[0][newIndex] = aiColor4D(color.x, color.y, color.z, 1.0); - } - - // Copy all texture coordinates - if (uvok && !pModel->m_TextureCoord.empty() && vertexIndex < sourceFace->m_texturCoords.size()) { - const unsigned int tex = sourceFace->m_texturCoords.at(vertexIndex); - - if (tex >= pModel->m_TextureCoord.size()) { - uvok = false; - } else { - const aiVector3D &coord3d = pModel->m_TextureCoord[tex]; - pMesh->mTextureCoords[0][newIndex] = aiVector3D(coord3d.x, coord3d.y, coord3d.z); - } - } - - // Get destination face - aiFace *pDestFace = &pMesh->mFaces[outIndex]; - - const bool last = (vertexIndex == sourceFace->m_vertices.size() - 1); - if (sourceFace->m_PrimitiveType != aiPrimitiveType_LINE || !last) { - pDestFace->mIndices[outVertexIndex] = newIndex; - outVertexIndex++; - } - - if (sourceFace->m_PrimitiveType == aiPrimitiveType_POINT) { - outIndex++; - outVertexIndex = 0; - } else if (sourceFace->m_PrimitiveType == aiPrimitiveType_LINE) { - outVertexIndex = 0; - - if (!last) - outIndex++; - - if (vertexIndex) { - if (!last) { - pMesh->mVertices[newIndex + 1] = pMesh->mVertices[newIndex]; - if (!sourceFace->m_normals.empty() && !pModel->m_Normals.empty()) { - pMesh->mNormals[newIndex + 1] = pMesh->mNormals[newIndex]; - } - if (!pModel->m_TextureCoord.empty()) { - for (size_t i = 0; i < pMesh->GetNumUVChannels(); i++) { - pMesh->mTextureCoords[i][newIndex + 1] = pMesh->mTextureCoords[i][newIndex]; - } - } - ++newIndex; - } - - pDestFace[-1].mIndices[1] = newIndex; - } - } else if (last) { - outIndex++; - } - ++newIndex; - } - } - - if (!normalsok) { - delete[] pMesh->mNormals; - pMesh->mNormals = nullptr; - } - - if (!uvok) { - delete[] pMesh->mTextureCoords[0]; - pMesh->mTextureCoords[0] = nullptr; - } -} - -// ------------------------------------------------------------------------------------------------ -// Counts all stored meshes -void ObjFileImporter::countObjects(const std::vector<ObjFile::Object *> &rObjects, int &iNumMeshes) { - iNumMeshes = 0; - if (rObjects.empty()) - return; - - iNumMeshes += static_cast<unsigned int>(rObjects.size()); - for (auto object : rObjects) { - if (!object->m_SubObjects.empty()) { - countObjects(object->m_SubObjects, iNumMeshes); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Add clamp mode property to material if necessary -void ObjFileImporter::addTextureMappingModeProperty(aiMaterial *mat, aiTextureType type, int clampMode, int index) { - if (nullptr == mat) { - return; - } - - mat->AddProperty<int>(&clampMode, 1, AI_MATKEY_MAPPINGMODE_U(type, index)); - mat->AddProperty<int>(&clampMode, 1, AI_MATKEY_MAPPINGMODE_V(type, index)); -} - -// ------------------------------------------------------------------------------------------------ -// Creates the material -void ObjFileImporter::createMaterials(const ObjFile::Model *pModel, aiScene *pScene) { - if (nullptr == pScene) { - return; - } - - const unsigned int numMaterials = (unsigned int)pModel->m_MaterialLib.size(); - pScene->mNumMaterials = 0; - if (pModel->m_MaterialLib.empty()) { - ASSIMP_LOG_DEBUG("OBJ: no materials specified"); - return; - } - - pScene->mMaterials = new aiMaterial *[numMaterials]; - for (unsigned int matIndex = 0; matIndex < numMaterials; matIndex++) { - // Store material name - std::map<std::string, ObjFile::Material *>::const_iterator it; - it = pModel->m_MaterialMap.find(pModel->m_MaterialLib[matIndex]); - - // No material found, use the default material - if (pModel->m_MaterialMap.end() == it) - continue; - - aiMaterial *mat = new aiMaterial; - ObjFile::Material *pCurrentMaterial = (*it).second; - mat->AddProperty(&pCurrentMaterial->MaterialName, AI_MATKEY_NAME); - - // convert illumination model - int sm = 0; - switch (pCurrentMaterial->illumination_model) { - case 0: - sm = aiShadingMode_NoShading; - break; - case 1: - sm = aiShadingMode_Gouraud; - break; - case 2: - sm = aiShadingMode_Phong; - break; - default: - sm = aiShadingMode_Gouraud; - ASSIMP_LOG_ERROR("OBJ: unexpected illumination model (0-2 recognized)"); - } - - mat->AddProperty<int>(&sm, 1, AI_MATKEY_SHADING_MODEL); - - // Preserve the original illum value - mat->AddProperty<int>(&pCurrentMaterial->illumination_model, 1, AI_MATKEY_OBJ_ILLUM); - - // Adding material colors - mat->AddProperty(&pCurrentMaterial->ambient, 1, AI_MATKEY_COLOR_AMBIENT); - mat->AddProperty(&pCurrentMaterial->diffuse, 1, AI_MATKEY_COLOR_DIFFUSE); - mat->AddProperty(&pCurrentMaterial->specular, 1, AI_MATKEY_COLOR_SPECULAR); - mat->AddProperty(&pCurrentMaterial->emissive, 1, AI_MATKEY_COLOR_EMISSIVE); - mat->AddProperty(&pCurrentMaterial->shineness, 1, AI_MATKEY_SHININESS); - mat->AddProperty(&pCurrentMaterial->alpha, 1, AI_MATKEY_OPACITY); - mat->AddProperty(&pCurrentMaterial->transparent, 1, AI_MATKEY_COLOR_TRANSPARENT); - mat->AddProperty(&pCurrentMaterial->roughness, 1, AI_MATKEY_ROUGHNESS_FACTOR); - mat->AddProperty(&pCurrentMaterial->metallic, 1, AI_MATKEY_METALLIC_FACTOR); - mat->AddProperty(&pCurrentMaterial->sheen, 1, AI_MATKEY_SHEEN_COLOR_FACTOR); - mat->AddProperty(&pCurrentMaterial->clearcoat_thickness, 1, AI_MATKEY_CLEARCOAT_FACTOR); - mat->AddProperty(&pCurrentMaterial->clearcoat_roughness, 1, AI_MATKEY_CLEARCOAT_ROUGHNESS_FACTOR); - mat->AddProperty(&pCurrentMaterial->anisotropy, 1, AI_MATKEY_ANISOTROPY_FACTOR); - - // Adding refraction index - mat->AddProperty(&pCurrentMaterial->ior, 1, AI_MATKEY_REFRACTI); - - // Adding textures - const int uvwIndex = 0; - - if (0 != pCurrentMaterial->texture.length) { - mat->AddProperty(&pCurrentMaterial->texture, AI_MATKEY_TEXTURE_DIFFUSE(0)); - mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_DIFFUSE(0)); - if (pCurrentMaterial->clamp[ObjFile::Material::TextureDiffuseType]) { - addTextureMappingModeProperty(mat, aiTextureType_DIFFUSE); - } - } - - if (0 != pCurrentMaterial->textureAmbient.length) { - mat->AddProperty(&pCurrentMaterial->textureAmbient, AI_MATKEY_TEXTURE_AMBIENT(0)); - mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_AMBIENT(0)); - if (pCurrentMaterial->clamp[ObjFile::Material::TextureAmbientType]) { - addTextureMappingModeProperty(mat, aiTextureType_AMBIENT); - } - } - - if (0 != pCurrentMaterial->textureEmissive.length) { - mat->AddProperty(&pCurrentMaterial->textureEmissive, AI_MATKEY_TEXTURE_EMISSIVE(0)); - mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_EMISSIVE(0)); - } - - if (0 != pCurrentMaterial->textureSpecular.length) { - mat->AddProperty(&pCurrentMaterial->textureSpecular, AI_MATKEY_TEXTURE_SPECULAR(0)); - mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_SPECULAR(0)); - if (pCurrentMaterial->clamp[ObjFile::Material::TextureSpecularType]) { - addTextureMappingModeProperty(mat, aiTextureType_SPECULAR); - } - } - - if (0 != pCurrentMaterial->textureBump.length) { - mat->AddProperty(&pCurrentMaterial->textureBump, AI_MATKEY_TEXTURE_HEIGHT(0)); - mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_HEIGHT(0)); - if (pCurrentMaterial->bump_multiplier != 1.0) { - mat->AddProperty(&pCurrentMaterial->bump_multiplier, 1, AI_MATKEY_OBJ_BUMPMULT_HEIGHT(0)); - } - if (pCurrentMaterial->clamp[ObjFile::Material::TextureBumpType]) { - addTextureMappingModeProperty(mat, aiTextureType_HEIGHT); - } - } - - if (0 != pCurrentMaterial->textureNormal.length) { - mat->AddProperty(&pCurrentMaterial->textureNormal, AI_MATKEY_TEXTURE_NORMALS(0)); - mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_NORMALS(0)); - if (pCurrentMaterial->bump_multiplier != 1.0) { - mat->AddProperty(&pCurrentMaterial->bump_multiplier, 1, AI_MATKEY_OBJ_BUMPMULT_NORMALS(0)); - } - if (pCurrentMaterial->clamp[ObjFile::Material::TextureNormalType]) { - addTextureMappingModeProperty(mat, aiTextureType_NORMALS); - } - } - - if (0 != pCurrentMaterial->textureReflection[0].length) { - ObjFile::Material::TextureType type = 0 != pCurrentMaterial->textureReflection[1].length ? - ObjFile::Material::TextureReflectionCubeTopType : - ObjFile::Material::TextureReflectionSphereType; - - unsigned count = type == ObjFile::Material::TextureReflectionSphereType ? 1 : 6; - for (unsigned i = 0; i < count; i++) { - mat->AddProperty(&pCurrentMaterial->textureReflection[i], AI_MATKEY_TEXTURE_REFLECTION(i)); - mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_REFLECTION(i)); - - if (pCurrentMaterial->clamp[type]) - addTextureMappingModeProperty(mat, aiTextureType_REFLECTION, 1, i); - } - } - - if (0 != pCurrentMaterial->textureDisp.length) { - mat->AddProperty(&pCurrentMaterial->textureDisp, AI_MATKEY_TEXTURE_DISPLACEMENT(0)); - mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_DISPLACEMENT(0)); - if (pCurrentMaterial->clamp[ObjFile::Material::TextureDispType]) { - addTextureMappingModeProperty(mat, aiTextureType_DISPLACEMENT); - } - } - - if (0 != pCurrentMaterial->textureOpacity.length) { - mat->AddProperty(&pCurrentMaterial->textureOpacity, AI_MATKEY_TEXTURE_OPACITY(0)); - mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_OPACITY(0)); - if (pCurrentMaterial->clamp[ObjFile::Material::TextureOpacityType]) { - addTextureMappingModeProperty(mat, aiTextureType_OPACITY); - } - } - - if (0 != pCurrentMaterial->textureSpecularity.length) { - mat->AddProperty(&pCurrentMaterial->textureSpecularity, AI_MATKEY_TEXTURE_SHININESS(0)); - mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_SHININESS(0)); - if (pCurrentMaterial->clamp[ObjFile::Material::TextureSpecularityType]) { - addTextureMappingModeProperty(mat, aiTextureType_SHININESS); - } - } - - if (0 != pCurrentMaterial->textureRoughness.length) { - mat->AddProperty(&pCurrentMaterial->textureRoughness, _AI_MATKEY_TEXTURE_BASE, aiTextureType_DIFFUSE_ROUGHNESS, 0); - mat->AddProperty(&uvwIndex, 1, _AI_MATKEY_UVWSRC_BASE, aiTextureType_DIFFUSE_ROUGHNESS, 0 ); - if (pCurrentMaterial->clamp[ObjFile::Material::TextureRoughnessType]) { - addTextureMappingModeProperty(mat, aiTextureType_DIFFUSE_ROUGHNESS); - } - } - - if (0 != pCurrentMaterial->textureMetallic.length) { - mat->AddProperty(&pCurrentMaterial->textureMetallic, _AI_MATKEY_TEXTURE_BASE, aiTextureType_METALNESS, 0); - mat->AddProperty(&uvwIndex, 1, _AI_MATKEY_UVWSRC_BASE, aiTextureType_METALNESS, 0 ); - if (pCurrentMaterial->clamp[ObjFile::Material::TextureMetallicType]) { - addTextureMappingModeProperty(mat, aiTextureType_METALNESS); - } - } - - if (0 != pCurrentMaterial->textureSheen.length) { - mat->AddProperty(&pCurrentMaterial->textureSheen, _AI_MATKEY_TEXTURE_BASE, aiTextureType_SHEEN, 0); - mat->AddProperty(&uvwIndex, 1, _AI_MATKEY_UVWSRC_BASE, aiTextureType_SHEEN, 0 ); - if (pCurrentMaterial->clamp[ObjFile::Material::TextureSheenType]) { - addTextureMappingModeProperty(mat, aiTextureType_SHEEN); - } - } - - if (0 != pCurrentMaterial->textureRMA.length) { - // NOTE: glTF importer places Rough/Metal/AO texture in Unknown so doing the same here for consistency. - mat->AddProperty(&pCurrentMaterial->textureRMA, _AI_MATKEY_TEXTURE_BASE, aiTextureType_UNKNOWN, 0); - mat->AddProperty(&uvwIndex, 1, _AI_MATKEY_UVWSRC_BASE, aiTextureType_UNKNOWN, 0 ); - if (pCurrentMaterial->clamp[ObjFile::Material::TextureRMAType]) { - addTextureMappingModeProperty(mat, aiTextureType_UNKNOWN); - } - } - - // Store material property info in material array in scene - pScene->mMaterials[pScene->mNumMaterials] = mat; - pScene->mNumMaterials++; - } - - // Test number of created materials. - ai_assert(pScene->mNumMaterials == numMaterials); -} - -// ------------------------------------------------------------------------------------------------ -// Appends this node to the parent node -void ObjFileImporter::appendChildToParentNode(aiNode *pParent, aiNode *pChild) { - // Checking preconditions - ai_assert(nullptr != pParent); - ai_assert(nullptr != pChild); - - // Assign parent to child - pChild->mParent = pParent; - - // Copy node instances into parent node - pParent->mNumChildren++; - pParent->mChildren[pParent->mNumChildren - 1] = pChild; -} - -// ------------------------------------------------------------------------------------------------ - -} // Namespace Assimp - -#endif // !! ASSIMP_BUILD_NO_OBJ_IMPORTER diff --git a/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileImporter.h b/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileImporter.h deleted file mode 100644 index e76c279..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileImporter.h +++ /dev/null @@ -1,122 +0,0 @@ -/* -Open Asset Import Library (assimp) ----------------------------------------------------------------------- - -Copyright (c) 2006-2020, assimp team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ -#pragma once -#ifndef OBJ_FILE_IMPORTER_H_INC -#define OBJ_FILE_IMPORTER_H_INC - -#include <assimp/BaseImporter.h> -#include <assimp/material.h> -#include <vector> - -struct aiMesh; -struct aiNode; - -namespace Assimp { - -namespace ObjFile { -struct Object; -struct Model; -} // namespace ObjFile - -// ------------------------------------------------------------------------------------------------ -/// \class ObjFileImporter -/// \brief Imports a waveform obj file -// ------------------------------------------------------------------------------------------------ -class ObjFileImporter : public BaseImporter { -public: - /// \brief Default constructor - ObjFileImporter(); - - /// \brief Destructor - ~ObjFileImporter() override; - - /// \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; - -protected: - //! \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 ObjFile::Model *pModel, aiScene *pScene); - - //! \brief Creates all nodes stored in imported content. - aiNode *createNodes(const ObjFile::Model *pModel, const ObjFile::Object *pData, - aiNode *pParent, aiScene *pScene, std::vector<aiMesh *> &MeshArray); - - //! \brief Creates topology data like faces and meshes for the geometry. - aiMesh *createTopology(const ObjFile::Model *pModel, const ObjFile::Object *pData, - unsigned int uiMeshIndex); - - //! \brief Creates vertices from model. - void createVertexArray(const ObjFile::Model *pModel, const ObjFile::Object *pCurrentObject, - unsigned int uiMeshIndex, aiMesh *pMesh, unsigned int numIndices); - - //! \brief Object counter helper method. - void countObjects(const std::vector<ObjFile::Object *> &rObjects, int &iNumMeshes); - - //! \brief Material creation. - void createMaterials(const ObjFile::Model *pModel, aiScene *pScene); - - /// @brief Adds special property for the used texture mapping mode of the model. - void addTextureMappingModeProperty(aiMaterial *mat, aiTextureType type, int clampMode = 1, int index = 0); - - //! \brief Appends a child node to a parent node and updates the data structures. - void appendChildToParentNode(aiNode *pParent, aiNode *pChild); - -private: - //! Data buffer - std::vector<char> m_Buffer; - //! Pointer to root object instance - ObjFile::Object *m_pRootObject; - //! Absolute pathname of model in file system - std::string m_strAbsPath; -}; - -// ------------------------------------------------------------------------------------------------ - -} // Namespace Assimp - -#endif diff --git a/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileMtlImporter.cpp b/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileMtlImporter.cpp deleted file mode 100644 index 2441c17..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileMtlImporter.cpp +++ /dev/null @@ -1,497 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (assimp) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2020, assimp team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -#ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER - -#include "ObjFileMtlImporter.h" -#include "ObjFileData.h" -#include "ObjTools.h" -#include <assimp/ParsingUtils.h> -#include <assimp/fast_atof.h> -#include <assimp/material.h> -#include <stdlib.h> -#include <assimp/DefaultLogger.hpp> - -namespace Assimp { - -// Material specific token (case insensitive compare) -static const std::string DiffuseTexture = "map_Kd"; -static const std::string AmbientTexture = "map_Ka"; -static const std::string SpecularTexture = "map_Ks"; -static const std::string OpacityTexture = "map_d"; -static const std::string EmissiveTexture1 = "map_emissive"; -static const std::string EmissiveTexture2 = "map_Ke"; -static const std::string BumpTexture1 = "map_bump"; -static const std::string BumpTexture2 = "bump"; -static const std::string NormalTextureV1 = "map_Kn"; -static const std::string NormalTextureV2 = "norm"; -static const std::string ReflectionTexture = "refl"; -static const std::string DisplacementTexture1 = "map_disp"; -static const std::string DisplacementTexture2 = "disp"; -static const std::string SpecularityTexture = "map_ns"; -static const std::string RoughnessTexture = "map_Pr"; -static const std::string MetallicTexture = "map_Pm"; -static const std::string SheenTexture = "map_Ps"; -static const std::string RMATexture = "map_Ps"; - -// texture option specific token -static const std::string BlendUOption = "-blendu"; -static const std::string BlendVOption = "-blendv"; -static const std::string BoostOption = "-boost"; -static const std::string ModifyMapOption = "-mm"; -static const std::string OffsetOption = "-o"; -static const std::string ScaleOption = "-s"; -static const std::string TurbulenceOption = "-t"; -static const std::string ResolutionOption = "-texres"; -static const std::string ClampOption = "-clamp"; -static const std::string BumpOption = "-bm"; -static const std::string ChannelOption = "-imfchan"; -static const std::string TypeOption = "-type"; - -// ------------------------------------------------------------------- -// Constructor -ObjFileMtlImporter::ObjFileMtlImporter(std::vector<char> &buffer, - const std::string &, - ObjFile::Model *pModel) : - m_DataIt(buffer.begin()), - m_DataItEnd(buffer.end()), - m_pModel(pModel), - m_uiLine(0), - m_buffer() { - ai_assert(nullptr != m_pModel); - m_buffer.resize(BUFFERSIZE); - std::fill(m_buffer.begin(), m_buffer.end(), '\0'); - if (nullptr == m_pModel->m_pDefaultMaterial) { - m_pModel->m_pDefaultMaterial = new ObjFile::Material; - m_pModel->m_pDefaultMaterial->MaterialName.Set("default"); - } - load(); -} - -// ------------------------------------------------------------------- -// Destructor -ObjFileMtlImporter::~ObjFileMtlImporter() { - // empty -} - -// ------------------------------------------------------------------- -// Loads the material description -void ObjFileMtlImporter::load() { - if (m_DataIt == m_DataItEnd) - return; - - while (m_DataIt != m_DataItEnd) { - switch (*m_DataIt) { - case 'k': - case 'K': { - ++m_DataIt; - if (*m_DataIt == 'a') // Ambient color - { - ++m_DataIt; - getColorRGBA(&m_pModel->m_pCurrentMaterial->ambient); - } else if (*m_DataIt == 'd') { - // Diffuse color - ++m_DataIt; - getColorRGBA(&m_pModel->m_pCurrentMaterial->diffuse); - } else if (*m_DataIt == 's') { - ++m_DataIt; - getColorRGBA(&m_pModel->m_pCurrentMaterial->specular); - } else if (*m_DataIt == 'e') { - ++m_DataIt; - getColorRGBA(&m_pModel->m_pCurrentMaterial->emissive); - } - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); - } break; - case 'T': { - ++m_DataIt; - // Material transmission color - if (*m_DataIt == 'f') { - ++m_DataIt; - getColorRGBA(&m_pModel->m_pCurrentMaterial->transparent); - } else if (*m_DataIt == 'r') { - // Material transmission alpha value - ++m_DataIt; - ai_real d; - getFloatValue(d); - m_pModel->m_pCurrentMaterial->alpha = static_cast<ai_real>(1.0) - d; - } - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); - } break; - case 'd': { - if (*(m_DataIt + 1) == 'i' && *(m_DataIt + 2) == 's' && *(m_DataIt + 3) == 'p') { - // A displacement map - getTexture(); - } else { - // Alpha value - ++m_DataIt; - getFloatValue(m_pModel->m_pCurrentMaterial->alpha); - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); - } - } break; - - case 'N': - case 'n': { - ++m_DataIt; - switch (*m_DataIt) { - case 's': // Specular exponent - ++m_DataIt; - getFloatValue(m_pModel->m_pCurrentMaterial->shineness); - break; - case 'i': // Index Of refraction - ++m_DataIt; - getFloatValue(m_pModel->m_pCurrentMaterial->ior); - break; - case 'e': // New material - createMaterial(); - break; - case 'o': // Norm texture - --m_DataIt; - getTexture(); - break; - } - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); - } break; - - case 'P': - { - ++m_DataIt; - switch(*m_DataIt) - { - case 'r': - ++m_DataIt; - getFloatValue(m_pModel->m_pCurrentMaterial->roughness); - break; - case 'm': - ++m_DataIt; - getFloatValue(m_pModel->m_pCurrentMaterial->metallic); - break; - case 's': - ++m_DataIt; - getColorRGBA(&m_pModel->m_pCurrentMaterial->sheen); - break; - case 'c': - ++m_DataIt; - if (*m_DataIt == 'r') { - ++m_DataIt; - getFloatValue(m_pModel->m_pCurrentMaterial->clearcoat_roughness); - } else { - getFloatValue(m_pModel->m_pCurrentMaterial->clearcoat_thickness); - } - break; - } - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); - } - break; - - case 'm': // Texture - case 'b': // quick'n'dirty - for 'bump' sections - case 'r': // quick'n'dirty - for 'refl' sections - { - getTexture(); - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); - } break; - - case 'i': // Illumination model - { - m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd); - getIlluminationModel(m_pModel->m_pCurrentMaterial->illumination_model); - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); - } break; - - case 'a': // Anisotropy - { - getFloatValue(m_pModel->m_pCurrentMaterial->anisotropy); - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); - } break; - - default: { - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); - } break; - } - } -} - -// ------------------------------------------------------------------- -// Loads a color definition -void ObjFileMtlImporter::getColorRGBA(aiColor3D *pColor) { - ai_assert(nullptr != pColor); - - ai_real r(0.0), g(0.0), b(0.0); - m_DataIt = getFloat<DataArrayIt>(m_DataIt, m_DataItEnd, r); - pColor->r = r; - - // we have to check if color is default 0 with only one token - if (!IsLineEnd(*m_DataIt)) { - m_DataIt = getFloat<DataArrayIt>(m_DataIt, m_DataItEnd, g); - m_DataIt = getFloat<DataArrayIt>(m_DataIt, m_DataItEnd, b); - } - pColor->g = g; - pColor->b = b; -} - -// ------------------------------------------------------------------- -// Loads the kind of illumination model. -void ObjFileMtlImporter::getIlluminationModel(int &illum_model) { - m_DataIt = CopyNextWord<DataArrayIt>(m_DataIt, m_DataItEnd, &m_buffer[0], BUFFERSIZE); - illum_model = atoi(&m_buffer[0]); -} - -// ------------------------------------------------------------------- -// Loads a single float value. -void ObjFileMtlImporter::getFloatValue(ai_real &value) { - m_DataIt = CopyNextWord<DataArrayIt>(m_DataIt, m_DataItEnd, &m_buffer[0], BUFFERSIZE); - size_t len = std::strlen(&m_buffer[0]); - if (0 == len) { - value = 0.0f; - return; - } - - value = (ai_real)fast_atof(&m_buffer[0]); -} - -// ------------------------------------------------------------------- -// Creates a material from loaded data. -void ObjFileMtlImporter::createMaterial() { - std::string line; - while (!IsLineEnd(*m_DataIt)) { - line += *m_DataIt; - ++m_DataIt; - } - - std::vector<std::string> token; - const unsigned int numToken = tokenize<std::string>(line, token, " \t"); - std::string name; - if (numToken == 1) { - name = AI_DEFAULT_MATERIAL_NAME; - } else { - // skip newmtl and all following white spaces - std::size_t first_ws_pos = line.find_first_of(" \t"); - std::size_t first_non_ws_pos = line.find_first_not_of(" \t", first_ws_pos); - if (first_non_ws_pos != std::string::npos) { - name = line.substr(first_non_ws_pos); - } - } - - name = trim_whitespaces(name); - - std::map<std::string, ObjFile::Material *>::iterator it = m_pModel->m_MaterialMap.find(name); - if (m_pModel->m_MaterialMap.end() == it) { - // New Material created - m_pModel->m_pCurrentMaterial = new ObjFile::Material(); - m_pModel->m_pCurrentMaterial->MaterialName.Set(name); - m_pModel->m_MaterialLib.push_back(name); - m_pModel->m_MaterialMap[name] = m_pModel->m_pCurrentMaterial; - - if (m_pModel->m_pCurrentMesh) { - m_pModel->m_pCurrentMesh->m_uiMaterialIndex = static_cast<unsigned int>(m_pModel->m_MaterialLib.size() - 1); - } - } else { - // Use older material - m_pModel->m_pCurrentMaterial = (*it).second; - } -} - -// ------------------------------------------------------------------- -// Gets a texture name from data. -void ObjFileMtlImporter::getTexture() { - aiString *out(nullptr); - int clampIndex = -1; - - const char *pPtr(&(*m_DataIt)); - if (!ASSIMP_strincmp(pPtr, DiffuseTexture.c_str(), static_cast<unsigned int>(DiffuseTexture.size()))) { - // Diffuse texture - out = &m_pModel->m_pCurrentMaterial->texture; - clampIndex = ObjFile::Material::TextureDiffuseType; - } else if (!ASSIMP_strincmp(pPtr, AmbientTexture.c_str(), static_cast<unsigned int>(AmbientTexture.size()))) { - // Ambient texture - out = &m_pModel->m_pCurrentMaterial->textureAmbient; - clampIndex = ObjFile::Material::TextureAmbientType; - } else if (!ASSIMP_strincmp(pPtr, SpecularTexture.c_str(), static_cast<unsigned int>(SpecularTexture.size()))) { - // Specular texture - out = &m_pModel->m_pCurrentMaterial->textureSpecular; - clampIndex = ObjFile::Material::TextureSpecularType; - } else if (!ASSIMP_strincmp(pPtr, DisplacementTexture1.c_str(), static_cast<unsigned int>(DisplacementTexture1.size())) || - !ASSIMP_strincmp(pPtr, DisplacementTexture2.c_str(), static_cast<unsigned int>(DisplacementTexture2.size()))) { - // Displacement texture - out = &m_pModel->m_pCurrentMaterial->textureDisp; - clampIndex = ObjFile::Material::TextureDispType; - } else if (!ASSIMP_strincmp(pPtr, OpacityTexture.c_str(), static_cast<unsigned int>(OpacityTexture.size()))) { - // Opacity texture - out = &m_pModel->m_pCurrentMaterial->textureOpacity; - clampIndex = ObjFile::Material::TextureOpacityType; - } else if (!ASSIMP_strincmp(pPtr, EmissiveTexture1.c_str(), static_cast<unsigned int>(EmissiveTexture1.size())) || - !ASSIMP_strincmp(pPtr, EmissiveTexture2.c_str(), static_cast<unsigned int>(EmissiveTexture2.size()))) { - // Emissive texture - out = &m_pModel->m_pCurrentMaterial->textureEmissive; - clampIndex = ObjFile::Material::TextureEmissiveType; - } else if (!ASSIMP_strincmp(pPtr, BumpTexture1.c_str(), static_cast<unsigned int>(BumpTexture1.size())) || - !ASSIMP_strincmp(pPtr, BumpTexture2.c_str(), static_cast<unsigned int>(BumpTexture2.size()))) { - // Bump texture - out = &m_pModel->m_pCurrentMaterial->textureBump; - clampIndex = ObjFile::Material::TextureBumpType; - } else if (!ASSIMP_strincmp(pPtr, NormalTextureV1.c_str(), static_cast<unsigned int>(NormalTextureV1.size())) || !ASSIMP_strincmp(pPtr, NormalTextureV2.c_str(), static_cast<unsigned int>(NormalTextureV2.size()))) { - // Normal map - out = &m_pModel->m_pCurrentMaterial->textureNormal; - clampIndex = ObjFile::Material::TextureNormalType; - } else if (!ASSIMP_strincmp(pPtr, ReflectionTexture.c_str(), static_cast<unsigned int>(ReflectionTexture.size()))) { - // Reflection texture(s) - //Do nothing here - return; - } else if (!ASSIMP_strincmp(pPtr, SpecularityTexture.c_str(), static_cast<unsigned int>(SpecularityTexture.size()))) { - // Specularity scaling (glossiness) - out = &m_pModel->m_pCurrentMaterial->textureSpecularity; - clampIndex = ObjFile::Material::TextureSpecularityType; - } else if ( !ASSIMP_strincmp( pPtr, RoughnessTexture.c_str(), static_cast<unsigned int>(RoughnessTexture.size()))) { - // PBR Roughness texture - out = & m_pModel->m_pCurrentMaterial->textureRoughness; - clampIndex = ObjFile::Material::TextureRoughnessType; - } else if ( !ASSIMP_strincmp( pPtr, MetallicTexture.c_str(), static_cast<unsigned int>(MetallicTexture.size()))) { - // PBR Metallic texture - out = & m_pModel->m_pCurrentMaterial->textureMetallic; - clampIndex = ObjFile::Material::TextureMetallicType; - } else if (!ASSIMP_strincmp( pPtr, SheenTexture.c_str(), static_cast<unsigned int>(SheenTexture.size()))) { - // PBR Sheen (reflectance) texture - out = & m_pModel->m_pCurrentMaterial->textureSheen; - clampIndex = ObjFile::Material::TextureSheenType; - } else if (!ASSIMP_strincmp( pPtr, RMATexture.c_str(), static_cast<unsigned int>(RMATexture.size()))) { - // PBR Rough/Metal/AO texture - out = & m_pModel->m_pCurrentMaterial->textureRMA; - clampIndex = ObjFile::Material::TextureRMAType; - } else { - ASSIMP_LOG_ERROR("OBJ/MTL: Encountered unknown texture type"); - return; - } - - bool clamp = false; - getTextureOption(clamp, clampIndex, out); - m_pModel->m_pCurrentMaterial->clamp[clampIndex] = clamp; - - std::string texture; - m_DataIt = getName<DataArrayIt>(m_DataIt, m_DataItEnd, texture); - if (nullptr != out) { - out->Set(texture); - } -} - -/* ///////////////////////////////////////////////////////////////////////////// - * Texture Option - * ///////////////////////////////////////////////////////////////////////////// - * According to http://en.wikipedia.org/wiki/Wavefront_.obj_file#Texture_options - * Texture map statement can contains various texture option, for example: - * - * map_Ka -o 1 1 1 some.png - * map_Kd -clamp on some.png - * - * So we need to parse and skip these options, and leave the last part which is - * the url of image, otherwise we will get a wrong url like "-clamp on some.png". - * - * Because aiMaterial supports clamp option, so we also want to return it - * ///////////////////////////////////////////////////////////////////////////// - */ -void ObjFileMtlImporter::getTextureOption(bool &clamp, int &clampIndex, aiString *&out) { - m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd); - - // If there is any more texture option - while (!isEndOfBuffer(m_DataIt, m_DataItEnd) && *m_DataIt == '-') { - const char *pPtr(&(*m_DataIt)); - //skip option key and value - int skipToken = 1; - - if (!ASSIMP_strincmp(pPtr, ClampOption.c_str(), static_cast<unsigned int>(ClampOption.size()))) { - DataArrayIt it = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd); - char value[3]; - CopyNextWord(it, m_DataItEnd, value, sizeof(value) / sizeof(*value)); - if (!ASSIMP_strincmp(value, "on", 2)) { - clamp = true; - } - - skipToken = 2; - } else if (!ASSIMP_strincmp(pPtr, TypeOption.c_str(), static_cast<unsigned int>(TypeOption.size()))) { - DataArrayIt it = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd); - char value[12]; - CopyNextWord(it, m_DataItEnd, value, sizeof(value) / sizeof(*value)); - if (!ASSIMP_strincmp(value, "cube_top", 8)) { - clampIndex = ObjFile::Material::TextureReflectionCubeTopType; - out = &m_pModel->m_pCurrentMaterial->textureReflection[0]; - } else if (!ASSIMP_strincmp(value, "cube_bottom", 11)) { - clampIndex = ObjFile::Material::TextureReflectionCubeBottomType; - out = &m_pModel->m_pCurrentMaterial->textureReflection[1]; - } else if (!ASSIMP_strincmp(value, "cube_front", 10)) { - clampIndex = ObjFile::Material::TextureReflectionCubeFrontType; - out = &m_pModel->m_pCurrentMaterial->textureReflection[2]; - } else if (!ASSIMP_strincmp(value, "cube_back", 9)) { - clampIndex = ObjFile::Material::TextureReflectionCubeBackType; - out = &m_pModel->m_pCurrentMaterial->textureReflection[3]; - } else if (!ASSIMP_strincmp(value, "cube_left", 9)) { - clampIndex = ObjFile::Material::TextureReflectionCubeLeftType; - out = &m_pModel->m_pCurrentMaterial->textureReflection[4]; - } else if (!ASSIMP_strincmp(value, "cube_right", 10)) { - clampIndex = ObjFile::Material::TextureReflectionCubeRightType; - out = &m_pModel->m_pCurrentMaterial->textureReflection[5]; - } else if (!ASSIMP_strincmp(value, "sphere", 6)) { - clampIndex = ObjFile::Material::TextureReflectionSphereType; - out = &m_pModel->m_pCurrentMaterial->textureReflection[0]; - } - - skipToken = 2; - } else if (!ASSIMP_strincmp(pPtr, BumpOption.c_str(), static_cast<unsigned int>(BumpOption.size()))) { - DataArrayIt it = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd); - getFloat(it, m_DataItEnd, m_pModel->m_pCurrentMaterial->bump_multiplier); - skipToken = 2; - } else if (!ASSIMP_strincmp(pPtr, BlendUOption.c_str(), static_cast<unsigned int>(BlendUOption.size())) || !ASSIMP_strincmp(pPtr, BlendVOption.c_str(), static_cast<unsigned int>(BlendVOption.size())) || !ASSIMP_strincmp(pPtr, BoostOption.c_str(), static_cast<unsigned int>(BoostOption.size())) || !ASSIMP_strincmp(pPtr, ResolutionOption.c_str(), static_cast<unsigned int>(ResolutionOption.size())) || !ASSIMP_strincmp(pPtr, ChannelOption.c_str(), static_cast<unsigned int>(ChannelOption.size()))) { - skipToken = 2; - } else if (!ASSIMP_strincmp(pPtr, ModifyMapOption.c_str(), static_cast<unsigned int>(ModifyMapOption.size()))) { - skipToken = 3; - } else if (!ASSIMP_strincmp(pPtr, OffsetOption.c_str(), static_cast<unsigned int>(OffsetOption.size())) || !ASSIMP_strincmp(pPtr, ScaleOption.c_str(), static_cast<unsigned int>(ScaleOption.size())) || !ASSIMP_strincmp(pPtr, TurbulenceOption.c_str(), static_cast<unsigned int>(TurbulenceOption.size()))) { - skipToken = 4; - } - - for (int i = 0; i < skipToken; ++i) { - m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd); - } - } -} - -// ------------------------------------------------------------------- - -} // Namespace Assimp - -#endif // !! ASSIMP_BUILD_NO_OBJ_IMPORTER diff --git a/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileMtlImporter.h b/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileMtlImporter.h deleted file mode 100644 index cda7415..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileMtlImporter.h +++ /dev/null @@ -1,113 +0,0 @@ -/* -Open Asset Import Library (assimp) ----------------------------------------------------------------------- - -Copyright (c) 2006-2020, assimp team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -----------------------------------------------------------------------*/ -#ifndef OBJFILEMTLIMPORTER_H_INC -#define OBJFILEMTLIMPORTER_H_INC - -#include <assimp/defs.h> -#include <string> -#include <vector> - -struct aiColor3D; -struct aiString; - -namespace Assimp { - -namespace ObjFile { -struct Model; -struct Material; -} // namespace ObjFile - -/** - * @class ObjFileMtlImporter - * @brief Loads the material description from a mtl file. - */ -class ObjFileMtlImporter { -public: - static const size_t BUFFERSIZE = 2048; - using DataArray = std::vector<char>; - using DataArrayIt = std::vector<char>::iterator; - using ConstDataArrayIt = std::vector<char>::const_iterator; - - //! \brief The class default constructor - ObjFileMtlImporter(std::vector<char> &buffer, const std::string &strAbsPath, - ObjFile::Model *pModel); - - //! \brief The class destructor - ~ObjFileMtlImporter(); - - ObjFileMtlImporter(const ObjFileMtlImporter &rOther) = delete; - ObjFileMtlImporter &operator=(const ObjFileMtlImporter &rOther) = delete; - -private: - /// Copy constructor, empty. - /// Load the whole material description - void load(); - /// Get color data. - void getColorRGBA(aiColor3D *pColor); - /// Get illumination model from loaded data - void getIlluminationModel(int &illum_model); - /// Gets a float value from data. - void getFloatValue(ai_real &value); - /// Creates a new material from loaded data. - void createMaterial(); - /// Get texture name from loaded data. - void getTexture(); - void getTextureOption(bool &clamp, int &clampIndex, aiString *&out); - -private: - //! Absolute pathname - std::string m_strAbsPath; - //! Data iterator showing to the current position in data buffer - DataArrayIt m_DataIt; - //! Data iterator to end of buffer - DataArrayIt m_DataItEnd; - //! USed model instance - ObjFile::Model *m_pModel; - //! Current line in file - unsigned int m_uiLine; - //! Helper buffer - std::vector<char> m_buffer; -}; - -// ------------------------------------------------------------------------------------------------ - -} // Namespace Assimp - -#endif // OBJFILEMTLIMPORTER_H_INC diff --git a/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileParser.cpp b/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileParser.cpp deleted file mode 100644 index 2e998a8..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileParser.cpp +++ /dev/null @@ -1,838 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (assimp) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2020, assimp team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ -#ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER - -#include "ObjFileParser.h" -#include "ObjFileData.h" -#include "ObjFileMtlImporter.h" -#include "ObjTools.h" -#include <assimp/BaseImporter.h> -#include <assimp/DefaultIOSystem.h> -#include <assimp/ParsingUtils.h> -#include <assimp/DefaultLogger.hpp> -#include <assimp/Importer.hpp> -#include <cstdlib> -#include <memory> -#include <utility> - -namespace Assimp { - -constexpr char ObjFileParser::DEFAULT_MATERIAL[]; - -ObjFileParser::ObjFileParser() : - m_DataIt(), - m_DataItEnd(), - m_pModel(nullptr), - m_uiLine(0), - m_buffer(), - m_pIO(nullptr), - m_progress(nullptr), - m_originalObjFileName() { - std::fill_n(m_buffer, Buffersize, '\0'); -} - -ObjFileParser::ObjFileParser(IOStreamBuffer<char> &streamBuffer, const std::string &modelName, - IOSystem *io, ProgressHandler *progress, - const std::string &originalObjFileName) : - m_DataIt(), - m_DataItEnd(), - m_pModel(nullptr), - m_uiLine(0), - m_buffer(), - m_pIO(io), - m_progress(progress), - m_originalObjFileName(originalObjFileName) { - std::fill_n(m_buffer, Buffersize, '\0'); - - // Create the model instance to store all the data - m_pModel.reset(new ObjFile::Model()); - m_pModel->m_ModelName = modelName; - - // create default material and store it - m_pModel->m_pDefaultMaterial = new ObjFile::Material; - m_pModel->m_pDefaultMaterial->MaterialName.Set(DEFAULT_MATERIAL); - m_pModel->m_MaterialLib.push_back(DEFAULT_MATERIAL); - m_pModel->m_MaterialMap[DEFAULT_MATERIAL] = m_pModel->m_pDefaultMaterial; - - // Start parsing the file - parseFile(streamBuffer); -} - -ObjFileParser::~ObjFileParser() { -} - -void ObjFileParser::setBuffer(std::vector<char> &buffer) { - m_DataIt = buffer.begin(); - m_DataItEnd = buffer.end(); -} - -ObjFile::Model *ObjFileParser::GetModel() const { - return m_pModel.get(); -} - -void ObjFileParser::parseFile(IOStreamBuffer<char> &streamBuffer) { - // only update every 100KB or it'll be too slow - //const unsigned int updateProgressEveryBytes = 100 * 1024; - unsigned int progressCounter = 0; - const unsigned int bytesToProcess = static_cast<unsigned int>(streamBuffer.size()); - const unsigned int progressTotal = bytesToProcess; - unsigned int processed = 0; - size_t lastFilePos(0); - - std::vector<char> buffer; - while (streamBuffer.getNextDataLine(buffer, '\\')) { - m_DataIt = buffer.begin(); - m_DataItEnd = buffer.end(); - - // Handle progress reporting - const size_t filePos(streamBuffer.getFilePos()); - if (lastFilePos < filePos) { - processed = static_cast<unsigned int>(filePos); - lastFilePos = filePos; - progressCounter++; - m_progress->UpdateFileRead(processed, progressTotal); - } - - // parse line - switch (*m_DataIt) { - case 'v': // Parse a vertex texture coordinate - { - ++m_DataIt; - if (*m_DataIt == ' ' || *m_DataIt == '\t') { - size_t numComponents = getNumComponentsInDataDefinition(); - if (numComponents == 3) { - // read in vertex definition - getVector3(m_pModel->m_Vertices); - } else if (numComponents == 4) { - // read in vertex definition (homogeneous coords) - getHomogeneousVector3(m_pModel->m_Vertices); - } else if (numComponents == 6) { - // read vertex and vertex-color - getTwoVectors3(m_pModel->m_Vertices, m_pModel->m_VertexColors); - } - } else if (*m_DataIt == 't') { - // read in texture coordinate ( 2D or 3D ) - ++m_DataIt; - size_t dim = getTexCoordVector(m_pModel->m_TextureCoord); - m_pModel->m_TextureCoordDim = std::max(m_pModel->m_TextureCoordDim, (unsigned int)dim); - } else if (*m_DataIt == 'n') { - // Read in normal vector definition - ++m_DataIt; - getVector3(m_pModel->m_Normals); - } - } break; - - case 'p': // Parse a face, line or point statement - case 'l': - case 'f': { - getFace(*m_DataIt == 'f' ? aiPrimitiveType_POLYGON : (*m_DataIt == 'l' ? aiPrimitiveType_LINE : aiPrimitiveType_POINT)); - } break; - - case '#': // Parse a comment - { - getComment(); - } break; - - case 'u': // Parse a material desc. setter - { - std::string name; - - getNameNoSpace(m_DataIt, m_DataItEnd, name); - - size_t nextSpace = name.find(' '); - if (nextSpace != std::string::npos) - name = name.substr(0, nextSpace); - - if (name == "usemtl") { - getMaterialDesc(); - } - } break; - - case 'm': // Parse a material library or merging group ('mg') - { - std::string name; - - getNameNoSpace(m_DataIt, m_DataItEnd, name); - - size_t nextSpace = name.find(' '); - if (nextSpace != std::string::npos) - name = name.substr(0, nextSpace); - - if (name == "mg") - getGroupNumberAndResolution(); - else if (name == "mtllib") - getMaterialLib(); - else - goto pf_skip_line; - } break; - - case 'g': // Parse group name - { - getGroupName(); - } break; - - case 's': // Parse group number - { - getGroupNumber(); - } break; - - case 'o': // Parse object name - { - getObjectName(); - } break; - - default: { - pf_skip_line: - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); - } break; - } - } -} - -void ObjFileParser::copyNextWord(char *pBuffer, size_t length) { - size_t index = 0; - m_DataIt = getNextWord<DataArrayIt>(m_DataIt, m_DataItEnd); - if (*m_DataIt == '\\') { - ++m_DataIt; - ++m_DataIt; - m_DataIt = getNextWord<DataArrayIt>(m_DataIt, m_DataItEnd); - } - while (m_DataIt != m_DataItEnd && !IsSpaceOrNewLine(*m_DataIt)) { - pBuffer[index] = *m_DataIt; - index++; - if (index == length - 1) { - break; - } - ++m_DataIt; - } - - ai_assert(index < length); - pBuffer[index] = '\0'; -} - -static bool isDataDefinitionEnd(const char *tmp) { - if (*tmp == '\\') { - tmp++; - if (IsLineEnd(*tmp)) { - return true; - } - } - return false; -} - -static bool isNanOrInf(const char *in) { - // Look for "nan" or "inf", case insensitive - return ((in[0] == 'N' || in[0] == 'n') && ASSIMP_strincmp(in, "nan", 3) == 0) || - ((in[0] == 'I' || in[0] == 'i') && ASSIMP_strincmp(in, "inf", 3) == 0); -} - -size_t ObjFileParser::getNumComponentsInDataDefinition() { - size_t numComponents(0); - const char *tmp(&m_DataIt[0]); - bool end_of_definition = false; - while (!end_of_definition) { - if (isDataDefinitionEnd(tmp)) { - tmp += 2; - } else if (IsLineEnd(*tmp)) { - end_of_definition = true; - } - if (!SkipSpaces(&tmp)) { - break; - } - const bool isNum(IsNumeric(*tmp) || isNanOrInf(tmp)); - SkipToken(tmp); - if (isNum) { - ++numComponents; - } - if (!SkipSpaces(&tmp)) { - break; - } - } - return numComponents; -} - -size_t ObjFileParser::getTexCoordVector(std::vector<aiVector3D> &point3d_array) { - size_t numComponents = getNumComponentsInDataDefinition(); - ai_real x, y, z; - if (2 == numComponents) { - copyNextWord(m_buffer, Buffersize); - x = (ai_real)fast_atof(m_buffer); - - copyNextWord(m_buffer, Buffersize); - y = (ai_real)fast_atof(m_buffer); - z = 0.0; - } else if (3 == numComponents) { - copyNextWord(m_buffer, Buffersize); - x = (ai_real)fast_atof(m_buffer); - - copyNextWord(m_buffer, Buffersize); - y = (ai_real)fast_atof(m_buffer); - - copyNextWord(m_buffer, Buffersize); - z = (ai_real)fast_atof(m_buffer); - } else { - throw DeadlyImportError("OBJ: Invalid number of components"); - } - - // Coerce nan and inf to 0 as is the OBJ default value - if (!std::isfinite(x)) - x = 0; - - if (!std::isfinite(y)) - y = 0; - - if (!std::isfinite(z)) - z = 0; - - point3d_array.emplace_back(x, y, z); - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); - return numComponents; -} - -void ObjFileParser::getVector3(std::vector<aiVector3D> &point3d_array) { - ai_real x, y, z; - copyNextWord(m_buffer, Buffersize); - x = (ai_real)fast_atof(m_buffer); - - copyNextWord(m_buffer, Buffersize); - y = (ai_real)fast_atof(m_buffer); - - copyNextWord(m_buffer, Buffersize); - z = (ai_real)fast_atof(m_buffer); - - point3d_array.emplace_back(x, y, z); - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); -} - -void ObjFileParser::getHomogeneousVector3(std::vector<aiVector3D> &point3d_array) { - ai_real x, y, z, w; - copyNextWord(m_buffer, Buffersize); - x = (ai_real)fast_atof(m_buffer); - - copyNextWord(m_buffer, Buffersize); - y = (ai_real)fast_atof(m_buffer); - - copyNextWord(m_buffer, Buffersize); - z = (ai_real)fast_atof(m_buffer); - - copyNextWord(m_buffer, Buffersize); - w = (ai_real)fast_atof(m_buffer); - - if (w == 0) - throw DeadlyImportError("OBJ: Invalid component in homogeneous vector (Division by zero)"); - - point3d_array.emplace_back(x / w, y / w, z / w); - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); -} - -void ObjFileParser::getTwoVectors3(std::vector<aiVector3D> &point3d_array_a, std::vector<aiVector3D> &point3d_array_b) { - ai_real x, y, z; - copyNextWord(m_buffer, Buffersize); - x = (ai_real)fast_atof(m_buffer); - - copyNextWord(m_buffer, Buffersize); - y = (ai_real)fast_atof(m_buffer); - - copyNextWord(m_buffer, Buffersize); - z = (ai_real)fast_atof(m_buffer); - - point3d_array_a.emplace_back(x, y, z); - - copyNextWord(m_buffer, Buffersize); - x = (ai_real)fast_atof(m_buffer); - - copyNextWord(m_buffer, Buffersize); - y = (ai_real)fast_atof(m_buffer); - - copyNextWord(m_buffer, Buffersize); - z = (ai_real)fast_atof(m_buffer); - - point3d_array_b.emplace_back(x, y, z); - - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); -} - -void ObjFileParser::getVector2(std::vector<aiVector2D> &point2d_array) { - ai_real x, y; - copyNextWord(m_buffer, Buffersize); - x = (ai_real)fast_atof(m_buffer); - - copyNextWord(m_buffer, Buffersize); - y = (ai_real)fast_atof(m_buffer); - - point2d_array.emplace_back(x, y); - - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); -} - -static const std::string DefaultObjName = "defaultobject"; - -void ObjFileParser::getFace(aiPrimitiveType type) { - m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd); - if (m_DataIt == m_DataItEnd || *m_DataIt == '\0') { - return; - } - - ObjFile::Face *face = new ObjFile::Face(type); - bool hasNormal = false; - - const int vSize = static_cast<unsigned int>(m_pModel->m_Vertices.size()); - const int vtSize = static_cast<unsigned int>(m_pModel->m_TextureCoord.size()); - const int vnSize = static_cast<unsigned int>(m_pModel->m_Normals.size()); - - const bool vt = (!m_pModel->m_TextureCoord.empty()); - const bool vn = (!m_pModel->m_Normals.empty()); - int iPos = 0; - while (m_DataIt != m_DataItEnd) { - int iStep = 1; - - if (IsLineEnd(*m_DataIt)) { - break; - } - - if (*m_DataIt == '/') { - if (type == aiPrimitiveType_POINT) { - ASSIMP_LOG_ERROR("Obj: Separator unexpected in point statement"); - } - iPos++; - } else if (IsSpaceOrNewLine(*m_DataIt)) { - iPos = 0; - } else { - //OBJ USES 1 Base ARRAYS!!!! - const int iVal(::atoi(&(*m_DataIt))); - - // increment iStep position based off of the sign and # of digits - int tmp = iVal; - if (iVal < 0) { - ++iStep; - } - while ((tmp = tmp / 10) != 0) { - ++iStep; - } - - if (iPos == 1 && !vt && vn) - iPos = 2; // skip texture coords for normals if there are no tex coords - - if (iVal > 0) { - // Store parsed index - if (0 == iPos) { - face->m_vertices.push_back(iVal - 1); - } else if (1 == iPos) { - face->m_texturCoords.push_back(iVal - 1); - } else if (2 == iPos) { - face->m_normals.push_back(iVal - 1); - hasNormal = true; - } else { - reportErrorTokenInFace(); - } - } else if (iVal < 0) { - // Store relatively index - if (0 == iPos) { - face->m_vertices.push_back(vSize + iVal); - } else if (1 == iPos) { - face->m_texturCoords.push_back(vtSize + iVal); - } else if (2 == iPos) { - face->m_normals.push_back(vnSize + iVal); - hasNormal = true; - } else { - reportErrorTokenInFace(); - } - } else { - //On error, std::atoi will return 0 which is not a valid value - delete face; - throw DeadlyImportError("OBJ: Invalid face indice"); - } - } - m_DataIt += iStep; - } - - if (face->m_vertices.empty()) { - ASSIMP_LOG_ERROR("Obj: Ignoring empty face"); - // skip line and clean up - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); - delete face; - return; - } - - // Set active material, if one set - if (nullptr != m_pModel->m_pCurrentMaterial) { - face->m_pMaterial = m_pModel->m_pCurrentMaterial; - } else { - face->m_pMaterial = m_pModel->m_pDefaultMaterial; - } - - // Create a default object, if nothing is there - if (nullptr == m_pModel->m_pCurrent) { - createObject(DefaultObjName); - } - - // Assign face to mesh - if (nullptr == m_pModel->m_pCurrentMesh) { - createMesh(DefaultObjName); - } - - // Store the face - m_pModel->m_pCurrentMesh->m_Faces.push_back(face); - m_pModel->m_pCurrentMesh->m_uiNumIndices += (unsigned int)face->m_vertices.size(); - m_pModel->m_pCurrentMesh->m_uiUVCoordinates[0] += (unsigned int)face->m_texturCoords.size(); - if (!m_pModel->m_pCurrentMesh->m_hasNormals && hasNormal) { - m_pModel->m_pCurrentMesh->m_hasNormals = true; - } - // Skip the rest of the line - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); -} - -void ObjFileParser::getMaterialDesc() { - // Get next data for material data - m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd); - if (m_DataIt == m_DataItEnd) { - return; - } - - char *pStart = &(*m_DataIt); - while (m_DataIt != m_DataItEnd && !IsLineEnd(*m_DataIt)) { - ++m_DataIt; - } - - // In some cases we should ignore this 'usemtl' command, this variable helps us to do so - bool skip = false; - - // Get name - std::string strName(pStart, &(*m_DataIt)); - strName = trim_whitespaces(strName); - if (strName.empty()) - skip = true; - - // If the current mesh has the same material, we simply ignore that 'usemtl' command - // There is no need to create another object or even mesh here - if (m_pModel->m_pCurrentMaterial && m_pModel->m_pCurrentMaterial->MaterialName == aiString(strName)) { - skip = true; - } - - if (!skip) { - // Search for material - std::map<std::string, ObjFile::Material *>::iterator it = m_pModel->m_MaterialMap.find(strName); - if (it == m_pModel->m_MaterialMap.end()) { - // Not found, so we don't know anything about the material except for its name. - // This may be the case if the material library is missing. We don't want to lose all - // materials if that happens, so create a new named material instead of discarding it - // completely. - ASSIMP_LOG_ERROR("OBJ: failed to locate material ", strName, ", creating new material"); - m_pModel->m_pCurrentMaterial = new ObjFile::Material(); - m_pModel->m_pCurrentMaterial->MaterialName.Set(strName); - m_pModel->m_MaterialLib.push_back(strName); - m_pModel->m_MaterialMap[strName] = m_pModel->m_pCurrentMaterial; - } else { - // Found, using detected material - m_pModel->m_pCurrentMaterial = (*it).second; - } - - if (needsNewMesh(strName)) { - createMesh(strName); - } - - m_pModel->m_pCurrentMesh->m_uiMaterialIndex = getMaterialIndex(strName); - } - - // Skip rest of line - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); -} - -// ------------------------------------------------------------------- -// Get a comment, values will be skipped -void ObjFileParser::getComment() { - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); -} - -// ------------------------------------------------------------------- -// Get material library from file. -void ObjFileParser::getMaterialLib() { - // Translate tuple - m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd); - if (m_DataIt == m_DataItEnd) { - return; - } - - char *pStart = &(*m_DataIt); - while (m_DataIt != m_DataItEnd && !IsLineEnd(*m_DataIt)) { - ++m_DataIt; - } - - // Check for existence - const std::string strMatName(pStart, &(*m_DataIt)); - std::string absName; - - // Check if directive is valid. - if (0 == strMatName.length()) { - ASSIMP_LOG_WARN("OBJ: no name for material library specified."); - return; - } - - if (m_pIO->StackSize() > 0) { - std::string path = m_pIO->CurrentDirectory(); - if ('/' != *path.rbegin()) { - path += '/'; - } - absName += path; - absName += strMatName; - } else { - absName = strMatName; - } - - IOStream *pFile = m_pIO->Open(absName); - if (nullptr == pFile) { - ASSIMP_LOG_ERROR("OBJ: Unable to locate material file ", strMatName); - std::string strMatFallbackName = m_originalObjFileName.substr(0, m_originalObjFileName.length() - 3) + "mtl"; - ASSIMP_LOG_INFO("OBJ: Opening fallback material file ", strMatFallbackName); - pFile = m_pIO->Open(strMatFallbackName); - if (!pFile) { - ASSIMP_LOG_ERROR("OBJ: Unable to locate fallback material file ", strMatFallbackName); - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); - return; - } - } - - // Import material library data from file. - // Some exporters (e.g. Silo) will happily write out empty - // material files if the model doesn't use any materials, so we - // allow that. - std::vector<char> buffer; - BaseImporter::TextFileToBuffer(pFile, buffer, BaseImporter::ALLOW_EMPTY); - m_pIO->Close(pFile); - - // Importing the material library - ObjFileMtlImporter mtlImporter(buffer, strMatName, m_pModel.get()); -} - -// ------------------------------------------------------------------- -// Set a new material definition as the current material. -void ObjFileParser::getNewMaterial() { - m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd); - m_DataIt = getNextWord<DataArrayIt>(m_DataIt, m_DataItEnd); - if (m_DataIt == m_DataItEnd) { - return; - } - - char *pStart = &(*m_DataIt); - std::string strMat(pStart, *m_DataIt); - while (m_DataIt != m_DataItEnd && IsSpaceOrNewLine(*m_DataIt)) { - ++m_DataIt; - } - std::map<std::string, ObjFile::Material *>::iterator it = m_pModel->m_MaterialMap.find(strMat); - if (it == m_pModel->m_MaterialMap.end()) { - // Show a warning, if material was not found - ASSIMP_LOG_WARN("OBJ: Unsupported material requested: ", strMat); - m_pModel->m_pCurrentMaterial = m_pModel->m_pDefaultMaterial; - } else { - // Set new material - if (needsNewMesh(strMat)) { - createMesh(strMat); - } - m_pModel->m_pCurrentMesh->m_uiMaterialIndex = getMaterialIndex(strMat); - } - - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); -} - -// ------------------------------------------------------------------- -int ObjFileParser::getMaterialIndex(const std::string &strMaterialName) { - int mat_index = -1; - if (strMaterialName.empty()) { - return mat_index; - } - for (size_t index = 0; index < m_pModel->m_MaterialLib.size(); ++index) { - if (strMaterialName == m_pModel->m_MaterialLib[index]) { - mat_index = (int)index; - break; - } - } - return mat_index; -} - -// ------------------------------------------------------------------- -// Getter for a group name. -void ObjFileParser::getGroupName() { - std::string groupName; - - // here we skip 'g ' from line - m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd); - m_DataIt = getName<DataArrayIt>(m_DataIt, m_DataItEnd, groupName); - if (isEndOfBuffer(m_DataIt, m_DataItEnd)) { - return; - } - - // Change active group, if necessary - if (m_pModel->m_strActiveGroup != groupName) { - // Search for already existing entry - ObjFile::Model::ConstGroupMapIt it = m_pModel->m_Groups.find(groupName); - - // We are mapping groups into the object structure - createObject(groupName); - - // New group name, creating a new entry - if (it == m_pModel->m_Groups.end()) { - std::vector<unsigned int> *pFaceIDArray = new std::vector<unsigned int>; - m_pModel->m_Groups[groupName] = pFaceIDArray; - m_pModel->m_pGroupFaceIDs = (pFaceIDArray); - } else { - m_pModel->m_pGroupFaceIDs = (*it).second; - } - m_pModel->m_strActiveGroup = groupName; - } - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); -} - -// ------------------------------------------------------------------- -// Not supported -void ObjFileParser::getGroupNumber() { - // Not used - - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); -} - -// ------------------------------------------------------------------- -// Not supported -void ObjFileParser::getGroupNumberAndResolution() { - // Not used - - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); -} - -// ------------------------------------------------------------------- -// Stores values for a new object instance, name will be used to -// identify it. -void ObjFileParser::getObjectName() { - m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd); - if (m_DataIt == m_DataItEnd) { - return; - } - char *pStart = &(*m_DataIt); - while (m_DataIt != m_DataItEnd && !IsSpaceOrNewLine(*m_DataIt)) { - ++m_DataIt; - } - - std::string strObjectName(pStart, &(*m_DataIt)); - if (!strObjectName.empty()) { - // Reset current object - m_pModel->m_pCurrent = nullptr; - - // Search for actual object - for (std::vector<ObjFile::Object *>::const_iterator it = m_pModel->m_Objects.begin(); - it != m_pModel->m_Objects.end(); - ++it) { - if ((*it)->m_strObjName == strObjectName) { - m_pModel->m_pCurrent = *it; - break; - } - } - - // Allocate a new object, if current one was not found before - if (nullptr == m_pModel->m_pCurrent) { - createObject(strObjectName); - } - } - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); -} -// ------------------------------------------------------------------- -// Creates a new object instance -void ObjFileParser::createObject(const std::string &objName) { - ai_assert(nullptr != m_pModel); - - m_pModel->m_pCurrent = new ObjFile::Object; - m_pModel->m_pCurrent->m_strObjName = objName; - m_pModel->m_Objects.push_back(m_pModel->m_pCurrent); - - createMesh(objName); - - if (m_pModel->m_pCurrentMaterial) { - m_pModel->m_pCurrentMesh->m_uiMaterialIndex = - getMaterialIndex(m_pModel->m_pCurrentMaterial->MaterialName.data); - m_pModel->m_pCurrentMesh->m_pMaterial = m_pModel->m_pCurrentMaterial; - } -} -// ------------------------------------------------------------------- -// Creates a new mesh -void ObjFileParser::createMesh(const std::string &meshName) { - ai_assert(nullptr != m_pModel); - - m_pModel->m_pCurrentMesh = new ObjFile::Mesh(meshName); - m_pModel->m_Meshes.push_back(m_pModel->m_pCurrentMesh); - unsigned int meshId = static_cast<unsigned int>(m_pModel->m_Meshes.size() - 1); - if (nullptr != m_pModel->m_pCurrent) { - m_pModel->m_pCurrent->m_Meshes.push_back(meshId); - } else { - ASSIMP_LOG_ERROR("OBJ: No object detected to attach a new mesh instance."); - } -} - -// ------------------------------------------------------------------- -// Returns true, if a new mesh must be created. -bool ObjFileParser::needsNewMesh(const std::string &materialName) { - // If no mesh data yet - if (m_pModel->m_pCurrentMesh == nullptr) { - return true; - } - bool newMat = false; - int matIdx = getMaterialIndex(materialName); - int curMatIdx = m_pModel->m_pCurrentMesh->m_uiMaterialIndex; - if (curMatIdx != int(ObjFile::Mesh::NoMaterial) && curMatIdx != matIdx - // no need create a new mesh if no faces in current - // lets say 'usemtl' goes straight after 'g' - && !m_pModel->m_pCurrentMesh->m_Faces.empty()) { - // New material -> only one material per mesh, so we need to create a new - // material - newMat = true; - } - return newMat; -} - -// ------------------------------------------------------------------- -// Shows an error in parsing process. -void ObjFileParser::reportErrorTokenInFace() { - m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); - ASSIMP_LOG_ERROR("OBJ: Not supported token in face description detected"); -} - -// ------------------------------------------------------------------- - -} // Namespace Assimp - -#endif // !! ASSIMP_BUILD_NO_OBJ_IMPORTER diff --git a/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileParser.h b/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileParser.h deleted file mode 100644 index fbd2f2c..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileParser.h +++ /dev/null @@ -1,165 +0,0 @@ -/* -Open Asset Import Library (assimp) ----------------------------------------------------------------------- - -Copyright (c) 2006-2020, assimp team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ -#ifndef OBJ_FILEPARSER_H_INC -#define OBJ_FILEPARSER_H_INC - -#include <assimp/IOStreamBuffer.h> -#include <assimp/material.h> -#include <assimp/mesh.h> -#include <assimp/vector2.h> -#include <assimp/vector3.h> -#include <map> -#include <memory> -#include <string> -#include <vector> - -namespace Assimp { - -namespace ObjFile { -struct Model; -struct Object; -struct Material; -struct Point3; -struct Point2; -} // namespace ObjFile - -class ObjFileImporter; -class IOSystem; -class ProgressHandler; - -/// \class ObjFileParser -/// \brief Parser for a obj waveform file -class ASSIMP_API ObjFileParser { -public: - static const size_t Buffersize = 4096; - typedef std::vector<char> DataArray; - typedef std::vector<char>::iterator DataArrayIt; - typedef std::vector<char>::const_iterator ConstDataArrayIt; - - /// @brief The default constructor. - ObjFileParser(); - /// @brief Constructor with data array. - ObjFileParser(IOStreamBuffer<char> &streamBuffer, const std::string &modelName, IOSystem *io, ProgressHandler *progress, const std::string &originalObjFileName); - /// @brief Destructor - ~ObjFileParser(); - /// @brief If you want to load in-core data. - void setBuffer(std::vector<char> &buffer); - /// @brief Model getter. - ObjFile::Model *GetModel() const; - - ObjFileParser(const ObjFileParser&) = delete; - ObjFileParser &operator=(const ObjFileParser& ) = delete; - -protected: - /// Parse the loaded file - void parseFile(IOStreamBuffer<char> &streamBuffer); - /// Method to copy the new delimited word in the current line. - void copyNextWord(char *pBuffer, size_t length); - /// Method to copy the new line. - // void copyNextLine(char *pBuffer, size_t length); - /// Get the number of components in a line. - size_t getNumComponentsInDataDefinition(); - /// Stores the vector - size_t getTexCoordVector(std::vector<aiVector3D> &point3d_array); - /// Stores the following 3d vector. - void getVector3(std::vector<aiVector3D> &point3d_array); - /// Stores the following homogeneous vector as a 3D vector - void getHomogeneousVector3(std::vector<aiVector3D> &point3d_array); - /// Stores the following two 3d vectors on the line. - void getTwoVectors3(std::vector<aiVector3D> &point3d_array_a, std::vector<aiVector3D> &point3d_array_b); - /// Stores the following 3d vector. - void getVector2(std::vector<aiVector2D> &point2d_array); - /// Stores the following face. - void getFace(aiPrimitiveType type); - /// Reads the material description. - void getMaterialDesc(); - /// Gets a comment. - void getComment(); - /// Gets a a material library. - void getMaterialLib(); - /// Creates a new material. - void getNewMaterial(); - /// Gets the group name from file. - void getGroupName(); - /// Gets the group number from file. - void getGroupNumber(); - /// Gets the group number and resolution from file. - void getGroupNumberAndResolution(); - /// Returns the index of the material. Is -1 if not material was found. - int getMaterialIndex(const std::string &strMaterialName); - /// Parse object name - void getObjectName(); - /// Creates a new object. - void createObject(const std::string &strObjectName); - /// Creates a new mesh. - void createMesh(const std::string &meshName); - /// Returns true, if a new mesh instance must be created. - bool needsNewMesh(const std::string &rMaterialName); - /// Error report in token - void reportErrorTokenInFace(); - -private: - // Copy and assignment constructor should be private - // because the class contains pointer to allocated memory - - /// Default material name - static constexpr char DEFAULT_MATERIAL[] = AI_DEFAULT_MATERIAL_NAME; - //! Iterator to current position in buffer - DataArrayIt m_DataIt; - //! Iterator to end position of buffer - DataArrayIt m_DataItEnd; - //! Pointer to model instance - std::unique_ptr<ObjFile::Model> m_pModel; - //! Current line (for debugging) - unsigned int m_uiLine; - //! Helper buffer - char m_buffer[Buffersize]; - /// Pointer to IO system instance. - IOSystem *m_pIO; - //! Pointer to progress handler - ProgressHandler *m_progress; - /// Path to the current model, name of the obj file where the buffer comes from - const std::string m_originalObjFileName; -}; - -} // Namespace Assimp - -#endif diff --git a/src/mesh/assimp-master/code/AssetLib/Obj/ObjTools.h b/src/mesh/assimp-master/code/AssetLib/Obj/ObjTools.h deleted file mode 100644 index 9e57a1c..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Obj/ObjTools.h +++ /dev/null @@ -1,284 +0,0 @@ -/* -Open Asset Import Library (assimp) ----------------------------------------------------------------------- - -Copyright (c) 2006-2021, assimp team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ - -/** @file ObjTools.h - * @brief Some helpful templates for text parsing - */ -#ifndef OBJ_TOOLS_H_INC -#define OBJ_TOOLS_H_INC - -#include <assimp/ParsingUtils.h> -#include <assimp/fast_atof.h> -#include <vector> - -namespace Assimp { - -/** - * @brief Returns true, if the last entry of the buffer is reached. - * @param[in] it Iterator of current position. - * @param[in] end Iterator with end of buffer. - * @return true, if the end of the buffer is reached. - */ -template <class char_t> -inline bool isEndOfBuffer(char_t it, char_t end) { - if (it == end) { - return true; - } - --end; - - return (it == end); -} - -/** - * @brief Returns next word separated by a space - * @param[in] pBuffer Pointer to data buffer - * @param[in] pEnd Pointer to end of buffer - * @return Pointer to next space - */ -template <class Char_T> -inline Char_T getNextWord(Char_T pBuffer, Char_T pEnd) { - while (!isEndOfBuffer(pBuffer, pEnd)) { - if (!IsSpaceOrNewLine(*pBuffer) || IsLineEnd(*pBuffer)) { - break; - } - ++pBuffer; - } - - return pBuffer; -} - -/** - * @brief Returns pointer a next token - * @param[in] pBuffer Pointer to data buffer - * @param[in] pEnd Pointer to end of buffer - * @return Pointer to next token - */ -template <class Char_T> -inline Char_T getNextToken(Char_T pBuffer, Char_T pEnd) { - while (!isEndOfBuffer(pBuffer, pEnd)) { - if (IsSpaceOrNewLine(*pBuffer)) { - break; - } - ++pBuffer; - } - return getNextWord(pBuffer, pEnd); -} - -/** - * @brief Skips a line - * @param[in] it Iterator set to current position - * @param[in] end Iterator set to end of scratch buffer for readout - * @param[out] uiLine Current line number in format - * @return Current-iterator with new position - */ -template <class char_t> -inline char_t skipLine(char_t it, char_t end, unsigned int &uiLine) { - while (!isEndOfBuffer(it, end) && !IsLineEnd(*it)) { - ++it; - } - - if (it != end) { - ++it; - ++uiLine; - } - // fix .. from time to time there are spaces at the beginning of a material line - while (it != end && (*it == '\t' || *it == ' ')) { - ++it; - } - - return it; -} - -/** - * @brief Get a name from the current line. Preserve space in the middle, - * but trim it at the end. - * @param[in] it set to current position - * @param[in] end set to end of scratch buffer for readout - * @param[out] name Separated name - * @return Current-iterator with new position - */ -template <class char_t> -inline char_t getName(char_t it, char_t end, std::string &name) { - name = ""; - if (isEndOfBuffer(it, end)) { - return end; - } - - char *pStart = &(*it); - while (!isEndOfBuffer(it, end) && !IsLineEnd(*it)) { - ++it; - } - - while (IsSpace(*it)) { - --it; - } - // Get name - // if there is no name, and the previous char is a separator, come back to start - while (&(*it) < pStart) { - ++it; - } - std::string strName(pStart, &(*it)); - if (!strName.empty()) { - name = strName; - } - - - return it; -} - -/** - * @brief Get a name from the current line. Do not preserve space - * in the middle, but trim it at the end. - * @param it set to current position - * @param end set to end of scratch buffer for readout - * @param name Separated name - * @return Current-iterator with new position - */ -template <class char_t> -inline char_t getNameNoSpace(char_t it, char_t end, std::string &name) { - name = ""; - if (isEndOfBuffer(it, end)) { - return end; - } - - char *pStart = &(*it); - while (!isEndOfBuffer(it, end) && !IsLineEnd(*it) && !IsSpaceOrNewLine(*it)) { - ++it; - } - - while (isEndOfBuffer(it, end) || IsLineEnd(*it) || IsSpaceOrNewLine(*it)) { - --it; - } - ++it; - - // Get name - // if there is no name, and the previous char is a separator, come back to start - while (&(*it) < pStart) { - ++it; - } - std::string strName(pStart, &(*it)); - if (!strName.empty()) { - name = strName; - } - - return it; -} - -/** - * @brief Get next word from given line - * @param[in] it set to current position - * @param[in] end set to end of scratch buffer for readout - * @param[in] pBuffer Buffer for next word - * @param[in] length Buffer length - * @return Current-iterator with new position - */ -template <class char_t> -inline char_t CopyNextWord(char_t it, char_t end, char *pBuffer, size_t length) { - size_t index = 0; - it = getNextWord<char_t>(it, end); - while (!IsSpaceOrNewLine(*it) && !isEndOfBuffer(it, end)) { - pBuffer[index] = *it; - ++index; - if (index == length - 1) { - break; - } - ++it; - } - pBuffer[index] = '\0'; - return it; -} - -/** - * @brief Get next float from given line - * @param[in] it set to current position - * @param[in] end set to end of scratch buffer for readout - * @param[out] value Separated float value. - * @return Current-iterator with new position - */ -template <class char_t> -inline char_t getFloat(char_t it, char_t end, ai_real &value) { - static const size_t BUFFERSIZE = 1024; - char buffer[BUFFERSIZE]; - it = CopyNextWord<char_t>(it, end, buffer, BUFFERSIZE); - value = (ai_real)fast_atof(buffer); - - return it; -} - -/** - * @brief Will remove white-spaces for a string. - * @param[in] str The string to clean - * @return The trimmed string. - */ -template <class string_type> -inline string_type trim_whitespaces(string_type str) { - while (!str.empty() && IsSpace(str[0])) { - str.erase(0); - } - while (!str.empty() && IsSpace(str[str.length() - 1])) { - str.erase(str.length() - 1); - } - return str; -} - -/** - * @brief Checks for a line-end. - * @param[in] it Current iterator in string. - * @param[in] end End of the string. - * @return The trimmed string. - */ -template <class T> -bool hasLineEnd(T it, T end) { - bool hasLineEnd = false; - while (!isEndOfBuffer(it, end)) { - ++it; - if (IsLineEnd(it)) { - hasLineEnd = true; - break; - } - } - - return hasLineEnd; -} - -} // Namespace Assimp - -#endif // OBJ_TOOLS_H_INC |