bImportAnimations

bImportAnimations

#Overview

name: bImportAnimations

The value of this variable can be defined or overridden in .ini config files. 1 .ini config file referencing this setting variable.

It is referenced in 33 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of bImportAnimations is to control whether animations should be imported from an FBX file during the import process. This variable is primarily used in the Unreal Engine’s FBX import system for skeletal meshes and animations.

The bImportAnimations variable is primarily used by the Unreal Engine’s FBX import system, which is part of the Editor module. It’s also referenced in various plugins and runtime modules related to asset import and interchange.

The value of this variable is typically set through the FBX import user interface or programmatically when initiating an FBX import. It can be found in the UFbxImportUI class, which represents the import settings for FBX files.

This variable interacts with several other import-related variables, such as bImportMesh, bImportSkeletalMeshLODs, and bImportMorph. These variables collectively determine what types of data are imported from an FBX file.

Developers should be aware that:

  1. Setting bImportAnimations to true doesn’t guarantee animation import if other conditions aren’t met (e.g., if there’s no valid skeleton).
  2. For performance reasons, you might want to set this to false if you’re only interested in importing mesh data.
  3. When reimporting assets, this flag might be automatically set based on the asset type being reimported.

Best practices when using this variable include:

  1. Only set it to true when you actually need to import animations to avoid unnecessary processing.
  2. When importing animations, ensure that the correct skeleton is specified (if applicable).
  3. Consider the implications on import time and memory usage, especially for large files with complex animations.
  4. When writing custom import logic, check this flag to determine whether animation-related import steps should be performed.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Config/BaseEditorPerProjectUserSettings.ini:633, section: [/Script/UnrealEd.FbxImportUI]

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Plugins/Interchange/Editor/Source/InterchangeEditor/Private/InterchangeFbxAssetImportDataConverter.cpp:667

Scope (from outer to inner):

file
namespace    UE::Interchange::Private
function     UAssetImportData* ConvertToInterchange

Source code excerpt:

			GenericAssetPipeline->MeshPipeline->CommonMeshesProperties->ForceAllMeshAsType = EInterchangeForceMeshType::IFMT_SkeletalMesh;

			GenericAssetPipeline->AnimationPipeline->bImportAnimations = FbxImportUI->bImportAnimations;

			GenericAssetPipeline->ImportOffsetRotation = FbxImportUI->SkeletalMeshImportData->ImportRotation;
			GenericAssetPipeline->ImportOffsetTranslation = FbxImportUI->SkeletalMeshImportData->ImportTranslation;
			GenericAssetPipeline->ImportOffsetUniformScale = FbxImportUI->SkeletalMeshImportData->ImportUniformScale;

			SetTranslatorSettings(FbxImportUI->SkeletalMeshImportData);

#Loc: <Workspace>/Engine/Plugins/Interchange/Editor/Source/InterchangeEditor/Private/InterchangeFbxAssetImportDataConverter.cpp:682

Scope (from outer to inner):

file
namespace    UE::Interchange::Private
function     UAssetImportData* ConvertToInterchange

Source code excerpt:

			GenericAssetPipeline->MeshPipeline->CommonMeshesProperties->ForceAllMeshAsType = EInterchangeForceMeshType::IFMT_StaticMesh;

			GenericAssetPipeline->AnimationPipeline->bImportAnimations = false;
			GenericAssetPipeline->MeshPipeline->bImportSkeletalMeshes = false;

			GenericAssetPipeline->ImportOffsetRotation = FbxImportUI->StaticMeshImportData->ImportRotation;
			GenericAssetPipeline->ImportOffsetTranslation = FbxImportUI->StaticMeshImportData->ImportTranslation;
			GenericAssetPipeline->ImportOffsetUniformScale = FbxImportUI->StaticMeshImportData->ImportUniformScale;

#Loc: <Workspace>/Engine/Plugins/Interchange/Editor/Source/InterchangeEditor/Private/InterchangeFbxAssetImportDataConverter.cpp:695

Scope (from outer to inner):

file
namespace    UE::Interchange::Private
function     UAssetImportData* ConvertToInterchange

Source code excerpt:

		else if (FbxImportUI->MeshTypeToImport == EFBXImportType::FBXIT_Animation)
		{
			GenericAssetPipeline->AnimationPipeline->bImportAnimations = true;
			if (FbxImportUI->Skeleton)
			{
				GenericAssetPipeline->CommonSkeletalMeshesAndAnimationsProperties->bImportOnlyAnimations = true;
				GenericAssetPipeline->CommonSkeletalMeshesAndAnimationsProperties->Skeleton = FbxImportUI->Skeleton;

				GenericAssetPipeline->MeshPipeline->bImportStaticMeshes = false;

#Loc: <Workspace>/Engine/Plugins/Interchange/Editor/Source/InterchangeEditor/Private/InterchangeFbxAssetImportDataConverter.cpp:724

Scope (from outer to inner):

file
namespace    UE::Interchange::Private
function     UAssetImportData* ConvertToInterchange

Source code excerpt:

			GenericAssetPipeline->MeshPipeline->bImportStaticMeshes = true;
			GenericAssetPipeline->MeshPipeline->bImportSkeletalMeshes = true;
			GenericAssetPipeline->AnimationPipeline->bImportAnimations = true;

			SetTranslatorSettings(FbxImportUI->StaticMeshImportData);

			//Use the static mesh data
			FillInterchangeGenericAssetsPipelineFromFbxMeshImportData(GenericAssetPipeline, Cast<UFbxStaticMeshImportData>(FbxImportUI->StaticMeshImportData));
		}

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Pipelines/Private/InterchangeGenericAnimationPipeline.cpp:30

Scope (from outer to inner):

file
function     bool UInterchangeGenericAnimationPipeline::CanEditChange

Source code excerpt:

	if (InProperty->GetFName() == GET_MEMBER_NAME_CHECKED(UInterchangeGenericAnimationPipeline, FrameImportRange))
	{
		return ParentVal && bImportAnimations && bImportBoneTracks && AnimationRange == EInterchangeAnimationRange::SetRange;
	}
	return ParentVal;
}
#endif

void UInterchangeGenericAnimationPipeline::AdjustSettingsForContext(EInterchangePipelineContext ImportType, TObjectPtr<UObject> ReimportAsset)

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Pipelines/Private/InterchangeGenericAnimationPipeline.cpp:51

Scope (from outer to inner):

file
function     void UInterchangeGenericAnimationPipeline::AdjustSettingsForContext

Source code excerpt:

		|| ImportType == EInterchangePipelineContext::AssetAlternateSkinningReimport)
	{
		bImportAnimations = false;
		CommonSkeletalMeshesAndAnimationsProperties->Skeleton = nullptr;
		CommonSkeletalMeshesAndAnimationsProperties->bImportOnlyAnimations = false;
	}
	
	TArray<FString> HideCategories;
	if (ImportType == EInterchangePipelineContext::AssetReimport)

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Pipelines/Private/InterchangeGenericAnimationPipeline.cpp:91

Scope (from outer to inner):

file
function     void UInterchangeGenericAnimationPipeline::ExecutePipeline

Source code excerpt:

	BaseNodeContainer = InBaseNodeContainer;

	if (!bImportAnimations)
	{
		//Nothing to import
		return;
	}

	TArray<UInterchangeAnimationTrackSetNode*> TrackSetNodes;

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Pipelines/Public/InterchangeGenericAnimationPipeline.h:52

Scope (from outer to inner):

file
class        class UInterchangeGenericAnimationPipeline : public UInterchangePipelineBase

Source code excerpt:

	/** If enabled, import all animation assets found in the source. */
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Animations")
	bool bImportAnimations = true;

	/** Import bone transform tracks. If false, this will discard any bone transform tracks.*/
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Animations", meta = (EditCondition = "bImportAnimations"))
	bool bImportBoneTracks = true;

	/** Determines which animation range to import: the range defined at export, the range of frames with animation, or a manually defined range. */

#Loc: <Workspace>/Engine/Source/Editor/DetailCustomizations/Private/FbxImportUIDetails.cpp:560

Scope (from outer to inner):

file
function     void FFbxImportUIDetails::CustomizeDetails

Source code excerpt:


		// Before we add the import data properties we need to re-add any properties we want to appear above them in the UI
		TSharedRef<IPropertyHandle> ImportAnimProp = DetailBuilder.GetProperty(GET_MEMBER_NAME_CHECKED(UFbxImportUI, bImportAnimations));
		// If we're importing an animation file we really don't need to ask this
		DetailBuilder.HideProperty(ImportAnimProp);
		if(ImportType == FBXIT_Animation)
		{
			ImportUI->bImportAnimations = true;
		}
		else
		{
			AnimCategory.AddProperty(ImportAnimProp);
		}

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Classes/Factories/FbxImportUI.h:175

Scope (from outer to inner):

file
class        class UFbxImportUI : public UObject, public IImportSettingsParser

Source code excerpt:

	/** True to import animations from the FBX File */
	UPROPERTY(EditAnywhere, BlueprintReadWrite, config, Category=Animation, meta=(ImportType="SkeletalMesh|Animation|RigOnly"))
	uint32 bImportAnimations:1;

	/** Override for the name of the animation to import. By default, it will be the name of FBX **/
	UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category=Animation, meta=(editcondition="bImportAnimations", ImportType="SkeletalMesh|RigOnly"))
	FString OverrideAnimationName;

	/** Enables importing of 'rigid skeletalmesh' (unskinned, hierarchy-based animation) from this FBX file, no longer shown, used behind the scenes */

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Classes/Factories/FbxSceneImportOptionsSkeletalMesh.h:71

Scope (from outer to inner):

file
class        class UFbxSceneImportOptionsSkeletalMesh : public UObject

Source code excerpt:

	/** True to import animations from the FBX File */
	UPROPERTY(EditAnywhere, config, Category = Animation)
	uint32 bImportAnimations : 1;

	/** Type of asset to import from the FBX file */
	UPROPERTY(EditAnywhere, Category = Animation, config, meta = (DisplayName = "Animation Length"))
	TEnumAsByte<enum EFBXAnimationLengthImportType> AnimationLength;

	/** Frame range used when Set Range is used in Animation Length */

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Factories/EditorFactories.cpp:6487

Scope (from outer to inner):

file
function     EReimportResult::Type UReimportFbxSkeletalMeshFactory::Reimport

Source code excerpt:

	ReimportUI->bCreatePhysicsAsset = false;
	ReimportUI->PhysicsAsset = SkeletalMesh->GetPhysicsAsset();
	ReimportUI->bImportAnimations = false;
	ReimportUI->OverrideAnimationName = TEXT("");
	ReimportUI->bImportRigidMesh = false;

	if (!ImportUI)
	{
		ImportUI = NewObject<UFbxImportUI>(this, NAME_None, RF_Public);

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Factories/EditorFactories.cpp:6743

Scope (from outer to inner):

file
function     EReimportResult::Type UReimportFbxSkeletalMeshFactory::Reimport

Source code excerpt:

				ImportOptions->bImportLOD = false;
				ImportOptions->bImportSkeletalMeshLODs = false;
				ImportOptions->bImportAnimations = false;
				ImportOptions->bImportMorph = false;
				ImportOptions->VertexColorImportOption = EVertexColorImportOption::Ignore;
			}
			else if (ImportOptions->bImportAsSkeletalGeometry)
			{
				ImportOptions->bImportAnimations = false;
				ImportOptions->bUpdateSkeletonReferencePose = false;
			}

			//Save all skinweight profile infos (need a copy, because they will be removed)
			const TArray<FSkinWeightProfileInfo> ExistingSkinWeightProfileInfos = SkeletalMesh->GetSkinWeightProfiles();

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxFactory.cpp:396

Scope (from outer to inner):

file
function     UObject* UFbxFactory::FactoryCreateFile

Source code excerpt:

				ImportOptions->bImportLOD = false;
				ImportOptions->bImportSkeletalMeshLODs = false;
				ImportOptions->bImportAnimations = false;
				ImportOptions->bImportMorph = false;
			}
			else if (ImportOptions->bImportAsSkeletalGeometry)
			{
				ImportOptions->bImportAnimations = false;
				ImportOptions->bUpdateSkeletonReferencePose = false;
			}
		}
		if (!FbxImporter->CanImportClass(UPhysicsAsset::StaticClass()))
		{
			ImportOptions->bCreatePhysicsAsset = false;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxFactory.cpp:749

Scope: file

Source code excerpt:

									ScopedPostEditChange.SetSkeletalMesh(BaseSkeletalMesh);

									if (ImportOptions->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(BaseSkeletalMesh, Package, SkelMeshNodeArray, ImportUI->AnimSequenceImportData, OutputName.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxFactory.cpp:1265

Scope (from outer to inner):

file
function     bool UFbxImportUI::CanEditChange

Source code excerpt:

		if(PropName == TEXT("FrameImportRange"))
		{
			bIsMutable = AnimSequenceImportData->AnimationLength == FBXALIT_SetRange && bImportAnimations;
		}
		else if(PropName == TEXT("bImportCustomAttribute") || PropName == TEXT("AnimationLength") || PropName == TEXT("CustomSampleRate") || PropName == TEXT("bUseDefaultSampleRate"))
		{
			bIsMutable = bImportAnimations;
		}

		if(bIsObjImport && InProperty->GetBoolMetaData(TEXT("OBJRestrict")))
		{
			bIsMutable = false;
		}

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:266

Scope (from outer to inner):

file
namespace    UnFbx
function     FBXImportOptions* GetImportOptions

Source code excerpt:

			ImportOptions->bTransformVertexToAbsolute = true;
			//when user import animation only we must get duplicate "bImportMeshesInBoneHierarchy" option from ImportUI anim sequence data
			if (!ImportUI->bImportMesh && ImportUI->bImportAnimations)
			{
				ImportUI->SkeletalMeshImportData->bImportMeshesInBoneHierarchy = ImportUI->AnimSequenceImportData->bImportMeshesInBoneHierarchy;
			}
			else
			{
				ImportUI->AnimSequenceImportData->bImportMeshesInBoneHierarchy = ImportUI->SkeletalMeshImportData->bImportMeshesInBoneHierarchy;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:376

Scope (from outer to inner):

file
namespace    UnFbx
function     void ApplyImportUIToImportOptions

Source code excerpt:

	//Animation and skeletal mesh options
	{
		InOutImportOptions.bImportAnimations		= ImportUI->bImportAnimations;
		InOutImportOptions.SkeletonForAnimation		= ImportUI->Skeleton;
		InOutImportOptions.bCreatePhysicsAsset		= ImportUI->bCreatePhysicsAsset;
		InOutImportOptions.PhysicsAsset				= ImportUI->PhysicsAsset;
		InOutImportOptions.AnimationName			= ImportUI->OverrideAnimationName;
	}

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:443

Scope (from outer to inner):

file
namespace    UnFbx
function     void ApplyImportUIToImportOptions

Source code excerpt:

		InOutImportOptions.bImportVertexAttributes		= SkeletalMeshData->bImportVertexAttributes;

		if(ImportUI->bImportAnimations)
		{
			// Copy the transform information into the animation data to match the mesh.
			UFbxAnimSequenceImportData* AnimData	= ImportUI->AnimSequenceImportData;
			AnimData->ImportTranslation				= SkeletalMeshData->ImportTranslation;
			AnimData->ImportRotation				= SkeletalMeshData->ImportRotation;
			AnimData->ImportUniformScale			= SkeletalMeshData->ImportUniformScale;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:1754

Scope (from outer to inner):

file
lambda-function

Source code excerpt:

						{
							Attribs.Add(FAnalyticsEventAttribute(TEXT("SkeletalMeshOpt CreatePhysicsAsset"), CaptureImportOptions->bCreatePhysicsAsset));
							Attribs.Add(FAnalyticsEventAttribute(TEXT("SkeletalMeshOpt ImportAnimations"), CaptureImportOptions->bImportAnimations));
							Attribs.Add(FAnalyticsEventAttribute(TEXT("SkeletalMeshOpt ImportAsSkeletalGeometry"), CaptureImportOptions->bImportAsSkeletalGeometry));
							Attribs.Add(FAnalyticsEventAttribute(TEXT("SkeletalMeshOpt ImportAsSkeletalSkinning"), CaptureImportOptions->bImportAsSkeletalSkinning));
							Attribs.Add(FAnalyticsEventAttribute(TEXT("SkeletalMeshOpt ImportMeshesInBoneHierarchy"), CaptureImportOptions->bImportMeshesInBoneHierarchy));
							Attribs.Add(FAnalyticsEventAttribute(TEXT("SkeletalMeshOpt ImportMorph"), CaptureImportOptions->bImportMorph));
							Attribs.Add(FAnalyticsEventAttribute(TEXT("SkeletalMeshOpt ImportSkeletalMeshLODs"), CaptureImportOptions->bImportSkeletalMeshLODs));
							Attribs.Add(FAnalyticsEventAttribute(TEXT("SkeletalMeshOpt PreserveSmoothingGroups"), CaptureImportOptions->bPreserveSmoothingGroups));

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:1807

Scope (from outer to inner):

file
namespace    UnFbx
function     bool FFbxImporter::ImportFromFile

Source code excerpt:

							AddMeshAnalytic();
							AddSKAnalytic();
							if (ImportOptions->bImportAnimations)
							{
								AddAnimAnalytic();
							}
						}
						else if (ImportOptions->ImportType == FBXIT_StaticMesh)
						{

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxOptionWindow.cpp:210

Scope (from outer to inner):

file
function     bool SFbxOptionWindow::CanImport

Source code excerpt:

	if (ImportUI->MeshTypeToImport == FBXIT_Animation)
	{
		if (ImportUI->Skeleton == NULL || !ImportUI->bImportAnimations)
		{
			return false;
		}
	}

	if (ImportUI->AnimSequenceImportData->AnimationLength == FBXALIT_SetRange)

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSceneImportFactory.cpp:1983

Scope (from outer to inner):

file
function     UObject* UFbxSceneImportFactory::ImportOneSkeletalMesh

Source code excerpt:

					AllNewAssets.Add(SkelMeshNodeInfo->AttributeInfo, NewObject);
				}
				if (GlobalImportSettings->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, SkeletalMeshImportData);
					FbxImporter->SetupAnimationDataFromMesh(NewMesh, Pkg, SkelMeshNodeArray, AnimSequenceImportData, OutputName.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSceneImportOptionsSkeletalMesh.cpp:24

Scope (from outer to inner):

file
function     UFbxSceneImportOptionsSkeletalMesh::UFbxSceneImportOptionsSkeletalMesh

Source code excerpt:

	, ThresholdUV(THRESH_UVS_ARE_SAME)
	, MorphThresholdPosition(THRESH_POINTS_ARE_NEAR)
	, bImportAnimations(true)
	, AnimationLength(EFBXAnimationLengthImportType::FBXALIT_AnimatedKey)
	, FrameImportRange(0, 0)
	, bUseDefaultSampleRate(false)
	, CustomSampleRate(0)
	, bImportCustomAttribute(true)
	, bDeleteExistingCustomAttributeCurves(false)

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSkeletalMeshImport.cpp:2425

Scope (from outer to inner):

file
function     USkeletalMesh* UnFbx::FFbxImporter::ReimportSkeletalMesh

Source code excerpt:

	bool Old_ImportMaterials = ImportOptions->bImportMaterials;
	bool Old_ImportTextures = ImportOptions->bImportTextures;
	bool Old_ImportAnimations = ImportOptions->bImportAnimations;

	auto CleanUpImportOptionsData = [&]()
	{
		ImportOptions->bImportRigidMesh = Old_ImportRigidMesh;
		ImportOptions->bImportMaterials = Old_ImportMaterials;
		ImportOptions->bImportTextures = Old_ImportTextures;
		ImportOptions->bImportAnimations = Old_ImportAnimations;
	};

	// support to update rigid animation mesh
	ImportOptions->bImportRigidMesh = true;

	UFbxSkeletalMeshImportData* SKImportData = Cast<UFbxSkeletalMeshImportData>(Mesh->GetAssetImportData());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSkeletalMeshImport.cpp:2580

Scope (from outer to inner):

file
function     USkeletalMesh* UnFbx::FFbxImporter::ReimportSkeletalMesh

Source code excerpt:

		}
		//In case of a scene reimport animations are reimport later so its ok to hardcode animation to false here
		ImportOptions->bImportAnimations = false;
		// check if there is LODGroup for this skeletal mesh
		int32 MaxLODLevel = 1;
		int32 NumPrevLODs = Mesh->GetLODNum();

		for (int32 j = 0; j < (*FbxNodes).Num(); j++)
		{

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/ReimportFbxSceneFactory.cpp:1336

Scope (from outer to inner):

file
function     EReimportResult::Type UReimportFbxSceneFactory::ReimportSkeletalMesh

Source code excerpt:

		//2. On reimport match the existing one
		//3. Reimport matching animation
		if (GlobalImportSettings->bImportAnimations && ensure(Mesh->GetSkeleton()))
		{
			TArray<FbxNode*> FBXMeshNodeArray;
			FbxNode* SkeletonRoot = FbxImporter->FindFBXMeshesByBone(Mesh->GetSkeleton()->GetReferenceSkeleton().GetBoneName(0), true, FBXMeshNodeArray);

			FString AnimName = FbxImporter->MakeNameForMesh(FBXMeshNodeArray[0]->GetName(), FBXMeshNodeArray[0]).ToString();
			AnimName = (GlobalImportSettings->AnimationName != "") ? GlobalImportSettings->AnimationName : AnimName + TEXT("_Anim");

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SFbxSceneOptionWindow.cpp:1506

Scope (from outer to inner):

file
function     void SFbxSceneOptionWindow::CopySkeletalMeshOptionsToFbxOptions

Source code excerpt:

	ImportSettings->bUseT0AsRefPose = SkeletalMeshOptions->bUseT0AsRefPose;

	ImportSettings->bImportAnimations = SkeletalMeshOptions->bImportAnimations;
	ImportSettings->AnimationLengthImportType = SkeletalMeshOptions->AnimationLength;
	ImportSettings->bDeleteExistingMorphTargetCurves = SkeletalMeshOptions->bDeleteExistingMorphTargetCurves;
	ImportSettings->bImportCustomAttribute = SkeletalMeshOptions->bImportCustomAttribute;
	ImportSettings->bDeleteExistingCustomAttributeCurves = SkeletalMeshOptions->bDeleteExistingCustomAttributeCurves;
	ImportSettings->bDeleteExistingNonCurveCustomAttributes = SkeletalMeshOptions->bDeleteExistingNonCurveCustomAttributes;	
	ImportSettings->bPreserveLocalTransform = SkeletalMeshOptions->bPreserveLocalTransform;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SFbxSceneOptionWindow.cpp:1535

Scope (from outer to inner):

file
function     void SFbxSceneOptionWindow::CopyFbxOptionsToSkeletalMeshOptions

Source code excerpt:

	SkeletalMeshOptions->bUseT0AsRefPose = ImportSettings->bUseT0AsRefPose;

	SkeletalMeshOptions->bImportAnimations = ImportSettings->bImportAnimations;
	SkeletalMeshOptions->AnimationLength = ImportSettings->AnimationLengthImportType;
	SkeletalMeshOptions->bDeleteExistingMorphTargetCurves = ImportSettings->bDeleteExistingMorphTargetCurves;
	SkeletalMeshOptions->bImportCustomAttribute = ImportSettings->bImportCustomAttribute;
	SkeletalMeshOptions->bDeleteExistingCustomAttributeCurves = ImportSettings->bDeleteExistingCustomAttributeCurves;
	SkeletalMeshOptions->bDeleteExistingNonCurveCustomAttributes = ImportSettings->bDeleteExistingNonCurveCustomAttributes;	
	SkeletalMeshOptions->bPreserveLocalTransform = ImportSettings->bPreserveLocalTransform;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/FbxMeshUtils.cpp:615

Scope (from outer to inner):

file
namespace    FbxMeshUtils
function     bool ImportSkeletalMeshLOD

Source code excerpt:

			ImportOptions->bImportTextures = false;
		}
		ImportOptions->bImportAnimations = false;
		//Adjust the option in case we import only the skinning or the geometry
		if (ImportOptions->bImportAsSkeletalSkinning)
		{
			ImportOptions->bImportMaterials = false;
			ImportOptions->bImportTextures = false;
			ImportOptions->bImportLOD = false;
			ImportOptions->bImportSkeletalMeshLODs = false;
			ImportOptions->bImportAnimations = false;
			ImportOptions->bImportMorph = false;
		}
		else if (ImportOptions->bImportAsSkeletalGeometry)
		{
			ImportOptions->bImportAnimations = false;
			ImportOptions->bUpdateSkeletonReferencePose = false;
		}

		if ( !FFbxImporter->ImportFromFile( *Filename, FPaths::GetExtension( Filename ), true ) )
		{
			ReapplyClothing();

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/SkeletalMeshEdit.cpp:138

Scope (from outer to inner):

file
function     bool UEditorEngine::ReimportFbxAnimation

Source code excerpt:

	ReimportUI->MeshTypeToImport = FBXIT_Animation;
	ReimportUI->bOverrideFullName = false;
	ReimportUI->bImportAnimations = true;

	const bool ShowImportDialogAtReimport = GetDefault<UEditorPerProjectUserSettings>()->bShowImportDialogAtReimport && !GIsAutomationTesting && bFactoryShowOptions;
	if (ImportData && !ShowImportDialogAtReimport)
	{
		// Prepare the import options
		if (!bOverrideImportSettings)

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/SkinWeightsUtilities.cpp:174

Scope (from outer to inner):

file
function     bool FSkinWeightsUtilities::ImportAlternateSkinWeight

Source code excerpt:

		FbxFactory->ImportUI->ReimportMesh = nullptr;
		FbxFactory->ImportUI->bAllowContentTypeImport = true;
		FbxFactory->ImportUI->bImportAnimations = false;
		FbxFactory->ImportUI->bAutomatedImportShouldDetectType = false;
		FbxFactory->ImportUI->bCreatePhysicsAsset = false;
		FbxFactory->ImportUI->bImportMaterials = false;
		FbxFactory->ImportUI->bImportTextures = false;
		FbxFactory->ImportUI->bImportMesh = true;
		FbxFactory->ImportUI->bImportRigidMesh = false;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Public/FbxImporter.h:176

Scope (from outer to inner):

file
namespace    UnFbx

Source code excerpt:

	bool bImportMorph;
	bool bImportVertexAttributes;
	bool bImportAnimations;
	bool bUpdateSkeletonReferencePose;
	bool bResample;
	int32 ResampleRate;
	bool bSnapToClosestFrameBoundary;
	bool bImportRigidMesh;
	bool bUseT0AsRefPose;