1. Epic GamesDeveloper
  3. FFbxImporter

FFbxImporter

Main FBX Importer class.

Unreal Engine C++ API Reference > Editor > UnrealEd

References

   
Module UnrealEd
Header /Engine/Source/Editor/UnrealEd/Public/FbxImporter.h
Include #include "FbxImporter.h"

Syntax

class FFbxImporter

Remarks

Main FBX Importer class.

Variables

  Type Name Description
Protected variable bool bFirstMesh Flag that the mesh is the first mesh to import in current FBX scene FBX scene may contain multiple meshes, importer can import them at one time.
Protected variable FbxMap< FbxString, TSharedPtr< FbxArray< FbxNode * > > > CollisionModels Collision model list.
Protected variable FFbxDataConverter Converter Scene management
Protected variable TArray< TWeakObjectPtr< UObject > > CreatedObjects  
Protected variable IMPORTPHASE CurPhase  
Protected variable FString ErrorMessage  
Protected variable EFbxCreator FbxCreator Value is true if the file was create by blender.
Protected variable FString FbxFileCreator  
Protected variable FString FbxFileVersion  
Protected variable TMap< FbxFileTexture *, FString > FbxTextureToUniqueNameMap A map holding pairs of fbx texture that needs to be renamed with the associated string to avoid name conflicts.
Protected variable FbxAxisSystem FileAxisSystem Original File Info.
Protected variable FString FileBasePath Base path of fbx file
Protected variable FbxSystemUnit FileUnitSystem  
Protected variable FbxGeometryConverter * GeometryConverter  
Protected variable FbxImporter * Importer  
Public variable FBXImportOptions * ImportOptions  
Protected variable EAppReturnType::Type LastMergeBonesChoice Set when importing skeletal meshes if the merge bones step fails.
Public variable FMD5Hash Md5Hash 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.
Protected variable FbxMap< FbxString, FbxString > NodeUniqueNameToOriginalNameMap A map holding the original name of the renamed fbx nodes, It is used namely to associate collision meshes to their corresponding static mesh if it has been renamed.
Protected variable TWeakObjectPtr< UObject > Parent  
Public variable FbxScene * Scene Current Fbx scene we are importing. Make sure to release it after import
Protected variable FbxManager * SdkManager  
Protected variable TArray< FbxNode * > TransformSettingsToFbxApply Make sure we are not applying two time the option transform to the same node

Constructors

  Type Name Description
Protected function    

Destructors

  Type Name Description
Public function    

Functions

  Type Name Description
Public function void

AddStaticMeshSourceModelGeneratedLOD ( UStaticMesh* StaticMesh,
int32 LODIndex
)

 Add a GeneratedLOD to the staticmesh at the specified LOD index
Public function void Error message handler
Public function void Apply asset import settings for transform to an FBX node
Public function 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
Public function void

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

 Fill FBX skeletons to OutSortedLinks
Protected function 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.
Public function Const bool

CanCreateClass ( UClass* Class
)

 The asset tool have a filter mecanism for CreateAsset, return true if the asset can be created, false otherwise
Public function Const bool

CanImportClass ( UClass* Class
)

 The asset tool have a filter mecanism for ImportAsset, return true if the asset can be imported, false otherwise
Protected function void

CheckSmoothingInfo ( FbxMesh* FbxMesh
)

  
Protected function void

CleanUp ()

 Clean up for destroy the Importer.
Protected function void Make sure there is no unused material in the raw data.
Public function void Clear all data that need to be clear when we start importing a fbx file.
Public function void  
Protected function 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.
Protected function 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
Public function void Convert the scene from the current options.
Protected function bool

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

 Material
Protected function Static T *

CreateAsset ( FString ParentPackageName,
FString ObjectName,
bool bAllowReplace
)

 Templated function to create an asset with given package and name
Protected function Static UObject *

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

 Create a new asset from the package and objectname and class
Protected function ACameraActor *

CreateCamera ( FbxCamera* InCamera,
UWorld* InWorld
)

 Import Fbx Camera object
Protected function ALight *

CreateLight ( FbxLight* InLight,
UWorld* InWorld
)

 Various actors, current the Fbx importer don't importe them
Protected function UMaterialInterface *

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

 Create Unreal material from Fbx material.
Public function Static void  
Protected function int32

DoUnSmoothVerts ( FSkeletalMeshImportData& ImportData,
bool bDuplicateUnSmoothWedges
)

 Make un-smooth faces work.
Protected function bool

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

 Check if two faces belongs to same smoothing group
Protected function void

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

 Fill up and verify bone names for animation
Protected function bool

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

 Anims
Public function bool

FillCollisionModelList ( FbxNode* Node
)

 If the node model is a collision model, then fill it into collision model list
Public function void

FillFbxCollisionMeshArray ( FbxNode* Node
)

 Fill the collision models array by going through all mesh node recursively
Public function 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
Public function void

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

 Get all Fbx mesh objects
Public function 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
Protected function bool

FillLightComponent ( FbxLight* Light,
ULightComponent* UnrealLight
)

 Import Light detail info
Public function 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
)

 Fill FSkeletalMeshIMportData from Fbx Nodes and FbxShape Array if exists.
Protected function 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.
Protected function 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
Public function void

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

 Find the all the node containing a mesh attribute for the specified LOD index.
Protected function UMaterialInterface *

FindExistingMaterialFromFbxMaterial ( const FbxSurfaceMaterial& FbxMaterial,
EMaterialSearchLocation MaterialSearchLocation
)

 Tries to find an existing UnrealMaterial from the FbxMaterial, returns nullptr if could not find a material.
Public function FbxNode *

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

 Find FBX meshes that match Unreal skeletal mesh according to the bone of mesh
Public function FbxNode *

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

 Find the first node containing a mesh attribute for the specified LOD index.
Protected function void

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

 Create materials from Fbx node.
Protected function void

FixupMaterial ( const FbxSurfaceMaterial& FbxMaterial,
UMaterial* unMaterial
)

 Add a basic white diffuse color if no expression is linked to diffuse input.
Public function void  
Protected function bool

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

 Fill the Points in FSkeletalMeshIMportData from Fbx Nodes and FbxShape Array if it exists.
Public function 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.
Public function FbxTimeSpan

GetAnimationTimeSpan ( FbxNode* RootNode,
FbxAnimStack* AnimStack
)

 Get Animation Time Span - duration of the animation
Public function Const const TArray< TWeakObjectPtr< UObject > > & Get the UObjects that have been created so far during the import process.
Public function Const const TCHAR * Retrieve the FBX loader's error message explaining its failure to read a given FBX file.
Public function FString  
Public function int32

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

 Get mesh count (including static mesh and skeletal mesh, except collision models) and find collision models
Public function FString  
Public function FString  
Public function FString  
Public function FbxGeometryConverter *  
Public function int32

GetGlobalAnimStackSampleRate ( FbxAnimStack* CurAnimStack
)

 Calculate the global Sample Rate for all the nodes in the FbxAnimStack pass in parameter
Public function Const bool Returns true if the last import operation was canceled.
Public function Const FBXImportOptions * Get the object of import options
Public function int32

GetImportType ( const FString& InFilename
)

 Detect if the FBX file has skeletal mesh model.
Public function Static FFbxImporter * Returns the importer singleton. It will be created on the first request.
Protected function Const FString

GetMaterialBasePackageName ( const FString& MaterialFullName
)

  
Protected function Const FString

GetMaterialFullName ( const FbxSurfaceMaterial& FbxMaterial
)

 Make material Unreal asset name from the Fbx material
Public function int32

GetMaxSampleRate ( TArray< FbxNode* >& SortedLinks
)

 Calculate Max Sample Rate - separate out of the original ImportAnimations
Public function FbxNode *

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

 Return the node that match the mesh name. Return nullptr in case there is no match
Public function float  
Public function FbxNode *

GetRootSkeleton ( FbxNode* Link
)

 Get Unreal skeleton root from the FBX skeleton node. Mesh and dummy can be used as skeleton.
Public function bool

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

 Get detail infomation in the Fbx scene
Public function 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
Public function 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
Protected function 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.
Public function bool

ImportCollisionModels ( UStaticMesh* StaticMesh,
const FbxString& NodeName
)

 Import collision models for one static mesh if it has collision models
Public function Static bool

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

 Import FbxCurve to Curve
Public function void

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

 Import Fbx Morph object for the Skeletal Mesh. In Fbx, morph object is a property of the Fbx Node.
Public function bool

ImportFile ( FString Filename,
bool bPreventMaterialNameClash
)

 Import Fbx file.
Public function bool

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

 Attempt to load an FBX scene from a given filename.
Protected function void

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

 Import the user-defined properties on the node as FBX metadata on the object
Public function USkeletalMesh *

ImportSkeletalMesh ( FImportSkeletalMeshArgs& ImportSkeletalMeshArgs
)

  
Public function bool

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

 Import LOD object for skeletal mesh
Public function 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.
Public function 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.
Public function void  
Public function void

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

  
Protected function UTexture *

ImportTexture ( FbxFileTexture* FbxTexture,
bool bSetupAsNormalMap
)

 Generate Unreal texture object from FBX texture.
Protected function void

ImportTexturesFromNode ( FbxNode* Node
)

 Visit all materials of one node, import textures from materials.
Protected function bool

IsOddNegativeScale ( FbxAMatrix& TotalMatrix
)

 Check if there are negative scale in the transform matrix and its number is odd.
Public function bool

IsUnrealBone ( FbxNode* Link
)

 Returns if the passed FbxNode can be used as a skeleton bone in Unreal.
Public function bool

IsUnrealTransformAttribute ( FbxNode* Link
)

 Returns if the passed FbxNode can be used as a transform attribute in Unreal.
Protected function bool

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

 Is valid animation data
Protected function bool

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

 Create and link texture to the right material parameter value
Protected function void

LoadNodeKeyframeAnimation ( FbxNode* NodeToQuery,
FFbxCurvesAPI& CurvesAPI
)

  
Protected function void

LoadNodeKeyframeAnimationRecursively ( FFbxCurvesAPI& CurvesAPI,
FbxNode* NodeToQuery
)

  
Public function Static FString

MakeName ( const ANSICHAR* name
)

 Help
Public function FName

MakeNameForMesh ( FString InName,
FbxObject* FbxObject
)

  
Public function Static FString

MakeString ( const ANSICHAR* Name
)

  
Public function void

MergeAllLayerAnimation ( FbxAnimStack* AnimStack,
int32 ResampleRate
)

 Merge all layers of one AnimStack to one layer.
Public function bool

OpenFile ( FString Filename
)

 Initialize Fbx file for import.
Public function void Cleanup the fbx file data so we can read again another file
Public function void For sequencer import
Public function 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).
Public function Static void

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

  
Public function bool

ReadHeaderFromFile ( const FString& Filename,
bool bPreventMaterialNameClash
)

 Make sure the file header is read
Public function void

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

 Fill FBX skeletons to OutSortedLinks recursively
Public function FbxNode *

RecursiveFindParentLodGroup ( FbxNode* ParentNode
)

 Find the first parent node containing a eLODGroup attribute.
Public function 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
Public function 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.
Public function UStaticMesh * Re-import Unreal static mesh from updated Fbx file if the Fbx mesh is in LODGroup, the LOD of mesh will be updated
Public function void Empties the FBX scene, releasing its memory.
Public function void Remove asset import settings for transform to an FBX node
Protected function bool

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

  
Protected function bool

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

  
Public function FbxNode *

RetrieveObjectFromName ( const TCHAR* ObjectName,
FbxNode* Root
)

 Retrieve the object inside the FBX scene from the name
Protected function Const bool

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

 Retrieve pose array from bind pose
Protected function void

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

  
Protected function void Get material mapping array according "Skinxx" flag in material name
Public function void

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

 Import and set up animation related data from mesh
Protected function void

SetupTransformForNode ( FbxNode* Node
)

  
Public function 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
Public function Static void This function show a dialog to let the user know what will be change in the skeleton if the fbx is imported
Protected function 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.
Protected function void

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

 Fill the FbxNodeInfo structure recursively to reflect the FbxNode hierarchy.
Public function Static void

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

  
Public function Static void

UpdateStaticMeshImportData ( UStaticMesh* StaticMesh,
UFbxStaticMeshImportData* StaticMeshImportData
)

  
Public function 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

Classes

  Type Name Description
Public struct FFbxMaterial    
Public class FImportSkeletalMeshArgs Creates a skeletal mesh from Fbx Nodes with the given name and flags, imported from within the FBX scene.  

Enums

  Type Name Description
Protected enum IMPORTPHASE    

Constants

Name Description
StaticInstance  
StaticPreviewInstance  

Deprecated Functions

  Type Name Description
Public function void

SetScene ( FbxScene* InScene
)

 Do not use this function.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page