CC_FILE_ERROR FBXFilter::saveToFile(ccHObject* entity, QString filename, SaveParameters& parameters)
{
if (!entity)
return CC_FERR_BAD_ARGUMENT;
std::vector<ccGenericMesh*> meshes;
if (entity->isKindOf(CC_TYPES::MESH))
{
meshes.push_back(static_cast<ccGenericMesh*>(entity));
}
else if (entity->isA(CC_TYPES::HIERARCHY_OBJECT))
{
for (unsigned i=0; i<entity->getChildrenNumber(); ++i)
{
ccHObject* child = entity->getChild(i);
if (child->isKindOf(CC_TYPES::MESH))
meshes.push_back(static_cast<ccGenericMesh*>(child));
}
}
if (meshes.empty())
{
return CC_FERR_NO_SAVE;
}
//The first thing to do is to create the FBX Manager which is the object allocator for almost all the classes in the SDK
FbxManager* lSdkManager = FbxManager::Create();
if( !lSdkManager )
{
ccLog::Warning("[FBX] Error: Unable to create FBX Manager!");
return CC_FERR_CONSOLE_ERROR;
}
else
{
ccLog::Print("[FBX] Autodesk FBX SDK version %s", lSdkManager->GetVersion());
}
try
{
//Create an IOSettings object. This object holds all import/export settings.
FbxIOSettings* ios = FbxIOSettings::Create(lSdkManager, IOSROOT);
lSdkManager->SetIOSettings(ios);
//Load plugins from the executable directory (optional)
//FbxString lPath = FbxGetApplicationDirectory();
//lSdkManager->LoadPluginsDirectory(lPath.Buffer());
//Create an FBX scene. This object holds most objects imported/exported from/to files.
FbxScene* lScene = FbxScene::Create(lSdkManager, "My Scene");
if( !lScene )
{
ccLog::Warning("[FBX] Error: Unable to create FBX scene!");
return CC_FERR_CONSOLE_ERROR;
}
// create scene info
{
FbxDocumentInfo* sceneInfo = FbxDocumentInfo::Create(lSdkManager,"SceneInfo");
sceneInfo->mTitle = qPrintable(QString("Mesh: ") + (meshes.size() == 1 ? meshes[0]->getName() : QString("Multiple meshes")));
sceneInfo->mAuthor = "CloudCompare";
sceneInfo->mRevision = "rev. 1.0";
sceneInfo->mKeywords = "cloudcompare mesh";
// we need to add the sceneInfo before calling AddThumbNailToScene because
// that function is asking the scene for the sceneInfo.
lScene->SetSceneInfo(sceneInfo);
}
//create thumbnail
//{
// FbxThumbnail* lThumbnail = FbxThumbnail::Create(lScene,"");
// lThumbnail->SetDataFormat(FbxThumbnail::eRGB_24);
// lThumbnail->SetSize(FbxThumbnail::e64x64);
// lThumbnail->SetThumbnailImage(cSceneThumbnail);
// if (lScene->GetSceneInfo())
// {
// lScene->GetSceneInfo()->SetSceneThumbnail(lThumbnail);
// }
//}
// Build the node tree.
FbxNode* lRootNode = lScene->GetRootNode();
{
for (size_t i=0; i<meshes.size(); ++i)
{
FbxNode* meshNode = ToFbxMesh(meshes[i],lScene,filename,i);
if (meshNode)
lRootNode->AddChild(meshNode);
else
ccLog::Warning(QString("[FBX] Failed to convert mesh '%1' to FBX mesh/node!").arg(meshes[i]->getName()));
}
}
int fileFormat = -1;
//Display a combox box to let the user choose the export file format
{
FbxManager* pSdkManager = FbxManager::GetDefaultManager();
int lFormatCount = pSdkManager ? pSdkManager->GetIOPluginRegistry()->GetWriterFormatCount() : 0;
if (lFormatCount > 0)
{
if (s_defaultOutputFormat.isEmpty())
{
try
{
QMessageBox msgBox(QMessageBox::Question,"FBX format","Choose output format:");
QMap<QAbstractButton*,int> buttons;
for (int lFormatIndex=0; lFormatIndex<lFormatCount; lFormatIndex++)
{
if (pSdkManager->GetIOPluginRegistry()->WriterIsFBX(lFormatIndex))
{
FbxString lDesc = pSdkManager->GetIOPluginRegistry()->GetWriterFormatDescription(lFormatIndex);
QPushButton *button = msgBox.addButton(lDesc.Buffer(), QMessageBox::AcceptRole);
buttons[button] = lFormatIndex;
}
}
msgBox.exec();
//get the right format
fileFormat = buttons[msgBox.clickedButton()];
}
catch(...)
{
}
}
else
{
//try to find the default output format as set by the user
for (int lFormatIndex=0; lFormatIndex<lFormatCount; lFormatIndex++)
{
if (pSdkManager->GetIOPluginRegistry()->WriterIsFBX(lFormatIndex))
{
FbxString lDesc = pSdkManager->GetIOPluginRegistry()->GetWriterFormatDescription(lFormatIndex);
QString sanitizedDesc = SanitizeFBXFormatString(lDesc.Buffer());
if (s_defaultOutputFormat == sanitizedDesc)
{
ccLog::Print(QString("[FBX] Default output file format: %1").arg(sanitizedDesc));
fileFormat = lFormatIndex;
break;
}
}
}
//if we failed to find the specified file format, warn the user and display the list of supported formats
if (fileFormat < 0)
{
ccLog::Warning(QString("[FBX] File format '%1' not supported").arg(s_defaultOutputFormat));
ccLog::Print("[FBX] Supported output formats:");
for (int lFormatIndex=0; lFormatIndex<lFormatCount; lFormatIndex++)
{
if (pSdkManager->GetIOPluginRegistry()->WriterIsFBX(lFormatIndex))
{
FbxString lDesc = pSdkManager->GetIOPluginRegistry()->GetWriterFormatDescription(lFormatIndex);
ccLog::Print(QString("\t- %1").arg(SanitizeFBXFormatString(lDesc.Buffer())));
}
}
}
}
}
}
// Save the scene.
bool lResult = SaveScene(lSdkManager, lScene, qPrintable(filename),fileFormat);
// Destroy all objects created by the FBX SDK.
if( lSdkManager )
lSdkManager->Destroy();
return lResult ? CC_FERR_NO_ERROR : CC_FERR_CONSOLE_ERROR;
}
catch(...)
{
ccLog::Warning("[FBX] FBX SDK has thrown an unknown exception!");
return CC_FERR_THIRD_PARTY_LIB_EXCEPTION;
}
}
/**
* Exports all the animation sequences part of a single Group in a Matinee sequence
* as a single animation in the FBX document. The animation is created by sampling the
* sequence at DEFAULT_SAMPLERATE updates/second and extracting the resulting bone transforms from the given
* skeletal mesh
*/
void FFbxExporter::ExportMatineeGroup(class AMatineeActor* MatineeActor, USkeletalMeshComponent* SkeletalMeshComponent)
{
float MatineeLength = MatineeActor->MatineeData->InterpLength;
if (Scene == NULL || MatineeActor == NULL || SkeletalMeshComponent == NULL || MatineeLength == 0)
{
return;
}
FbxString NodeName("MatineeSequence");
FbxNode* BaseNode = FbxNode::Create(Scene, NodeName);
Scene->GetRootNode()->AddChild(BaseNode);
AActor* Owner = SkeletalMeshComponent->GetOwner();
if(Owner && Owner->GetRootComponent())
{
// Set the default position of the actor on the transforms
// The UE3 transformation is different from FBX's Z-up: invert the Y-axis for translations and the Y/Z angle values in rotations.
BaseNode->LclTranslation.Set(Converter.ConvertToFbxPos(Owner->GetActorLocation()));
BaseNode->LclRotation.Set(Converter.ConvertToFbxRot(Owner->GetActorRotation().Euler()));
BaseNode->LclScaling.Set(Converter.ConvertToFbxScale(Owner->GetRootComponent()->RelativeScale3D));
}
// Create the Skeleton
TArray<FbxNode*> BoneNodes;
FbxNode* SkeletonRootNode = CreateSkeleton(SkeletalMeshComponent->SkeletalMesh, BoneNodes);
FbxSkeletonRoots.Add(SkeletalMeshComponent, SkeletonRootNode);
BaseNode->AddChild(SkeletonRootNode);
ExportAnimTrack(MatineeActor, SkeletalMeshComponent);
}
int ILDLMesh::CreateFBXScene( FbxManager *pSdkManager, FbxScene* pScene )
{
// create scene info
FbxDocumentInfo* sceneInfo = FbxDocumentInfo::Create(pSdkManager,"SceneInfo");
sceneInfo->mTitle = "ILDL export";
pScene->SetSceneInfo(sceneInfo);
FbxNode* lMesh = CreateMesh( pScene, "Mesh" );
// Build the node tree.
FbxNode* lRootNode = pScene->GetRootNode();
lRootNode->AddChild( lMesh );
return -1;
}
bool Animation::save(QString file)
{
// ex:
// create a SdkManager
FbxManager* lSdkManager = FbxManager::Create();
// create an IOSettings object
FbxIOSettings* ios = FbxIOSettings::Create(lSdkManager, IOSROOT);
// set some IOSettings options
ios->SetBoolProp(EXP_FBX_MATERIAL, true);
ios->SetBoolProp(EXP_FBX_TEXTURE, true);
ios->SetBoolProp(EXP_FBX_SHAPE, true);
ios->SetBoolProp(EXP_FBX_GOBO, true);
ios->SetBoolProp(EXP_FBX_ANIMATION, true);
ios->SetBoolProp(EXP_FBX_GLOBAL_SETTINGS, true);
// create an empty scene
FbxScene* pScene = FbxScene::Create(lSdkManager, m_name.toStdString().c_str());
QMap<int,FbxNode*> nodes;
FbxNode* lRootNode = pScene->GetRootNode();
// Create the Animation Stack
FbxAnimStack* lAnimStack = FbxAnimStack::Create(pScene, "Show all faces");
// The animation nodes can only exist on AnimLayers therefore it is mandatory to
// add at least one AnimLayer to the AnimStack. And for the purpose of this example,
// one layer is all we need.
FbxAnimLayer* lAnimLayer = FbxAnimLayer::Create(pScene, "Base animation Layer");
lAnimStack->AddMember(lAnimLayer);
int time = 0;
foreach (const Frame &frame, m_frames)
{
time += frame.elapsedTime();
foreach (const Marker &marker, frame.markers())
{
int id = marker.id();
if(! nodes.contains(id))
{
FbxNode *newMarker = WccToFbxExporter::createSphere(pScene, (QString("marker_")+QString::number(id)).toStdString().c_str() , 1.0f);
nodes[id] = newMarker;
lRootNode->AddChild(newMarker);
}
WccToFbxExporter::addPositionKeyToNode(nodes[id], lAnimLayer, time, marker.position()*m_roomDimensions);
}
}
void FFbxExporter::ExportAnimSequencesAsSingle( USkeletalMesh* SkelMesh, const ASkeletalMeshActor* SkelMeshActor, const FString& ExportName, const TArray<UAnimSequence*>& AnimSeqList, const TArray<struct FAnimControlTrackKey>& TrackKeys )
{
if (Scene == NULL || SkelMesh == NULL || AnimSeqList.Num() == 0 || AnimSeqList.Num() != TrackKeys.Num()) return;
FbxNode* BaseNode = FbxNode::Create(Scene, Converter.ConvertToFbxString(ExportName));
Scene->GetRootNode()->AddChild(BaseNode);
if( SkelMeshActor )
{
// Set the default position of the actor on the transforms
// The Unreal transformation is different from FBX's Z-up: invert the Y-axis for translations and the Y/Z angle values in rotations.
BaseNode->LclTranslation.Set(Converter.ConvertToFbxPos(SkelMeshActor->GetActorLocation()));
BaseNode->LclRotation.Set(Converter.ConvertToFbxRot(SkelMeshActor->GetActorRotation().Euler()));
BaseNode->LclScaling.Set(Converter.ConvertToFbxScale(SkelMeshActor->GetRootComponent()->RelativeScale3D));
}
// Create the Skeleton
TArray<FbxNode*> BoneNodes;
FbxNode* SkeletonRootNode = CreateSkeleton(SkelMesh, BoneNodes);
BaseNode->AddChild(SkeletonRootNode);
bool bAnyObjectMissingSourceData = false;
float ExportStartTime = 0.f;
for(int32 AnimSeqIndex = 0; AnimSeqIndex < AnimSeqList.Num(); ++AnimSeqIndex)
{
const UAnimSequence* AnimSeq = AnimSeqList[AnimSeqIndex];
const FAnimControlTrackKey& TrackKey = TrackKeys[AnimSeqIndex];
// Shift the anim sequences so the first one is at time zero in the FBX file
const float CurrentStartTime = TrackKey.StartTime - ExportStartTime;
ExportAnimSequenceToFbx(AnimSeq,
SkelMesh,
BoneNodes,
AnimLayer,
TrackKey.AnimStartOffset,
TrackKey.AnimEndOffset,
TrackKey.AnimPlayRate,
CurrentStartTime);
}
CorrectAnimTrackInterpolation(BoneNodes, AnimLayer);
if (bAnyObjectMissingSourceData)
{
FMessageDialog::Open( EAppMsgType::Ok, NSLOCTEXT("UnrealEd", "Exporter_Error_SourceDataUnavailable", "No source data available for some objects. See the log for details.") );
}
}
int main(int argc, char** argv) {
if (argc < 2) {
printf("Usage: emdfbx model.emd skeleton.esk output.fbx\n Can include multiple emd and esk files into one fbx.");
getchar();
return 1;
}
LibXenoverse::initializeDebuggingLog();
vector<string> model_filenames;
vector<string> skeleton_filenames;
vector<string> animation_filenames;
string export_filename = "";
for (int i = 1; i < argc; i++) {
string parameter = ToString(argv[i]);
string extension = LibXenoverse::extensionFromFilename(parameter);
if (extension == "emd") {
model_filenames.push_back(parameter);
}
if (extension == "esk") {
skeleton_filenames.push_back(parameter);
}
if (extension == "ean") {
animation_filenames.push_back(parameter);
}
if (extension == "fbx") {
export_filename = parameter;
}
}
if (!export_filename.size()) {
if (model_filenames.size()) {
export_filename = model_filenames[0] + ".fbx";
}
else if (skeleton_filenames.size()) {
export_filename = skeleton_filenames[0] + ".fbx";
}
else {
export_filename = "Out.fbx";
}
}
// Create FBX Manager
FbxManager *sdk_manager = FbxManager::Create();
FbxIOSettings *ios = FbxIOSettings::Create(sdk_manager, IOSROOT);
ios->SetBoolProp(EXP_FBX_EMBEDDED, true);
sdk_manager->SetIOSettings(ios);
// Create Scene
vector<FbxNode *> global_fbx_bones;
global_fbx_bones.reserve(300);
vector<size_t> global_fbx_bones_index; //TODO find a better way to link skeleton and animations
global_fbx_bones_index.reserve(300);
vector<FbxAnimCurveNode *> global_fbx_animation;
global_fbx_animation.reserve(300);
FbxScene *scene = FbxScene::Create(sdk_manager, "EMDFBXScene");
// Load Shaders and convert it to fx file (will be use by fbx).
vector<string> shader_names;
shader_names.push_back("adam_shader/shader_age_vs.emb"); //must specified vs folloxed by ps shaders
shader_names.push_back("adam_shader/shader_age_ps.emb");
shader_names.push_back("adam_shader/shader_default_vs.emb");
shader_names.push_back("adam_shader/shader_default_ps.emb");
bool needs_install_shaders = false;
for (size_t i = 0; i < shader_names.size(); i++) {
if (!LibXenoverse::fileCheck(shader_names[i])) {
needs_install_shaders = true;
break;
}
}
if (needs_install_shaders) {
printf("Shaders not found. Please use Xenoviewer to prepare shaders in bin folder.");
return -1;
}
for (size_t i = 0; i+1 < shader_names.size(); i+=2) {
LibXenoverse::EMB *shader_pack_vs = new LibXenoverse::EMB();
LibXenoverse::EMB *shader_pack_ps = new LibXenoverse::EMB();
if (!shader_pack_vs->load(shader_names[i])) {
delete shader_pack_vs;
printf("Couldn't load Shader Pack %s. File is either missing, open by another application, or corrupt.", shader_names[i].c_str());
continue;
}
if (!shader_pack_ps->load(shader_names[i+1])) {
delete shader_pack_vs;
delete shader_pack_ps;
printf("Couldn't load Shader Pack %s. File is either missing, open by another application, or corrupt.", shader_names[i].c_str());
continue;
}
shader_pack_vs->exportShadersToFx(shader_pack_vs, shader_pack_ps); //convert all shaders in fx file with defaults program parameters (like Ogre's version).
}
//build FBX skeleton
for (size_t i = 0; i < skeleton_filenames.size(); i++) {
LibXenoverse::ESK *esk_skeleton = new LibXenoverse::ESK();
esk_skeleton->load(skeleton_filenames[i]);
vector<FbxNode *> fbx_bones = esk_skeleton->createFBXSkeleton(scene);
for (size_t j = 0; j < fbx_bones.size(); j++) {
global_fbx_bones.push_back(fbx_bones[j]);
global_fbx_bones_index.push_back(j); //kepp index of bone to link with animations.
}
}
//build FBX animations
for (size_t i = 0; i < animation_filenames.size(); i++) {
string filename = animation_filenames.at(i);
string ean_name = LibXenoverse::nameFromFilenameNoExtension(filename, true);
//vector<FbxAnimCurveNode *> global_fbx_animation;
LibXenoverse::EAN *animation = new LibXenoverse::EAN();
if (animation->load(filename)) {
std::vector<FbxAnimStack *> list_AnimStack;
size_t nbAnims = animation->getAnimations().size();
for (size_t j = 0; j < nbAnims; j++) { //we create only one stack and one layer by animation. each will animate all bones of all skeleton.
LibXenoverse::EANAnimation *anim_tmp = &(animation->getAnimations().at(j));
FbxAnimStack* lAnimStack = FbxAnimStack::Create(scene, anim_tmp->getName().c_str());
FbxAnimLayer* lAnimLayer = FbxAnimLayer::Create(scene, (anim_tmp->getName() + "_Layer0").c_str());
lAnimStack->AddMember(lAnimLayer);
list_AnimStack.push_back(lAnimStack);
}
size_t k = 0;
for (vector<FbxNode *>::iterator it = global_fbx_bones.begin(); it != global_fbx_bones.end(); it++) {
vector<FbxAnimCurveNode *> fbx_anim = animation->exportFBXAnimations(scene, list_AnimStack, *it, global_fbx_bones_index.at(k));
for (size_t j = 0; j < fbx_anim.size(); j++) {
global_fbx_animation.push_back(fbx_anim[j]);
}
k++;
}
}
else {
delete animation;
animation = NULL;
}
}
for (size_t i = 0; i < model_filenames.size(); i++) {
string node_name = LibXenoverse::nameFromFilenameNoExtension(model_filenames[i]);
string path = model_filenames[i].substr(0, model_filenames[i].size() - LibXenoverse::nameFromFilename(model_filenames[i]).size());
LibXenoverse::EMD *emd_model = new LibXenoverse::EMD();
emd_model->load(model_filenames[i]);
// Fill Scene
FbxNode *lMeshNode = NULL;
// Create Node
lMeshNode = FbxNode::Create(scene, node_name.c_str());
lMeshNode->LclTranslation.Set(FbxVector4(0, 0, 0));
lMeshNode->LclScaling.Set(FbxVector4(1, 1, 1));
lMeshNode->LclRotation.Set(FbxVector4(0, 0, 0));
// Create and attach Mesh
FbxMesh *lMesh = emd_model->exportFBX(scene, lMeshNode, path);
lMeshNode->SetNodeAttribute(lMesh);
if (global_fbx_bones.size()) {
emd_model->exportFBXSkin(scene, lMesh, global_fbx_bones, lMeshNode->EvaluateGlobalTransform());
}
// Add node to scene
FbxNode *lRootNode = scene->GetRootNode();
lRootNode->AddChild(lMeshNode);
}
// Export FBX
int lFileFormat = sdk_manager->GetIOPluginRegistry()->GetNativeWriterFormat();
FbxExporter* lExporter = FbxExporter::Create(sdk_manager, "");
bool lExportStatus = lExporter->Initialize(export_filename.c_str(), lFileFormat, sdk_manager->GetIOSettings());
if (!lExportStatus) {
printf("Call to FbxExporter::Initialize() failed.\n");
printf("Error returned: %s\n\n", lExporter->GetStatus().GetErrorString());
return 1;
}
scene->GetGlobalSettings().SetAxisSystem(FbxAxisSystem::eMax);
scene->GetGlobalSettings().SetSystemUnit(FbxSystemUnit::m);
// Export scene
lExporter->Export(scene);
lExporter->Destroy();
return 0;
}
CC_FILE_ERROR FBXFilter::saveToFile(ccHObject* entity, const char* filename)
{
if (!entity)
return CC_FERR_BAD_ARGUMENT;
std::vector<ccGenericMesh*> meshes;
if (entity->isKindOf(CC_MESH))
{
meshes.push_back(static_cast<ccGenericMesh*>(entity));
}
else if (entity->isA(CC_HIERARCHY_OBJECT))
{
for (unsigned i=0; i<entity->getChildrenNumber(); ++i)
{
ccHObject* child = entity->getChild(i);
if (child->isKindOf(CC_MESH))
meshes.push_back(static_cast<ccGenericMesh*>(child));
}
}
if (meshes.empty())
{
return CC_FERR_NO_SAVE;
}
//The first thing to do is to create the FBX Manager which is the object allocator for almost all the classes in the SDK
FbxManager* lSdkManager = FbxManager::Create();
if( !lSdkManager )
{
ccLog::Warning("[FBX] Error: Unable to create FBX Manager!");
return CC_FERR_CONSOLE_ERROR;
}
else
{
ccLog::Print("[FBX] Autodesk FBX SDK version %s", lSdkManager->GetVersion());
}
//Create an IOSettings object. This object holds all import/export settings.
FbxIOSettings* ios = FbxIOSettings::Create(lSdkManager, IOSROOT);
lSdkManager->SetIOSettings(ios);
//Load plugins from the executable directory (optional)
//FbxString lPath = FbxGetApplicationDirectory();
//lSdkManager->LoadPluginsDirectory(lPath.Buffer());
//Create an FBX scene. This object holds most objects imported/exported from/to files.
FbxScene* lScene = FbxScene::Create(lSdkManager, "My Scene");
if( !lScene )
{
ccLog::Warning("[FBX] Error: Unable to create FBX scene!");
return CC_FERR_CONSOLE_ERROR;
}
// create scene info
{
FbxDocumentInfo* sceneInfo = FbxDocumentInfo::Create(lSdkManager,"SceneInfo");
sceneInfo->mTitle = qPrintable(QString("Mesh: ") + (meshes.size() == 1 ? meshes[0]->getName() : QString("Multiple meshes")));
sceneInfo->mAuthor = "CloudCompare";
sceneInfo->mRevision = "rev. 1.0";
sceneInfo->mKeywords = "cloudcompare mesh";
// we need to add the sceneInfo before calling AddThumbNailToScene because
// that function is asking the scene for the sceneInfo.
lScene->SetSceneInfo(sceneInfo);
}
//create thumbnail
//{
// FbxThumbnail* lThumbnail = FbxThumbnail::Create(lScene,"");
// lThumbnail->SetDataFormat(FbxThumbnail::eRGB_24);
// lThumbnail->SetSize(FbxThumbnail::e64x64);
// lThumbnail->SetThumbnailImage(cSceneThumbnail);
// if (lScene->GetSceneInfo())
// {
// lScene->GetSceneInfo()->SetSceneThumbnail(lThumbnail);
// }
//}
// Build the node tree.
FbxNode* lRootNode = lScene->GetRootNode();
{
for (size_t i=0; i<meshes.size(); ++i)
{
FbxNode* meshNode = ToFbxMesh(meshes[i],lScene);
if (meshNode)
lRootNode->AddChild(meshNode);
else
ccLog::Warning(QString("[FBX] Failed to convert mesh '%1' to FBX mesh/node!").arg(meshes[i]->getName()));
}
}
// Save the scene.
bool lResult = SaveScene(lSdkManager, lScene, filename);
// Destroy all objects created by the FBX SDK.
if( lSdkManager )
lSdkManager->Destroy();
return lResult ? CC_FERR_NO_ERROR : CC_FERR_CONSOLE_ERROR;
}
FbxNode* FFbxExporter::ExportAnimSequence( const UAnimSequence* AnimSeq, const USkeletalMesh* SkelMesh, bool bExportSkelMesh, const TCHAR* MeshName, FbxNode* ActorRootNode )
{
if( Scene == NULL || AnimSeq == NULL || SkelMesh == NULL )
{
return NULL;
}
FbxNode* RootNode = (ActorRootNode)? ActorRootNode : Scene->GetRootNode();
// Create the Skeleton
TArray<FbxNode*> BoneNodes;
FbxNode* SkeletonRootNode = CreateSkeleton(SkelMesh, BoneNodes);
RootNode->AddChild(SkeletonRootNode);
// Export the anim sequence
{
ExportAnimSequenceToFbx(AnimSeq,
SkelMesh,
BoneNodes,
AnimLayer,
0.f, // AnimStartOffset
0.f, // AnimEndOffset
1.f, // AnimPlayRate
0.f); // StartTime
CorrectAnimTrackInterpolation(BoneNodes, AnimLayer);
}
// Optionally export the mesh
if(bExportSkelMesh)
{
FString MeshNodeName;
if (MeshName)
{
MeshNodeName = MeshName;
}
else
{
SkelMesh->GetName(MeshNodeName);
}
// Add the mesh
FbxNode* MeshRootNode = CreateMesh(SkelMesh, *MeshNodeName);
if(MeshRootNode)
{
RootNode->AddChild(MeshRootNode);
}
if(SkeletonRootNode && MeshRootNode)
{
// Bind the mesh to the skeleton
BindMeshToSkeleton(SkelMesh, MeshRootNode, BoneNodes);
// Add the bind pose
CreateBindPose(MeshRootNode);
}
}
return SkeletonRootNode;
}
