/** Check that root bone is the same, and that any bones that are common have the correct parent. */
bool SkeletonsAreCompatible( const FReferenceSkeleton& NewSkel, const FReferenceSkeleton& ExistSkel )
{
if(NewSkel.GetBoneName(0) != ExistSkel.GetBoneName(0))
{
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, FText::Format(LOCTEXT("MeshHasDifferentRoot", "Root Bone is '{0}' instead of '{1}'.\nDiscarding existing LODs."),
FText::FromName(NewSkel.GetBoneName(0)), FText::FromName(ExistSkel.GetBoneName(0)))));
return false;
}
for(int32 i=1; i<NewSkel.GetNum(); i++)
{
// See if bone is in both skeletons.
int32 NewBoneIndex = i;
FName NewBoneName = NewSkel.GetBoneName(NewBoneIndex);
int32 BBoneIndex = ExistSkel.FindBoneIndex(NewBoneName);
// If it is, check parents are the same.
if(BBoneIndex != INDEX_NONE)
{
FName NewParentName = NewSkel.GetBoneName( NewSkel.GetParentIndex(NewBoneIndex) );
FName ExistParentName = ExistSkel.GetBoneName( ExistSkel.GetParentIndex(BBoneIndex) );
if(NewParentName != ExistParentName)
{
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, FText::Format(LOCTEXT("MeshHasDifferentRoot", "Root Bone is '{0}' instead of '{1}'.\nDiscarding existing LODs."),
FText::FromName(NewBoneName), FText::FromName(NewParentName))));
return false;
}
}
}
return true;
}
UObject* UFbxFactory::ImportANode(void* VoidFbxImporter, void* VoidNode, UObject* InParent, FName InName, EObjectFlags Flags, int32& NodeIndex, int32 Total, UObject* InMesh, int LODIndex)
{
UnFbx::FFbxImporter* FFbxImporter = (UnFbx::FFbxImporter*)VoidFbxImporter;
FbxNode* Node = (FbxNode*)VoidNode;
UObject* NewObject = NULL;
FName OutputName = FFbxImporter->MakeNameForMesh(InName.ToString(), Node);
{
// skip collision models
FbxString NodeName(Node->GetName());
if ( NodeName.Find("UCX") != -1 || NodeName.Find("MCDCX") != -1 ||
NodeName.Find("UBX") != -1 || NodeName.Find("USP") != -1 )
{
return NULL;
}
NewObject = FFbxImporter->ImportStaticMesh( InParent, Node, OutputName, Flags, ImportUI->StaticMeshImportData, Cast<UStaticMesh>(InMesh), LODIndex );
}
if (NewObject)
{
NodeIndex++;
FFormatNamedArguments Args;
Args.Add( TEXT("NodeIndex"), NodeIndex );
Args.Add( TEXT("ArrayLength"), Total );
GWarn->StatusUpdate( NodeIndex, Total, FText::Format( NSLOCTEXT("UnrealEd", "Importingf", "Importing ({NodeIndex} of {ArrayLength})"), Args ) );
}
return NewObject;
}
void OutputAnimationTransformDebugData(TArray<AnimationTransformDebug::FAnimationTransformDebugData> &TransformDebugData, int32 TotalNumKeys, const FReferenceSkeleton& RefSkeleton)
{
bool bShouldOutputToMessageLog = true;
for(int32 Key=0; Key<TotalNumKeys; ++Key)
{
// go through all bones and find
for(int32 BoneIndex=0; BoneIndex<TransformDebugData.Num(); ++BoneIndex)
{
FAnimationTransformDebugData& Data = TransformDebugData[BoneIndex];
int32 ParentIndex = RefSkeleton.GetParentIndex(Data.BoneIndex);
int32 ParentTransformDebugDataIndex = 0;
check(Data.RecalculatedLocalTransform.Num() == TotalNumKeys);
check(Data.SourceGlobalTransform.Num() == TotalNumKeys);
check(Data.SourceParentGlobalTransform.Num() == TotalNumKeys);
for(; ParentTransformDebugDataIndex<BoneIndex; ++ParentTransformDebugDataIndex)
{
if(ParentIndex == TransformDebugData[ParentTransformDebugDataIndex].BoneIndex)
{
FTransform ParentTransform = TransformDebugData[ParentTransformDebugDataIndex].RecalculatedLocalTransform[Key] * TransformDebugData[ParentTransformDebugDataIndex].RecalculatedParentTransform[Key];
Data.RecalculatedParentTransform.Add(ParentTransform);
break;
}
}
// did not find Parent
if(ParentTransformDebugDataIndex == BoneIndex)
{
Data.RecalculatedParentTransform.Add(FTransform::Identity);
}
check(Data.RecalculatedParentTransform.Num() == Key+1);
FTransform GlobalTransform = Data.RecalculatedLocalTransform[Key] * Data.RecalculatedParentTransform[Key];
// makes more generous on the threshold.
if(GlobalTransform.Equals(Data.SourceGlobalTransform[Key], 0.1f) == false)
{
// so that we don't spawm with this message
if(bShouldOutputToMessageLog)
{
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
// now print information - it doesn't match well, find out what it is
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Warning, FText::Format(LOCTEXT("FBXImport_TransformError", "Imported bone transform is different from original. Please check Output Log to see detail of error. "),
FText::FromName(Data.BoneName), FText::AsNumber(Data.BoneIndex), FText::FromString(Data.SourceGlobalTransform[Key].ToString()), FText::FromString(GlobalTransform.ToString()))), FFbxErrors::Animation_TransformError);
bShouldOutputToMessageLog = false;
}
// now print information - it doesn't match well, find out what it is
UE_LOG(LogFbx, Warning, TEXT("IMPORT TRANSFORM ERROR : Bone (%s:%d) \r\nSource Global Transform (%s), \r\nConverted Global Transform (%s)"),
*Data.BoneName.ToString(), Data.BoneIndex, *Data.SourceGlobalTransform[Key].ToString(), *GlobalTransform.ToString());
}
}
}
}
EReimportResult::Type UReimportFbxSceneFactory::ImportStaticMesh(void* VoidFbxImporter, TSharedPtr<FFbxMeshInfo> MeshInfo, TSharedPtr<FFbxSceneInfo> SceneInfoPtr)
{
UnFbx::FFbxImporter* FbxImporter = (UnFbx::FFbxImporter*)VoidFbxImporter;
//FEditorDelegates::OnAssetPreImport.Broadcast(this, UStaticMesh::StaticClass(), GWorld, FName(""), TEXT("fbx"));
FbxNode *GeometryParentNode = nullptr;
//Get the first parent geometry node
for (int idx = 0; idx < FbxImporter->Scene->GetGeometryCount(); ++idx)
{
FbxGeometry *Geometry = FbxImporter->Scene->GetGeometry(idx);
if (Geometry->GetUniqueID() == MeshInfo->UniqueId)
{
GeometryParentNode = Geometry->GetNode();
break;
}
}
if (GeometryParentNode == nullptr)
{
FbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, FText::Format(FText::FromString("Reimport Mesh {0} fail, the mesh dont have any parent node inside the fbx."), FText::FromString(MeshInfo->GetImportPath()))), FName(TEXT("Reimport Fbx Scene")));
return EReimportResult::Failed;
}
FString PackageName = MeshInfo->GetImportPath();
FString StaticMeshName;
UPackage* Pkg = CreatePackageForNode(PackageName, StaticMeshName);
if (Pkg == nullptr)
{
return EReimportResult::Failed;
}
//Copy default options to StaticMeshImportData
SFbxSceneOptionWindow::CopyFbxOptionsToStaticMeshOptions(GlobalImportSettingsReference, SceneImportOptionsStaticMesh);
SceneImportOptionsStaticMesh->FillStaticMeshInmportData(StaticMeshImportData, SceneImportOptions);
UnFbx::FBXImportOptions* OverrideImportSettings = GetOptionsFromName(MeshInfo->OptionName);
if (OverrideImportSettings != nullptr)
{
SFbxSceneOptionWindow::CopyFbxOptionsToFbxOptions(OverrideImportSettings, GlobalImportSettings);
SFbxSceneOptionWindow::CopyFbxOptionsToStaticMeshOptions(OverrideImportSettings, SceneImportOptionsStaticMesh);
}
else
{
SFbxSceneOptionWindow::CopyFbxOptionsToFbxOptions(GlobalImportSettingsReference, GlobalImportSettings);
SFbxSceneOptionWindow::CopyFbxOptionsToStaticMeshOptions(GlobalImportSettingsReference, SceneImportOptionsStaticMesh);
}
SceneImportOptionsStaticMesh->FillStaticMeshInmportData(StaticMeshImportData, SceneImportOptions);
FName StaticMeshFName = FName(*(MeshInfo->Name));
UStaticMesh *NewObject = FbxImporter->ImportStaticMesh(Pkg, GeometryParentNode, StaticMeshFName, EObjectFlags::RF_Standalone, StaticMeshImportData );
if (NewObject == nullptr)
{
return EReimportResult::Failed;
}
AllNewAssets.Add(MeshInfo, NewObject);
AssetToSyncContentBrowser.Add(NewObject);
return EReimportResult::Succeeded;
}
/**
* Process and fill in the mesh ref skeleton bone hierarchy using the raw binary import data
*
* @param RefSkeleton - [out] reference skeleton hierarchy to update
* @param SkeletalDepth - [out] depth of the reference skeleton hierarchy
* @param ImportData - raw binary import data to process
* @return true if the operation completed successfully
*/
bool ProcessImportMeshSkeleton(FReferenceSkeleton& RefSkeleton, int32& SkeletalDepth, FSkeletalMeshImportData& ImportData)
{
TArray <VBone>& RefBonesBinary = ImportData.RefBonesBinary;
// Setup skeletal hierarchy + names structure.
RefSkeleton.Empty();
// Digest bones to the serializable format.
for( int32 b=0; b<RefBonesBinary.Num(); b++ )
{
const VBone & BinaryBone = RefBonesBinary[ b ];
const FString BoneName = FSkeletalMeshImportData::FixupBoneName( BinaryBone.Name );
const FMeshBoneInfo BoneInfo(FName(*BoneName, FNAME_Add, true), BinaryBone.ParentIndex);
const FTransform BoneTransform(BinaryBone.BonePos.Orientation, BinaryBone.BonePos.Position, FVector(1.f));
if(RefSkeleton.FindBoneIndex(BoneInfo.Name) != INDEX_NONE)
{
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, FText::Format(LOCTEXT("SkeletonHasDuplicateBones", "Skeleton has non-unique bone names.\nBone named '{0}' encountered more than once."), FText::FromName(BoneInfo.Name))));
return false;
}
RefSkeleton.Add(BoneInfo, BoneTransform);
}
// Add hierarchy index to each bone and detect max depth.
SkeletalDepth = 0;
TArray<int32> SkeletalDepths;
SkeletalDepths.Empty( RefBonesBinary.Num() );
SkeletalDepths.AddZeroed( RefBonesBinary.Num() );
for( int32 b=0; b < RefSkeleton.GetNum(); b++ )
{
int32 Parent = RefSkeleton.GetParentIndex(b);
int32 Depth = 1.0f;
SkeletalDepths[b] = 1.0f;
if( Parent != INDEX_NONE )
{
Depth += SkeletalDepths[Parent];
}
if( SkeletalDepth < Depth )
{
SkeletalDepth = Depth;
}
SkeletalDepths[b] = Depth;
}
return true;
}
void UFbxFactory::CleanUp()
{
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
bDetectImportTypeOnImport = true;
bShowOption = true;
// load options
if (FFbxImporter)
{
struct UnFbx::FBXImportOptions* ImportOptions = FFbxImporter->GetImportOptions();
if ( ImportOptions )
{
ImportOptions->SkeletonForAnimation = NULL;
ImportOptions->PhysicsAsset = NULL;
}
}
}
void FSavedCustomSortInfo::Restore(USkeletalMesh* NewSkeletalMesh, int32 LODModelIndex)
{
FStaticLODModel& LODModel = NewSkeletalMesh->GetImportedResource()->LODModels[LODModelIndex];
FSkeletalMeshLODInfo& LODInfo = NewSkeletalMesh->LODInfo[LODModelIndex];
// List of sections in the new model yet to be matched to the sorted sections
TArray<int32> UnmatchedSections;
for( int32 SectionIdx=0;SectionIdx<LODModel.Sections.Num();SectionIdx++ )
{
UnmatchedSections.Add(SectionIdx);
}
for( int32 Idx=0;Idx<SortSectionInfos.Num();Idx++ )
{
FSavedCustomSortSectionInfo& SortSectionInfo = SortSectionInfos[Idx];
if( SortSectionInfo.SavedSortOption == TRISORT_Custom || SortSectionInfo.SavedSortOption == TRISORT_CustomLeftRight )
{
// Restore saved custom sort order
SortSectionInfo.Restore(NewSkeletalMesh, LODModelIndex, UnmatchedSections);
}
else
{
if( !LODModel.Sections.IsValidIndex(SortSectionInfo.SavedSectionIdx) ||
!LODInfo.TriangleSortSettings.IsValidIndex(SortSectionInfo.SavedSectionIdx) )
{
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, FText::Format(LOCTEXT("FailedRestoreSortingForSectionNumber", "Unable to restore triangle sort setting \"{0}\" for section {1} as the new mesh does not contain that many sections. Please find the matching section and apply manually."),
FText::FromString(TriangleSortOptionToString((ETriangleSortOption)SortSectionInfo.SavedSortOption)),
FText::AsNumber(SortSectionInfo.SavedSectionIdx))),
FFbxErrors::SkeletalMesh_RestoreSortingForSectionNumber);
continue;
}
// Update the UI version of the data.
FTriangleSortSettings& TriangleSortSettings = LODInfo.TriangleSortSettings[SortSectionInfo.SavedSectionIdx];
TriangleSortSettings.TriangleSorting = SortSectionInfo.SavedSortOption;
TriangleSortSettings.CustomLeftRightAxis = SortSectionInfo.SavedCustomLeftRightAxis;
TriangleSortSettings.CustomLeftRightBoneName = SortSectionInfo.SavedCustomLeftRightBoneName;
// Just reapply the same sorting method to the section again.
FVector SortCenter;
bool bHaveSortCenter = NewSkeletalMesh->GetSortCenterPoint(SortCenter);
LODModel.SortTriangles(SortCenter, bHaveSortCenter, SortSectionInfo.SavedSectionIdx, (ETriangleSortOption)SortSectionInfo.SavedSortOption);
}
}
}
bool UFbxFactory::DetectImportType(const FString& InFilename)
{
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
UnFbx::FFbxLoggerSetter Logger(FFbxImporter);
int32 ImportType = FFbxImporter->GetImportType(InFilename);
if ( ImportType == -1)
{
return false;
}
else
{
ImportUI->MeshTypeToImport = EFBXImportType(ImportType);
ImportUI->OriginalImportType = ImportUI->MeshTypeToImport;
}
return true;
}
void FSavedCustomSortSectionInfo::Restore(USkeletalMesh* NewSkelMesh, int32 LODModelIndex, TArray<int32>& UnmatchedSections)
{
FStaticLODModel& LODModel = NewSkelMesh->GetImportedResource()->LODModels[LODModelIndex];
FSkeletalMeshLODInfo& LODInfo = NewSkelMesh->LODInfo[LODModelIndex];
// Re-order the UnmatchedSections so the old section index from the previous model is tried first
int32 PrevSectionIndex = UnmatchedSections.Find(SavedSectionIdx);
if( PrevSectionIndex != 0 && PrevSectionIndex != INDEX_NONE )
{
Exchange( UnmatchedSections[0], UnmatchedSections[PrevSectionIndex] );
}
// Find the strips in the old triangle data.
TArray< TArray<uint32> > OldStrips[2];
for( int32 IndexCopy=0; IndexCopy < (SavedSortOption==TRISORT_CustomLeftRight ? 2 : 1); IndexCopy++ )
{
const uint32* OldIndices = &SavedIndices[(SavedIndices.Num()>>1)*IndexCopy];
TArray<uint32> OldTriSet;
GetConnectedTriangleSets( SavedNumTriangles, OldIndices, OldTriSet );
// Convert to strips
int32 PrevTriSet = MAX_int32;
for( int32 TriIndex=0;TriIndex<SavedNumTriangles; TriIndex++ )
{
if( OldTriSet[TriIndex] != PrevTriSet )
{
OldStrips[IndexCopy].AddZeroed();
PrevTriSet = OldTriSet[TriIndex];
}
OldStrips[IndexCopy][OldStrips[IndexCopy].Num()-1].Add(OldIndices[TriIndex*3+0]);
OldStrips[IndexCopy][OldStrips[IndexCopy].Num()-1].Add(OldIndices[TriIndex*3+1]);
OldStrips[IndexCopy][OldStrips[IndexCopy].Num()-1].Add(OldIndices[TriIndex*3+2]);
}
}
bool bFoundMatchingSection = false;
// Try all remaining sections to find a match
for( int32 UnmatchedSectionsIdx=0; !bFoundMatchingSection && UnmatchedSectionsIdx<UnmatchedSections.Num(); UnmatchedSectionsIdx++ )
{
// Section of the new mesh to try
int32 SectionIndex = UnmatchedSections[UnmatchedSectionsIdx];
FSkelMeshSection& Section = LODModel.Sections[SectionIndex];
TArray<uint32> Indices;
LODModel.MultiSizeIndexContainer.GetIndexBuffer( Indices );
const uint32* NewSectionIndices = Indices.GetData() + Section.BaseIndex;
// Build the list of triangle sets in the new mesh's section
TArray<uint32> TriSet;
GetConnectedTriangleSets( Section.NumTriangles, NewSectionIndices, TriSet );
// Mapping from triangle set number to the array of indices that make up the contiguous strip.
TMap<uint32, TArray<uint32> > NewStripsMap;
// Go through each triangle and assign it to the appropriate contiguous strip.
// This is necessary if the strips in the index buffer are not contiguous.
int32 Index=0;
for( int32 s=0;s<TriSet.Num();s++ )
{
// Store the indices for this triangle in the appropriate contiguous set.
TArray<uint32>* ThisStrip = NewStripsMap.Find(TriSet[s]);
if( !ThisStrip )
{
ThisStrip = &NewStripsMap.Add(TriSet[s],TArray<uint32>());
}
// Add the three indices for this triangle.
ThisStrip->Add(NewSectionIndices[Index++]);
ThisStrip->Add(NewSectionIndices[Index++]);
ThisStrip->Add(NewSectionIndices[Index++]);
}
// Get the new vertices
TArray<FSoftSkinVertex> NewVertices;
LODModel.GetVertices(NewVertices);
// Do the processing once for each copy if the index data
for( int32 IndexCopy=0; IndexCopy < (SavedSortOption==TRISORT_CustomLeftRight ? 2 : 1); IndexCopy++ )
{
// Copy strips in the new mesh's section into an array. We'll remove items from
// here as we match to the old strips, so we need to keep a new copy of it each time.
TArray<TArray<uint32> > NewStrips;
for( TMap<uint32, TArray<uint32> >::TIterator It(NewStripsMap); It; ++It )
{
NewStrips.Add(It.Value());
}
// Match up old strips to new
int32 NumMismatchedStrips = 0;
TArray<TArray<uint32> > NewSortedStrips; // output
for( int32 OsIdx=0;OsIdx<OldStrips[IndexCopy].Num();OsIdx++ )
{
TArray<uint32>& OldStripIndices = OldStrips[IndexCopy][OsIdx];
int32 MatchingNewStrip = INDEX_NONE;
for( int32 NsIdx=0;NsIdx<NewStrips.Num() && MatchingNewStrip==INDEX_NONE;NsIdx++ )
{
// Check if we have the same number of triangles in the old and new strips.
if( NewStrips[NsIdx].Num() != OldStripIndices.Num() )
{
continue;
}
// Make a copy of the indices, as we'll remove them as we try to match triangles.
TArray<uint32> NewStripIndices = NewStrips[NsIdx];
// Check if all the triangles in the new strip closely match those in the old.
for( int32 OldTriIdx=0;OldTriIdx<OldStripIndices.Num();OldTriIdx+=3 )
{
// Try to find a match for this triangle in the new strip.
bool FoundMatch = false;
for( int32 NewTriIdx=0;NewTriIdx<NewStripIndices.Num();NewTriIdx+=3 )
{
if( (SavedVertices[OldStripIndices[OldTriIdx+0]] - NewVertices[NewStripIndices[NewTriIdx+0]].Position).SizeSquared() < KINDA_SMALL_NUMBER &&
(SavedVertices[OldStripIndices[OldTriIdx+1]] - NewVertices[NewStripIndices[NewTriIdx+1]].Position).SizeSquared() < KINDA_SMALL_NUMBER &&
(SavedVertices[OldStripIndices[OldTriIdx+2]] - NewVertices[NewStripIndices[NewTriIdx+2]].Position).SizeSquared() < KINDA_SMALL_NUMBER )
{
// Found a triangle match. Remove the triangle from the new list and try to match the next old triangle.
NewStripIndices.RemoveAt(NewTriIdx,3);
FoundMatch = true;
break;
}
}
// If we didn't find a match for this old triangle, the whole strip doesn't match.
if( !FoundMatch )
{
break;
}
}
if( NewStripIndices.Num() == 0 )
{
// strip completely matched
MatchingNewStrip = NsIdx;
}
}
if( MatchingNewStrip != INDEX_NONE )
{
NewSortedStrips.Add( NewStrips[MatchingNewStrip] );
NewStrips.RemoveAt(MatchingNewStrip);
}
else
{
NumMismatchedStrips++;
}
}
if( IndexCopy == 0 )
{
if( 100 * NumMismatchedStrips / OldStrips[0].Num() > 50 )
{
// If less than 50% of this section's strips match, we assume this is not the correct section.
break;
}
// This section matches!
bFoundMatchingSection = true;
// Warn the user if we couldn't match things up.
if( NumMismatchedStrips )
{
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Warning, FText::Format(LOCTEXT("RestoreSortingMismatchedStripsForSection", "While restoring \"{0}\" sort order for section {1}, {2} of {3} strips could not be matched to the new data."),
FText::FromString(TriangleSortOptionToString((ETriangleSortOption)SavedSortOption)),
FText::AsNumber(SavedSectionIdx),
FText::AsNumber(NumMismatchedStrips),
FText::AsNumber(OldStrips[0].Num()))));
}
// Restore the settings saved in the LODInfo (used for the UI)
FTriangleSortSettings& TriangleSortSettings = LODInfo.TriangleSortSettings[SectionIndex];
TriangleSortSettings.TriangleSorting = SavedSortOption;
TriangleSortSettings.CustomLeftRightAxis = SavedCustomLeftRightAxis;
TriangleSortSettings.CustomLeftRightBoneName = SavedCustomLeftRightBoneName;
// Restore the sorting mode. For TRISORT_CustomLeftRight, this will also make the second copy of the index data.
FVector SortCenter;
bool bHaveSortCenter = NewSkelMesh->GetSortCenterPoint(SortCenter);
LODModel.SortTriangles(SortCenter, bHaveSortCenter, SectionIndex, (ETriangleSortOption)SavedSortOption);
}
// Append any strips we couldn't match to the end
NewSortedStrips += NewStrips;
// Export the strips out to the index buffer in order
TArray<uint32> Indexes;
LODModel.MultiSizeIndexContainer.GetIndexBuffer( Indexes );
uint32* NewIndices = Indexes.GetData() + (Section.BaseIndex + Section.NumTriangles*3*IndexCopy);
for( int32 StripIdx=0;StripIdx<NewSortedStrips.Num();StripIdx++ )
{
FMemory::Memcpy( NewIndices, &NewSortedStrips[StripIdx][0], NewSortedStrips[StripIdx].Num() * sizeof(uint32) );
// Cache-optimize the triangle order inside the final strip
CacheOptimizeSortStrip( NewIndices, NewSortedStrips[StripIdx].Num() );
NewIndices += NewSortedStrips[StripIdx].Num();
}
LODModel.MultiSizeIndexContainer.CopyIndexBuffer( Indexes );
}
}
if( !bFoundMatchingSection )
{
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Warning, FText::Format(LOCTEXT("FailedRestoreSortingNoSectionMatch", "Unable to restore triangle sort setting \"{0}\" for section number {1} in the old mesh, as a matching section could not be found in the new mesh. The custom sorting information has been lost."),
FText::FromString(TriangleSortOptionToString((ETriangleSortOption)SavedSortOption)), FText::AsNumber(SavedSectionIdx))));
}
}
ExistingSkelMeshData* SaveExistingSkelMeshData(USkeletalMesh* ExistingSkelMesh)
{
struct ExistingSkelMeshData* ExistingMeshDataPtr = NULL;
if(ExistingSkelMesh)
{
ExistingMeshDataPtr = new ExistingSkelMeshData();
FSkeletalMeshResource* ImportedResource = ExistingSkelMesh->GetImportedResource();
if (ImportedResource->LODModels.Num() > 0)
{
ExistingMeshDataPtr->ExistingSortInfo.Save(ExistingSkelMesh, 0);
}
ExistingMeshDataPtr->ExistingSockets = ExistingSkelMesh->GetMeshOnlySocketList();
ExistingMeshDataPtr->ExistingMaterials = ExistingSkelMesh->Materials;
if( ImportedResource->LODModels.Num() > 0 &&
ExistingSkelMesh->LODInfo.Num() == ImportedResource->LODModels.Num() )
{
// Remove the zero'th LOD (ie: the LOD being reimported).
ImportedResource->LODModels.RemoveAt(0);
ExistingSkelMesh->LODInfo.RemoveAt(0);
// Copy off the remaining LODs.
for ( int32 LODModelIndex = 0 ; LODModelIndex < ImportedResource->LODModels.Num() ; ++LODModelIndex )
{
FStaticLODModel& LODModel = ImportedResource->LODModels[LODModelIndex];
LODModel.RawPointIndices.Lock( LOCK_READ_ONLY );
LODModel.LegacyRawPointIndices.Lock( LOCK_READ_ONLY );
}
ExistingMeshDataPtr->ExistingLODModels = ImportedResource->LODModels;
#if PLATFORM_COMPILER_HAS_RANGED_FOR_LOOP
for ( auto& LODModel : ImportedResource->LODModels )
{
#else
for ( int32 LODModelIndex = 0 ; LODModelIndex < ImportedResource->LODModels.Num() ; ++LODModelIndex )
{
FStaticLODModel& LODModel = ImportedResource->LODModels[LODModelIndex];
#endif
LODModel.RawPointIndices.Unlock();
LODModel.LegacyRawPointIndices.Unlock();
FMultiSizeIndexContainerData ExistingData;
LODModel.MultiSizeIndexContainer.GetIndexBufferData( ExistingData );
ExistingMeshDataPtr->ExistingIndexBufferData.Add( ExistingData );
}
ExistingMeshDataPtr->ExistingLODInfo = ExistingSkelMesh->LODInfo;
ExistingMeshDataPtr->ExistingRefSkeleton = ExistingSkelMesh->RefSkeleton;
}
// First asset should be the one that the skeletal mesh should point too
ExistingMeshDataPtr->ExistingPhysicsAssets.Empty();
ExistingMeshDataPtr->ExistingPhysicsAssets.Add( ExistingSkelMesh->PhysicsAsset );
for (TObjectIterator<UPhysicsAsset> It; It; ++It)
{
UPhysicsAsset* PhysicsAsset = *It;
if ( PhysicsAsset->PreviewSkeletalMesh == ExistingSkelMesh && ExistingSkelMesh->PhysicsAsset != PhysicsAsset )
{
ExistingMeshDataPtr->ExistingPhysicsAssets.Add( PhysicsAsset );
}
}
ExistingMeshDataPtr->ExistingSkeleton = ExistingSkelMesh->Skeleton;
ExistingSkelMesh->ExportMirrorTable(ExistingMeshDataPtr->ExistingMirrorTable);
ExistingMeshDataPtr->ExistingMorphTargets.Empty(ExistingSkelMesh->MorphTargets.Num());
ExistingMeshDataPtr->ExistingMorphTargets.Append(ExistingSkelMesh->MorphTargets);
ExistingMeshDataPtr->bExistingUseFullPrecisionUVs = ExistingSkelMesh->bUseFullPrecisionUVs;
ExistingMeshDataPtr->ExistingAssetImportData = ExistingSkelMesh->AssetImportData;
ExistingMeshDataPtr->ExistingThumbnailInfo = ExistingSkelMesh->ThumbnailInfo;
}
return ExistingMeshDataPtr;
}
void RestoreExistingSkelMeshData(ExistingSkelMeshData* MeshData, USkeletalMesh* SkeletalMesh)
{
if(MeshData && SkeletalMesh)
{
// Fix Materials array to be the correct size.
if(MeshData->ExistingMaterials.Num() > SkeletalMesh->Materials.Num())
{
MeshData->ExistingMaterials.RemoveAt( SkeletalMesh->Materials.Num(), MeshData->ExistingMaterials.Num() - SkeletalMesh->Materials.Num() );
}
else if(SkeletalMesh->Materials.Num() > MeshData->ExistingMaterials.Num())
{
MeshData->ExistingMaterials.AddZeroed( SkeletalMesh->Materials.Num() - MeshData->ExistingMaterials.Num() );
}
SkeletalMesh->Materials = MeshData->ExistingMaterials;
// Assign sockets from old version of this SkeletalMesh.
// Only copy ones for bones that exist in the new mesh.
for(int32 i=0; i<MeshData->ExistingSockets.Num(); i++)
{
const int32 BoneIndex = SkeletalMesh->RefSkeleton.FindBoneIndex( MeshData->ExistingSockets[i]->BoneName );
if(BoneIndex != INDEX_NONE)
{
SkeletalMesh->GetMeshOnlySocketList().Add( MeshData->ExistingSockets[i] );
}
}
// We copy back and fix-up the LODs that still work with this skeleton.
if( MeshData->ExistingLODModels.Num() > 0 && SkeletonsAreCompatible(SkeletalMesh->RefSkeleton, MeshData->ExistingRefSkeleton) )
{
// First create mapping table from old skeleton to new skeleton.
TArray<int32> OldToNewMap;
OldToNewMap.AddUninitialized(MeshData->ExistingRefSkeleton.GetNum());
for(int32 i=0; i<MeshData->ExistingRefSkeleton.GetNum(); i++)
{
OldToNewMap[i] = SkeletalMesh->RefSkeleton.FindBoneIndex(MeshData->ExistingRefSkeleton.GetBoneName(i));
}
for(int32 i=0; i<MeshData->ExistingLODModels.Num(); i++)
{
FStaticLODModel& LODModel = MeshData->ExistingLODModels[i];
FSkeletalMeshLODInfo& LODInfo = MeshData->ExistingLODInfo[i];
// Fix ActiveBoneIndices array.
bool bMissingBone = false;
FName MissingBoneName = NAME_None;
for(int32 j=0; j<LODModel.ActiveBoneIndices.Num() && !bMissingBone; j++)
{
int32 NewBoneIndex = OldToNewMap[ LODModel.ActiveBoneIndices[j] ];
if(NewBoneIndex == INDEX_NONE)
{
bMissingBone = true;
MissingBoneName = MeshData->ExistingRefSkeleton.GetBoneName( LODModel.ActiveBoneIndices[j] );
}
else
{
LODModel.ActiveBoneIndices[j] = NewBoneIndex;
}
}
// Fix RequiredBones array.
for(int32 j=0; j<LODModel.RequiredBones.Num() && !bMissingBone; j++)
{
int32 NewBoneIndex = OldToNewMap[ LODModel.RequiredBones[j] ];
if(NewBoneIndex == INDEX_NONE)
{
bMissingBone = true;
MissingBoneName = MeshData->ExistingRefSkeleton.GetBoneName( LODModel.RequiredBones[j] );
}
else
{
LODModel.RequiredBones[j] = NewBoneIndex;
}
}
// Sort ascending for parent child relationship
LODModel.RequiredBones.Sort();
// Fix the chunks' BoneMaps.
for(int32 ChunkIndex = 0;ChunkIndex < LODModel.Chunks.Num();ChunkIndex++)
{
FSkelMeshChunk& Chunk = LODModel.Chunks[ChunkIndex];
for(int32 BoneIndex = 0;BoneIndex < Chunk.BoneMap.Num();BoneIndex++)
{
int32 NewBoneIndex = OldToNewMap[ Chunk.BoneMap[BoneIndex] ];
if(NewBoneIndex == INDEX_NONE)
{
bMissingBone = true;
MissingBoneName = MeshData->ExistingRefSkeleton.GetBoneName(Chunk.BoneMap[BoneIndex]);
break;
}
else
{
Chunk.BoneMap[BoneIndex] = NewBoneIndex;
}
}
if(bMissingBone)
{
break;
}
}
if(bMissingBone)
{
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Warning, FText::Format(LOCTEXT("NewMeshMissingBoneFromLOD", "New mesh is missing bone '{0}' required by an LOD. LOD will be removed."), FText::FromName(MissingBoneName))));
}
else
{
FStaticLODModel* NewLODModel = new(SkeletalMesh->GetImportedResource()->LODModels) FStaticLODModel( LODModel );
NewLODModel->MultiSizeIndexContainer.RebuildIndexBuffer( MeshData->ExistingIndexBufferData[i] );
SkeletalMesh->LODInfo.Add( LODInfo );
}
}
}
for (int32 AssetIndex = 0; AssetIndex < MeshData->ExistingPhysicsAssets.Num(); ++AssetIndex)
{
UPhysicsAsset* PhysicsAsset = MeshData->ExistingPhysicsAssets[AssetIndex];
if ( AssetIndex == 0 )
{
// First asset is the one that the skeletal mesh should point too
SkeletalMesh->PhysicsAsset = PhysicsAsset;
}
// No need to mark as modified here, because the asset hasn't actually changed
if (PhysicsAsset)
{
PhysicsAsset->PreviewSkeletalMesh = SkeletalMesh;
}
}
SkeletalMesh->Skeleton = MeshData->ExistingSkeleton;
// Copy mirror table.
SkeletalMesh->ImportMirrorTable(MeshData->ExistingMirrorTable);
SkeletalMesh->MorphTargets.Empty(MeshData->ExistingMorphTargets.Num());
SkeletalMesh->MorphTargets.Append(MeshData->ExistingMorphTargets);
SkeletalMesh->InitMorphTargets();
SkeletalMesh->bUseFullPrecisionUVs = MeshData->bExistingUseFullPrecisionUVs;
MeshData->ExistingSortInfo.Restore(SkeletalMesh, 0);
SkeletalMesh->AssetImportData = MeshData->ExistingAssetImportData.Get();
SkeletalMesh->ThumbnailInfo = MeshData->ExistingThumbnailInfo.Get();
}
}
EReimportResult::Type UReimportFbxSceneFactory::ReimportStaticMesh(void* VoidFbxImporter, TSharedPtr<FFbxMeshInfo> MeshInfo)
{
UnFbx::FFbxImporter* FbxImporter = (UnFbx::FFbxImporter*)VoidFbxImporter;
//Find the UObject associate with this MeshInfo
UPackage* PkgExist = LoadPackage(nullptr, *(MeshInfo->GetImportPath()), LOAD_Verify | LOAD_NoWarn);
if (PkgExist != nullptr)
{
PkgExist->FullyLoad();
}
FString AssetName = MeshInfo->GetFullImportName();
UStaticMesh* Mesh = FindObjectSafe<UStaticMesh>(ANY_PACKAGE, *AssetName);
if (Mesh == nullptr)
{
//We reimport only static mesh here
FbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, FText::Format(FText::FromString("Reimport Mesh {0} fail, the original staicmesh in the content browser cannot be load."), FText::FromString(MeshInfo->GetImportPath()))), FName(TEXT("Reimport Fbx Scene")));
return EReimportResult::Failed;
}
//Copy default options to StaticMeshImportData
SFbxSceneOptionWindow::CopyFbxOptionsToStaticMeshOptions(GlobalImportSettingsReference, SceneImportOptionsStaticMesh);
SceneImportOptionsStaticMesh->FillStaticMeshInmportData(StaticMeshImportData, SceneImportOptions);
UnFbx::FBXImportOptions* OverrideImportSettings = GetOptionsFromName(MeshInfo->OptionName);
if (OverrideImportSettings != nullptr)
{
SFbxSceneOptionWindow::CopyFbxOptionsToFbxOptions(OverrideImportSettings, GlobalImportSettings);
SFbxSceneOptionWindow::CopyFbxOptionsToStaticMeshOptions(OverrideImportSettings, SceneImportOptionsStaticMesh);
}
else
{
SFbxSceneOptionWindow::CopyFbxOptionsToFbxOptions(GlobalImportSettingsReference, GlobalImportSettings);
SFbxSceneOptionWindow::CopyFbxOptionsToStaticMeshOptions(GlobalImportSettingsReference, SceneImportOptionsStaticMesh);
}
SceneImportOptionsStaticMesh->FillStaticMeshInmportData(StaticMeshImportData, SceneImportOptions);
FbxImporter->ApplyTransformSettingsToFbxNode(FbxImporter->Scene->GetRootNode(), StaticMeshImportData);
const TArray<UAssetUserData*>* UserData = Mesh->GetAssetUserDataArray();
TArray<UAssetUserData*> UserDataCopy;
if (UserData)
{
for (int32 Idx = 0; Idx < UserData->Num(); Idx++)
{
UserDataCopy.Add((UAssetUserData*)StaticDuplicateObject((*UserData)[Idx], GetTransientPackage()));
}
}
// preserve settings in navcollision subobject
UNavCollision* NavCollision = Mesh->NavCollision ?
(UNavCollision*)StaticDuplicateObject(Mesh->NavCollision, GetTransientPackage()) :
nullptr;
// preserve extended bound settings
const FVector PositiveBoundsExtension = Mesh->PositiveBoundsExtension;
const FVector NegativeBoundsExtension = Mesh->NegativeBoundsExtension;
Mesh = FbxImporter->ReimportSceneStaticMesh(MeshInfo->UniqueId, Mesh, StaticMeshImportData);
if (Mesh != nullptr)
{
//Put back the new mesh data since the reimport is putting back the original import data
SceneImportOptionsStaticMesh->FillStaticMeshInmportData(StaticMeshImportData, SceneImportOptions);
Mesh->AssetImportData = StaticMeshImportData;
// Copy user data to newly created mesh
for (int32 Idx = 0; Idx < UserDataCopy.Num(); Idx++)
{
UserDataCopy[Idx]->Rename(nullptr, Mesh, REN_DontCreateRedirectors | REN_DoNotDirty);
Mesh->AddAssetUserData(UserDataCopy[Idx]);
}
if (NavCollision)
{
Mesh->NavCollision = NavCollision;
NavCollision->Rename(nullptr, Mesh, REN_DontCreateRedirectors | REN_DoNotDirty);
}
// Restore bounds extension settings
Mesh->PositiveBoundsExtension = PositiveBoundsExtension;
Mesh->NegativeBoundsExtension = NegativeBoundsExtension;
Mesh->AssetImportData->Update(FbxImportFileName);
// Try to find the outer package so we can dirty it up
if (Mesh->GetOutermost())
{
Mesh->GetOutermost()->MarkPackageDirty();
}
else
{
Mesh->MarkPackageDirty();
}
AllNewAssets.Add(MeshInfo, Mesh);
AssetToSyncContentBrowser.Add(Mesh);
}
else
{
return EReimportResult::Failed;
}
return EReimportResult::Succeeded;
}
/**
* Process and update the vertex Influences using the raw binary import data
*
* @param ImportData - raw binary import data to process
*/
void ProcessImportMeshInfluences(FSkeletalMeshImportData& ImportData)
{
TArray <FVector>& Points = ImportData.Points;
TArray <VVertex>& Wedges = ImportData.Wedges;
TArray <VRawBoneInfluence>& Influences = ImportData.Influences;
// Sort influences by vertex index.
struct FCompareVertexIndex
{
bool operator()( const VRawBoneInfluence& A, const VRawBoneInfluence& B ) const
{
if ( A.VertexIndex > B.VertexIndex ) return false;
else if ( A.VertexIndex < B.VertexIndex ) return true;
else if ( A.Weight < B.Weight ) return false;
else if ( A.Weight > B.Weight ) return true;
else if ( A.BoneIndex > B.BoneIndex ) return false;
else if ( A.BoneIndex < B.BoneIndex ) return true;
else return false;
}
};
Influences.Sort( FCompareVertexIndex() );
// Remove more than allowed number of weights by removing least important influences (setting them to 0).
// Relies on influences sorted by vertex index and weight and the code actually removing the influences below.
int32 LastVertexIndex = INDEX_NONE;
int32 InfluenceCount = 0;
for( int32 i=0; i<Influences.Num(); i++ )
{
if( ( LastVertexIndex != Influences[i].VertexIndex ) )
{
InfluenceCount = 0;
LastVertexIndex = Influences[i].VertexIndex;
}
InfluenceCount++;
if( InfluenceCount > MAX_TOTAL_INFLUENCES || LastVertexIndex >= Points.Num() )
{
Influences[i].Weight = 0.f;
}
}
// Remove influences below a certain threshold.
int32 RemovedInfluences = 0;
const float MINWEIGHT = 0.01f; // 1%
for( int32 i=Influences.Num()-1; i>=0; i-- )
{
if( Influences[i].Weight < MINWEIGHT )
{
Influences.RemoveAt(i);
RemovedInfluences++;
}
}
// Renormalize influence weights.
int32 LastInfluenceCount = 0;
InfluenceCount = 0;
LastVertexIndex = INDEX_NONE;
float TotalWeight = 0.f;
for( int32 i=0; i<Influences.Num(); i++ )
{
if( LastVertexIndex != Influences[i].VertexIndex )
{
LastInfluenceCount = InfluenceCount;
InfluenceCount = 0;
// Normalize the last set of influences.
if( LastInfluenceCount && (TotalWeight != 1.0f) )
{
float OneOverTotalWeight = 1.f / TotalWeight;
for( int r=0; r<LastInfluenceCount; r++)
{
Influences[i-r-1].Weight *= OneOverTotalWeight;
}
}
TotalWeight = 0.f;
LastVertexIndex = Influences[i].VertexIndex;
}
InfluenceCount++;
TotalWeight += Influences[i].Weight;
}
// Ensure that each vertex has at least one influence as e.g. CreateSkinningStream relies on it.
// The below code relies on influences being sorted by vertex index.
LastVertexIndex = -1;
InfluenceCount = 0;
if( Influences.Num() == 0 )
{
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
// warn about no influences
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Warning, LOCTEXT("WarningNoSkelInfluences", "Warning skeletal mesh is has no vertex influences")));
// add one for each wedge entry
Influences.AddUninitialized(Wedges.Num());
for( int32 WedgeIdx=0; WedgeIdx<Wedges.Num(); WedgeIdx++ )
{
Influences[WedgeIdx].VertexIndex = WedgeIdx;
Influences[WedgeIdx].BoneIndex = 0;
Influences[WedgeIdx].Weight = 1.0f;
}
}
for( int32 i=0; i<Influences.Num(); i++ )
{
int32 CurrentVertexIndex = Influences[i].VertexIndex;
if( LastVertexIndex != CurrentVertexIndex )
{
for( int32 j=LastVertexIndex+1; j<CurrentVertexIndex; j++ )
{
// Add a 0-bone weight if none other present (known to happen with certain MAX skeletal setups).
Influences.InsertUninitialized(i,1);
Influences[i].VertexIndex = j;
Influences[i].BoneIndex = 0;
Influences[i].Weight = 1.f;
}
LastVertexIndex = CurrentVertexIndex;
}
}
}
bool UnFbx::FFbxImporter::ImportAnimation(USkeleton* Skeleton, UAnimSequence * DestSeq, const FString& FileName, TArray<FbxNode*>& SortedLinks, TArray<FbxNode*>& NodeArray, FbxAnimStack* CurAnimStack, const int32 ResampleRate, const FbxTimeSpan AnimTimeSpan)
{
// @todo : the length might need to change w.r.t. sampling keys
FbxTime SequenceLength = AnimTimeSpan.GetDuration();
float PreviousSequenceLength = DestSeq->SequenceLength;
// if you have one pose(thus 0.f duration), it still contains animation, so we'll need to consider that as MINIMUM_ANIMATION_LENGTH time length
DestSeq->SequenceLength = FGenericPlatformMath::Max<float>(SequenceLength.GetSecondDouble(), MINIMUM_ANIMATION_LENGTH);
if(PreviousSequenceLength > MINIMUM_ANIMATION_LENGTH && DestSeq->RawCurveData.FloatCurves.Num() > 0)
{
// The sequence already existed when we began the import. We need to scale the key times for all curves to match the new
// duration before importing over them. This is to catch any user-added curves
float ScaleFactor = DestSeq->SequenceLength / PreviousSequenceLength;
for(FFloatCurve& Curve : DestSeq->RawCurveData.FloatCurves)
{
Curve.FloatCurve.ScaleCurve(0.0f, ScaleFactor);
}
}
if (ImportOptions->bDeleteExistingMorphTargetCurves)
{
for (int32 CurveIdx=0; CurveIdx<DestSeq->RawCurveData.FloatCurves.Num(); ++CurveIdx)
{
auto& Curve = DestSeq->RawCurveData.FloatCurves[CurveIdx];
if (Curve.GetCurveTypeFlag(ACF_DrivesMorphTarget))
{
DestSeq->RawCurveData.FloatCurves.RemoveAt(CurveIdx, 1, false);
--CurveIdx;
}
}
DestSeq->RawCurveData.FloatCurves.Shrink();
}
//
// import blend shape curves
//
{
GWarn->BeginSlowTask( LOCTEXT("BeginImportMorphTargetCurves", "Importing Morph Target Curves"), true);
for ( int32 NodeIndex = 0; NodeIndex < NodeArray.Num(); NodeIndex++ )
{
// consider blendshape animation curve
FbxGeometry* Geometry = (FbxGeometry*)NodeArray[NodeIndex]->GetNodeAttribute();
if (Geometry)
{
int32 BlendShapeDeformerCount = Geometry->GetDeformerCount(FbxDeformer::eBlendShape);
for(int32 BlendShapeIndex = 0; BlendShapeIndex<BlendShapeDeformerCount; ++BlendShapeIndex)
{
FbxBlendShape* BlendShape = (FbxBlendShape*)Geometry->GetDeformer(BlendShapeIndex, FbxDeformer::eBlendShape);
const int32 BlendShapeChannelCount = BlendShape->GetBlendShapeChannelCount();
FString BlendShapeName = UTF8_TO_TCHAR(MakeName(BlendShape->GetName()));
for(int32 ChannelIndex = 0; ChannelIndex<BlendShapeChannelCount; ++ChannelIndex)
{
FbxBlendShapeChannel* Channel = BlendShape->GetBlendShapeChannel(ChannelIndex);
if(Channel)
{
FString ChannelName = UTF8_TO_TCHAR(MakeName(Channel->GetName()));
// Maya adds the name of the blendshape and an underscore to the front of the channel name, so remove it
if(ChannelName.StartsWith(BlendShapeName))
{
ChannelName = ChannelName.Right(ChannelName.Len() - (BlendShapeName.Len()+1));
}
FbxAnimCurve* Curve = Geometry->GetShapeChannel(BlendShapeIndex, ChannelIndex, (FbxAnimLayer*)CurAnimStack->GetMember(0));
if (Curve && Curve->KeyGetCount() > 0)
{
FFormatNamedArguments Args;
Args.Add(TEXT("BlendShape"), FText::FromString(ChannelName));
const FText StatusUpate = FText::Format(LOCTEXT("ImportingMorphTargetCurvesDetail", "Importing Morph Target Curves [{BlendShape}]"), Args);
GWarn->StatusUpdate(NodeIndex + 1, NodeArray.Num(), StatusUpate);
// now see if we have one already exists. If so, just overwrite that. if not, add new one.
ImportCurveToAnimSequence(DestSeq, *ChannelName, Curve, ACF_DrivesMorphTarget | ACF_TriggerEvent, AnimTimeSpan, 0.01f /** for some reason blend shape values are coming as 100 scaled **/);
}
}
}
}
}
}
GWarn->EndSlowTask();
}
//
// importing custom attribute START
//
if (ImportOptions->bImportCustomAttribute)
{
GWarn->BeginSlowTask( LOCTEXT("BeginImportMorphTargetCurves", "Importing Custom Attirubte Curves"), true);
const int32 TotalLinks = SortedLinks.Num();
int32 CurLinkIndex=0;
for(auto Node: SortedLinks)
{
FbxProperty Property = Node->GetFirstProperty();
while (Property.IsValid())
{
FbxAnimCurveNode* CurveNode = Property.GetCurveNode();
// do this if user defined and animated and leaf node
if( CurveNode && Property.GetFlag(FbxPropertyAttr::eUserDefined) &&
CurveNode->IsAnimated() && IsSupportedCurveDataType(Property.GetPropertyDataType().GetType()) )
{
FString CurveName = UTF8_TO_TCHAR(CurveNode->GetName());
UE_LOG(LogFbx, Log, TEXT("CurveName : %s"), *CurveName );
int32 TotalCount = CurveNode->GetChannelsCount();
for (int32 ChannelIndex=0; ChannelIndex<TotalCount; ++ChannelIndex)
{
FbxAnimCurve * AnimCurve = CurveNode->GetCurve(ChannelIndex);
FString ChannelName = CurveNode->GetChannelName(ChannelIndex).Buffer();
if (AnimCurve)
{
FString FinalCurveName;
if (TotalCount == 1)
{
FinalCurveName = CurveName;
}
else
{
FinalCurveName = CurveName + "_" + ChannelName;
}
FFormatNamedArguments Args;
Args.Add(TEXT("CurveName"), FText::FromString(FinalCurveName));
const FText StatusUpate = FText::Format(LOCTEXT("ImportingCustomAttributeCurvesDetail", "Importing Custom Attribute [{CurveName}]"), Args);
GWarn->StatusUpdate(CurLinkIndex + 1, TotalLinks, StatusUpate);
ImportCurveToAnimSequence(DestSeq, FinalCurveName, AnimCurve, ACF_DefaultCurve, AnimTimeSpan);
}
}
}
Property = Node->GetNextProperty(Property);
}
CurLinkIndex++;
}
GWarn->EndSlowTask();
}
// importing custom attribute END
const bool bSourceDataExists = (DestSeq->SourceRawAnimationData.Num() > 0);
TArray<AnimationTransformDebug::FAnimationTransformDebugData> TransformDebugData;
int32 TotalNumKeys = 0;
const FReferenceSkeleton& RefSkeleton = Skeleton->GetReferenceSkeleton();
// import animation
{
GWarn->BeginSlowTask( LOCTEXT("BeginImportAnimation", "Importing Animation"), true);
TArray<struct FRawAnimSequenceTrack>& RawAnimationData = bSourceDataExists? DestSeq->SourceRawAnimationData : DestSeq->RawAnimationData;
DestSeq->TrackToSkeletonMapTable.Empty();
DestSeq->AnimationTrackNames.Empty();
RawAnimationData.Empty();
TArray<FName> FbxRawBoneNames;
FillAndVerifyBoneNames(Skeleton, SortedLinks, FbxRawBoneNames, FileName);
UnFbx::FFbxImporter* FbxImporter = UnFbx::FFbxImporter::GetInstance();
const bool bPreserveLocalTransform = FbxImporter->GetImportOptions()->bPreserveLocalTransform;
// Build additional transform matrix
UFbxAnimSequenceImportData* TemplateData = Cast<UFbxAnimSequenceImportData>(DestSeq->AssetImportData);
FbxAMatrix FbxAddedMatrix;
BuildFbxMatrixForImportTransform(FbxAddedMatrix, TemplateData);
FMatrix AddedMatrix = Converter.ConvertMatrix(FbxAddedMatrix);
const int32 NumSamplingKeys = FMath::FloorToInt(AnimTimeSpan.GetDuration().GetSecondDouble() * ResampleRate);
const FbxTime TimeIncrement = (NumSamplingKeys > 1)? AnimTimeSpan.GetDuration() / (NumSamplingKeys - 1) : AnimTimeSpan.GetDuration();
for(int32 SourceTrackIdx = 0; SourceTrackIdx < FbxRawBoneNames.Num(); ++SourceTrackIdx)
{
int32 NumKeysForTrack = 0;
// see if it's found in Skeleton
FName BoneName = FbxRawBoneNames[SourceTrackIdx];
int32 BoneTreeIndex = RefSkeleton.FindBoneIndex(BoneName);
// update status
FFormatNamedArguments Args;
Args.Add(TEXT("TrackName"), FText::FromName(BoneName));
Args.Add(TEXT("TotalKey"), FText::AsNumber(NumSamplingKeys));
Args.Add(TEXT("TrackIndex"), FText::AsNumber(SourceTrackIdx+1));
Args.Add(TEXT("TotalTracks"), FText::AsNumber(FbxRawBoneNames.Num()));
const FText StatusUpate = FText::Format(LOCTEXT("ImportingAnimTrackDetail", "Importing Animation Track [{TrackName}] ({TrackIndex}/{TotalTracks}) - TotalKey {TotalKey}"), Args);
GWarn->StatusForceUpdate(SourceTrackIdx + 1, FbxRawBoneNames.Num(), StatusUpate);
if (BoneTreeIndex!=INDEX_NONE)
{
bool bSuccess = true;
FRawAnimSequenceTrack RawTrack;
RawTrack.PosKeys.Empty();
RawTrack.RotKeys.Empty();
RawTrack.ScaleKeys.Empty();
AnimationTransformDebug::FAnimationTransformDebugData NewDebugData;
FbxNode* Link = SortedLinks[SourceTrackIdx];
FbxNode * LinkParent = Link->GetParent();
for(FbxTime CurTime = AnimTimeSpan.GetStart(); CurTime <= AnimTimeSpan.GetStop(); CurTime += TimeIncrement)
{
// save global trasnform
FbxAMatrix GlobalMatrix = Link->EvaluateGlobalTransform(CurTime);
// we'd like to verify this before going to Transform.
// currently transform has tons of NaN check, so it will crash there
FMatrix GlobalUEMatrix = Converter.ConvertMatrix(GlobalMatrix);
if (GlobalUEMatrix.ContainsNaN())
{
bSuccess = false;
AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, FText::Format(LOCTEXT("Error_InvalidTransform",
"Track {0} contains invalid transform. Could not import the track."), FText::FromName(BoneName))), FFbxErrors::Animation_TransformError);
break;
}
FTransform GlobalTransform = Converter.ConvertTransform(GlobalMatrix);
if (GlobalTransform.ContainsNaN())
{
bSuccess = false;
AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, FText::Format(LOCTEXT("Error_InvalidUnrealTransform",
"Track {0} did not yeild valid transform. Please report this to animation team."), FText::FromName(BoneName))), FFbxErrors::Animation_TransformError);
break;
}
// debug data, including import transformation
FTransform AddedTransform(AddedMatrix);
NewDebugData.SourceGlobalTransform.Add(GlobalTransform * AddedTransform);
FTransform LocalTransform;
if( !bPreserveLocalTransform && LinkParent)
{
// I can't rely on LocalMatrix. I need to recalculate quaternion/scale based on global transform if Parent exists
FbxAMatrix ParentGlobalMatrix = Link->GetParent()->EvaluateGlobalTransform(CurTime);
FTransform ParentGlobalTransform = Converter.ConvertTransform(ParentGlobalMatrix);
LocalTransform = GlobalTransform.GetRelativeTransform(ParentGlobalTransform);
NewDebugData.SourceParentGlobalTransform.Add(ParentGlobalTransform);
}
else
{
FbxAMatrix& LocalMatrix = Link->EvaluateLocalTransform(CurTime);
FbxVector4 NewLocalT = LocalMatrix.GetT();
FbxVector4 NewLocalS = LocalMatrix.GetS();
FbxQuaternion NewLocalQ = LocalMatrix.GetQ();
LocalTransform.SetTranslation(Converter.ConvertPos(NewLocalT));
LocalTransform.SetScale3D(Converter.ConvertScale(NewLocalS));
LocalTransform.SetRotation(Converter.ConvertRotToQuat(NewLocalQ));
NewDebugData.SourceParentGlobalTransform.Add(FTransform::Identity);
}
if(TemplateData && BoneTreeIndex == 0)
{
// If we found template data earlier, apply the import transform matrix to
// the root track.
LocalTransform.SetFromMatrix(LocalTransform.ToMatrixWithScale() * AddedMatrix);
}
if (LocalTransform.ContainsNaN())
{
bSuccess = false;
AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, FText::Format(LOCTEXT("Error_InvalidUnrealLocalTransform",
"Track {0} did not yeild valid local transform. Please report this to animation team."), FText::FromName(BoneName))), FFbxErrors::Animation_TransformError);
break;
}
RawTrack.ScaleKeys.Add(LocalTransform.GetScale3D());
RawTrack.PosKeys.Add(LocalTransform.GetTranslation());
RawTrack.RotKeys.Add(LocalTransform.GetRotation());
NewDebugData.RecalculatedLocalTransform.Add(LocalTransform);
++NumKeysForTrack;
}
if (bSuccess)
{
//add new track
int32 NewTrackIdx = RawAnimationData.Add(RawTrack);
DestSeq->AnimationTrackNames.Add(BoneName);
NewDebugData.SetTrackData(NewTrackIdx, BoneTreeIndex, BoneName);
// add mapping to skeleton bone track
DestSeq->TrackToSkeletonMapTable.Add(FTrackToSkeletonMap(BoneTreeIndex));
TransformDebugData.Add(NewDebugData);
}
}
TotalNumKeys = FMath::Max( TotalNumKeys, NumKeysForTrack );
}
DestSeq->NumFrames = TotalNumKeys;
GWarn->EndSlowTask();
}
// compress animation
{
GWarn->BeginSlowTask( LOCTEXT("BeginCompressAnimation", "Compress Animation"), true);
GWarn->StatusForceUpdate(1, 1, LOCTEXT("CompressAnimation", "Compressing Animation"));
// if source data exists, you should bake it to Raw to apply
if(bSourceDataExists)
{
DestSeq->BakeTrackCurvesToRawAnimation();
}
else
{
// otherwise just compress
DestSeq->PostProcessSequence();
}
// run debug mode
AnimationTransformDebug::OutputAnimationTransformDebugData(TransformDebugData, TotalNumKeys, RefSkeleton);
GWarn->EndSlowTask();
}
return true;
}
/**
* Process and update the vertex Influences using the raw binary import data
*
* @param ImportData - raw binary import data to process
*/
void ProcessImportMeshInfluences(FSkeletalMeshImportData& ImportData)
{
TArray <FVector>& Points = ImportData.Points;
TArray <VVertex>& Wedges = ImportData.Wedges;
TArray <VRawBoneInfluence>& Influences = ImportData.Influences;
// Sort influences by vertex index.
struct FCompareVertexIndex
{
bool operator()( const VRawBoneInfluence& A, const VRawBoneInfluence& B ) const
{
if ( A.VertexIndex > B.VertexIndex ) return false;
else if ( A.VertexIndex < B.VertexIndex ) return true;
else if ( A.Weight < B.Weight ) return false;
else if ( A.Weight > B.Weight ) return true;
else if ( A.BoneIndex > B.BoneIndex ) return false;
else if ( A.BoneIndex < B.BoneIndex ) return true;
else return false;
}
};
Influences.Sort( FCompareVertexIndex() );
TArray <VRawBoneInfluence> NewInfluences;
int32 LastNewInfluenceIndex=0;
int32 LastVertexIndex = INDEX_NONE;
int32 InfluenceCount = 0;
float TotalWeight = 0.f;
const float MINWEIGHT = 0.01f;
for( int32 i=0; i<Influences.Num(); i++ )
{
// we found next verts, normalize it now
if (LastVertexIndex != Influences[i].VertexIndex )
{
// Normalize the last set of influences.
if (InfluenceCount && (TotalWeight != 1.0f))
{
float OneOverTotalWeight = 1.f / TotalWeight;
for (int r = 0; r < InfluenceCount; r++)
{
NewInfluences[LastNewInfluenceIndex - r].Weight *= OneOverTotalWeight;
}
}
// now we insert missing verts
if (LastVertexIndex != INDEX_NONE)
{
int32 CurrentVertexIndex = Influences[i].VertexIndex;
for(int32 j=LastVertexIndex+1; j<CurrentVertexIndex; j++)
{
// Add a 0-bone weight if none other present (known to happen with certain MAX skeletal setups).
LastNewInfluenceIndex = NewInfluences.AddUninitialized();
NewInfluences[LastNewInfluenceIndex].VertexIndex = j;
NewInfluences[LastNewInfluenceIndex].BoneIndex = 0;
NewInfluences[LastNewInfluenceIndex].Weight = 1.f;
}
}
// clear to count next one
InfluenceCount = 0;
TotalWeight = 0.f;
LastVertexIndex = Influences[i].VertexIndex;
}
// if less than min weight, or it's more than 8, then we clear it to use weight
if (Influences[i].Weight > MINWEIGHT && InfluenceCount < MAX_TOTAL_INFLUENCES)
{
LastNewInfluenceIndex = NewInfluences.Add(Influences[i]);
InfluenceCount++;
TotalWeight += Influences[i].Weight;
}
}
Influences = NewInfluences;
// Ensure that each vertex has at least one influence as e.g. CreateSkinningStream relies on it.
// The below code relies on influences being sorted by vertex index.
if( Influences.Num() == 0 )
{
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
// warn about no influences
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Warning, LOCTEXT("WarningNoSkelInfluences", "Warning skeletal mesh is has no vertex influences")), FFbxErrors::SkeletalMesh_NoInfluences);
// add one for each wedge entry
Influences.AddUninitialized(Wedges.Num());
for( int32 WedgeIdx=0; WedgeIdx<Wedges.Num(); WedgeIdx++ )
{
Influences[WedgeIdx].VertexIndex = WedgeIdx;
Influences[WedgeIdx].BoneIndex = 0;
Influences[WedgeIdx].Weight = 1.0f;
}
for(int32 i=0; i<Influences.Num(); i++)
{
int32 CurrentVertexIndex = Influences[i].VertexIndex;
if(LastVertexIndex != CurrentVertexIndex)
{
for(int32 j=LastVertexIndex+1; j<CurrentVertexIndex; j++)
{
// Add a 0-bone weight if none other present (known to happen with certain MAX skeletal setups).
Influences.InsertUninitialized(i, 1);
Influences[i].VertexIndex = j;
Influences[i].BoneIndex = 0;
Influences[i].Weight = 1.f;
}
LastVertexIndex = CurrentVertexIndex;
}
}
}
}
bool UEditorEngine::ReimportFbxAnimation( USkeleton* Skeleton, UAnimSequence* AnimSequence, UFbxAnimSequenceImportData* ImportData, const TCHAR* InFilename)
{
check(Skeleton);
GWarn->BeginSlowTask( LOCTEXT("ImportingFbxAnimations", "Importing FBX animations"), true );
UnFbx::FFbxImporter* FbxImporter = UnFbx::FFbxImporter::GetInstance();
// logger for all error/warnings
// this one prints all messages that are stored in FFbxImporter
UnFbx::FFbxLoggerSetter Logger(FbxImporter);
const bool bPrevImportMorph = (AnimSequence->RawCurveData.FloatCurves.Num() > 0) ;
if ( ImportData )
{
// Prepare the import options
UFbxImportUI* ReimportUI = NewObject<UFbxImportUI>();
ReimportUI->MeshTypeToImport = FBXIT_Animation;
ReimportUI->bOverrideFullName = false;
ReimportUI->AnimSequenceImportData = ImportData;
ApplyImportUIToImportOptions(ReimportUI, *FbxImporter->ImportOptions);
}
else
{
FbxImporter->ImportOptions->ResetForReimportAnimation();
}
if ( !FbxImporter->ImportFromFile( InFilename, FPaths::GetExtension( InFilename ) ) )
{
// Log the error message and fail the import.
FbxImporter->FlushToTokenizedErrorMessage(EMessageSeverity::Error);
}
else
{
// Log the import message and import the mesh.
FbxImporter->FlushToTokenizedErrorMessage(EMessageSeverity::Warning);
const FString Filename( InFilename );
// Get Mesh nodes array that bind to the skeleton system, then morph animation is imported.
TArray<FbxNode*> FBXMeshNodeArray;
FbxNode* SkeletonRoot = FbxImporter->FindFBXMeshesByBone(Skeleton->GetReferenceSkeleton().GetBoneName(0), true, FBXMeshNodeArray);
if (!SkeletonRoot)
{
FbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, FText::Format(LOCTEXT("Error_CouldNotFindFbxTrack", "Mesh contains {0} bone as root but animation doesn't contain the root track.\nImport failed."), FText::FromName(Skeleton->GetReferenceSkeleton().GetBoneName(0)))), FFbxErrors::Animation_CouldNotFindTrack);
FbxImporter->ReleaseScene();
GWarn->EndSlowTask();
return false;
}
// for now import all the time?
bool bImportMorphTracks = true;
// Check for blend shape curves that are not skinned. Unskinned geometry can still contain morph curves
if( bImportMorphTracks )
{
TArray<FbxNode*> MeshNodes;
FbxImporter->FillFbxMeshArray( FbxImporter->Scene->GetRootNode(), MeshNodes, FbxImporter );
for( int32 NodeIndex = 0; NodeIndex < MeshNodes.Num(); ++NodeIndex )
{
// Its possible the nodes already exist so make sure they are only added once
FBXMeshNodeArray.AddUnique( MeshNodes[NodeIndex] );
}
}
TArray<FbxNode*> SortedLinks;
FbxImporter->RecursiveBuildSkeleton(SkeletonRoot, SortedLinks);
if(SortedLinks.Num() == 0)
{
FbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Warning, LOCTEXT("Error_CouldNotBuildValidSkeleton", "Could not create a valid skeleton from the import data that matches the given Skeletal Mesh. Check the bone names of both the Skeletal Mesh for this AnimSet and the animation data you are trying to import.")), FFbxErrors::Animation_CouldNotBuildSkeleton);
}
else
{
// find the correct animation based on import data
FbxAnimStack* CurAnimStack = nullptr;
//ignore the source animation name if there's only one animation in the file.
//this is to make it easier for people who use content creation programs that only export one animation and/or ones that don't allow naming animations
if (FbxImporter->Scene->GetSrcObjectCount(FbxCriteria::ObjectType(FbxAnimStack::ClassId)) > 1 && !ImportData->SourceAnimationName.IsEmpty())
{
CurAnimStack = FbxCast<FbxAnimStack>(FbxImporter->Scene->FindSrcObject(FbxCriteria::ObjectType(FbxAnimStack::ClassId), TCHAR_TO_UTF8(*ImportData->SourceAnimationName), 0));
}
else
{
CurAnimStack = FbxCast<FbxAnimStack>(FbxImporter->Scene->GetSrcObject(FbxCriteria::ObjectType(FbxAnimStack::ClassId), 0));
}
if (CurAnimStack)
{
// set current anim stack
int32 ResampleRate = DEFAULT_SAMPLERATE;
if (FbxImporter->ImportOptions->bResample)
{
ResampleRate = FbxImporter->GetMaxSampleRate(SortedLinks, FBXMeshNodeArray);
}
FbxTimeSpan AnimTimeSpan = FbxImporter->GetAnimationTimeSpan(SortedLinks[0], CurAnimStack);
// for now it's not importing morph - in the future, this should be optional or saved with asset
if (FbxImporter->ValidateAnimStack(SortedLinks, FBXMeshNodeArray, CurAnimStack, ResampleRate, bImportMorphTracks, AnimTimeSpan))
{
FbxImporter->ImportAnimation( Skeleton, AnimSequence, Filename, SortedLinks, FBXMeshNodeArray, CurAnimStack, ResampleRate, AnimTimeSpan);
}
}
else
{
// no track is found
FbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, LOCTEXT("Error_CouldNotFindTrack", "Could not find needed track.")), FFbxErrors::Animation_CouldNotFindTrack);
FbxImporter->ReleaseScene();
GWarn->EndSlowTask();
return false;
}
}
}
FbxImporter->ImportOptions->bImportMorph = bPrevImportMorph;
FbxImporter->ReleaseScene();
GWarn->EndSlowTask();
return true;
}
void FDestructibleMeshEditorViewportClient::ImportFBXChunks()
{
// Get the FBX that we want to import
TArray<FString> OpenFilenames;
IDesktopPlatform* DesktopPlatform = FDesktopPlatformModule::Get();
bool bOpened = false;
if (DesktopPlatform != NULL)
{
bOpened = DesktopPlatform->OpenFileDialog(
NULL,
NSLOCTEXT("UnrealEd", "ImportMatineeSequence", "Import UnrealMatinee Sequence").ToString(),
*(FEditorDirectories::Get().GetLastDirectory(ELastDirectory::GENERIC_IMPORT)),
TEXT(""),
TEXT("FBX document|*.fbx"),
EFileDialogFlags::None,
OpenFilenames);
}
if (bOpened)
{
// Get the filename from dialog
FString ImportFilename = OpenFilenames[0];
FString FileName = OpenFilenames[0];
FEditorDirectories::Get().SetLastDirectory(ELastDirectory::GENERIC_IMPORT, FPaths::GetPath(FileName)); // Save path as default for next time.
const FString FileExtension = FPaths::GetExtension(FileName);
const bool bIsFBX = FCString::Stricmp(*FileExtension, TEXT("FBX")) == 0;
if (bIsFBX)
{
FlushRenderingCommands();
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
if (FFbxImporter->ImportFromFile( *ImportFilename, FPaths::GetExtension( ImportFilename ) ) )
{
TArray<FbxNode*> FbxMeshArray;
FFbxImporter->FillFbxMeshArray(FFbxImporter->Scene->GetRootNode(), FbxMeshArray, FFbxImporter);
UFbxStaticMeshImportData* ImportData = NewObject<UFbxStaticMeshImportData>(GetTransientPackage(), NAME_None, RF_NoFlags, NULL);
TArray<UStaticMesh*> ChunkMeshes;
for (int32 i=0; i < FbxMeshArray.Num(); ++i)
{
UStaticMesh* TempStaticMesh = NULL;
TempStaticMesh = (UStaticMesh*)FFbxImporter->ImportStaticMesh(GetTransientPackage(), FbxMeshArray[i], NAME_None, RF_NoFlags, ImportData, 0);
ChunkMeshes.Add(TempStaticMesh);
}
UDestructibleMesh* DestructibleMesh = DestructibleMeshEditorPtr.Pin()->GetDestructibleMesh();
if (DestructibleMesh)
{
DestructibleMesh->SetupChunksFromStaticMeshes(ChunkMeshes);
}
}
FFbxImporter->ReleaseScene();
// Update the viewport
DestructibleMeshEditorPtr.Pin()->RefreshTool();
DestructibleMeshEditorPtr.Pin()->SetCurrentPreviewDepth(0xFFFFFFFF); // This will get clamped to the max depth
}
else
{
// Invalid filename
}
}
#if WITH_APEX
#endif // WITH_APEX
}
void SetImportOption(UFbxImportUI* ImportUI)
{
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
UnFbx::FBXImportOptions* ImportOptions = FFbxImporter->GetImportOptions();
ApplyImportUIToImportOptions(ImportUI, *ImportOptions);
}
void ImportSkeletalMeshLOD( class USkeletalMesh* SelectedSkelMesh, const FString& Filename, int32 LODLevel )
{
// Check the file extension for FBX. Anything that isn't .FBX is rejected
const FString FileExtension = FPaths::GetExtension(Filename);
const bool bIsFBX = FCString::Stricmp(*FileExtension, TEXT("FBX")) == 0;
if (bIsFBX)
{
#if WITH_APEX_CLOTHING
FClothingBackup ClothingBackup;
if(LODLevel == 0)
{
ApexClothingUtils::BackupClothingDataFromSkeletalMesh(SelectedSkelMesh, ClothingBackup);
}
#endif// #if WITH_APEX_CLOTHING
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
// don't import material and animation
UnFbx::FBXImportOptions* ImportOptions = FFbxImporter->GetImportOptions();
ImportOptions->bImportMaterials = false;
ImportOptions->bImportTextures = false;
ImportOptions->bImportAnimations = false;
if ( !FFbxImporter->ImportFromFile( *Filename, FPaths::GetExtension( Filename ) ) )
{
// Log the error message and fail the import.
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, LOCTEXT("FBXImport_ParseFailed", "FBX file parsing failed.")), FFbxErrors::Generic_FBXFileParseFailed);
}
else
{
bool bUseLODs = true;
int32 MaxLODLevel = 0;
TArray< TArray<FbxNode*>* > MeshArray;
TArray<FString> LODStrings;
TArray<FbxNode*>* MeshObject = NULL;;
// Populate the mesh array
FFbxImporter->FillFbxSkelMeshArrayInScene(FFbxImporter->Scene->GetRootNode(), MeshArray, false);
// Nothing found, error out
if (MeshArray.Num() == 0)
{
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, LOCTEXT("FBXImport_NoMesh", "No meshes were found in file.")), FFbxErrors::Generic_MeshNotFound);
FFbxImporter->ReleaseScene();
return;
}
MeshObject = MeshArray[0];
// check if there is LODGroup for this skeletal mesh
for (int32 j = 0; j < MeshObject->Num(); j++)
{
FbxNode* Node = (*MeshObject)[j];
if (Node->GetNodeAttribute() && Node->GetNodeAttribute()->GetAttributeType() == FbxNodeAttribute::eLODGroup)
{
// get max LODgroup level
if (MaxLODLevel < (Node->GetChildCount() - 1))
{
MaxLODLevel = Node->GetChildCount() - 1;
}
}
}
// No LODs found, switch to supporting a mesh array containing meshes instead of LODs
if (MaxLODLevel == 0)
{
bUseLODs = false;
MaxLODLevel = SelectedSkelMesh->LODInfo.Num();
}
// Create LOD dropdown strings
LODStrings.AddZeroed(MaxLODLevel + 1);
LODStrings[0] = FString::Printf( TEXT("Base") );
for(int32 i = 1; i < MaxLODLevel + 1; i++)
{
LODStrings[i] = FString::Printf(TEXT("%d"), i);
}
int32 SelectedLOD = LODLevel;
if (SelectedLOD > SelectedSkelMesh->LODInfo.Num())
{
// Make sure they don't manage to select a bad LOD index
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Warning, FText::Format(LOCTEXT("FBXImport_InvalidLODIdx", "Invalid mesh LOD index {0}, no prior LOD index exists"), FText::AsNumber(SelectedLOD))), FFbxErrors::Generic_Mesh_LOD_InvalidIndex);
}
else
{
TArray<FbxNode*> SkelMeshNodeArray;
if (bUseLODs || ImportOptions->bImportMorph)
{
for (int32 j = 0; j < MeshObject->Num(); j++)
{
FbxNode* Node = (*MeshObject)[j];
if (Node->GetNodeAttribute() && Node->GetNodeAttribute()->GetAttributeType() == FbxNodeAttribute::eLODGroup)
{
if (Node->GetChildCount() > SelectedLOD)
{
SkelMeshNodeArray.Add(Node->GetChild(SelectedLOD));
}
else // in less some LODGroups have less level, use the last level
{
SkelMeshNodeArray.Add(Node->GetChild(Node->GetChildCount() - 1));
}
}
else
{
SkelMeshNodeArray.Add(Node);
}
}
}
// Import mesh
USkeletalMesh* TempSkelMesh = NULL;
// @todo AssetImportData does this temp skeletal mesh need import data?
UFbxSkeletalMeshImportData* TempAssetImportData = NULL;
TempSkelMesh = (USkeletalMesh*)FFbxImporter->ImportSkeletalMesh(GetTransientPackage(), bUseLODs? SkelMeshNodeArray: *MeshObject, NAME_None, (EObjectFlags)0, TempAssetImportData);
// Add imported mesh to existing model
bool bImportSucceeded = false;
if( TempSkelMesh )
{
bImportSucceeded = FFbxImporter->ImportSkeletalMeshLOD(TempSkelMesh, SelectedSkelMesh, SelectedLOD);
// Mark package containing skeletal mesh as dirty.
SelectedSkelMesh->MarkPackageDirty();
}
if(ImportOptions->bImportMorph)
{
FFbxImporter->ImportFbxMorphTarget(SkelMeshNodeArray, SelectedSkelMesh, SelectedSkelMesh->GetOutermost(), SelectedLOD);
}
if (bImportSucceeded)
{
// Notification of success
FNotificationInfo NotificationInfo(FText::GetEmpty());
NotificationInfo.Text = FText::Format(NSLOCTEXT("UnrealEd", "LODImportSuccessful", "Mesh for LOD {0} imported successfully!"), FText::AsNumber(SelectedLOD));
NotificationInfo.ExpireDuration = 5.0f;
FSlateNotificationManager::Get().AddNotification(NotificationInfo);
}
else
{
// Notification of failure
FNotificationInfo NotificationInfo(FText::GetEmpty());
NotificationInfo.Text = FText::Format(NSLOCTEXT("UnrealEd", "LODImportFail", "Failed to import mesh for LOD {0}!"), FText::AsNumber(SelectedLOD));
NotificationInfo.ExpireDuration = 5.0f;
FSlateNotificationManager::Get().AddNotification(NotificationInfo);
}
}
// Cleanup
for (int32 i=0; i<MeshArray.Num(); i++)
{
delete MeshArray[i];
}
}
FFbxImporter->ReleaseScene();
#if WITH_APEX_CLOTHING
if(LODLevel == 0)
{
ApexClothingUtils::ReapplyClothingDataToSkeletalMesh(SelectedSkelMesh, ClothingBackup);
}
ApexClothingUtils::ReImportClothingSectionsFromClothingAsset(SelectedSkelMesh);
#endif// #if WITH_APEX_CLOTHING
}
}
UObject* UFbxFactory::FactoryCreateBinary
(
UClass* Class,
UObject* InParent,
FName Name,
EObjectFlags Flags,
UObject* Context,
const TCHAR* Type,
const uint8*& Buffer,
const uint8* BufferEnd,
FFeedbackContext* Warn,
bool& bOutOperationCanceled
)
{
if( bOperationCanceled )
{
bOutOperationCanceled = true;
FEditorDelegates::OnAssetPostImport.Broadcast(this, NULL);
return NULL;
}
FEditorDelegates::OnAssetPreImport.Broadcast(this, Class, InParent, Name, Type);
UObject* NewObject = NULL;
if ( bDetectImportTypeOnImport )
{
if ( !DetectImportType(UFactory::CurrentFilename) )
{
// Failed to read the file info, fail the import
FEditorDelegates::OnAssetPostImport.Broadcast(this, NULL);
return NULL;
}
}
// logger for all error/warnings
// this one prints all messages that are stored in FFbxImporter
UnFbx::FFbxImporter* FbxImporter = UnFbx::FFbxImporter::GetInstance();
UnFbx::FFbxLoggerSetter Logger(FbxImporter);
EFBXImportType ForcedImportType = FBXIT_StaticMesh;
bool bIsObjFormat = false;
if( FString(Type).Equals(TEXT("obj"), ESearchCase::IgnoreCase ) )
{
bIsObjFormat = true;
}
bool bShowImportDialog = bShowOption && !GIsAutomationTesting;
bool bImportAll = false;
UnFbx::FBXImportOptions* ImportOptions = GetImportOptions(FbxImporter, ImportUI, bShowImportDialog, InParent->GetPathName(), bOperationCanceled, bImportAll, bIsObjFormat, bIsObjFormat, ForcedImportType );
bOutOperationCanceled = bOperationCanceled;
if( bImportAll )
{
// If the user chose to import all, we don't show the dialog again and use the same settings for each object until importing another set of files
bShowOption = false;
}
// For multiple files, use the same settings
bDetectImportTypeOnImport = false;
if (ImportOptions)
{
Warn->BeginSlowTask( NSLOCTEXT("FbxFactory", "BeginImportingFbxMeshTask", "Importing FBX mesh"), true );
if ( !FbxImporter->ImportFromFile( *UFactory::CurrentFilename, Type ) )
{
// Log the error message and fail the import.
Warn->Log(ELogVerbosity::Error, FbxImporter->GetErrorMessage() );
}
else
{
// Log the import message and import the mesh.
const TCHAR* errorMessage = FbxImporter->GetErrorMessage();
if (errorMessage[0] != '\0')
{
Warn->Log( errorMessage );
}
FbxNode* RootNodeToImport = NULL;
RootNodeToImport = FbxImporter->Scene->GetRootNode();
// For animation and static mesh we assume there is at lease one interesting node by default
int32 InterestingNodeCount = 1;
TArray< TArray<FbxNode*>* > SkelMeshArray;
bool bImportStaticMeshLODs = ImportUI->StaticMeshImportData->bImportMeshLODs;
bool bCombineMeshes = ImportUI->bCombineMeshes;
if ( ImportUI->MeshTypeToImport == FBXIT_SkeletalMesh )
{
FbxImporter->FillFbxSkelMeshArrayInScene(RootNodeToImport, SkelMeshArray, false);
InterestingNodeCount = SkelMeshArray.Num();
}
else if( ImportUI->MeshTypeToImport == FBXIT_StaticMesh )
{
FbxImporter->ApplyTransformSettingsToFbxNode(RootNodeToImport, ImportUI->StaticMeshImportData);
if( bCombineMeshes && !bImportStaticMeshLODs )
{
// If Combine meshes and dont import mesh LODs, the interesting node count should be 1 so all the meshes are grouped together into one static mesh
InterestingNodeCount = 1;
}
else
{
// count meshes in lod groups if we dont care about importing LODs
bool bCountLODGroupMeshes = !bImportStaticMeshLODs;
int32 NumLODGroups = 0;
InterestingNodeCount = FbxImporter->GetFbxMeshCount(RootNodeToImport,bCountLODGroupMeshes,NumLODGroups);
// if there were LODs in the file, do not combine meshes even if requested
if( bImportStaticMeshLODs && bCombineMeshes )
{
bCombineMeshes = NumLODGroups == 0;
}
}
}
if (InterestingNodeCount > 1)
{
// the option only works when there are only one asset
ImportOptions->bUsedAsFullName = false;
}
const FString Filename( UFactory::CurrentFilename );
if (RootNodeToImport && InterestingNodeCount > 0)
{
int32 NodeIndex = 0;
int32 ImportedMeshCount = 0;
UStaticMesh* NewStaticMesh = NULL;
if ( ImportUI->MeshTypeToImport == FBXIT_StaticMesh ) // static mesh
{
if (bCombineMeshes)
{
TArray<FbxNode*> FbxMeshArray;
FbxImporter->FillFbxMeshArray(RootNodeToImport, FbxMeshArray, FbxImporter);
if (FbxMeshArray.Num() > 0)
{
NewStaticMesh = FbxImporter->ImportStaticMeshAsSingle(InParent, FbxMeshArray, Name, Flags, ImportUI->StaticMeshImportData, NULL, 0);
}
ImportedMeshCount = NewStaticMesh ? 1 : 0;
}
else
{
TArray<UObject*> AllNewAssets;
UObject* Object = RecursiveImportNode(FbxImporter,RootNodeToImport,InParent,Name,Flags,NodeIndex,InterestingNodeCount, AllNewAssets);
NewStaticMesh = Cast<UStaticMesh>( Object );
// Make sure to notify the asset registry of all assets created other than the one returned, which will notify the asset registry automatically.
for ( auto AssetIt = AllNewAssets.CreateConstIterator(); AssetIt; ++AssetIt )
{
UObject* Asset = *AssetIt;
if ( Asset != NewStaticMesh )
{
FAssetRegistryModule::AssetCreated(Asset);
Asset->MarkPackageDirty();
}
}
ImportedMeshCount = AllNewAssets.Num();
}
// Importing static mesh sockets only works if one mesh is being imported
if( ImportedMeshCount == 1 && NewStaticMesh )
{
FbxImporter->ImportStaticMeshSockets( NewStaticMesh );
}
NewObject = NewStaticMesh;
}
else if ( ImportUI->MeshTypeToImport == FBXIT_SkeletalMesh )// skeletal mesh
{
int32 TotalNumNodes = 0;
for (int32 i = 0; i < SkelMeshArray.Num(); i++)
{
TArray<FbxNode*> NodeArray = *SkelMeshArray[i];
TotalNumNodes += NodeArray.Num();
// check if there is LODGroup for this skeletal mesh
int32 MaxLODLevel = 1;
for (int32 j = 0; j < NodeArray.Num(); j++)
{
FbxNode* Node = NodeArray[j];
if (Node->GetNodeAttribute() && Node->GetNodeAttribute()->GetAttributeType() == FbxNodeAttribute::eLODGroup)
{
// get max LODgroup level
if (MaxLODLevel < Node->GetChildCount())
{
MaxLODLevel = Node->GetChildCount();
}
}
}
int32 LODIndex;
bool bImportSkeletalMeshLODs = ImportUI->SkeletalMeshImportData->bImportMeshLODs;
for (LODIndex = 0; LODIndex < MaxLODLevel; LODIndex++)
{
if ( !bImportSkeletalMeshLODs && LODIndex > 0) // not import LOD if UI option is OFF
{
break;
}
TArray<FbxNode*> SkelMeshNodeArray;
for (int32 j = 0; j < NodeArray.Num(); j++)
{
FbxNode* Node = NodeArray[j];
if (Node->GetNodeAttribute() && Node->GetNodeAttribute()->GetAttributeType() == FbxNodeAttribute::eLODGroup)
{
if (Node->GetChildCount() > LODIndex)
{
SkelMeshNodeArray.Add(Node->GetChild(LODIndex));
}
else // in less some LODGroups have less level, use the last level
{
SkelMeshNodeArray.Add(Node->GetChild(Node->GetChildCount() - 1));
}
}
else
{
SkelMeshNodeArray.Add(Node);
}
}
if (LODIndex == 0 && SkelMeshNodeArray.Num() != 0)
{
FName OutputName = FbxImporter->MakeNameForMesh(Name.ToString(), SkelMeshNodeArray[0]);
USkeletalMesh* NewMesh = FbxImporter->ImportSkeletalMesh( InParent, SkelMeshNodeArray, OutputName, Flags, ImportUI->SkeletalMeshImportData, &bOperationCanceled );
NewObject = NewMesh;
if(bOperationCanceled)
{
// User cancelled, clean up and return
FbxImporter->ReleaseScene();
Warn->EndSlowTask();
bOperationCanceled = true;
return nullptr;
}
if ( NewMesh && ImportUI->bImportAnimations )
{
// We need to remove all scaling from the root node before we set up animation data.
// Othewise some of the global transform calculations will be incorrect.
FbxImporter->RemoveTransformSettingsFromFbxNode(RootNodeToImport, ImportUI->SkeletalMeshImportData);
FbxImporter->SetupAnimationDataFromMesh(NewMesh, InParent, SkelMeshNodeArray, ImportUI->AnimSequenceImportData, OutputName.ToString());
// Reapply the transforms for the rest of the import
FbxImporter->ApplyTransformSettingsToFbxNode(RootNodeToImport, ImportUI->SkeletalMeshImportData);
}
}
else if (NewObject) // the base skeletal mesh is imported successfully
{
USkeletalMesh* BaseSkeletalMesh = Cast<USkeletalMesh>(NewObject);
FName LODObjectName = NAME_None;
USkeletalMesh *LODObject = FbxImporter->ImportSkeletalMesh( GetTransientPackage(), SkelMeshNodeArray, LODObjectName, RF_NoFlags, ImportUI->SkeletalMeshImportData, &bOperationCanceled );
bool bImportSucceeded = !bOperationCanceled && FbxImporter->ImportSkeletalMeshLOD(LODObject, BaseSkeletalMesh, LODIndex, false);
if (bImportSucceeded)
{
BaseSkeletalMesh->LODInfo[LODIndex].ScreenSize = 1.0f / (MaxLODLevel * LODIndex);
}
else
{
FbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, LOCTEXT("FailedToImport_SkeletalMeshLOD", "Failed to import Skeletal mesh LOD.")), FFbxErrors::SkeletalMesh_LOD_FailedToImport);
}
}
// import morph target
if ( NewObject && ImportUI->SkeletalMeshImportData->bImportMorphTargets)
{
// Disable material importing when importing morph targets
uint32 bImportMaterials = ImportOptions->bImportMaterials;
ImportOptions->bImportMaterials = 0;
FbxImporter->ImportFbxMorphTarget(SkelMeshNodeArray, Cast<USkeletalMesh>(NewObject), InParent, LODIndex);
ImportOptions->bImportMaterials = !!bImportMaterials;
}
}
if (NewObject)
{
NodeIndex++;
FFormatNamedArguments Args;
Args.Add( TEXT("NodeIndex"), NodeIndex );
Args.Add( TEXT("ArrayLength"), SkelMeshArray.Num() );
GWarn->StatusUpdate( NodeIndex, SkelMeshArray.Num(), FText::Format( NSLOCTEXT("UnrealEd", "Importingf", "Importing ({NodeIndex} of {ArrayLength})"), Args ) );
}
}
for (int32 i = 0; i < SkelMeshArray.Num(); i++)
{
delete SkelMeshArray[i];
}
// if total nodes we found is 0, we didn't find anything.
if (TotalNumNodes == 0)
{
FbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, LOCTEXT("FailedToImport_NoMeshFoundOnRoot", "Could not find any valid mesh on the root hierarchy. If you have mesh in the sub hierarchy, please enable option of [Import Meshes In Bone Hierarchy] when import.")),
FFbxErrors::SkeletalMesh_NoMeshFoundOnRoot);
}
}
else if ( ImportUI->MeshTypeToImport == FBXIT_Animation )// animation
{
if (ImportOptions->SkeletonForAnimation)
{
// will return the last animation sequence that were added
NewObject = UEditorEngine::ImportFbxAnimation( ImportOptions->SkeletonForAnimation, InParent, ImportUI->AnimSequenceImportData, *Filename, *Name.ToString(), true );
}
}
}
else
{
if (RootNodeToImport == NULL)
{
FbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, LOCTEXT("FailedToImport_InvalidRoot", "Could not find root node.")), FFbxErrors::SkeletalMesh_InvalidRoot);
}
else if (ImportUI->MeshTypeToImport == FBXIT_SkeletalMesh)
{
FbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, LOCTEXT("FailedToImport_InvalidBone", "Failed to find any bone hierarchy. Try disabling the \"Import As Skeletal\" option to import as a rigid mesh. ")), FFbxErrors::SkeletalMesh_InvalidBone);
}
else
{
FbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, LOCTEXT("FailedToImport_InvalidNode", "Could not find any node.")), FFbxErrors::SkeletalMesh_InvalidNode);
}
}
}
if (NewObject == NULL)
{
FbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, LOCTEXT("FailedToImport_NoObject", "Import failed.")), FFbxErrors::Generic_ImportingNewObjectFailed);
}
FbxImporter->ReleaseScene();
Warn->EndSlowTask();
}
FEditorDelegates::OnAssetPostImport.Broadcast(this, NewObject);
return NewObject;
}
void ImportMeshLODDialog( class UObject* SelectedMesh, int32 LODLevel )
{
if(!SelectedMesh)
{
return;
}
USkeletalMesh* SkeletonMesh = Cast<USkeletalMesh>(SelectedMesh);
UStaticMesh* StaticMesh = Cast<UStaticMesh>(SelectedMesh);
if( !SkeletonMesh && !StaticMesh )
{
return;
}
FString ExtensionStr;
ExtensionStr += TEXT("All model files|*.fbx;*.obj|");
ExtensionStr += TEXT("FBX files|*.fbx|");
ExtensionStr += TEXT("Object files|*.obj|");
ExtensionStr += TEXT("All files|*.*");
// First, display the file open dialog for selecting the file.
TArray<FString> OpenFilenames;
IDesktopPlatform* DesktopPlatform = FDesktopPlatformModule::Get();
bool bOpen = false;
if ( DesktopPlatform )
{
void* ParentWindowWindowHandle = NULL;
IMainFrameModule& MainFrameModule = FModuleManager::LoadModuleChecked<IMainFrameModule>(TEXT("MainFrame"));
const TSharedPtr<SWindow>& MainFrameParentWindow = MainFrameModule.GetParentWindow();
if ( MainFrameParentWindow.IsValid() && MainFrameParentWindow->GetNativeWindow().IsValid() )
{
ParentWindowWindowHandle = MainFrameParentWindow->GetNativeWindow()->GetOSWindowHandle();
}
bOpen = DesktopPlatform->OpenFileDialog(
ParentWindowWindowHandle,
FText::Format( NSLOCTEXT("UnrealEd", "ImportMeshLOD", "Failed to import mesh for LOD {0}!"), FText::AsNumber( LODLevel ) ).ToString(),
*FEditorDirectories::Get().GetLastDirectory(ELastDirectory::FBX),
TEXT(""),
*ExtensionStr,
EFileDialogFlags::None,
OpenFilenames
);
}
// Only continue if we pressed OK and have only one file selected.
if( bOpen )
{
if( OpenFilenames.Num() == 0)
{
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, LOCTEXT("NoFileSelectedForLOD", "No file was selected for the LOD.")), FFbxErrors::Generic_Mesh_LOD_NoFileSelected);
}
else if(OpenFilenames.Num() > 1)
{
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, LOCTEXT("MultipleFilesSelectedForLOD", "You may only select one file for the LOD.")), FFbxErrors::Generic_Mesh_LOD_MultipleFilesSelected);
}
else
{
FString Filename = OpenFilenames[0];
FEditorDirectories::Get().SetLastDirectory(ELastDirectory::FBX, FPaths::GetPath(Filename)); // Save path as default for next time.
if( SkeletonMesh )
{
ImportSkeletalMeshLOD(SkeletonMesh, Filename, LODLevel);
}
else if( StaticMesh )
{
ImportStaticMeshLOD(StaticMesh, Filename, LODLevel);
}
}
}
}
UAnimSequence * UEditorEngine::ImportFbxAnimation( USkeleton* Skeleton, UObject* Outer, UFbxAnimSequenceImportData* TemplateImportData, const TCHAR* InFilename, const TCHAR* AnimName, bool bImportMorphTracks )
{
check(Skeleton);
UAnimSequence * NewAnimation=NULL;
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
const bool bPrevImportMorph = FFbxImporter->ImportOptions->bImportMorph;
FFbxImporter->ImportOptions->bImportMorph = bImportMorphTracks;
if ( !FFbxImporter->ImportFromFile( InFilename, FPaths::GetExtension( InFilename ) ) )
{
// Log the error message and fail the import.
FFbxImporter->FlushToTokenizedErrorMessage(EMessageSeverity::Error);
}
else
{
// Log the import message and import the mesh.
FFbxImporter->FlushToTokenizedErrorMessage(EMessageSeverity::Warning);
const FString Filename( InFilename );
// Get Mesh nodes array that bind to the skeleton system, then morph animation is imported.
TArray<FbxNode*> FBXMeshNodeArray;
FbxNode* SkeletonRoot = FFbxImporter->FindFBXMeshesByBone(Skeleton->GetReferenceSkeleton().GetBoneName(0), true, FBXMeshNodeArray);
if (!SkeletonRoot)
{
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, FText::Format(LOCTEXT("Error_CouldNotFindFbxTrack", "Mesh contains {0} bone as root but animation doesn't contain the root track.\nImport failed."), FText::FromName(Skeleton->GetReferenceSkeleton().GetBoneName(0)))), FFbxErrors::Animation_CouldNotFindRootTrack);
FFbxImporter->ReleaseScene();
return NULL;
}
// Check for blend shape curves that are not skinned. Unskinned geometry can still contain morph curves
if( bImportMorphTracks )
{
TArray<FbxNode*> MeshNodes;
FFbxImporter->FillFbxMeshArray( FFbxImporter->Scene->GetRootNode(), MeshNodes, FFbxImporter );
for( int32 NodeIndex = 0; NodeIndex < MeshNodes.Num(); ++NodeIndex )
{
// Its possible the nodes already exist so make sure they are only added once
FBXMeshNodeArray.AddUnique( MeshNodes[NodeIndex] );
}
}
TArray<FbxNode*> SortedLinks;
FFbxImporter->RecursiveBuildSkeleton(SkeletonRoot, SortedLinks);
if(SortedLinks.Num() == 0)
{
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Warning, LOCTEXT("Error_CouldNotBuildValidSkeleton", "Could not create a valid skeleton from the import data that matches the given Skeletal Mesh. Check the bone names of both the Skeletal Mesh for this AnimSet and the animation data you are trying to import.")),
FFbxErrors::Animation_CouldNotBuildSkeleton);
}
else
{
NewAnimation = FFbxImporter->ImportAnimations( Skeleton, Outer, SortedLinks, AnimName, TemplateImportData, FBXMeshNodeArray);
if( NewAnimation )
{
// since to know full path, reimport will need to do same
UFbxAnimSequenceImportData* ImportData = UFbxAnimSequenceImportData::GetImportDataForAnimSequence(NewAnimation, TemplateImportData);
ImportData->Update(UFactory::CurrentFilename);
}
}
}
FFbxImporter->ImportOptions->bImportMorph = bPrevImportMorph;
FFbxImporter->ReleaseScene();
return NewAnimation;
}
void ImportStaticMeshLOD( UStaticMesh* BaseStaticMesh, const FString& Filename, int32 LODLevel )
{
UE_LOG(LogExportMeshUtils, Log, TEXT("Fbx LOD loading"));
// logger for all error/warnings
// this one prints all messages that are stored in FFbxImporter
// this function seems to get called outside of FBX factory
UnFbx::FFbxImporter* FFbxImporter = UnFbx::FFbxImporter::GetInstance();
UnFbx::FFbxLoggerSetter Logger(FFbxImporter);
// don't import materials
UnFbx::FBXImportOptions* ImportOptions = FFbxImporter->GetImportOptions();
ImportOptions->bImportMaterials = false;
ImportOptions->bImportTextures = false;
if ( !FFbxImporter->ImportFromFile( *Filename, FPaths::GetExtension( Filename ) ) )
{
// Log the error message and fail the import.
// @todo verify if the message works
FFbxImporter->FlushToTokenizedErrorMessage(EMessageSeverity::Error);
}
else
{
FFbxImporter->FlushToTokenizedErrorMessage(EMessageSeverity::Warning);
bool bUseLODs = true;
int32 MaxLODLevel = 0;
TArray< TArray<FbxNode*>* > LODNodeList;
TArray<FString> LODStrings;
// Create a list of LOD nodes
PopulateFBXStaticMeshLODList(FFbxImporter, FFbxImporter->Scene->GetRootNode(), LODNodeList, MaxLODLevel, bUseLODs);
// No LODs, so just grab all of the meshes in the file
if (MaxLODLevel == 0)
{
bUseLODs = false;
MaxLODLevel = BaseStaticMesh->GetNumLODs();
// Create a list of meshes
PopulateFBXStaticMeshLODList(FFbxImporter, FFbxImporter->Scene->GetRootNode(), LODNodeList, MaxLODLevel, bUseLODs);
// Nothing found, error out
if (LODNodeList.Num() == 0)
{
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Error, FText(LOCTEXT("Prompt_NoMeshFound", "No meshes were found in file."))), FFbxErrors::Generic_Mesh_MeshNotFound);
FFbxImporter->ReleaseScene();
return;
}
}
// Display the LOD selection dialog
if (LODLevel > BaseStaticMesh->GetNumLODs())
{
// Make sure they don't manage to select a bad LOD index
FFbxImporter->AddTokenizedErrorMessage(FTokenizedMessage::Create(EMessageSeverity::Warning, FText::Format(LOCTEXT("Prompt_InvalidLODIndex", "Invalid mesh LOD index {0}, as no prior LOD index exists!"), FText::AsNumber(LODLevel))), FFbxErrors::Generic_Mesh_LOD_InvalidIndex);
}
else
{
// Import mesh
UStaticMesh* TempStaticMesh = NULL;
TempStaticMesh = (UStaticMesh*)FFbxImporter->ImportStaticMeshAsSingle(GetTransientPackage(), *(LODNodeList[bUseLODs? LODLevel: 0]), NAME_None, RF_NoFlags, NULL, BaseStaticMesh, LODLevel);
// Add imported mesh to existing model
if( TempStaticMesh )
{
// Update mesh component
BaseStaticMesh->MarkPackageDirty();
// Import worked
FNotificationInfo NotificationInfo(FText::GetEmpty());
NotificationInfo.Text = FText::Format(LOCTEXT("LODImportSuccessful", "Mesh for LOD {0} imported successfully!"), FText::AsNumber(LODLevel));
NotificationInfo.ExpireDuration = 5.0f;
FSlateNotificationManager::Get().AddNotification(NotificationInfo);
}
else
{
// Import failed
FNotificationInfo NotificationInfo(FText::GetEmpty());
NotificationInfo.Text = FText::Format(LOCTEXT("LODImportFail", "Failed to import mesh for LOD {0}!"), FText::AsNumber( LODLevel ));
NotificationInfo.ExpireDuration = 5.0f;
FSlateNotificationManager::Get().AddNotification(NotificationInfo);
}
}
// Cleanup
for (int32 i = 0; i < LODNodeList.Num(); ++i)
{
delete LODNodeList[i];
}
}
FFbxImporter->ReleaseScene();
}
EReimportResult::Type UReimportFbxSceneFactory::Reimport(UObject* Obj)
{
ReimportData = GetFbxSceneImportData(Obj);
if (!ReimportData)
{
return EReimportResult::Failed;
}
//We will call other factory store the filename value since UFactory::CurrentFilename is static
FbxImportFileName = ReimportData->SourceFbxFile;
UnFbx::FFbxImporter* FbxImporter = UnFbx::FFbxImporter::GetInstance();
UnFbx::FFbxLoggerSetter Logger(FbxImporter);
GWarn->BeginSlowTask(NSLOCTEXT("FbxSceneReImportFactory", "BeginReImportingFbxSceneTask", "ReImporting FBX scene"), true);
GlobalImportSettings = FbxImporter->GetImportOptions();
//Fill the original options
for (auto kvp : ReimportData->NameOptionsMap)
{
if (kvp.Key.Compare(DefaultOptionName) == 0)
{
SFbxSceneOptionWindow::CopyFbxOptionsToFbxOptions(kvp.Value, GlobalImportSettings);
NameOptionsMap.Add(kvp.Key, GlobalImportSettings);
}
else
{
NameOptionsMap.Add(kvp.Key, kvp.Value);
}
}
//Always convert the scene
GlobalImportSettings->bConvertScene = true;
GlobalImportSettings->bImportScene = ReimportData->bImportScene;
//Read the fbx and store the hierarchy's information so we can reuse it after importing all the model in the fbx file
if (!FbxImporter->ImportFromFile(*FbxImportFileName, FPaths::GetExtension(FbxImportFileName)))
{
// Log the error message and fail the import.
GWarn->Log(ELogVerbosity::Error, FbxImporter->GetErrorMessage());
FbxImporter->ReleaseScene();
FbxImporter = nullptr;
GWarn->EndSlowTask();
return EReimportResult::Failed;
}
FString PackageName = "";
Obj->GetOutermost()->GetName(PackageName);
Path = FPaths::GetPath(PackageName);
UnFbx::FbxSceneInfo SceneInfo;
//Read the scene and found all instance with their scene information.
FbxImporter->GetSceneInfo(FbxImportFileName, SceneInfo);
//Convert old structure to the new scene export structure
TSharedPtr<FFbxSceneInfo> SceneInfoPtr = ConvertSceneInfo(&SceneInfo);
//Get import material info
ExtractMaterialInfo(FbxImporter, SceneInfoPtr);
if (!ReimportData->bCreateFolderHierarchy)
{
for (TSharedPtr<FFbxMeshInfo> MeshInfo : SceneInfoPtr->MeshInfo)
{
FString AssetName = Path + TEXT("/") + MeshInfo->Name;
MeshInfo->SetOriginalImportPath(AssetName);
FString OriginalFullImportName = PackageTools::SanitizePackageName(AssetName);
OriginalFullImportName = OriginalFullImportName + TEXT(".") + PackageTools::SanitizePackageName(MeshInfo->Name);
MeshInfo->SetOriginalFullImportName(OriginalFullImportName);
}
}
else
{
TSet<uint64> AssetPathDone;
FString AssetPath = Path;
for (TSharedPtr<FFbxNodeInfo> NodeInfo : SceneInfoPtr->HierarchyInfo)
{
//Iterate the hierarchy and build the original path
RecursivelyCreateOriginalPath(FbxImporter, NodeInfo, AssetPath, AssetPathDone);
}
}
FillSceneHierarchyPath(SceneInfoPtr);
FbxSceneReimportStatusMap MeshStatusMap;
FbxSceneReimportStatusMap NodeStatusMap;
bool bCanReimportHierarchy = ReimportData->HierarchyType == (int32)EFBXSceneOptionsCreateHierarchyType::FBXSOCHT_CreateBlueprint && !ReimportData->BluePrintFullName.IsEmpty();
if (!GetFbxSceneReImportOptions(FbxImporter
, SceneInfoPtr
, ReimportData->SceneInfoSourceData
, GlobalImportSettings
, SceneImportOptions
, SceneImportOptionsStaticMesh
, NameOptionsMap
, MeshStatusMap
, NodeStatusMap
, bCanReimportHierarchy
, Path))
{
//User cancel the scene import
FbxImporter->ReleaseScene();
FbxImporter = nullptr;
GlobalImportSettings = nullptr;
GWarn->EndSlowTask();
return EReimportResult::Cancelled;
}
GlobalImportSettingsReference = new UnFbx::FBXImportOptions();
SFbxSceneOptionWindow::CopyFbxOptionsToFbxOptions(GlobalImportSettings, GlobalImportSettingsReference);
//Overwrite the reimport asset data with the new data
ReimportData->SceneInfoSourceData = SceneInfoPtr;
ReimportData->SourceFbxFile = FPaths::ConvertRelativePathToFull(FbxImportFileName);
ReimportData->bImportScene = GlobalImportSettingsReference->bImportScene;
//Copy the options map
ReimportData->NameOptionsMap.Reset();
for (auto kvp : NameOptionsMap)
{
ReimportData->NameOptionsMap.Add(kvp.Key, kvp.Value);
}
FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
TArray<FAssetData> AssetDataToDelete;
for (TSharedPtr<FFbxMeshInfo> MeshInfo : SceneInfoPtr->MeshInfo)
{
//Delete all the delete asset
if (!MeshStatusMap.Contains(MeshInfo->OriginalImportPath))
{
continue;
}
EFbxSceneReimportStatusFlags MeshStatus = *(MeshStatusMap.Find(MeshInfo->OriginalImportPath));
if ((MeshStatus & EFbxSceneReimportStatusFlags::Removed) == EFbxSceneReimportStatusFlags::None || (MeshStatus & EFbxSceneReimportStatusFlags::ReimportAsset) == EFbxSceneReimportStatusFlags::None)
{
continue;
}
//Make sure we load all package that will be deleted
UPackage* PkgExist = LoadPackage(nullptr, *(MeshInfo->GetImportPath()), LOAD_Verify | LOAD_NoWarn);
if (PkgExist == nullptr)
{
continue;
}
PkgExist->FullyLoad();
//Find the asset
AssetDataToDelete.Add(AssetRegistryModule.Get().GetAssetByObjectPath(FName(*(MeshInfo->GetFullImportName()))));
}
AllNewAssets.Empty();
AssetToSyncContentBrowser.Empty();
EReimportResult::Type ReimportResult = EReimportResult::Succeeded;
//Reimport and add asset
for (TSharedPtr<FFbxMeshInfo> MeshInfo : SceneInfoPtr->MeshInfo)
{
if (!MeshStatusMap.Contains(MeshInfo->OriginalImportPath))
{
continue;
}
EFbxSceneReimportStatusFlags MeshStatus = *(MeshStatusMap.Find(MeshInfo->OriginalImportPath));
//Set the import status for the next reimport
MeshInfo->bImportAttribute = (MeshStatus & EFbxSceneReimportStatusFlags::ReimportAsset) != EFbxSceneReimportStatusFlags::None;
if ((MeshStatus & EFbxSceneReimportStatusFlags::Removed) != EFbxSceneReimportStatusFlags::None ||
(MeshStatus & EFbxSceneReimportStatusFlags::ReimportAsset) == EFbxSceneReimportStatusFlags::None)
{
continue;
}
if (((MeshStatus & EFbxSceneReimportStatusFlags::Same) != EFbxSceneReimportStatusFlags::None || (MeshStatus & EFbxSceneReimportStatusFlags::Added) != EFbxSceneReimportStatusFlags::None) &&
(MeshStatus & EFbxSceneReimportStatusFlags::FoundContentBrowserAsset) != EFbxSceneReimportStatusFlags::None)
{
//Reimport over the old asset
if (!MeshInfo->bIsSkelMesh)
{
ReimportResult = ReimportStaticMesh(FbxImporter, MeshInfo);
}
else
{
//TODO reimport skeletal mesh
}
}
else if ((MeshStatus & EFbxSceneReimportStatusFlags::Added) != EFbxSceneReimportStatusFlags::None || (MeshStatus & EFbxSceneReimportStatusFlags::Same) != EFbxSceneReimportStatusFlags::None)
{
//Create a package for this node
//Get Parent hierarchy name to create new package path
ReimportResult = ImportStaticMesh(FbxImporter, MeshInfo, SceneInfoPtr);
}
}
//Put back the default option in the static mesh import data, so next import will have those last import option
SFbxSceneOptionWindow::CopyFbxOptionsToFbxOptions(GlobalImportSettingsReference, GlobalImportSettings);
SFbxSceneOptionWindow::CopyFbxOptionsToStaticMeshOptions(GlobalImportSettingsReference, SceneImportOptionsStaticMesh);
SceneImportOptionsStaticMesh->FillStaticMeshInmportData(StaticMeshImportData, SceneImportOptions);
StaticMeshImportData->SaveConfig();
//Update the blueprint
UBlueprint *ReimportBlueprint = nullptr;
if (bCanReimportHierarchy && GlobalImportSettingsReference->bImportScene)
{
ReimportBlueprint = UpdateOriginalBluePrint(ReimportData->BluePrintFullName, &NodeStatusMap, SceneInfoPtr, ReimportData->SceneInfoSourceData, AssetDataToDelete);
}
//Remove the deleted meshinfo node from the reimport data
TArray<TSharedPtr<FFbxMeshInfo>> ToRemoveHierarchyNode;
for (TSharedPtr<FFbxMeshInfo> MeshInfo : ReimportData->SceneInfoSourceData->MeshInfo)
{
EFbxSceneReimportStatusFlags MeshStatus = *(MeshStatusMap.Find(MeshInfo->OriginalImportPath));
if ((MeshStatus & EFbxSceneReimportStatusFlags::Removed) != EFbxSceneReimportStatusFlags::None)
{
ToRemoveHierarchyNode.Add(MeshInfo);
}
}
for (TSharedPtr<FFbxMeshInfo> MeshInfo : ToRemoveHierarchyNode)
{
ReimportData->SceneInfoSourceData->MeshInfo.Remove(MeshInfo);
}
ReimportData->Modify();
ReimportData->PostEditChange();
//Make sure the content browser is in sync before we delete
FContentBrowserModule& ContentBrowserModule = FModuleManager::Get().LoadModuleChecked<FContentBrowserModule>("ContentBrowser");
ContentBrowserModule.Get().SyncBrowserToAssets(AssetToSyncContentBrowser);
if (AssetDataToDelete.Num() > 0)
{
bool AbortDelete = false;
if (ReimportBlueprint != nullptr)
{
//Save the blueprint to avoid reference from the old blueprint
FAssetData ReimportBlueprintAsset(ReimportBlueprint);
TArray<UPackage*> Packages;
Packages.Add(ReimportBlueprintAsset.GetPackage());
FEditorFileUtils::PromptForCheckoutAndSave(Packages, false, false);
//Make sure the Asset registry is up to date after the save
TArray<FString> Paths;
Paths.Add(ReimportBlueprintAsset.PackagePath.ToString());
AssetRegistryModule.Get().ScanPathsSynchronous(Paths, true);
}
if (!AbortDelete)
{
//Delete the asset and use the normal dialog to make sure the user understand he will remove some content
//The user can decide to cancel the delete or not. This will not interrupt the reimport process
//The delete is done at the end because we want to remove the blueprint reference before deleting object
ObjectTools::DeleteAssets(AssetDataToDelete, true);
}
}
//Make sure the content browser is in sync
ContentBrowserModule.Get().SyncBrowserToAssets(AssetToSyncContentBrowser);
AllNewAssets.Empty();
GlobalImportSettings = nullptr;
GlobalImportSettingsReference = nullptr;
FbxImporter->ReleaseScene();
FbxImporter = nullptr;
GWarn->EndSlowTask();
return EReimportResult::Succeeded;
}
