1. Epic GamesDeveloper
  3. FFbxImporter

FFbxImporter

Main FBX Importer class.

API > API/Editor > API/Editor/UnrealEd

Main FBX Importer class.

   
Name FFbxImporter
Type class
Header File /Engine/Source/Editor/UnrealEd/Public/FbxImporter.h
Include Path #include "FbxImporter.h"

Syntax

class FFbxImporter

Constructors

Name Remarks Include Path Unreal Specifiers

FFbxImporter()

   FbxImporter.h  

Destructors

Name Remarks Include Path Unreal Specifiers

~FFbxImporter()

   FbxImporter.h  

Classes

Name Remarks
FImportSkeletalMeshArgs Creates a skeletal mesh from Fbx Nodes with the given name and flags, imported from within the FBX scene.

Structs

Name Remarks
FAnimCurveImportSettings Helper structure to pass around the common animation parameters.
FFbxMaterial  

Enums

Protected

Name Remarks
IMPORTPHASE  

Constants

Name Type Remarks Include Path
StaticInstance TSharedPtr< FFbxImporter >   FbxImporter.h
StaticPreviewInstance TSharedPtr< FFbxImporter >   FbxImporter.h

Variables

Public

Name Type Remarks Include Path Unreal Specifiers
ImportOptions FBXImportOptions *   FbxImporter.h  
Md5Hash FMD5Hash We cache the hash of the file when we open the file. This is to avoid calculating the hash many time when importing many asset in one fbx file. FbxImporter.h  
Scene FbxScene * Current Fbx scene we are importing. Make sure to release it after import FbxImporter.h  

Protected

Name Type Remarks Include Path Unreal Specifiers
bImportOperationCanceled bool Holds if the current import operation was canceled or not. FbxImporter.h  
ImportedMaterialData FImportedMaterialData   FbxImporter.h  
ImportOperationStack int32 Internal counter used to group import operation together when canceling (ie: Import Skeletal Mesh can trigger Import of Morph Targets.) FbxImporter.h  
Logger FFbxLogger * Logger set/clear function FbxImporter.h  
MeshNamesCache TArray< FString > Cache to create unique name for mesh. This is use to fix name clash. FbxImporter.h  
OriginalFbxFramerate float   FbxImporter.h  

Functions

Public

Name Remarks Include Path Unreal Specifiers

void AddStaticMeshSourceModelGeneratedLOD ( UStaticMesh* StaticMesh,
int32 LODIndex
)

 Add a GeneratedLOD to the staticmesh at the specified LOD index FbxImporter.h  

void AddTokenizedErrorMessage ( TSharedRef< FTokenizedMessage > Error,
FName FbxErrorName
)

 Error message handler FbxImporter.h  

void ApplyTransformSettingsToFbxNode ( FbxNode* Node,
UFbxAssetImportData* AssetData
)

 Apply asset import settings for transform to an FBX node FbxImporter.h  

void BuildFbxMatrixForImportTransform ( FbxAMatrix& OutMatrix,
UFbxAssetImportData* AssetData
)

 Populate the given matrix with the correct information for the asset data, in a format that matches FBX internals or without conversion FbxImporter.h  

void BuildSkeletonSystem ( TArray< FbxCluster* >& ClusterArray,
TArray< FbxNode* >& OutSortedLinks
)

 Fill FBX skeletons to OutSortedLinks FbxImporter.h  

bool CanCreateClass ( UClass* Class
) const

 The asset tool have a filter mecanism for CreateAsset, return true if the asset can be created, false otherwise FbxImporter.h  

bool CanImportClass ( UClass* Class
) const

 The asset tool have a filter mecanism for ImportAsset, return true if the asset can be imported, false otherwise FbxImporter.h  

void ClearAllCaches()

 Clear all data that need to be clear when we start importing a fbx file. FbxImporter.h  

void ClearTokenizedErrorMessages()

   FbxImporter.h  

void ConvertScene ()

 Convert the scene from the current options. FbxImporter.h  

bool FillCollisionModelList ( FbxNode* Node
)

 If the node model is a collision model, then fill it into collision model list FbxImporter.h  

void FillFbxCollisionMeshArray ( FbxNode* Node
)

 Fill the collision models array by going through all mesh node recursively FbxImporter.h  

void FillFbxMeshAndLODGroupArray ( FbxNode* Node,
TArray< FbxNode* >& outLODGroupArray,
TArray< FbxNode* >& outMeshArray
)

 Get all Fbx mesh objects not under a LOD group and all LOD group node FbxImporter.h  

void FillFbxMeshArray ( FbxNode* Node,
TArray< FbxNode* >& outMeshArray,
UnFbx::FFbxImporter* FFbxImporter
)

 Get all Fbx mesh objects FbxImporter.h  

void FillFbxSkelMeshArrayInScene ( FbxNode* Node,
TArray< TArray< FbxNode* >* >& outSkelMeshArray,
bool ExpandLOD,
bool bCombineSkeletalMesh,
bool bForceFindRigid
)

 Get all Fbx skeletal mesh objects in the scene. these meshes are grouped by skeleton they bind to FbxImporter.h  

bool FillSkeletalMeshImportData ( TArray< FbxNode* >& NodeArray,
UFbxSkeletalMeshImportData* TemplateImportData,
TArray< FbxShape* >* FbxShapeArray,
FSkeletalMeshImportData* OutData,
TArray< FbxNode* >& OutImportedSkeletonLinkNodes,
TArray< FName >& LastImportedMaterialNames,
const bool bIsReimport,
const TMap< FVector3f, FColor >& ExistingVertexColorData,
bool& bMapMorphTargetToTimeZero
)

 Fill FSkeletalMeshIMportData from Fbx Nodes and FbxShape Array if exists. FbxImporter.h  

void FindAllLODGroupNode ( TArray< FbxNode* >& OutNodeInLod,
FbxNode* NodeLodGroup,
int32 LodIndex
)

 Find the all the node containing a mesh attribute for the specified LOD index. FbxImporter.h  

FbxNode * FindFBXMeshesByBone ( const FName& RootBoneName,
bool bExpandLOD,
TArray< FbxNode* >& OutFBXMeshNodeArray
)

 Find FBX meshes that match Unreal skeletal mesh according to the bone of mesh FbxImporter.h  

FbxNode * FindLODGroupNode ( FbxNode* NodeLodGroup,
int32 LodIndex,
FbxNode* NodeToFind
)

 Find the first node containing a mesh attribute for the specified LOD index. FbxImporter.h  

void FlushToTokenizedErrorMessage ( enum EMessageSeverity::Type Severity
)

   FbxImporter.h  

void GetAnimationIntervalMultiLayer ( FbxNode* RootNode,
FbxAnimStack* AnimStack,
FbxTimeSpan& AnimTimeSpan
)

 When we get exported time we call GetanimationInterval from fbx sdk and it return the layer 0 by default This function return the sum of all layer instead of just the layer 0. FbxImporter.h  

FbxTimeSpan GetAnimationTimeSpan ( FbxNode* RootNode,
FbxAnimStack* AnimStack
)

 Get Animation Time Span - duration of the animation FbxImporter.h  

const TArray< TWeakObjectPtr< UObject > > & GetCreatedObjects()

 Get the UObjects that have been created so far during the import process. FbxImporter.h  

const TCHAR * GetErrorMessage ()

 Retrieve the FBX loader's error message explaining its failure to read a given FBX file. FbxImporter.h  

FString GetFbxFileVersion()

   FbxImporter.h  

int32 GetFbxMeshCount ( FbxNode* Node,
bool bCountLODs,
int32& OutNumLODGroups
)

 Get mesh count (including static mesh and skeletal mesh, except collision models) and find collision models FbxImporter.h  

FString GetFileAxisDirection()

   FbxImporter.h  

FString GetFileCreator()

   FbxImporter.h  

FString GetFileUnitSystem()

   FbxImporter.h  

FbxGeometryConverter * GetGeometryConverter()

   FbxImporter.h  

int32 GetGlobalAnimStackSampleRate ( FbxAnimStack* CurAnimStack
)

 Calculate the global Sample Rate for all the nodes in the FbxAnimStack pass in parameter FbxImporter.h  

bool GetImportOperationCancelled()

 Returns true if the last import operation was canceled. FbxImporter.h  

FBXImportOptions * GetImportOptions()

 Get the object of import options FbxImporter.h  

int32 GetImportType ( const FString& InFilename
)

 Detect if the FBX file has skeletal mesh model. FbxImporter.h  

int32 GetMaxSampleRate ( TArray< FbxNode* >& SortedLinks
)

 Calculate Max Sample Rate - separate out of the original ImportAnimations FbxImporter.h  

FbxNode * GetMeshNodesFromName ( const FString& ReimportMeshName,
TArray< FbxNode* >& FbxMeshArray
)

 Return the node that match the mesh name. Return nullptr in case there is no match FbxImporter.h  

float GetOriginalFbxFramerate()

   FbxImporter.h  

FbxNode * GetRootSkeleton ( FbxNode* Link
)

 Get Unreal skeleton root from the FBX skeleton node. Mesh and dummy can be used as skeleton. FbxImporter.h  

bool GetSceneInfo ( FString Filename,
FbxSceneInfo& SceneInfo,
bool bPreventMaterialNameClash
)

 Get detail infomation in the Fbx scene FbxImporter.h  

bool ImportAnimation ( USkeleton* Skeleton,
UAnimSequence* DestSeq,
const FString& FileName,
TArray< FbxNode* >& SortedLinks,
TArray< FbxNode* >& NodeArray,
FbxAnimStack* CurAnimStack,
const int32 ResampleRate,
const FbxTimeSpan AnimTimeSpan,
const bool bReimport
)

 Import one animation from CurAnimStack FbxImporter.h  

UAnimSequence * ImportAnimations ( USkeleton* Skeleton,
UObject* Outer,
TArray< FbxNode* >& SortedLinks,
const FString& Name,
UFbxAnimSequenceImportData* TemplateImportData,
TArray< FbxNode* >& NodeArray
)

 Add to the animation set, the animations contained within the FBX scene, for the given skeletal mesh FbxImporter.h  

bool ImportCollisionModels ( UStaticMesh* StaticMesh,
const FbxString& NodeName
)

 Import collision models for one static mesh if it has collision models FbxImporter.h  

void ImportFbxMorphTarget ( TArray< FbxNode* >& SkelMeshNodeArray,
USkeletalMesh* BaseSkelMesh,
int32 LODIndex,
FSkeletalMeshImportData& BaseSkeletalMeshImportData,
const bool bSkinControlPointToTimeZero
)

 Import Fbx Morph object for the Skeletal Mesh. In Fbx, morph object is a property of the Fbx Node. FbxImporter.h  

bool ImportFile ( FString Filename,
bool bPreventMaterialNameClash
)

 Import Fbx file. FbxImporter.h  

bool ImportFromFile ( const FString& Filename,
const FString& Type,
bool bPreventMaterialNameClash
)

 Attempt to load an FBX scene from a given filename. FbxImporter.h  

USkeletalMesh * ImportSkeletalMesh ( FImportSkeletalMeshArgs& ImportSkeletalMeshArgs
)

   FbxImporter.h  

bool ImportSkeletalMeshLOD ( USkeletalMesh* InSkeletalMesh,
USkeletalMesh* BaseSkeletalMesh,
int32 DesiredLOD,
UFbxSkeletalMeshImportData* TemplateImportData
)

 Import LOD object for skeletal mesh FbxImporter.h  

UStaticMesh * ImportStaticMesh ( UObject* InParent,
FbxNode* Node,
const FName& Name,
EObjectFlags Flags,
UFbxStaticMeshImportData* ImportData,
UStaticMesh* InStaticMesh,
int LODIndex,
const FExistingStaticMeshData* ExistMeshDataPtr
)

 Creates a static mesh with the given name and flags, imported from within the FBX scene. FbxImporter.h  

UStaticMesh * ImportStaticMeshAsSingle ( UObject* InParent,
TArray< FbxNode* >& MeshNodeArray,
const FName InName,
EObjectFlags Flags,
UFbxStaticMeshImportData* TemplateImportData,
UStaticMesh* InStaticMesh,
int LODIndex,
const FExistingStaticMeshData* ExistMeshDataPtr
)

 Creates a static mesh from all the meshes in FBX scene with the given name and flags. FbxImporter.h  

void ImportStaticMeshGlobalSockets ( UStaticMesh* StaticMesh
)

   FbxImporter.h  

void ImportStaticMeshLocalSockets ( UStaticMesh* StaticMesh,
TArray< FbxNode* >& MeshNodeArray
)

   FbxImporter.h  

bool IsUnrealBone ( FbxNode* Link
)

 Returns if the passed FbxNode can be used as a skeleton bone in Unreal. FbxImporter.h  

bool IsUnrealTransformAttribute ( FbxNode* Link
)

 Returns if the passed FbxNode can be used as a transform attribute in Unreal. FbxImporter.h  

FName MakeNameForMesh ( FString InName,
FbxObject* FbxObject
)

   FbxImporter.h  

void MergeAllLayerAnimation ( FbxAnimStack* AnimStack,
int32 ResampleRate
)

 Merge all layers of one AnimStack to one layer. FbxImporter.h  

bool OpenFile ( FString Filename
)

 Initialize Fbx file for import. FbxImporter.h  

void PartialCleanUp()

 Cleanup the fbx file data so we can read again another file FbxImporter.h  

void PopulateAnimatedCurveData ( FFbxCurvesAPI& CurvesAPI
)

 For sequencer import FbxImporter.h  

void PostImportStaticMesh ( UStaticMesh* StaticMesh,
TArray< FbxNode* >& MeshNodeArray,
int32 LODIndex
)

 Finish the import of the staticmesh after all LOD have been process (cannot be call before all LOD are imported). FbxImporter.h  

bool ReadHeaderFromFile ( const FString& Filename,
bool bPreventMaterialNameClash
)

 Make sure the file header is read FbxImporter.h  

void RecursiveBuildSkeleton ( FbxNode* Link,
TArray< FbxNode* >& OutSortedLinks
)

 Fill FBX skeletons to OutSortedLinks recursively FbxImporter.h  

FbxNode * RecursiveFindParentLodGroup ( FbxNode* ParentNode
)

 Find the first parent node containing a eLODGroup attribute. FbxImporter.h  

UStaticMesh * ReimportSceneStaticMesh ( uint64 FbxNodeUniqueId,
uint64 FbxMeshUniqueId,
UStaticMesh* Mesh,
UFbxStaticMeshImportData* TemplateImportData
)

 Re-import Unreal static mesh from updated scene Fbx file if the Fbx mesh is in LODGroup, the LOD of mesh will be updated FbxImporter.h  

USkeletalMesh * ReimportSkeletalMesh ( USkeletalMesh* Mesh,
UFbxSkeletalMeshImportData* TemplateImportData,
uint64 SkeletalMeshFbxUID,
TArray< FbxNode* >* OutSkeletalMeshArray
)

 Re-import Unreal skeletal mesh from updated Fbx file If the Fbx mesh is in LODGroup, the LOD of mesh will be updated. FbxImporter.h  

UStaticMesh * ReimportStaticMesh ( UStaticMesh* Mesh,
UFbxStaticMeshImportData* TemplateImportData
)

 Re-import Unreal static mesh from updated Fbx file if the Fbx mesh is in LODGroup, the LOD of mesh will be updated FbxImporter.h  

void ReleaseScene ()

 Empties the FBX scene, releasing its memory. FbxImporter.h  

void RemoveTransformSettingsFromFbxNode ( FbxNode* Node,
UFbxAssetImportData* AssetData
)

 Remove asset import settings for transform to an FBX node FbxImporter.h  

FbxNode * RetrieveObjectFromName ( const TCHAR* ObjectName,
FbxNode* Root
)

 Retrieve the object inside the FBX scene from the name FbxImporter.h  

void SetScene ( FbxScene* InScene
)

 Prime the importer with an already existing scene object. FbxImporter.h  

void SetupAnimationDataFromMesh ( USkeletalMesh* SkeletalMesh,
UObject* InParent,
TArray< FbxNode* >& NodeArray,
UFbxAnimSequenceImportData* ImportData,
const FString& Filename
)

 Import and set up animation related data from mesh FbxImporter.h  

bool ValidateAnimStack ( TArray< FbxNode* >& SortedLinks,
TArray< FbxNode* >& NodeArray,
FbxAnimStack* CurAnimStack,
int32 ResampleRate,
bool bImportMorph,
bool bSnapToClosestFrameBoundary,
FbxTimeSpan& AnimTimeSpan
)

 Validate Anim Stack - multiple check for validating animstack FbxImporter.h  

Protected

Name Remarks Include Path Unreal Specifiers

bool BuildStaticMeshFromGeometry ( FbxNode* Node,
UStaticMesh* StaticMesh,
TArray< FFbxMaterial >& MeshMaterials,
int LODIndex,
EVertexColorImportOption::Type VertexColorImportOption,
const TMap< FVector3f, FColor >& ExistingVertexColorData,
const FColor& VertexOverrideColor
)

 Set up the static mesh data from Fbx Mesh. FbxImporter.h  

void CheckSmoothingInfo ( FbxMesh* FbxMesh
)

 Return UMaterial* Check if the meshes in FBX scene contain smoothing group info. FbxImporter.h  

void CleanUp()

 Clean up for destroy the Importer. FbxImporter.h  
Make sure there is no unused material in the raw data. FbxImporter.h  

FbxAMatrix ComputeSkeletalMeshTotalMatrix ( FbxNode* Node,
FbxNode* RootSkeletalNode
)

 Compute the matrix for skeletal Fbx Node If we import don't import a scene it will call ComputeTotalMatrix with Node as the parameter. FbxImporter.h  

FbxAMatrix ComputeTotalMatrix ( FbxNode* Node
)

 Compute the global matrix for Fbx Node If we import scene it will return identity plus the pivot if we turn the bake pivot option FbxImporter.h  

bool CreateAndLinkExpressionForMaterialProperty ( const FbxSurfaceMaterial& FbxMaterial,
UMaterial* UnrealMaterial,
const char* MaterialProperty,
FExpressionInput& MaterialInput,
bool bSetupAsNormalMap,
TArray< FString >& UVSet,
const FVector2D& Location
)

 Material FbxImporter.h  

ACameraActor * CreateCamera ( FbxCamera* InCamera,
UWorld* InWorld
)

 Import Fbx Camera object FbxImporter.h  

ALight * CreateLight ( FbxLight* InLight,
UWorld* InWorld
)

 Various actors, current the Fbx importer don't importe them FbxImporter.h  

UMaterialInterface * CreateUnrealMaterial ( const FbxSurfaceMaterial& FbxMaterial,
TArray< FString >& OutUVSets,
bool bForSkeletalMesh
)

 Create Unreal material from Fbx material. FbxImporter.h  

int32 DoUnSmoothVerts ( FSkeletalMeshImportData& ImportData,
bool bDuplicateUnSmoothWedges
)

 Make un-smooth faces work. FbxImporter.h  

bool FacesAreSmoothlyConnected ( FSkeletalMeshImportData& ImportData,
int32 Face1,
int32 Face2
)

 Check if two faces belongs to same smoothing group FbxImporter.h  

void FillAndVerifyBoneNames ( USkeleton* Skeleton,
TArray< FbxNode* >& SortedLinks,
TArray< FName >& OutRawBoneNames,
FString Filename
)

 Fill up and verify bone names for animation FbxImporter.h  

bool FillAnimSequenceByKey ( FbxNode* Node,
UAnimSequence* AnimSequence,
const char* TakeName,
FbxTime& Start,
FbxTime& End,
bool bIsRoot,
FbxVector4 Scale
)

 Anims FbxImporter.h  

bool FillLightComponent ( FbxLight* Light,
ULightComponent* UnrealLight
)

 Import Light detail info FbxImporter.h  

bool FillSkeletalMeshImportPoints ( FSkeletalMeshImportData* OutData,
FbxNode* RootNode,
FbxNode* Node,
FbxShape* FbxShape
)

 Fill the Points in FSkeletalMeshIMportData from a Fbx Node and a FbxShape if it exists. FbxImporter.h  

bool FillSkelMeshImporterFromFbx ( FSkeletalMeshImportData& ImportData,
FbxMesh*& Mesh,
FbxSkin* Skin,
FbxShape* Shape,
TArray< FbxNode* >& SortedLinks,
const TArray< FbxSurfaceMaterial* >& FbxMaterials,
FbxNode* RootNode,
const TMap< FVector3f, FColor >& ExistingVertexColorData
)

 Meshes FbxImporter.h  

UMaterialInterface * FindExistingMaterialFromFbxMaterial ( const FbxSurfaceMaterial& FbxMaterial,
EMaterialSearchLocation MaterialSearchLocation
)

 Tries to find an existing UnrealMaterial from the FbxMaterial, returns nullptr if could not find a material. FbxImporter.h  

void FindOrImportMaterialsFromNode ( FbxNode* FbxNode,
TArray< UMaterialInterface* >& outMaterials,
TArray< FString >& UVSets,
bool bForSkeletalMesh
)

 Create materials from Fbx node. FbxImporter.h  

void FixupMaterial ( const FbxSurfaceMaterial& FbxMaterial,
UMaterial* unMaterial
)

 Add a basic white diffuse color if no expression is linked to diffuse input. FbxImporter.h  

bool GatherPointsForMorphTarget ( FSkeletalMeshImportData* OutData,
TArray< FbxNode* >& NodeArray,
TArray< FbxShape* >* FbxShapeArray,
TSet< uint32 >& ModifiedPoints,
bool bSkinControlPointToTimeZero
)

 Fill the Points in FSkeletalMeshIMportData from Fbx Nodes and FbxShape Array if it exists. FbxImporter.h  

FString GetMaterialBasePackageName ( const FString& MaterialFullName
) const

   FbxImporter.h  

FString GetMaterialFullName ( const FbxSurfaceMaterial& FbxMaterial
) const

 Make material Unreal asset name from the Fbx material FbxImporter.h  

bool ImportBones ( TArray< FbxNode* >& NodeArray,
FSkeletalMeshImportData& ImportData,
UFbxSkeletalMeshImportData* TemplateData,
TArray< FbxNode* >& OutSortedLinks,
bool& bOutDiffPose,
bool bDisableMissingBindPoseWarning,
bool& bUseTime0AsRefPose,
FbxNode* SkeletalMeshNode,
bool bIsReimport
)

 Import bones from skeletons that NodeArray bind to. FbxImporter.h  

void ImportNodeCustomProperties ( UObject* Object,
FbxNode* Node,
bool bPrefixTagWithNodeName
)

 Import the user-defined properties on the node as FBX metadata on the object FbxImporter.h  

UTexture * ImportTexture ( FbxFileTexture* FbxTexture,
bool bSetupAsNormalMap
)

 Generate Unreal texture object from FBX texture. FbxImporter.h  

void ImportTexturesFromNode ( FbxNode* Node
)

 Visit all materials of one node, import textures from materials. FbxImporter.h  

bool IsOddNegativeScale ( FbxAMatrix& TotalMatrix
)

 Check if there are negative scale in the transform matrix and its number is odd. FbxImporter.h  

bool IsValidAnimationData ( TArray< FbxNode* >& SortedLinks,
TArray< FbxNode* >& NodeArray,
int32& ValidTakeCount
)

 Is valid animation data FbxImporter.h  

bool LinkMaterialProperty ( const FbxSurfaceMaterial& FbxMaterial,
UMaterialInstanceConstant* UnrealMaterial,
const char* MaterialProperty,
FName ParameterValue,
bool bSetupAsNormalMap
)

 Create and link texture to the right material parameter value FbxImporter.h  

void LoadNodeKeyframeAnimation ( FbxNode* NodeToQuery,
FFbxCurvesAPI& CurvesAPI
)

   FbxImporter.h  

void LoadNodeKeyframeAnimationRecursively ( FFbxCurvesAPI& CurvesAPI,
FbxNode* NodeToQuery
)

   FbxImporter.h  

bool ReplaceSkeletalMeshGeometryImportData ( const USkeletalMesh* SkeletalMesh,
FSkeletalMeshImportData* ImportData,
int32 LodIndex
)

   FbxImporter.h  

bool ReplaceSkeletalMeshSkinningImportData ( const USkeletalMesh* SkeletalMesh,
FSkeletalMeshImportData* ImportData,
int32 LodIndex
)

   FbxImporter.h  

bool RetrievePoseFromBindPose ( const TArray< FbxNode* >& NodeArray,
FbxArray< FbxPose* >& PoseArray
) const

 Retrieve pose array from bind pose FbxImporter.h  

void SetMaterialOrderByName ( FSkeletalMeshImportData& ImportData,
TArray< FName > LastImportedMaterialNames
)

   FbxImporter.h  

void SetMaterialSkinXXOrder ( FSkeletalMeshImportData& ImportData
)

 Get material mapping array according "Skinxx" flag in material name FbxImporter.h  

void SetupTransformForNode ( FbxNode* Node
)

   FbxImporter.h  

void SkinControlPointsToPose ( FSkeletalMeshImportData& ImportData,
FbxMesh* Mesh,
FbxShape* Shape,
bool bUseT0
)

 Skins the control points of the given mesh or shape using either the default pose for skinning or the first frame of the default animation. FbxImporter.h  

void TraverseHierarchyNodeRecursively ( FbxSceneInfo& SceneInfo,
FbxNode* ParentNode,
FbxNodeInfo& ParentInfo
)

 Fill the FbxNodeInfo structure recursively to reflect the FbxNode hierarchy. FbxImporter.h  

Static

Name Remarks Include Path Unreal Specifiers

static T * CreateAsset ( FString ParentPackageName,
FString ObjectName,
bool bAllowReplace
)

 Templated function to create an asset with given package and name FbxImporter.h  

static UObject * CreateAssetOfClass ( UClass* AssetClass,
FString ParentPackageName,
FString ObjectName,
bool bAllowReplace
)

 Create a new asset from the package and objectname and class FbxImporter.h  

static void DeleteInstance()

   FbxImporter.h  

static FFbxImporter * GetInstance ( bool bDoNotCreate
)

 Returns the importer singleton. It will be created on the first request. FbxImporter.h  

static bool ImportCurve ( const FbxAnimCurve* FbxCurve,
FRichCurve& RichCurve,
const FbxTimeSpan& AnimTimeSpan,
const bool bNegative,
const float ValueScale,
const bool bAutoSetTangents
)

 Import FbxCurve to Curve FbxImporter.h  

static FString MakeName ( const ANSICHAR* name
)

 Help FbxImporter.h  

static FString MakeString ( const ANSICHAR* Name
)

   FbxImporter.h  

static void PrepareAndShowMaterialConflictDialog ( const TArray< TMaterialType >& CurrentMaterial,
TArray< TMaterialType >& ResultMaterial,
TArray< int32 >& RemapMaterial,
TArray< FName >& RemapMaterialName,
bool bCanShowDialog,
bool bIsPreviewDialog,
bool bForceResetOnConflict,
EFBXReimportDialogReturnOption& OutReturnOption
)

   FbxImporter.h  

static void RemoveFBXMetaData ( const UObject* Object
)

 Remove metadata starting with the FBX_METADATA_PREFIX value associated to the specified UObject. FbxImporter.h  

static void ShowFbxMaterialConflictWindow ( const TArray< TMaterialType >& InSourceMaterials,
const TArray< TMaterialType >& InResultMaterials,
TArray< int32 >& RemapMaterials,
TArray< bool >& FuzzyRemapMaterials,
EFBXReimportDialogReturnOption& OutReturnOption,
bool bIsPreviewConflict
)

 This function show a dialog to let the user resolve the material conflict that arise when re-importing a mesh FbxImporter.h  

static void ShowFbxSkeletonConflictWindow ( USkeletalMesh* SkeletalMesh,
USkeleton* Skeleton,
ImportCompareHelper::FSkeletonCompareData& SkeletonCompareData
)

 This function show a dialog to let the user know what will be change in the skeleton if the fbx is imported FbxImporter.h  

static void UpdateSkeletalMeshImportData ( USkeletalMesh* SkeletalMesh,
UFbxSkeletalMeshImportData* SkeletalMeshImportData,
int32 SpecificLod,
TArray< FName >* ImportMaterialOriginalNameData,
TArray< FImportMeshLodSectionsData >* ImportMeshLodData
)

   FbxImporter.h  

static void UpdateStaticMeshImportData ( UStaticMesh* StaticMesh,
UFbxStaticMeshImportData* StaticMeshImportData
)

   FbxImporter.h  

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page