| /* |
| --------------------------------------------------------------------------- |
| Open Asset Import Library (assimp) |
| --------------------------------------------------------------------------- |
| |
| Copyright (c) 2006-2017, 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 "ObjFileMtlImporter.h" |
| #include "ObjTools.h" |
| #include "ObjFileData.h" |
| #include "ParsingUtils.h" |
| #include "BaseImporter.h" |
| #include <assimp/DefaultIOSystem.h> |
| #include <assimp/DefaultLogger.hpp> |
| #include <assimp/material.h> |
| #include <assimp/Importer.hpp> |
| #include <cstdlib> |
| |
| namespace Assimp { |
| |
| const std::string ObjFileParser::DEFAULT_MATERIAL = AI_DEFAULT_MATERIAL_NAME; |
| |
| ObjFileParser::ObjFileParser() |
| : m_DataIt() |
| , m_DataItEnd() |
| , m_pModel( NULL ) |
| , m_uiLine( 0 ) |
| , m_pIO( nullptr ) |
| , m_progress( nullptr ) |
| , m_originalObjFileName() { |
| // empty |
| } |
| |
| ObjFileParser::ObjFileParser( IOStreamBuffer<char> &streamBuffer, const std::string &modelName, |
| IOSystem *io, ProgressHandler* progress, |
| const std::string &originalObjFileName) : |
| m_DataIt(), |
| m_DataItEnd(), |
| m_pModel(NULL), |
| m_uiLine(0), |
| 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 = 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() { |
| delete m_pModel; |
| m_pModel = NULL; |
| } |
| |
| void ObjFileParser::setBuffer( std::vector<char> &buffer ) { |
| m_DataIt = buffer.begin(); |
| m_DataItEnd = buffer.end(); |
| } |
| |
| ObjFile::Model *ObjFileParser::GetModel() const { |
| return m_pModel; |
| } |
| |
| 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 = 3 * bytesToProcess; |
| const unsigned int progressOffset = 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( progressOffset + processed * 2, 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; |
| getVector( m_pModel->m_TextureCoord ); |
| } 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 ) ) { |
| tmp++; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| 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 ) ); |
| SkipToken( tmp ); |
| if ( isNum ) { |
| ++numComponents; |
| } |
| if ( !SkipSpaces( &tmp ) ) { |
| break; |
| } |
| } |
| return numComponents; |
| } |
| |
| void ObjFileParser::getVector( 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" ); |
| } |
| point3d_array.push_back( aiVector3D( x, y, z ) ); |
| m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine ); |
| } |
| |
| 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.push_back( aiVector3D( 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 ); |
| |
| ai_assert( w != 0 ); |
| |
| point3d_array.push_back( aiVector3D( 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.push_back( aiVector3D( 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.push_back( aiVector3D( 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.push_back(aiVector2D(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 iStep = 0, iPos = 0; |
| while ( m_DataIt != m_DataItEnd ) { |
| iStep = 1; |
| |
| if ( IsLineEnd( *m_DataIt ) ) { |
| break; |
| } |
| |
| if ( *m_DataIt =='/' ) { |
| if (type == aiPrimitiveType_POINT) { |
| DefaultLogger::get()->error("Obj: Separator unexpected in point statement"); |
| } |
| if (iPos == 0) { |
| //if there are no texture coordinates in the file, but normals |
| if (!vt && vn) { |
| iPos = 1; |
| iStep++; |
| } |
| } |
| 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 ( 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; |
| delete m_pModel; |
| m_pModel = nullptr; |
| throw DeadlyImportError("OBJ: Invalid face indice"); |
| } |
| |
| } |
| m_DataIt += iStep; |
| } |
| |
| if ( face->m_vertices.empty() ) { |
| DefaultLogger::get()->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( NULL != 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( NULL == m_pModel->m_pCurrent ) { |
| createObject( DefaultObjName ); |
| } |
| |
| // Assign face to mesh |
| if ( NULL == 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. |
| DefaultLogger::get()->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() ) { |
| DefaultLogger::get()->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 + strMatName; |
| } else { |
| absName = strMatName; |
| } |
| IOStream *pFile = m_pIO->Open( absName ); |
| |
| if (!pFile ) { |
| DefaultLogger::get()->error("OBJ: Unable to locate material file " + strMatName); |
| std::string strMatFallbackName = m_originalObjFileName.substr(0, m_originalObjFileName.length() - 3) + "mtl"; |
| DefaultLogger::get()->info("OBJ: Opening fallback material file " + strMatFallbackName); |
| pFile = m_pIO->Open(strMatFallbackName); |
| if (!pFile) { |
| DefaultLogger::get()->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 ); |
| } |
| |
| // ------------------------------------------------------------------- |
| // 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 |
| DefaultLogger::get()->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 = NULL; |
| |
| // 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( NULL == 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( NULL != 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( NULL != 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 ( NULL != m_pModel->m_pCurrent ) |
| { |
| m_pModel->m_pCurrent->m_Meshes.push_back( meshId ); |
| } |
| else |
| { |
| DefaultLogger::get()->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 == 0) |
| { |
| 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.size() > 0 ) |
| { |
| // 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 ); |
| DefaultLogger::get()->error("OBJ: Not supported token in face description detected"); |
| } |
| |
| // ------------------------------------------------------------------- |
| |
| } // Namespace Assimp |
| |
| #endif // !! ASSIMP_BUILD_NO_OBJ_IMPORTER |
