FbxScene* ImportFbxScene(const string& fileName, FbxManager* manager)
{
LOG("Importing \"%\"", fileName);
FbxImporter* importer = FbxImporter::Create(manager, "");
FbxIOSettings* iosettings = FbxIOSettings::Create(manager, IOSROOT);
manager->SetIOSettings(iosettings);
auto importStatus = importer->Initialize(fileName.c_str(), -1, iosettings); //bool
if (!importStatus)
{
LOG("Error initializing fbx importer: %", importer->GetStatus().GetErrorString());
return nullptr;
}
FbxScene* scene = FbxScene::Create(manager, "Scene");
importer->Import(scene);
int major, minor, revision;
importer->GetFileVersion(major, minor, revision);
LOG("Success! File version is %.%.%", major, minor, revision);
return scene;
}
void FbxUtil::LoadScene(const std::string &filePath, const std::shared_ptr<SceneNode> &rootNode, float scaleFactor, unsigned int options)
{
FbxManager* sdkManager = FbxManager::Create();
FbxIOSettings* ios = FbxIOSettings::Create(sdkManager, IOSROOT);
sdkManager->SetIOSettings(ios);
FbxImporter* importer = FbxImporter::Create(sdkManager, "");
m_ScaleFactor = scaleFactor;
m_Options = options;
if (importer->Initialize(filePath.c_str(), -1, sdkManager->GetIOSettings()))
{
FbxScene* lScene = FbxScene::Create(sdkManager, "");
importer->Import(lScene);
importer->Destroy();
FbxNode* lRootNode = lScene->GetRootNode();
if (lRootNode)
{
for (int i = 0; i < lRootNode->GetChildCount(); i++)
LoadNode(rootNode, lRootNode->GetChild(i));
rootNode->Recompose();
}
}
else
ASSERT_MSG(false, "Error: " << importer->GetStatus().GetErrorString());
// Destroy the SDK manager and all the other objects it was handling.
sdkManager->Destroy();
}
FbxScene* getScene(std::string filePath, FbxManager* manager) {
// Create an importer using the SDK manager.
FbxImporter* importer = FbxImporter::Create(manager,"");
// Use the first argument as the filename for the importer.
if(!importer->Initialize(filePath.c_str(), -1, manager->GetIOSettings())) {
printf("Call to FbxImporter::Initialize() failed.\n");
printf("Error returned: %s\n\n", importer->GetStatus().GetErrorString());
return nullptr;
}
// Create a new scene so that it can be populated by the imported file.
FbxScene* scene = FbxScene::Create(manager,"myScene");
// Import the contents of the file into the scene.
if (importer->Import(scene)) {
std::cout << "Scene is succefully loaded." << std::endl;
} else {
std::cout << "Scene is NOT loaded." << std::endl;
}
// The file is imported; so get rid of the importer.
importer->Destroy();
return scene;
}
int FbxLoader::LoadFbx(const char* fbxName)
{
m_fbxManager = FbxManager::Create();
FbxIOSettings *ios = FbxIOSettings::Create(m_fbxManager, IOSROOT);
m_fbxManager->SetIOSettings(ios);
FbxImporter* lImporter = FbxImporter::Create(m_fbxManager, "");
if (!lImporter->Initialize(fbxName, -1, m_fbxManager->GetIOSettings())) {
printf("Call to FbxImporter::Initialize() failed.\n");
printf("Error returned: %s\n\n", lImporter->GetStatus().GetErrorString());
return -1;
}
FbxScene* lScene = FbxScene::Create(m_fbxManager, "myScene");
lImporter->Import(lScene);
lImporter->Destroy();
m_rootNode = lScene->GetRootNode();
if (m_rootNode) {
m_firstNode = m_rootNode->GetChild(0);
for (int i = 0; i < m_rootNode->GetChildCount(); i++)
LoadNode(m_rootNode->GetChild(i));
}
m_animEvaluator = lScene->GetAnimationEvaluator();
return 0;
}
//FbxManager* lSdkManager = FbxManager::Create();
sb7fbxmodel::sb7fbxmodel(char *fileName)
{
FbxManager* lSdkManager = FbxManager::Create();
// Create the IO settings object.
FbxIOSettings *ios = FbxIOSettings::Create(lSdkManager, IOSROOT);
lSdkManager->SetIOSettings(ios);
// Create an importer using the SDK manager.
FbxImporter* lImporter = FbxImporter::Create(lSdkManager,"");
// Use the first argument as the filename for the importer.
if(!lImporter->Initialize(fileName, -1, lSdkManager->GetIOSettings())) {
printf("Call to FbxImporter::Initialize() failed.\n");
printf("Error returned: %s\n\n", lImporter->GetStatus().GetErrorString());
exit(-1);
}
// Create a new scene so that it can be populated by the imported file.
FbxScene* lScene = FbxScene::Create(lSdkManager,"myScene");
// Import the contents of the file into the scene.
lImporter->Import(lScene);
ProcessNode(lScene->GetRootNode());
// The file is imported; so get rid of the importer.
lImporter->Destroy();
}
void initializeFbxSdk() {
const char* lFilename = "testCube.fbx";
mySdkManager = FbxManager::Create();
// Create the IO settings object.
FbxIOSettings *ios = FbxIOSettings::Create(mySdkManager, IOSROOT);
mySdkManager->SetIOSettings(ios);
// Create an importer using the SDK manager.
FbxImporter* lImporter = FbxImporter::Create(mySdkManager,"");
// Use the first argument as the filename for the importer.
if(!lImporter->Initialize(lFilename, -1, mySdkManager->GetIOSettings())) {
printf("Call to FbxImporter::Initialize() failed.\n");
printf("Error returned: %s\n\n", lImporter->GetStatus().GetErrorString());
exit(-1);
}
// Create a new scene so that it can be populated by the imported file.
FbxScene* lScene = FbxScene::Create(mySdkManager,"myScene");
// Import the contents of the file into the scene.
lImporter->Import(lScene);
// The file is imported, so get rid of the importer.
lImporter->Destroy();
// Print the nodes of the scene and their attributes recursively.
// Note that we are not printing the root node because it should
// not contain any attributes.
FbxNode* lRootNode = lScene->GetRootNode();
if(lRootNode) {
for(int i = 0; i < lRootNode->GetChildCount(); i++)
PrintNode(lRootNode->GetChild(i));
}
// Destroy the SDK manager and all the other objects it was handling.
mySdkManager->Destroy();
}
FbxScene* FBXLoader::LoadScene(const char* aFile)
{
// Create an importer using the SDK manager.
FbxImporter* lImporter = FbxImporter::Create(myFbxManager,"");
// Use the first argument as the filename for the importer.
if(!lImporter->Initialize(aFile, -1, myFbxManager->GetIOSettings()))
{
printf("Call to FbxImporter::Initialize() failed.\n");
printf("Error returned: %s\n\n", lImporter->GetStatus().GetErrorString());
std::string errorMessage = "Could not find fbx file: " + std::string(aFile);
FBX_LOG(errorMessage.c_str());
MessageBoxA(nullptr, errorMessage.c_str(), "ERROR", 0);
//DL_ASSERT("Fbx file not found. Check the debug logger!");
}
// Create a new scene so that it can be populated by the imported file.
FbxScene* lScene = FbxScene::Create(myFbxManager, "myScene");
// Import the contents of the file into the scene.
lImporter->Import(lScene);
// The file is imported; so get rid of the importer.a
lImporter->Destroy();
FbxGeometryConverter lGeomConverter(myFbxManager);
lGeomConverter.Triangulate(lScene, /*replace*/true);
//FbxMesh mesh;
//mesh.GenerateTangentsData(
//lGeomConverter.Comp
//lGeomConverter.tr
// Split meshes per material, so that we only have one material per mesh (for VBO support)
lGeomConverter.SplitMeshesPerMaterial(lScene, /*replace*/true);
return lScene;
}
osgDB::ReaderWriter::ReadResult
ReaderWriterFBX::readNode(const std::string& filenameInit,
const Options* options) const
{
try
{
std::string ext(osgDB::getLowerCaseFileExtension(filenameInit));
if (!acceptsExtension(ext)) return ReadResult::FILE_NOT_HANDLED;
std::string filename(osgDB::findDataFile(filenameInit, options));
if (filename.empty()) return ReadResult::FILE_NOT_FOUND;
FbxManager* pSdkManager = FbxManager::Create();
if (!pSdkManager)
{
return ReadResult::ERROR_IN_READING_FILE;
}
CleanUpFbx cleanUpFbx(pSdkManager);
pSdkManager->SetIOSettings(FbxIOSettings::Create(pSdkManager, IOSROOT));
FbxScene* pScene = FbxScene::Create(pSdkManager, "");
// The FBX SDK interprets the filename as UTF-8
#ifdef OSG_USE_UTF8_FILENAME
const std::string& utf8filename(filename);
#else
std::string utf8filename(osgDB::convertStringFromCurrentCodePageToUTF8(filename));
#endif
FbxImporter* lImporter = FbxImporter::Create(pSdkManager, "");
if (!lImporter->Initialize(utf8filename.c_str(), -1, pSdkManager->GetIOSettings()))
{
#if FBXSDK_VERSION_MAJOR < 2014
return std::string(lImporter->GetLastErrorString());
#else
return std::string(lImporter->GetStatus().GetErrorString());
#endif
}
if (!lImporter->IsFBX())
{
return ReadResult::ERROR_IN_READING_FILE;
}
for (int i = 0; FbxTakeInfo* lTakeInfo = lImporter->GetTakeInfo(i); i++)
{
lTakeInfo->mSelect = true;
}
if (!lImporter->Import(pScene))
{
#if FBXSDK_VERSION_MAJOR < 2014
return std::string(lImporter->GetLastErrorString());
#else
return std::string(lImporter->GetStatus().GetErrorString());
#endif
}
//FbxAxisSystem::OpenGL.ConvertScene(pScene); // Doesn't work as expected. Still need to transform vertices.
if (FbxNode* pNode = pScene->GetRootNode())
{
bool useFbxRoot = false;
bool lightmapTextures = false;
bool tessellatePolygons = false;
if (options)
{
std::istringstream iss(options->getOptionString());
std::string opt;
while (iss >> opt)
{
if (opt == "UseFbxRoot")
{
useFbxRoot = true;
}
if (opt == "LightmapTextures")
{
lightmapTextures = true;
}
if (opt == "TessellatePolygons")
{
tessellatePolygons = true;
}
}
}
bool bIsBone = false;
int nLightCount = 0;
osg::ref_ptr<Options> localOptions = NULL;
if (options)
localOptions = options->cloneOptions();
else
localOptions = new osgDB::Options();
localOptions->setObjectCacheHint(osgDB::ReaderWriter::Options::CACHE_IMAGES);
std::string filePath = osgDB::getFilePath(filename);
FbxMaterialToOsgStateSet fbxMaterialToOsgStateSet(filePath, localOptions.get(), lightmapTextures);
std::set<const FbxNode*> fbxSkeletons;
findLinkedFbxSkeletonNodes(pNode, fbxSkeletons);
OsgFbxReader::AuthoringTool authoringTool = OsgFbxReader::UNKNOWN;
if (FbxDocumentInfo* pDocInfo = pScene->GetDocumentInfo())
{
struct ToolName
{
const char* name;
OsgFbxReader::AuthoringTool tool;
};
ToolName authoringTools[] = {
{"OpenSceneGraph", OsgFbxReader::OPENSCENEGRAPH},
{"3ds Max", OsgFbxReader::AUTODESK_3DSTUDIO_MAX}
};
FbxString appName = pDocInfo->LastSaved_ApplicationName.Get();
for (unsigned int i = 0; i < sizeof(authoringTools) / sizeof(authoringTools[0]); ++i)
{
if (0 ==
#ifdef WIN32
_strnicmp
#else
strncasecmp
#endif
(appName, authoringTools[i].name, strlen(authoringTools[i].name)))
{
authoringTool = authoringTools[i].tool;
break;
}
}
}
OsgFbxReader reader(*pSdkManager,
*pScene,
fbxMaterialToOsgStateSet,
fbxSkeletons,
*localOptions,
authoringTool,
lightmapTextures,
tessellatePolygons);
ReadResult res = reader.readFbxNode(pNode, bIsBone, nLightCount);
if (res.success())
{
fbxMaterialToOsgStateSet.checkInvertTransparency();
resolveBindMatrices(*res.getNode(), reader.boneBindMatrices, reader.nodeMap);
osg::Node* osgNode = res.getNode();
osgNode->getOrCreateStateSet()->setMode(GL_RESCALE_NORMAL,osg::StateAttribute::ON);
osgNode->getOrCreateStateSet()->setMode(GL_NORMALIZE,osg::StateAttribute::ON);
if (reader.pAnimationManager.valid())
{
if (osgNode->getUpdateCallback())
{
osg::Group* osgGroup = new osg::Group;
osgGroup->addChild(osgNode);
osgNode = osgGroup;
}
//because the animations may be altered after registering
reader.pAnimationManager->buildTargetReference();
osgNode->setUpdateCallback(reader.pAnimationManager.get());
}
FbxAxisSystem fbxAxis = pScene->GetGlobalSettings().GetAxisSystem();
if (fbxAxis != FbxAxisSystem::OpenGL)
{
int upSign;
FbxAxisSystem::EUpVector eUp = fbxAxis.GetUpVector(upSign);
bool bLeftHanded = fbxAxis.GetCoorSystem() == FbxAxisSystem::eLeftHanded;
float fSign = upSign < 0 ? -1.0f : 1.0f;
float zScale = bLeftHanded ? -1.0f : 1.0f;
osg::Matrix mat;
switch (eUp)
{
case FbxAxisSystem::eXAxis:
mat.set(0,fSign,0,0,-fSign,0,0,0,0,0,zScale,0,0,0,0,1);
break;
case FbxAxisSystem::eYAxis:
mat.set(1,0,0,0,0,fSign,0,0,0,0,fSign*zScale,0,0,0,0,1);
break;
case FbxAxisSystem::eZAxis:
mat.set(1,0,0,0,0,0,-fSign*zScale,0,0,fSign,0,0,0,0,0,1);
break;
}
osg::Transform* pTransformTemp = osgNode->asTransform();
osg::MatrixTransform* pMatrixTransform = pTransformTemp ?
pTransformTemp->asMatrixTransform() : NULL;
if (pMatrixTransform)
{
pMatrixTransform->setMatrix(pMatrixTransform->getMatrix() * mat);
}
else
{
pMatrixTransform = new osg::MatrixTransform(mat);
if (useFbxRoot && isBasicRootNode(*osgNode))
{
// If root node is a simple group, put all FBX elements under the OSG root
osg::Group* osgGroup = osgNode->asGroup();
for(unsigned int i = 0; i < osgGroup->getNumChildren(); ++i)
{
pMatrixTransform->addChild(osgGroup->getChild(i));
}
pMatrixTransform->setName(osgGroup->getName());
}
else
{
pMatrixTransform->addChild(osgNode);
}
}
osgNode = pMatrixTransform;
}
osgNode->setName(filenameInit);
return osgNode;
}
}
}
catch (...)
{
OSG_WARN << "Exception thrown while importing \"" << filenameInit << '\"' << std::endl;
}
return ReadResult::ERROR_IN_READING_FILE;
}
int main(int argc, char **argv)
{
#ifndef _DEBUG
if (argc != 2)
{
printf("invalid arg");
return 0;
}
const char* filename = argv[1];
#else
const char* filename = "*****@*****.**";
#endif
output.open("output.txt", ios::out | ios::trunc);
output2.open("output2.txt", ios::out | ios::trunc);
output3.open("output3.txt", ios::out | ios::trunc);
if (!output.is_open())
{
exit(1);
}
FbxManager* fm = FbxManager::Create();
FbxIOSettings *ios = FbxIOSettings::Create(fm, IOSROOT);
//ios->SetBoolProp(EXP_FBX_ANIMATION, false);
ios->SetIntProp(EXP_FBX_COMPRESS_LEVEL, 9);
ios->SetAllObjectFlags(true);
fm->SetIOSettings(ios);
FbxImporter* importer = FbxImporter::Create(fm, "");
if (!importer->Initialize(filename, -1, fm->GetIOSettings()))
{
printf("error returned : %s\n", importer->GetStatus().GetErrorString());
exit(-1);
}
FbxScene* scene = FbxScene::Create(fm, "myscene");
importer->Import(scene);
importer->Destroy();
output << "some\n";
output << "charcnt : " << scene->GetCharacterCount() << endl << "node cnt : " << scene->GetNodeCount() << endl;
int animstackcnt = scene->GetSrcObjectCount<FbxAnimStack>();
output << "animstackcnt : " << animstackcnt << endl;
output << "------------" << endl;
vector<FbxNode*> removableNodes;
for (int i = 0; i < scene->GetNodeCount(); i++)
{
FbxNode* node = scene->GetNode(i);
output << "scene's node " << i << " : " << node->GetName() << ", childcnt : " << node->GetChildCount();
if (node->GetNodeAttribute())
{
output <<", att type : " << node->GetNodeAttribute()->GetAttributeType();
if (node->GetNodeAttribute()->GetAttributeType() == FbxNodeAttribute::EType::eMesh)
{
FbxMesh* mesh = node->GetMesh();
output << ", mem usage : " << mesh->MemoryUsage() << ", deformer cnt : " << mesh->GetDeformerCount(FbxDeformer::EDeformerType::eSkin) << endl;
collapseMesh(mesh);
FbxSkin* skin = (FbxSkin*) (mesh->GetDeformer(0, FbxDeformer::EDeformerType::eSkin));
if (skin)
{
for (int cli = 0; cli < skin->GetClusterCount(); cli++)
{
FbxCluster* cluster = skin->GetCluster(cli);
output << "\tcluster no." << cli << " has " << cluster->GetControlPointIndicesCount() << " connected verts" << endl;
if (cluster->GetControlPointIndicesCount() == 0)
removableNodes.push_back( cluster->GetLink() );
//cluster->
//skin->RemoveCluster(cluster);효과없음
}
}
if (mesh->IsTriangleMesh())
{
output << "\tit's triangle mesh" << endl;
}
//mesh->RemoveDeformer(0);효과없음
}
else
output << endl;
}
else
{
output << ", att type : none" << endl;
}
}
for (int rni = 0; rni < removableNodes.size(); rni++)
{
FbxNode* rnd = removableNodes[rni];
if (rnd && rnd->GetNodeAttribute()->GetAttributeType() == FbxNodeAttribute::EType::eSkeleton)
{
output3 << rnd->GetName() << " node with no vert attached's curve : " << rnd->GetSrcObjectCount<FbxAnimCurve>() << "," << rnd->GetSrcObjectCount<FbxAnimCurveNode>() << endl;
}
}
output << "-----------animinfo" << endl;
int cubic = 0, linear = 0, cons = 0;
for (int si = 0; si < animstackcnt; si++)
{
FbxAnimStack* stack = scene->GetSrcObject<FbxAnimStack>(si);
for (int i = 0; i < stack->GetMemberCount<FbxAnimLayer>(); i++)
{
FbxAnimLayer* layer = stack->GetMember<FbxAnimLayer>(i);
int curvenodecnt = layer->GetMemberCount<FbxAnimCurveNode>();
int compositcnt = 0;
for (int j = 0; j < curvenodecnt; j++)
{
FbxAnimCurveNode* cnode = layer->GetMember<FbxAnimCurveNode>(j);
compositcnt += (cnode->IsComposite() ? 1 : 0);
}
output << "\tanimstack's layer " << i << " : " << layer->GetName() << ", curve node cnt : " << curvenodecnt << ", composit node cnt : " << compositcnt << endl;
vector<FbxAnimCurveNode*> nodes2del;
for (int j = 0; j < curvenodecnt; j++)
{
FbxAnimCurveNode* cnode = layer->GetMember<FbxAnimCurveNode>(j);
output << "\t\tcurvenode " << j << " channel cnt : " << cnode->GetChannelsCount() << ", dst obj cnt " << cnode->GetDstObjectCount() << "(";
for (int dsti = 0; dsti < cnode->GetDstObjectCount(); dsti++)
{
output << "," << cnode->GetDstObject(dsti)->GetName();
if (cnode->GetDstObject(dsti)->GetSrcObjectCount() > 0)
output << "<" << cnode->GetDstObject(dsti)->GetSrcObjectCount<FbxSkeleton>() << ">";
}
output << ")";
FbxTimeSpan interval;
if (cnode->GetAnimationInterval(interval))
{
output << ", start : " << interval.GetStart().GetTimeString() << ", end : " << interval.GetStop().GetTimeString() << endl;
}
else
{
nodes2del.push_back(cnode);
output << ", no interval" << endl;
}
for (int chi = 0; chi < cnode->GetChannelsCount(); chi++)
{
int curvecnt = cnode->GetCurveCount(chi);
output << "\t\t\tchannel." << chi << " curvecnt : " << curvecnt << endl;
for (int ci = 0; ci < curvecnt; ci++)
{
FbxAnimCurve* curve = cnode->GetCurve(chi, ci);
int keycnt = curve->KeyGetCount();
output << "\t\t\t\tcurve no." << ci << " : key count : " << keycnt;
output2 << "curve " << ci << endl;
vector<int> keys2Remove;
for (int cki = 0; cki < keycnt; cki++)
{
FbxAnimCurveKey prevkey, currkey, nextkey;
if (cki == 0 || cki == keycnt - 1)
continue;
currkey = curve->KeyGet(cki);
prevkey = curve->KeyGet(cki-1);
nextkey = curve->KeyGet(cki + 1);
bool keepit = true;
output2 << ci << "-" << cki;
// keepit = keepTestHorizon(curve, prevkey, currkey, nextkey);
// if (keepit)
// keepit = slopkeepTest(curve, prevkey, currkey, nextkey);
if (!keepit)
{
if (!(currkey.GetInterpolation() == FbxAnimCurveDef::EInterpolationType::eInterpolationConstant && nextkey.GetInterpolation() != FbxAnimCurveDef::EInterpolationType::eInterpolationConstant))
keys2Remove.push_back(cki);
}
}
for (int kri = keys2Remove.size() - 1; kri >= 0; kri--)
{
//curve->KeyRemove(keys2Remove[kri]);
}
output2 << endl;
//output << ", cubic:linear:const : " << cubic << ":" << linear << ":" << cons << endl;
if (keys2Remove.size() > 0)
output << ", " << keys2Remove.size() << " keys removed";
keycnt = curve->KeyGetCount();
}
}
}
//이부분은 별로 효과없음
/*
for (int di = 0; di < nodes2del.size(); di++)
{
layer->RemoveMember(nodes2del[di]);
}
*/
}
}
output << "cubic:linear:const " << cubic << ":" << linear << ":" << cons << endl;
FbxExporter* exporter = FbxExporter::Create(fm, "");
const char* outFBXName = "after.fbx";
bool exportstatus = exporter->Initialize(outFBXName, -1, fm->GetIOSettings());
if (exportstatus == false)
{
puts("err export fail");
}
exporter->Export(scene);
exporter->Destroy();
scene->Destroy();
ios->Destroy();
fm->Destroy();
output.close();
output2.close();
output3.close();
return 0;
}
CC_FILE_ERROR FBXFilter::loadFile(const char* filename, ccHObject& container, bool alwaysDisplayLoadDialog/*=true*/, bool* coordinatesShiftEnabled/*=0*/, CCVector3d* coordinatesShift/*=0*/)
{
// Initialize the SDK manager. This object handles memory management.
FbxManager* lSdkManager = FbxManager::Create();
// Create the IO settings object.
FbxIOSettings *ios = FbxIOSettings::Create(lSdkManager, IOSROOT);
lSdkManager->SetIOSettings(ios);
// Import options determine what kind of data is to be imported.
// True is the default, but here we’ll set some to true explicitly, and others to false.
//(*(lSdkManager->GetIOSettings())).SetBoolProp(IMP_FBX_MATERIAL, true);
//(*(lSdkManager->GetIOSettings())).SetBoolProp(IMP_FBX_TEXTURE, true);
// Create an importer using the SDK manager.
FbxImporter* lImporter = FbxImporter::Create(lSdkManager,"");
CC_FILE_ERROR result = CC_FERR_NO_ERROR;
// Use the first argument as the filename for the importer.
if (!lImporter->Initialize(filename, -1, lSdkManager->GetIOSettings()))
{
ccLog::Warning(QString("[FBX] Error: %1").arg(lImporter->GetStatus().GetErrorString()));
result = CC_FERR_READING;
}
else
{
// Create a new scene so that it can be populated by the imported file.
FbxScene* lScene = FbxScene::Create(lSdkManager,"myScene");
// Import the contents of the file into the scene.
if (lImporter->Import(lScene))
{
// Print the nodes of the scene and their attributes recursively.
// Note that we are not printing the root node because it should
// not contain any attributes.
FbxNode* lRootNode = lScene->GetRootNode();
std::vector<FbxNode*> nodes;
nodes.push_back(lRootNode);
while (!nodes.empty())
{
FbxNode* lNode = nodes.back();
nodes.pop_back();
const char* nodeName = lNode->GetName();
#ifdef _DEBUG
ccLog::Print(QString("Node: %1 - %2 properties").arg(nodeName).arg(lNode->GetNodeAttributeCount()));
#endif
// scan the node's attributes.
for(int i=0; i<lNode->GetNodeAttributeCount(); i++)
{
FbxNodeAttribute* pAttribute = lNode->GetNodeAttributeByIndex(i);
FbxNodeAttribute::EType type = pAttribute->GetAttributeType();
#ifdef _DEBUG
ccLog::Print(QString("\tProp. #%1").arg(GetAttributeTypeName(type)));
#endif
switch(type)
{
case FbxNodeAttribute::eMesh:
{
ccMesh* mesh = FromFbxMesh(static_cast<FbxMesh*>(pAttribute),alwaysDisplayLoadDialog,coordinatesShiftEnabled,coordinatesShift);
if (mesh)
{
//apply transformation
FbxAMatrix& transform = lNode->EvaluateGlobalTransform();
ccGLMatrix mat;
float* data = mat.data();
for (int c=0; c<4; ++c)
{
FbxVector4 C = transform.GetColumn(c);
*data++ = static_cast<float>(C[0]);
*data++ = static_cast<float>(C[1]);
*data++ = static_cast<float>(C[2]);
*data++ = static_cast<float>(C[3]);
}
mesh->applyGLTransformation_recursive(&mat);
if (mesh->getName().isEmpty())
mesh->setName(nodeName);
container.addChild(mesh);
}
}
break;
case FbxNodeAttribute::eUnknown:
case FbxNodeAttribute::eNull:
case FbxNodeAttribute::eMarker:
case FbxNodeAttribute::eSkeleton:
case FbxNodeAttribute::eNurbs:
case FbxNodeAttribute::ePatch:
case FbxNodeAttribute::eCamera:
case FbxNodeAttribute::eCameraStereo:
case FbxNodeAttribute::eCameraSwitcher:
case FbxNodeAttribute::eLight:
case FbxNodeAttribute::eOpticalReference:
case FbxNodeAttribute::eOpticalMarker:
case FbxNodeAttribute::eNurbsCurve:
case FbxNodeAttribute::eTrimNurbsSurface:
case FbxNodeAttribute::eBoundary:
case FbxNodeAttribute::eNurbsSurface:
case FbxNodeAttribute::eShape:
case FbxNodeAttribute::eLODGroup:
case FbxNodeAttribute::eSubDiv:
default:
//not handled yet
break;
}
}
// Recursively add the children.
for(int j=0; j<lNode->GetChildCount(); j++)
{
nodes.push_back(lNode->GetChild(j));
}
}
}
}
// The file is imported, so get rid of the importer.
lImporter->Destroy();
// Destroy the SDK manager and all the other objects it was handling.
lSdkManager->Destroy();
return container.getChildrenNumber() == 0 ? CC_FERR_NO_LOAD : CC_FERR_NO_ERROR;
}
bool LoaderFbx::loadScene(std::string filename)
{
bool success = true;
int fileMajor, fileMinor, fileRevision;
int sdkMajor, sdkMinor, sdkRevision;
std::stringstream message;
FbxManager::GetFileFormatVersion(sdkMajor, sdkMinor, sdkRevision);
FbxImporter* fbxImporter = FbxImporter::Create(fbxManager_, "");
success = fbxImporter->Initialize(filename.c_str(), -1, fbxManager_->GetIOSettings());
fbxImporter->GetFileVersion(fileMajor, fileMinor, fileRevision);
if(!success)
{
message.str("");
message << "LoaderFbx::loadScene | Call to FbxImporter::Initialize() failed! \n Error returned: "
<< fbxImporter->GetStatus().GetErrorString();
ERROR_MESSAGEBOX(message.str());
if(fbxImporter->GetStatus().GetCode() == FbxStatus::eInvalidFileVersion)
{
std::stringstream message;
message.str("");
message << "FBX file format version for this FBX SDK is " << sdkMajor << "." << sdkMinor << "." << sdkRevision << "\n"
<< "FBX file format version for file " << filename << " is " << fileMajor << "." << fileMinor << "." << fileRevision;
ERROR_MESSAGEBOX(message.str());
}
}
if(fbxImporter->IsFBX())
{
FBXSDK_printf("FBX file format version for file '%s' is %d.%d.%d\n\n", filename, fileMajor, fileMinor, fileRevision);
// From this point, it is possible to access animation stack information without
// the expense of loading the entire file.
FBXSDK_printf("Animation Stack Information\n");
int animStackCount = fbxImporter->GetAnimStackCount();
FBXSDK_printf(" Number of Animation Stacks: %d\n", animStackCount);
FBXSDK_printf(" Current Animation Stack: \"%s\"\n", fbxImporter->GetActiveAnimStackName().Buffer());
FBXSDK_printf("\n");
for(int i = 0; i < animStackCount; i++)
{
FbxTakeInfo* takeInfo = fbxImporter->GetTakeInfo(i);
FBXSDK_printf(" Animation Stack %d\n", i);
FBXSDK_printf(" Name: \"%s\"\n", takeInfo->mName.Buffer());
const char* debug = takeInfo->mDescription.Buffer();
// FBXSDK_printf(" Description: \"%s\"\n", takeInfo->mDescription.Buffer());
// Change the value of the import name if the animation stack should be imported
// under a different name.
FBXSDK_printf(" Import Name: \"%s\"\n", takeInfo->mImportName.Buffer());
// Set the value of the import state to false if the animation stack should be not
// be imported.
FBXSDK_printf(" Import State: %s\n", takeInfo->mSelect ? "true" : "false");
FBXSDK_printf("\n");
}
// Set the import states. By default, the import states are always set to
// true. The code below shows how to change these states.
fbxManager_->GetIOSettings()->SetBoolProp(IMP_FBX_MATERIAL, true);
fbxManager_->GetIOSettings()->SetBoolProp(IMP_FBX_TEXTURE, true);
fbxManager_->GetIOSettings()->SetBoolProp(IMP_FBX_LINK, true);
fbxManager_->GetIOSettings()->SetBoolProp(IMP_FBX_SHAPE, true);
fbxManager_->GetIOSettings()->SetBoolProp(IMP_FBX_GOBO, true);
fbxManager_->GetIOSettings()->SetBoolProp(IMP_FBX_ANIMATION, true);
fbxManager_->GetIOSettings()->SetBoolProp(IMP_FBX_GLOBAL_SETTINGS, true);
}
if(success)
{
success = fbxImporter->Import(fbxScene_);
}
if(!success)
{
message.str("");
message << "LoaderFbx::loadScene | Call to FbxImporter::Import() failed! \n Error returned: "
<< fbxImporter->GetStatus().GetErrorString();
ERROR_MESSAGEBOX(message.str());
}
return success;
}
bool FBXReader::loadScene(FbxManager* fbxManager, FbxDocument* scene, string fileName)
{
int lFileMajor, lFileMinor, lFileRevision;
int lSDKMajor, lSDKMinor, lSDKRevision;
//int lFileFormat = -1;
int i, lAnimStackCount;
bool lStatus;
char lPassword[1024];
// Get the file version number generate by the FBX SDK.
FbxManager::GetFileFormatVersion(lSDKMajor, lSDKMinor, lSDKRevision);
// Create an importer.
FbxImporter* lImporter = FbxImporter::Create(fbxManager, "");
// Initialize the importer by providing a filename.
const bool lImportStatus = lImporter->Initialize(fileName.c_str(), -1, fbxManager->GetIOSettings());
lImporter->GetFileVersion(lFileMajor, lFileMinor, lFileRevision);
if (!lImportStatus)
{
FbxString error = lImporter->GetStatus().GetErrorString();
FBXSDK_printf("Call to FbxImporter::Initialize() failed.\n");
FBXSDK_printf("Error returned: %s\n\n", error.Buffer());
if (lImporter->GetStatus().GetCode() == FbxStatus::eInvalidFileVersion)
{
FBXSDK_printf("FBX file format version for this FBX SDK is %d.%d.%d\n", lSDKMajor, lSDKMinor, lSDKRevision);
FBXSDK_printf("FBX file format version for file '%s' is %d.%d.%d\n\n", fileName, lFileMajor, lFileMinor, lFileRevision);
}
return false;
}
FBXSDK_printf("FBX file format version for this FBX SDK is %d.%d.%d\n", lSDKMajor, lSDKMinor, lSDKRevision);
if (lImporter->IsFBX())
{
FBXSDK_printf("FBX file format version for file '%s' is %d.%d.%d\n\n", fileName, lFileMajor, lFileMinor, lFileRevision);
// From this point, it is possible to access animation stack information without
// the expense of loading the entire file.
FBXSDK_printf("Animation Stack Information\n");
lAnimStackCount = lImporter->GetAnimStackCount();
FBXSDK_printf(" Number of Animation Stacks: %d\n", lAnimStackCount);
FBXSDK_printf(" Current Animation Stack: \"%s\"\n", lImporter->GetActiveAnimStackName().Buffer());
FBXSDK_printf("\n");
for (i = 0; i < lAnimStackCount; i++)
{
FbxTakeInfo* lTakeInfo = lImporter->GetTakeInfo(i);
FBXSDK_printf(" Animation Stack %d\n", i);
FBXSDK_printf(" Name: \"%s\"\n", lTakeInfo->mName.Buffer());
FBXSDK_printf(" Description: \"%s\"\n", lTakeInfo->mDescription.Buffer());
// Change the value of the import name if the animation stack should be imported
// under a different name.
FBXSDK_printf(" Import Name: \"%s\"\n", lTakeInfo->mImportName.Buffer());
// Set the value of the import state to false if the animation stack should be not
// be imported.
FBXSDK_printf(" Import State: %s\n", lTakeInfo->mSelect ? "true" : "false");
FBXSDK_printf("\n");
}
// Set the import states. By default, the import states are always set to
// true. The code below shows how to change these states.
IOS_REF.SetBoolProp(IMP_FBX_MATERIAL, true);
IOS_REF.SetBoolProp(IMP_FBX_TEXTURE, true);
IOS_REF.SetBoolProp(IMP_FBX_LINK, true);
IOS_REF.SetBoolProp(IMP_FBX_SHAPE, true);
IOS_REF.SetBoolProp(IMP_FBX_GOBO, true);
IOS_REF.SetBoolProp(IMP_FBX_ANIMATION, true);
IOS_REF.SetBoolProp(IMP_FBX_GLOBAL_SETTINGS, true);
}
// Import the scene.
lStatus = lImporter->Import(scene);
if (lStatus == false && lImporter->GetStatus().GetCode() == FbxStatus::ePasswordError)
{
FBXSDK_printf("Please enter password: "******"%s", lPassword);
FBXSDK_CRT_SECURE_NO_WARNING_END
FbxString lString(lPassword);
IOS_REF.SetStringProp(IMP_FBX_PASSWORD, lString);
IOS_REF.SetBoolProp(IMP_FBX_PASSWORD_ENABLE, true);
lStatus = lImporter->Import(scene);
if (lStatus == false && lImporter->GetStatus().GetCode() == FbxStatus::ePasswordError)
{
FBXSDK_printf("\nPassword is wrong, import aborted.\n");
}
}
// Destroy the importer.
lImporter->Destroy();
return lStatus;
}
int main()
{
// ※パスは「/」でしか通らない
const char* filename = "../datas/box.fbx";
//==============================================================================
// FBXオブジェクト初期化
//==============================================================================
// FBXマネージャー作成
FbxManager* pFBXManager = FbxManager::Create();
// シーン作成
FbxScene* pScene = FbxScene::Create(pFBXManager, "");
// FBXのIO設定オブジェクト作成
FbxIOSettings *pIO = FbxIOSettings::Create(pFBXManager, IOSROOT);
pFBXManager->SetIOSettings(pIO);
// インポートオブジェクト作成
FbxImporter* pImporter = FbxImporter::Create(pFBXManager, "");
// ファイルインポート
if(pImporter->Initialize(filename, -1, pFBXManager->GetIOSettings()) == false)
{
printf("FBXファイルインポートエラー\n");
printf("エラー内容: %s\n\n", pImporter->GetStatus().GetErrorString());
return 1;
}
// シーンへインポート
if(pImporter->Import(pScene) == false)
{
printf("FBXシーンインポートエラー\n");
printf("エラー内容: %s\n\n", pImporter->GetStatus().GetErrorString());
return 1;
}
// ※この時点でインポートオブジェクトはいらない
pImporter->Destroy();
//==============================================================================
// FBXオブジェクトの処理
//==============================================================================
// ノードを表示してみる
traverseScene(pScene->GetRootNode());
// シーンのものすべてを三角化
FbxGeometryConverter geometryConverte(pFBXManager);
geometryConverte.Triangulate(pScene, true);
// メッシュ情報処理
GetMeshData(pScene->GetRootNode());
//==============================================================================
// FBXオブジェクト色々破棄
//==============================================================================
pIO->Destroy();
pScene->Destroy();
pFBXManager->Destroy();
printf("全処理終了\n");
getchar();
return 0;
}
void LoadMeshes(Scene* pScene, std::vector<uint32_t>* loadedMeshIDs)
{
FbxManager* fbxManager = FbxManager::Create();
FbxIOSettings* pFbxIOSettings = FbxIOSettings::Create(fbxManager, IOSROOT);
fbxManager->SetIOSettings(pFbxIOSettings);
(*(fbxManager->GetIOSettings())).SetBoolProp(IMP_FBX_MATERIAL, true);
(*(fbxManager->GetIOSettings())).SetBoolProp(IMP_FBX_TEXTURE, true);
(*(fbxManager->GetIOSettings())).SetBoolProp(IMP_FBX_LINK, false);
(*(fbxManager->GetIOSettings())).SetBoolProp(IMP_FBX_SHAPE, false);
(*(fbxManager->GetIOSettings())).SetBoolProp(IMP_FBX_GOBO, false);
(*(fbxManager->GetIOSettings())).SetBoolProp(IMP_FBX_ANIMATION, true);
(*(fbxManager->GetIOSettings())).SetBoolProp(IMP_FBX_GLOBAL_SETTINGS, true);
bool bEmbedMedia = true;
(*(fbxManager->GetIOSettings())).SetBoolProp(EXP_FBX_MATERIAL, true);
(*(fbxManager->GetIOSettings())).SetBoolProp(EXP_FBX_TEXTURE, true);
(*(fbxManager->GetIOSettings())).SetBoolProp(EXP_FBX_EMBEDDED, bEmbedMedia);
(*(fbxManager->GetIOSettings())).SetBoolProp(EXP_FBX_SHAPE, true);
(*(fbxManager->GetIOSettings())).SetBoolProp(EXP_FBX_GOBO, true);
(*(fbxManager->GetIOSettings())).SetBoolProp(EXP_FBX_ANIMATION, true);
(*(fbxManager->GetIOSettings())).SetBoolProp(EXP_FBX_GLOBAL_SETTINGS, true);
FbxImporter* pFbxImporter = FbxImporter::Create(fbxManager, "");
// Initialize the importer.
bool result = pFbxImporter->Initialize(pScene->loadPath.c_str(), -1, fbxManager->GetIOSettings());
if (!result) {
printf("Get error when init FBX Importer: %s\n\n",
pFbxImporter->GetStatus().GetErrorString());
exit(-1);
}
// fbx version number
int major, minor, revision;
pFbxImporter->GetFileVersion(major, minor, revision);
// import pFbxScene
FbxScene* pFbxScene = FbxScene::Create(fbxManager, "myScene");
pFbxImporter->Import(pFbxScene);
pFbxImporter->Destroy();
pFbxImporter = nullptr;
// check axis system
FbxAxisSystem axisSystem = pFbxScene->GetGlobalSettings().GetAxisSystem();
FbxAxisSystem vulkanAxisSystem(FbxAxisSystem::eYAxis,
FbxAxisSystem::eParityOdd,
FbxAxisSystem::eRightHanded);
if (axisSystem != vulkanAxisSystem) {
axisSystem.ConvertScene(pFbxScene);
}
// check unit system
FbxSystemUnit systemUnit = pFbxScene->GetGlobalSettings().GetSystemUnit();
if (systemUnit.GetScaleFactor() != 1.0) {
FbxSystemUnit::cm.ConvertScene(pFbxScene);
}
// Triangulate Mesh
FbxGeometryConverter fbxGeometryConverter(fbxManager);
fbxGeometryConverter.Triangulate(pFbxScene, true);
// Load Texture
int textureCount = pFbxScene->GetTextureCount();
for (int i = 0; i < textureCount; ++i) {
FbxTexture* pFbxTexture = pFbxScene->GetTexture(i);
FbxFileTexture* pFbxFileTexture = FbxCast<FbxFileTexture>(pFbxTexture);
if (pFbxTexture && pFbxFileTexture->GetUserDataPtr()) {
}
}
LoadMeshes(pFbxScene->GetRootNode(), pScene->meshes);
}
float UFBXBLUEPRINT::getCircleAreaDLL() //(float radius)
{
// Create the FBX SDK manager
FbxManager* lSdkManager = FbxManager::Create();
// Create an IOSettings object.
FbxIOSettings * ios = FbxIOSettings::Create(lSdkManager, IOSROOT);
lSdkManager->SetIOSettings(ios);
// ... Configure the FbxIOSettings object ...
// Create an importer.
FbxImporter* lImporter = FbxImporter::Create(lSdkManager, "");
// Declare the path and filename of the file containing the scene.
// In this case, we are assuming the file is in the same directory as the executable.
const char* lFilename = "file.fbx";
// Initialize the importer.
bool lImportStatus = lImporter->Initialize(lFilename, -1, lSdkManager->GetIOSettings());
if (!lImportStatus) {
printf("Call to FbxImporter::Initialize() failed.\n");
printf("Error returned: %s\n\n", lImporter->GetStatus().GetErrorString());
exit(-1);
}
// Create a new scene so it can be populated by the imported file.
FbxScene* lScene = FbxScene::Create(lSdkManager, "myScene");
// Import the contents of the file into the scene.
lImporter->Import(lScene);
// The file has been imported; we can get rid of the importer.
lImporter->Destroy();
// File format version numbers to be populated.
int lFileMajor, lFileMinor, lFileRevision;
// Populate the FBX file format version numbers with the import file.
lImporter->GetFileVersion(lFileMajor, lFileMinor, lFileRevision);
int numofgeometrys = lScene->GetGeometryCount();
for (int i = 0; i < numofgeometrys; i++)
{
fbxsdk::FbxGeometry* fbxgeo = lScene->GetGeometry(i);
// fbxsdk::FbxMesh* fbxmesh = fbxgeo->Get
if (fbxgeo != 0)
{
int numofcontrolpoints =fbxgeo->GetControlPointsCount();
FbxVector4* controlpoints = fbxgeo->GetControlPoints(0);
// x[12] = controlpoints[12]->mData[0];
//Fbxsdk::FbxVector4* pNormalArray;
//fbxgeo->GetNormals(pNormalArray);
//fbxgeo->GetNormalsIndices();
// fbxgeo->GetNormals();
// fbxgeo->get
}
}
/*
FbxClassId lShaderClassID = lSdkManager->FindFbxFileClass("Shader", "FlatShader");
for(int i = 0; i < lNode->GetSrcObjectCount(lShaderClassID); i++)
{
FbxObject* lObject = lNode->GetSrcObject(lShaderClassID, i);
}
*/
return 1.00f;
}
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;
}
void FBXSceneEncoder::write(const string& filepath, const EncoderArguments& arguments)
{
FbxManager* sdkManager = FbxManager::Create();
FbxIOSettings *ios = FbxIOSettings::Create(sdkManager, IOSROOT);
sdkManager->SetIOSettings(ios);
FbxImporter* importer = FbxImporter::Create(sdkManager,"");
if (!importer->Initialize(filepath.c_str(), -1, sdkManager->GetIOSettings()))
{
LOG(1, "Call to FbxImporter::Initialize() failed.\n");
LOG(1, "Error returned: %s\n\n", importer->GetStatus().GetErrorString());
exit(-1);
}
FbxScene* fbxScene = FbxScene::Create(sdkManager,"__FBX_SCENE__");
print("Loading FBX file.");
importer->Import(fbxScene);
importer->Destroy();
// Determine if animations should be grouped.
if (arguments.getGroupAnimationAnimationId().empty() && isGroupAnimationPossible(fbxScene))
{
if ( arguments.getAnimationGrouping()==EncoderArguments::ANIMATIONGROUP_AUTO ||
(arguments.getAnimationGrouping()==EncoderArguments::ANIMATIONGROUP_PROMPT && promptUserGroupAnimations()))
{
_autoGroupAnimations = true;
}
}
if (arguments.tangentBinormalIdCount() > 0)
{
generateTangentsAndBinormals(fbxScene->GetRootNode(), arguments);
}
print("Loading Scene.");
loadScene(fbxScene);
print("Load materials");
loadMaterials(fbxScene);
print("Loading animations.");
loadAnimations(fbxScene, arguments);
sdkManager->Destroy();
print("Optimizing GamePlay Binary.");
_gamePlayFile.adjust();
if (_autoGroupAnimations)
{
_gamePlayFile.groupMeshSkinAnimations();
}
string outputFilePath = arguments.getOutputFilePath();
if (arguments.textOutputEnabled())
{
int pos = outputFilePath.find_last_of('.');
if (pos > 2)
{
string path = outputFilePath.substr(0, pos);
path.append(".xml");
LOG(1, "Saving debug file: %s\n", path.c_str());
if (!_gamePlayFile.saveText(path))
{
LOG(1, "Error writing text file: %s\n", path.c_str());
}
}
}
else
{
LOG(1, "Saving binary file: %s\n", outputFilePath.c_str());
if (!_gamePlayFile.saveBinary(outputFilePath))
{
LOG(1, "Error writing binary file: %s\n", outputFilePath.c_str());
}
}
// Write the material file
if (arguments.outputMaterialEnabled())
{
int pos = outputFilePath.find_last_of('.');
if (pos > 2)
{
string path = outputFilePath.substr(0, pos);
path.append(".material");
writeMaterial(path);
}
}
}
bool FBXScene::LoadScene(const char* filename, std::ostream& output, Vector3& minPos, Vector3& maxPos)
{
int lFileMajor, lFileMinor, lFileRevision;
int i, lAnimStackCount;
bool lStatus;
FbxIOSettings *ios = FbxIOSettings::Create(mSdkManager, IOSROOT);
mSdkManager->SetIOSettings(ios);
FbxGeometryConverter lGConverter(mSdkManager);
// Create an importer using our sdk manager.
FbxImporter* pFBXImporter = FbxImporter::Create(mSdkManager,"");
// Initialize the importer by providing a filename.
const bool lImportStatus = pFBXImporter->Initialize(filename, -1, mSdkManager->GetIOSettings());
pFBXImporter->GetFileVersion(lFileMajor, lFileMinor, lFileRevision);
if( !lImportStatus )
{
output << "FBX Importer Error: " << pFBXImporter->GetStatus().GetErrorString() << std::endl;
if ( pFBXImporter->GetStatus() == FbxStatus::eInvalidFileVersion )
{
output << "FBX version number for file " << filename << " is " << lFileMajor << " " << lFileMinor << " " << lFileRevision << std::endl;
}
return false;
}
if (pFBXImporter->IsFBX())
{
output << "FBX version number for file " << filename << " is " << lFileMajor << " " << lFileMinor << " " << lFileRevision << std::endl;
// From this point, it is possible to access animation stack information without
// the expense of loading the entire file.
output << "Animation Stack Information" << std::endl;
lAnimStackCount = pFBXImporter->GetAnimStackCount();
output << " Number of Animation Stacks: " << lAnimStackCount << std::endl;
output << " Current Animation Stack: " << pFBXImporter->GetActiveAnimStackName().Buffer() << std::endl;
for(i = 0; i < lAnimStackCount; i++)
{
FbxTakeInfo* lTakeInfo = pFBXImporter->GetTakeInfo(i);
output << " Animation Stack " << i << std::endl;
output << " Name: " << lTakeInfo->mName.Buffer() << std::endl;
output << " Description: " << lTakeInfo->mDescription.Buffer() << std::endl;
output << " Import Name: " << lTakeInfo->mImportName.Buffer() << std::endl;
output << " Import State: " << (lTakeInfo->mSelect ? "true" : "false") << std::endl;
}
}
// Import the scene.
lStatus = pFBXImporter->Import(mScene);
if ( !lStatus )
{
output << "Failed Importing FBX!" << std::endl;
output << "FBX is password protected!" << std::endl;
if ( pFBXImporter->GetStatus() == FbxStatus::ePasswordError )
{
output << "FBX is password protected!" << std::endl;
}
}
mFilename = pFBXImporter->GetFileName().Buffer();
// Destroy the importer.
pFBXImporter->Destroy();
ios->Destroy();
ProcessScene(mScene);
return lStatus;
}
int main ( int argc, char *argv[] )
{
std::vector<std::string> args (argv, argv + argc);
if ( args.size() == 1 )
{
PrintUsage (args[0]);
return EXIT_FAILURE;
}
std::string animationFile;
std::string outputPath ("model.glm");
unsigned i;
for ( i = 1; i < args.size(); i++ )
{
if ( args[i].compare ("-o") == 0 )
{
i++;
if ( args.size() > i )
{
outputPath = args[i];
continue;
}
else
{
PrintUsage (args[0]);
return EXIT_FAILURE;
}
}
else if ( args[i].compare ("-anim") == 0 )
{
i++;
if ( args.size() > i )
{
animationFile = args[i];
continue;
}
else
{
PrintUsage (args[0]);
return EXIT_FAILURE;
}
}
}
std::unique_ptr<Skeleton> skeleton;
std::string modelPath (args.back());
std::cout << "Converting " << modelPath << " to GLM.\n";
if ( !animationFile.empty() )
{
skeleton = LoadGLA (animationFile);
if ( !skeleton )
{
return EXIT_FAILURE;
}
std::cout << "Using " << animationFile << " for skeleton.\n";
}
FbxManager *fbxManager = FbxManager::Create();
FbxIOSettings *ios = FbxIOSettings::Create (fbxManager, IOSROOT);
fbxManager->SetIOSettings (ios);
FbxImporter *importer = FbxImporter::Create (fbxManager, "");
if ( !importer->Initialize (modelPath.c_str(), -1, fbxManager->GetIOSettings()) )
{
std::cerr << "ERROR: Failed to import '" << modelPath << "': " << importer->GetStatus().GetErrorString() << ".\n";
importer->Destroy();
fbxManager->Destroy();
return EXIT_FAILURE;
}
FbxScene *scene = FbxScene::Create (fbxManager, "model");
importer->Import (scene);
importer->Destroy();
FbxNode *root = scene->GetRootNode();
if ( root == nullptr )
{
std::cerr << "ERROR: The scene's root node could not be found.\n";
fbxManager->Destroy();
return EXIT_FAILURE;
}
std::vector<FbxNode *> modelRoots (GetLodRootModels (*root));
if ( modelRoots.empty() )
{
std::cerr << "ERROR: No model LODs found.\n";
fbxManager->Destroy();
return EXIT_FAILURE;
}
std::sort (modelRoots.begin(), modelRoots.end(),
[]( const FbxNode *a, const FbxNode *b ) { return std::strcmp (a->GetName(), b->GetName()) < 0; });
if ( !MakeGLMFile (*scene, modelRoots, skeleton.get(), outputPath) )
{
std::cerr << "ERROR: Failed to create GLM file " << outputPath << ".\n";
fbxManager->Destroy();
return EXIT_FAILURE;
}
std::cout << "GLM file has been written to '" << outputPath << "'.\n";
fbxManager->Destroy();
return 0;
}
FBXSceneImporter::FBXSceneImporter(std::string file_name)
{
std::string log_file_name = file_name;
log_file_name.append("log.txt");
myfile.open(log_file_name.c_str());
// Initialize the SDK manager. This object handles memory management.
lSdkManager = FbxManager::Create();
FbxIOSettings *ios = FbxIOSettings::Create(lSdkManager, IOSROOT);
lSdkManager->SetIOSettings(ios);
// Create an importer using the SDK manager.
FbxImporter* lImporter = FbxImporter::Create(lSdkManager, "");
// Use the first argument as the filename for the importer.
if (!lImporter->Initialize(file_name.c_str(), -1, lSdkManager->GetIOSettings())) {
myfile << "Call to FbxImporter::Initialize() failed.\n";
myfile << "Error returned: " << lImporter->GetStatus().GetErrorString() << "";
myfile.close();
exit(-1);
}
// Create a new scene so that it can be populated by the imported file.
lScene = FbxScene::Create(lSdkManager, "myScene");
// Import the contents of the file into the scene.
lImporter->Import(lScene);
// The file is imported, so get rid of the importer.
lImporter->Destroy();
FbxGeometryConverter converter(lSdkManager);
converter.Triangulate(lScene, true);
scene_to_fill = new Scene(Utilities::get_file_name_from_path_wo_extension(file_name));
resource_manager.add_scene(scene_to_fill);
// Print the nodes of the scene and their attributes recursively.
// Note that we are not printing the root node because it should
// not contain any attributes.
FbxNode* lRootNode = lScene->GetRootNode();
if (lRootNode)
{
for (int i = 0; i < lRootNode->GetChildCount(); i++)
{
read_node(lRootNode->GetChild(i));
}
}
if (lRootNode)
{
for (int i = 0; i < lRootNode->GetChildCount(); i++)
{
PrintNode(lRootNode->GetChild(i));
}
}
// Destroy the SDK manager and all the other objects it was handling.
myfile.close();
lSdkManager->Destroy();
}
boost::shared_ptr<FBXScene> FBXManager::loadScene(const std::string& filename)
{
PROFILE;
FbxImporter* importer = nullptr;
FbxScene* scene = nullptr;
std::string pathAbs;
std::string pathRel;
pathRel = m_pFilesystem->resourcePathRel(Filesystem::ResourceType::Fbx, filename);
pathAbs = m_pFilesystem->resourcePathAbs(Filesystem::ResourceType::Fbx, filename);
if (pathAbs.empty()) {
return boost::shared_ptr<FBXScene>();
}
LOGI << "Loading FBX file '" << pathRel << "'..";
importer = FbxImporter::Create(m_pFbxManager,"");
if(!importer->Initialize(pathAbs.c_str(), -1, m_pFbxManager->GetIOSettings())) {
LOGE << "FbxImporter initialization for failed with " << importer->GetStatus().GetErrorString();
return false;
}
scene = FbxScene::Create(m_pFbxManager, filename.c_str());
if(!scene)
{
LOGE << "Unable to create a FbxScene";
return boost::shared_ptr<FBXScene>();
}
if (!importer->Import(scene)) {
LOGE << "Failed to import scene '" << filename << "'";
return boost::shared_ptr<FBXScene>();
}
// Convert Axis System if needed
FbxAxisSystem sceneAxisSystem = scene->GetGlobalSettings().GetAxisSystem();
FbxAxisSystem axisSystem(FbxAxisSystem::eYAxis, FbxAxisSystem::eParityOdd, FbxAxisSystem::eRightHanded);
if(sceneAxisSystem != axisSystem)
{
LOGW << "Scene needed axis convertion";
axisSystem.ConvertScene(scene);
}
//// Convert Unit System if needed
//FbxSystemUnit sceneSystemUnit = scene->GetGlobalSettings().GetSystemUnit();
//if(sceneSystemUnit.GetScaleFactor() != 1.0)
//{
// LOGW << "Scene needed unit convertion";
// FbxSystemUnit::cm.ConvertScene(scene);
//}
// Convert fbxMesh, NURBS and patch into triangle fbxMesh
FbxGeometryConverter geomConverter(m_pFbxManager);
geomConverter.Triangulate(scene, true);
// Split meshes per material, so that we only have one material per fbxMesh (for VBO support)
geomConverter.SplitMeshesPerMaterial(scene, true);
importer->Destroy();
return boost::shared_ptr<FBXScene>(new FBXScene(scene, m_pDatabase));
}