437 lines
14 KiB
C++
437 lines
14 KiB
C++
#include "ObjFileImporter.h"
|
|
#include "ObjFileParser.h"
|
|
#include "ObjFileData.h"
|
|
#include "../include/IOStream.h"
|
|
#include "../include/IOSystem.h"
|
|
#include "../include/aiMesh.h"
|
|
#include "../include/aiScene.h"
|
|
#include "../include/aiAssert.h"
|
|
#include "MaterialSystem.h"
|
|
#include "../include/DefaultLogger.h"
|
|
|
|
#include <boost/scoped_ptr.hpp>
|
|
#include <boost/format.hpp>
|
|
|
|
namespace Assimp
|
|
{
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
using namespace std;
|
|
|
|
//! Obj-file-format extention
|
|
const string ObjFileImporter::OBJ_EXT = "obj";
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Default constructor
|
|
ObjFileImporter::ObjFileImporter() :
|
|
m_pRootObject(NULL),
|
|
m_strAbsPath("\\")
|
|
{
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Destructor
|
|
ObjFileImporter::~ObjFileImporter()
|
|
{
|
|
// Release root object instance
|
|
if (NULL != m_pRootObject)
|
|
{
|
|
delete m_pRootObject;
|
|
m_pRootObject = NULL;
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Returns true, fi file is an obj file
|
|
bool ObjFileImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler) const
|
|
{
|
|
if (pFile.empty())
|
|
return false;
|
|
|
|
string::size_type pos = pFile.find_last_of(".");
|
|
if (string::npos == pos)
|
|
return false;
|
|
|
|
const string ext = pFile.substr(pos+1, pFile.size() - pos - 1);
|
|
if (ext == OBJ_EXT)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Obj-file import implementation
|
|
void ObjFileImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
|
|
{
|
|
// Read file into memory
|
|
const std::string mode = "rb";
|
|
boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile, mode));
|
|
if (NULL == file.get())
|
|
throw new ImportErrorException( "Failed to open file " + pFile + ".");
|
|
|
|
// Get the filesize and vaslidate it, throwing an exception when failes
|
|
size_t fileSize = file->FileSize();
|
|
if( fileSize < 16)
|
|
throw new ImportErrorException( "OBJ-file is too small.");
|
|
|
|
// Allocate buffer and read file into it
|
|
m_Buffer.resize( fileSize );
|
|
const size_t readsize = file->Read(&m_Buffer.front(), sizeof(char), fileSize);
|
|
assert (readsize == fileSize);
|
|
|
|
//
|
|
std::string strDirectory("\\"), strModelName;
|
|
std::string::size_type pos = pFile.find_last_of("\\");
|
|
if (pos != std::string::npos)
|
|
{
|
|
strDirectory = pFile.substr(0, pos);
|
|
strModelName = pFile.substr(pos+1, pFile.size() - pos - 1);
|
|
}
|
|
else
|
|
{
|
|
strModelName = pFile;
|
|
}
|
|
|
|
// parse the file into a temporary representation
|
|
ObjFileParser parser(m_Buffer, strDirectory, strModelName);
|
|
|
|
// And create the proper return structures out of it
|
|
CreateDataFromImport(parser.GetModel(), pScene);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Create the data from parsed obj-file
|
|
void ObjFileImporter::CreateDataFromImport(const ObjFile::Model* pModel, aiScene* pScene)
|
|
{
|
|
if (0L == 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 an error, so break down the application
|
|
assert (false);
|
|
}
|
|
|
|
// Create nodes for the whole scene
|
|
std::vector<aiMesh*> MeshArray;
|
|
for (size_t index = 0; index < pModel->m_Objects.size(); index++)
|
|
{
|
|
createNodes(pModel, pModel->m_Objects[ index ], pScene->mRootNode, pScene, MeshArray);
|
|
}
|
|
|
|
// 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
|
|
for (size_t index = 0; index < pModel->m_Objects.size(); index++)
|
|
{
|
|
createMaterial( pModel, pModel->m_Objects[ index ], pScene );
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Creates all nodes of the model
|
|
aiNode *ObjFileImporter::createNodes(const ObjFile::Model* pModel, const ObjFile::Object* pData,
|
|
aiNode *pParent, aiScene* pScene,
|
|
std::vector<aiMesh*> &MeshArray)
|
|
{
|
|
if (NULL == pData)
|
|
return NULL;
|
|
|
|
// Store older mesh size to be able to computate mesh offsets for new mesh instances
|
|
size_t oldMeshSize = MeshArray.size();
|
|
aiNode *pNode = new aiNode();
|
|
|
|
if (pParent != NULL)
|
|
this->appendChildToParentNode(pParent, pNode);
|
|
|
|
aiMesh *pMesh = NULL;
|
|
for (unsigned int meshIndex = 0; meshIndex < pModel->m_Meshes.size(); meshIndex++)
|
|
{
|
|
pMesh = new aiMesh();
|
|
MeshArray.push_back( pMesh );
|
|
createTopology( pModel, pData, meshIndex, pMesh );
|
|
}
|
|
|
|
// Create all nodes from the subobjects stored in the current object
|
|
if (!pData->m_SubObjects.empty())
|
|
{
|
|
pNode->mNumChildren = (unsigned int)pData->m_SubObjects.size();
|
|
pNode->mChildren = new aiNode*[pData->m_SubObjects.size()];
|
|
pNode->mNumMeshes = 1;
|
|
pNode->mMeshes = new unsigned int[1];
|
|
|
|
// Loop over all child objects, TODO
|
|
/*for (size_t index = 0; index < pData->m_SubObjects.size(); index++)
|
|
{
|
|
// Create all child nodes
|
|
pNode->mChildren[ index ] = createNodes( pModel, pData, pNode, pScene, MeshArray );
|
|
for (unsigned int meshIndex = 0; meshIndex < pData->m_SubObjects[ index ]->m_Meshes.size(); meshIndex++)
|
|
{
|
|
pMesh = new aiMesh();
|
|
MeshArray.push_back( pMesh );
|
|
createTopology( pModel, pData, meshIndex, pMesh );
|
|
}
|
|
|
|
// Create material of this object
|
|
createMaterial(pModel, pData->m_SubObjects[ index ], pScene);
|
|
}*/
|
|
}
|
|
|
|
// 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 = 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
|
|
void ObjFileImporter::createTopology(const ObjFile::Model* pModel,
|
|
const ObjFile::Object* pData,
|
|
unsigned int uiMeshIndex,
|
|
aiMesh* pMesh )
|
|
{
|
|
// Checking preconditions
|
|
ai_assert( NULL != pModel );
|
|
if (NULL == pData)
|
|
return;
|
|
|
|
// Create faces
|
|
ObjFile::Mesh *pObjMesh = pModel->m_Meshes[ uiMeshIndex ];
|
|
pMesh->mNumFaces = (unsigned int) pObjMesh->m_Faces.size();
|
|
pMesh->mFaces = new aiFace[ pMesh->mNumFaces ];
|
|
pMesh->mMaterialIndex = pObjMesh->m_uiMaterialIndex;
|
|
|
|
// Copy all data from all stored meshes
|
|
for (size_t index = 0; index < pObjMesh->m_Faces.size(); index++)
|
|
{
|
|
aiFace *pFace = &pMesh->mFaces[ index ];
|
|
const unsigned int uiNumIndices = (unsigned int) pObjMesh->m_Faces[ index ]->m_pVertices->size();
|
|
pFace->mNumIndices = (unsigned int) uiNumIndices;
|
|
if (pFace->mNumIndices > 0)
|
|
{
|
|
pFace->mIndices = new unsigned int[ uiNumIndices ];
|
|
ObjFile::Face::IndexArray *pIndexArray = pObjMesh->m_Faces[ index ]->m_pVertices;
|
|
ai_assert ( NULL != pIndexArray );
|
|
for ( size_t a=0; a<pFace->mNumIndices; a++ )
|
|
{
|
|
pFace->mIndices[ a ] = pIndexArray->at( a );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pFace->mIndices = NULL;
|
|
}
|
|
}
|
|
|
|
// Create mesh vertices
|
|
createVertexArray(pModel, pData, uiMeshIndex, pMesh);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void ObjFileImporter::createVertexArray(const ObjFile::Model* pModel,
|
|
const ObjFile::Object* pCurrentObject,
|
|
unsigned int uiMeshIndex,
|
|
aiMesh* pMesh)
|
|
{
|
|
// Checking preconditions
|
|
ai_assert ( NULL != pCurrentObject );
|
|
|
|
// Break, if no faces are stored in object
|
|
if (pCurrentObject->m_Faces.empty())
|
|
return;
|
|
|
|
// Get current mesh
|
|
ObjFile::Mesh *pObjMesh = pModel->m_Meshes[ uiMeshIndex ];
|
|
if ( NULL == pObjMesh )
|
|
return;
|
|
|
|
// Copy vertices of this mesh instance
|
|
pMesh->mNumVertices = (unsigned int) pObjMesh->m_uiNumIndices;
|
|
pMesh->mVertices = new aiVector3D[ pMesh->mNumVertices ];
|
|
|
|
// Allocate buffer for normal vectors
|
|
if ( !pModel->m_Normals.empty() )
|
|
pMesh->mNormals = new aiVector3D[ pMesh->mNumVertices ];
|
|
|
|
// Allocate buffer for texture coordinates
|
|
if ( !pModel->m_TextureCoord.empty() )
|
|
{
|
|
for ( size_t i=0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; i++)
|
|
pMesh->mTextureCoords[ i ] = new aiVector3D[ pModel->m_TextureCoord.size() ];
|
|
}
|
|
|
|
// Copy vertices, normals and textures into aiMesh instance
|
|
unsigned int newIndex = 0;
|
|
for ( size_t index=0; index < pObjMesh->m_Faces.size(); index++ )
|
|
{
|
|
// get destination face
|
|
aiFace *pDestFace = &pMesh->mFaces[ index ];
|
|
|
|
// get source face
|
|
ObjFile::Face *pSourceFace = pObjMesh->m_Faces[ index ];
|
|
|
|
// Copy all index arrays
|
|
for ( size_t vertexIndex = 0; vertexIndex < pSourceFace->m_pVertices->size(); vertexIndex++ )
|
|
{
|
|
unsigned int vertex = pSourceFace->m_pVertices->at( vertexIndex );
|
|
assert ( vertex < pModel->m_Vertices.size() );
|
|
pMesh->mVertices[ newIndex ] = *pModel->m_Vertices[ vertex ];
|
|
|
|
if ( !pModel->m_Normals.empty() )
|
|
{
|
|
const unsigned int normal = pSourceFace->m_pNormals->at( vertexIndex );
|
|
assert( normal < pModel->m_Normals.size() );
|
|
pMesh->mNormals[ newIndex ] = *pModel->m_Normals[ normal ];
|
|
}
|
|
|
|
if ( !pModel->m_TextureCoord.empty() )
|
|
{
|
|
const unsigned int tex = pSourceFace->m_pTexturCoords->at( vertexIndex );
|
|
ai_assert ( tex < pModel->m_TextureCoord.size() );
|
|
for ( size_t i=0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; i++)
|
|
{
|
|
aiVector2D coord2d = *pModel->m_TextureCoord[ tex ];
|
|
pMesh->mTextureCoords[ i ][ newIndex ] = aiVector3D( coord2d.x, coord2d.y, 0.0 );
|
|
}
|
|
}
|
|
|
|
assert( pMesh->mNumVertices > newIndex );
|
|
pDestFace->mIndices[ vertexIndex ] = newIndex;
|
|
newIndex++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void ObjFileImporter::countObjects(const std::vector<ObjFile::Object*> &rObjects, int &iNumMeshes)
|
|
{
|
|
iNumMeshes = 0;
|
|
if (rObjects.empty())
|
|
return;
|
|
|
|
iNumMeshes += (unsigned int)rObjects.size();
|
|
for (std::vector<ObjFile::Object*>::const_iterator it = rObjects.begin();
|
|
it != rObjects.end();
|
|
++it)
|
|
{
|
|
if (!(*it)->m_SubObjects.empty())
|
|
{
|
|
countObjects((*it)->m_SubObjects, iNumMeshes);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void ObjFileImporter::createMaterial(const ObjFile::Model* pModel, const ObjFile::Object* pData,
|
|
aiScene* pScene)
|
|
{
|
|
ai_assert (NULL != pScene);
|
|
if (NULL == pData)
|
|
return;
|
|
|
|
const unsigned int numMaterials = (unsigned int) pModel->m_MaterialLib.size();
|
|
pScene->mNumMaterials = 0;
|
|
if ( pModel->m_MaterialLib.empty() )
|
|
return;
|
|
|
|
pScene->mMaterials = new aiMaterial*[ numMaterials ];
|
|
for ( unsigned int matIndex = 0; matIndex < numMaterials; matIndex++ )
|
|
{
|
|
Assimp::MaterialHelper* mat = new Assimp::MaterialHelper();
|
|
|
|
// Store material name
|
|
std::map<std::string, ObjFile::Material*>::const_iterator it = pModel->m_MaterialMap.find( pModel->m_MaterialLib[ matIndex ] );
|
|
|
|
// No material found, use the default material
|
|
if ( pModel->m_MaterialMap.end() == it)
|
|
continue;
|
|
|
|
ObjFile::Material *pCurrentMaterial = (*it).second;
|
|
mat->AddProperty( &pCurrentMaterial->MaterialName, AI_MATKEY_NAME );
|
|
mat->AddProperty<int>( &pCurrentMaterial->illumination_model, 1, AI_MATKEY_SHADING_MODEL);
|
|
|
|
// 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->shineness, 1, AI_MATKEY_SHININESS );
|
|
|
|
// Adding textures
|
|
if ( 0 != pCurrentMaterial->texture.length )
|
|
mat->AddProperty( &pCurrentMaterial->texture, AI_MATKEY_TEXTURE_DIFFUSE(0));
|
|
|
|
// 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 (NULL != pParent);
|
|
ai_assert (NULL != pChild);
|
|
|
|
// Assign parent to child
|
|
pChild->mParent = pParent;
|
|
size_t sNumChildren = 0;
|
|
|
|
// If already children was assigned to the parent node, store them in a
|
|
std::vector<aiNode*> temp;
|
|
if (pParent->mChildren != NULL)
|
|
{
|
|
sNumChildren = pParent->mNumChildren;
|
|
ai_assert (0 != sNumChildren);
|
|
for (size_t index = 0; index < pParent->mNumChildren; index++)
|
|
{
|
|
temp.push_back(pParent->mChildren [ index ] );
|
|
}
|
|
delete [] pParent->mChildren;
|
|
}
|
|
|
|
// Copy node instances into parent node
|
|
pParent->mNumChildren++;
|
|
pParent->mChildren = new aiNode*[ pParent->mNumChildren ];
|
|
for (size_t index = 0; index < pParent->mNumChildren-1; index++)
|
|
{
|
|
pParent->mChildren[ index ] = temp [ index ];
|
|
}
|
|
pParent->mChildren[ pParent->mNumChildren-1 ] = pChild;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
} // Namespace Assimp
|