/*!
Removes the specified mesh by name from the vector.
*/
bool SLNode::removeMesh(SLstring name)
{
assert(name!="");
SLMesh* found = findMesh(name);
if (found) return removeMesh(found);
return false;
}
FbxMesh* FBXConverter::findMesh( FbxNode* node )
{
if ( node->GetMesh() ) { std::cout << node->GetName() << std::endl; return node->GetMesh(); }
for ( int i = 0; i < node->GetChildCount(); i++ )
{
FbxMesh* theMesh = findMesh( node->GetChild( i ) );
if ( theMesh )
{
return theMesh;
}
};
return NULL;
}
CMesh *CModelManager::registerMesh(const std::string fname){
CMesh *found = findMesh(fname);
if(found)return found;
gcon.printString("Loading mesh " + fname + "\n");
CMeshPtr mesh = new CMesh();
try {
mesh->load(fname, CEngine::getSingleton()->vfs);
} catch (CException e) {
gcon.printString("Failed to load : " + fname + "\n ");
gcon.printString(e.getExplanation() + "\n");
return 0;
}
registerMesh(mesh);
return mesh;
}
void FBXConverter::convert( const char* input , const char* output )
{
if ( converting ) return;
converting = true;
FbxManager* fbxManger = FbxManager::Create();
FbxIOSettings* ios = FbxIOSettings::Create( fbxManger , IOSROOT );
fbxManger->SetIOSettings( ios );
FbxImporter* importer = FbxImporter::Create( fbxManger , "" );
bool status = importer->Initialize( input , -1 , fbxManger->GetIOSettings() );
if ( !status )
{
std::cout << importer->GetStatus().GetErrorString() << std::endl;
}
FbxScene* scene = FbxScene::Create( fbxManger , "theScene" );
importer->Import( scene );
importer->Destroy();
FbxMesh* theMesh = findMesh( scene->GetRootNode() );
if ( theMesh )
{
std::vector<VertexData> vertices;
std::vector<IndexData> indices;
FbxStringList uvSets;
theMesh->GetUVSetNames( uvSets );
processPolygons( theMesh , vertices , indices , uvSets );
std::vector<JointData> skeleton;
processSkeletonHierarchy( scene->GetRootNode() , skeleton );
if ( skeleton.size() ) processAnimations( theMesh->GetNode() , skeleton , vertices , indices );
std::string modelData;
for ( unsigned int i = 0; i < vertices.size(); ++i )
{
modelData += DATASTRING( vertices[i].position );
modelData += DATASTRING( vertices[i].uv );
modelData += DATASTRING( vertices[i].normal );
modelData += DATASTRING( vertices[i].tangent );
modelData += DATASTRING( vertices[i].bitangent );
for ( unsigned int j = 0; j < 4 ; ++j )
{
if ( j < vertices[i].blendingInfo.size() )
{
int blendingIndex = vertices[i].blendingInfo[j].blendingIndex;
modelData += DATASTRING( blendingIndex );
}
else
{
int blendingIndex = -1;
modelData += DATASTRING( blendingIndex );
}
}
for ( unsigned int j = 0; j < 4; ++j )
{
if ( j < vertices[i].blendingInfo.size() )
{
float blendingIndex = vertices[i].blendingInfo[j].blendingWeight;
modelData += DATASTRING( blendingIndex );
}
else
{
float blendingIndex = -1;
modelData += DATASTRING( blendingIndex );
}
}
}
for ( unsigned int i = 0; i < indices.size(); ++i)
{
modelData += DATASTRING( indices[i].index );
}
std::string boneData;
std::vector<unsigned int> boneChildren;
std::vector<AnimationData> boneAnimation;
for ( unsigned int i = 0; i < skeleton.size(); ++i )
{
boneData += DATASTRING( skeleton[i].offsetMatrix );
int childDataStart , childDataEnd , animationDataStart , animationDataEnd;
if ( skeleton[i].children.size() )
{
childDataStart = boneChildren.size();
for ( unsigned int j = 0; j < skeleton[i].children.size(); ++j )
{
boneChildren.push_back( skeleton[i].children[j] );
}
childDataEnd = boneChildren.size();
}
else
{
childDataStart = -1;
childDataEnd = -1;
}
if ( skeleton[i].animation.size() )
{
animationDataStart = boneAnimation.size();
for ( unsigned int j = 0; j < skeleton[i].animation.size(); ++j )
{
boneAnimation.push_back( skeleton[i].animation[j] );
}
animationDataEnd = boneAnimation.size();
}
else
{
animationDataStart = -1;
animationDataEnd = -1;
}
boneData += DATASTRING( childDataStart );
boneData += DATASTRING( childDataEnd );
boneData += DATASTRING( animationDataStart );
boneData += DATASTRING( animationDataEnd );
}
unsigned int sizeofAnimationRangeInfo;
AnimationFrameRangeInfo frameRange;
if ( boneAnimation.size() > 0 )
{
sizeofAnimationRangeInfo = 1;
frameRange.nextAnimationFrameInfo = 0;
frameRange.firstFrame = 1;
frameRange.lastFrame = boneAnimation[boneAnimation.size() - 1].frame;
}
else
{
sizeofAnimationRangeInfo = 0;
}
std::fstream stream( output , std::ios_base::binary | std::ios_base::out | std::ios_base::trunc );
unsigned int sizeofVertices = vertices.size();
stream.write( reinterpret_cast< char* >( &sizeofVertices ) , sizeof( sizeofVertices ));
unsigned int sizeofIndices = indices.size();
stream.write( reinterpret_cast< char* >( &sizeofIndices ) , sizeof( sizeofIndices ) );
unsigned int sizeofBoneData = skeleton.size();
stream.write( reinterpret_cast<char*>( &sizeofBoneData ) , sizeof( sizeofBoneData ) );
unsigned int sizeofBoneChildData = boneChildren.size();
stream.write( reinterpret_cast< char* >( &sizeofBoneChildData ) , sizeof( sizeofBoneChildData ));
unsigned int sizeofBoneAnimationData = boneAnimation.size();
stream.write( reinterpret_cast< char* >( &sizeofBoneAnimationData ) , sizeof( sizeofBoneAnimationData ) );
stream.write( reinterpret_cast< char* >( &sizeofAnimationRangeInfo ) , sizeof( sizeofAnimationRangeInfo ) );
stream.write( modelData.c_str() , modelData.size() );
stream.write( boneData.c_str() , boneData.size() );
for ( unsigned int i = 0; i < boneChildren.size(); ++i )
{
stream.write( reinterpret_cast< char* >( &boneChildren[i] ) , sizeof( boneChildren[i] ) );
}
for ( unsigned int i = 0; i < boneAnimation.size(); ++i )
{
stream.write( reinterpret_cast< char* >( &boneAnimation[i] ) , sizeof( boneAnimation[i] ) );
}
if(sizeofAnimationRangeInfo) stream.write( reinterpret_cast< char* >( &frameRange ) , sizeof( frameRange ) );
stream.close();
}
converting = false;
}
//! returns if a mesh already was loaded
bool CMeshCache::isMeshLoaded(const c8* filename)
{
core::stringc name = filename;
name.make_lower();
return findMesh(name.c_str()) != 0;
}