bBakePivotInVertex

bBakePivotInVertex

#Overview

name: bBakePivotInVertex

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 54 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of bBakePivotInVertex is to control whether the pivot point of a mesh should be baked into the vertex positions during import. This setting is primarily used in the mesh import and processing system of Unreal Engine 5.

Here are the key points about this variable:

  1. It is used by the FBX import system, which is part of Unreal Engine’s asset import pipeline.

  2. The variable is referenced in various modules related to importing and processing meshes, including the Interchange Editor plugin, FBX import functionality, and scene import options.

  3. The value of this variable is typically set through import options UI or programmatically when importing assets.

  4. It interacts with other import settings, particularly bTransformVertexToAbsolute. When bBakePivotInVertex is true, bTransformVertexToAbsolute should be false.

  5. Developers should be aware that this option is experimental and may not work consistently across all import scenarios. It’s primarily intended for static meshes and may not be fully supported for skeletal meshes.

  6. Best practices when using this variable include:

    • Only use it when you specifically need to preserve the pivot point from the source file in the vertex data.
    • Be cautious when using it with skeletal meshes, as it’s not fully supported in that context.
    • Ensure that bTransformVertexToAbsolute is set to false when using this option.
    • Test thoroughly after import to ensure the desired result is achieved.

  7. This setting can affect the way meshes are positioned and oriented in the engine, so it’s important to use it judiciously and understand its implications on your asset pipeline.

#Setting Variables

#References In INI files

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

#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:65

Scope (from outer to inner):

file
namespace    UE::Interchange::Private
function     void FillFbxMeshImportData

Source code excerpt:

	void FillFbxMeshImportData(const UInterchangeGenericAssetsPipeline* GenericAssetPipeline, UFbxMeshImportData* MeshImportData)
	{
		MeshImportData->bBakePivotInVertex = false;
		MeshImportData->bComputeWeightedNormals = GenericAssetPipeline->CommonMeshesProperties->bComputeWeightedNormals;
		MeshImportData->bImportMeshLODs = GenericAssetPipeline->CommonMeshesProperties->bImportLods;
		MeshImportData->bReorderMaterialToFbxOrder = true;
		MeshImportData->bTransformVertexToAbsolute = GenericAssetPipeline->CommonMeshesProperties->bBakeMeshes;

		if (GenericAssetPipeline->CommonMeshesProperties->bUseMikkTSpace)

#Loc: <Workspace>/Engine/Plugins/Tests/EditorTests/Source/EditorTests/Private/UnrealEd/FbxAutomationTests.cpp:389

Scope (from outer to inner):

file
function     BEGIN_FUNCTION_BUILD_OPTIMIZATION bool F

Source code excerpt:

					//Copy UFbxMeshImportData
					ImportData->bTransformVertexToAbsolute = TestPlan->ImportUI->StaticMeshImportData->bTransformVertexToAbsolute;
					ImportData->bBakePivotInVertex = TestPlan->ImportUI->StaticMeshImportData->bBakePivotInVertex;
					ImportData->bImportMeshLODs = TestPlan->ImportUI->StaticMeshImportData->bImportMeshLODs;
					ImportData->NormalImportMethod = TestPlan->ImportUI->StaticMeshImportData->NormalImportMethod;
					ImportData->NormalGenerationMethod = TestPlan->ImportUI->StaticMeshImportData->NormalGenerationMethod;
					ImportData->bComputeWeightedNormals = TestPlan->ImportUI->StaticMeshImportData->bComputeWeightedNormals;
					//Copy UFbxAssetImportData
					ImportData->ImportTranslation = TestPlan->ImportUI->StaticMeshImportData->ImportTranslation;

#Loc: <Workspace>/Engine/Plugins/Tests/EditorTests/Source/EditorTests/Private/UnrealEd/FbxAutomationTests.cpp:432

Scope (from outer to inner):

file
function     BEGIN_FUNCTION_BUILD_OPTIMIZATION bool F

Source code excerpt:

					//Copy UFbxMeshImportData
					ImportData->bTransformVertexToAbsolute = TestPlan->ImportUI->SkeletalMeshImportData->bTransformVertexToAbsolute;
					ImportData->bBakePivotInVertex = TestPlan->ImportUI->SkeletalMeshImportData->bBakePivotInVertex;
					ImportData->bImportMeshLODs = TestPlan->ImportUI->SkeletalMeshImportData->bImportMeshLODs;
					ImportData->NormalImportMethod = TestPlan->ImportUI->SkeletalMeshImportData->NormalImportMethod;
					ImportData->NormalGenerationMethod = TestPlan->ImportUI->SkeletalMeshImportData->NormalGenerationMethod;
					//Copy UFbxAssetImportData
					ImportData->ImportTranslation = TestPlan->ImportUI->SkeletalMeshImportData->ImportTranslation;
					ImportData->ImportRotation = TestPlan->ImportUI->SkeletalMeshImportData->ImportRotation;

#Loc: <Workspace>/Engine/Plugins/Tests/EditorTests/Source/EditorTests/Private/UnrealEd/FbxAutomationTests.cpp:497

Scope (from outer to inner):

file
function     BEGIN_FUNCTION_BUILD_OPTIMIZATION bool F

Source code excerpt:

					//Copy UFbxMeshImportData
					ImportData->bTransformVertexToAbsolute = TestPlan->ImportUI->StaticMeshImportData->bTransformVertexToAbsolute;
					ImportData->bBakePivotInVertex = TestPlan->ImportUI->StaticMeshImportData->bBakePivotInVertex;
					ImportData->bImportMeshLODs = TestPlan->ImportUI->StaticMeshImportData->bImportMeshLODs;
					ImportData->NormalImportMethod = TestPlan->ImportUI->StaticMeshImportData->NormalImportMethod;
					ImportData->NormalGenerationMethod = TestPlan->ImportUI->StaticMeshImportData->NormalGenerationMethod;
					ImportData->bComputeWeightedNormals = TestPlan->ImportUI->StaticMeshImportData->bComputeWeightedNormals;
					//Copy UFbxAssetImportData
					ImportData->ImportTranslation = TestPlan->ImportUI->StaticMeshImportData->ImportTranslation;

#Loc: <Workspace>/Engine/Plugins/Tests/EditorTests/Source/EditorTests/Private/UnrealEd/FbxAutomationTests.cpp:530

Scope (from outer to inner):

file
function     BEGIN_FUNCTION_BUILD_OPTIMIZATION bool F

Source code excerpt:

					//Copy UFbxMeshImportData
					ImportData->bTransformVertexToAbsolute = TestPlan->ImportUI->SkeletalMeshImportData->bTransformVertexToAbsolute;
					ImportData->bBakePivotInVertex = TestPlan->ImportUI->SkeletalMeshImportData->bBakePivotInVertex;
					ImportData->bImportMeshLODs = TestPlan->ImportUI->SkeletalMeshImportData->bImportMeshLODs;
					ImportData->NormalImportMethod = TestPlan->ImportUI->SkeletalMeshImportData->NormalImportMethod;
					ImportData->NormalGenerationMethod = TestPlan->ImportUI->SkeletalMeshImportData->NormalGenerationMethod;
					//Copy UFbxAssetImportData
					ImportData->ImportTranslation = TestPlan->ImportUI->SkeletalMeshImportData->ImportTranslation;
					ImportData->ImportRotation = TestPlan->ImportUI->SkeletalMeshImportData->ImportRotation;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Classes/Factories/FbxMeshImportData.h:68

Scope (from outer to inner):

file
class        class UFbxMeshImportData : public UFbxAssetImportData

Source code excerpt:

	/** - Experimental - If this option is true the inverse node rotation pivot will be apply to the mesh vertices. The pivot from the DCC will then be the origin of the mesh. Note: "TransformVertexToAbsolute" must be false.*/
	UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, config, Category = Mesh, meta = (EditCondition = "!bTransformVertexToAbsolute", ImportType = "StaticMesh"))
	bool bBakePivotInVertex;

	/** Enables importing of mesh LODs from FBX LOD groups, if present in the FBX file */
	UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, config, Category= Mesh, meta=(OBJRestrict="true", ImportType="Mesh|GeoOnly", ToolTip="If enabled, creates LOD models for Unreal meshes from LODs in the import file; If not enabled, only the base mesh from the LOD group is imported"))
	uint32 bImportMeshLODs:1;

	/** Enabling this option will read the tangents(tangent,binormal,normal) from FBX file instead of generating them automatically. */

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Classes/Factories/FbxSceneImportOptions.h:65

Scope (from outer to inner):

file
class        class UFbxSceneImportOptions : public UObject

Source code excerpt:

	/** - Experimental - If this option is true the inverse node pivot will be apply to the mesh vertices. The pivot from the DCC will then be the origin of the mesh. This option only work with static meshes.*/
	UPROPERTY(EditAnywhere, config, category = Meshes)
	bool bBakePivotInVertex;

	/** If enabled, creates LOD models for Unreal static meshes from LODs in the import file; If not enabled, only the base static mesh from the LOD group is imported. */
	UPROPERTY(EditAnywhere, config, category = Meshes)
	uint32 bImportStaticMeshLODs : 1;

	/** If enabled, creates LOD models for Unreal skeletal meshes from LODs in the import file; If not enabled, only the base skeletal mesh from the LOD group is imported. */

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

Scope (from outer to inner):

file
function     EReimportResult::Type UReimportFbxSkeletalMeshFactory::Reimport

Source code excerpt:

		// Import data already exists, apply it to the fbx import options
		//Some options not supported with skeletal mesh
		ImportData->bBakePivotInVertex = false;
		ImportData->bTransformVertexToAbsolute = true;

		if (!GetSourceFileName(ImportData, Filename, true))
		{
			UE_LOG(LogEditorFactories, Warning, TEXT("-- cannot reimport: source file cannot be found."));
			return EReimportResult::Failed;

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

Scope (from outer to inner):

file
namespace    UnFbx
function     FBXImportOptions* GetImportOptions

Source code excerpt:

		{
			//Set some hardcoded options for skeletal mesh
			ImportUI->SkeletalMeshImportData->bBakePivotInVertex = false;
			ImportOptions->bBakePivotInVertex = false;
			ImportUI->SkeletalMeshImportData->bTransformVertexToAbsolute = true;
			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;

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

Scope (from outer to inner):

file
namespace    UnFbx
function     void ApplyImportUIToImportOptions

Source code excerpt:

		InOutImportOptions.ImportUniformScale		= StaticMeshData->ImportUniformScale;
		InOutImportOptions.bTransformVertexToAbsolute = StaticMeshData->bTransformVertexToAbsolute;
		InOutImportOptions.bBakePivotInVertex		= StaticMeshData->bBakePivotInVertex;
		InOutImportOptions.bImportStaticMeshLODs	= StaticMeshData->bImportMeshLODs;
		InOutImportOptions.bConvertScene			= StaticMeshData->bConvertScene;
		InOutImportOptions.bForceFrontXAxis			= StaticMeshData->bForceFrontXAxis;
		InOutImportOptions.bConvertSceneUnit		= StaticMeshData->bConvertSceneUnit;
		InOutImportOptions.VertexColorImportOption	= StaticMeshData->VertexColorImportOption;
		InOutImportOptions.VertexOverrideColor		= StaticMeshData->VertexOverrideColor;

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

Scope (from outer to inner):

file
namespace    UnFbx
function     void ApplyImportUIToImportOptions

Source code excerpt:

		InOutImportOptions.ImportUniformScale			= SkeletalMeshData->ImportUniformScale;
		InOutImportOptions.bTransformVertexToAbsolute	= SkeletalMeshData->bTransformVertexToAbsolute;
		InOutImportOptions.bBakePivotInVertex			= SkeletalMeshData->bBakePivotInVertex;
		InOutImportOptions.bImportSkeletalMeshLODs		= SkeletalMeshData->bImportMeshLODs;
		InOutImportOptions.bConvertScene				= SkeletalMeshData->bConvertScene;
		InOutImportOptions.bForceFrontXAxis				= SkeletalMeshData->bForceFrontXAxis;
		InOutImportOptions.bConvertSceneUnit			= SkeletalMeshData->bConvertSceneUnit;
		InOutImportOptions.VertexColorImportOption		= SkeletalMeshData->VertexColorImportOption;
		InOutImportOptions.VertexOverrideColor			= SkeletalMeshData->VertexOverrideColor;

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

Scope (from outer to inner):

file
lambda-function

Source code excerpt:

							Attribs.Add(FAnalyticsEventAttribute(TEXT("MeshOpt AutoGenerateCollision"), CaptureImportOptions->bAutoGenerateCollision));
							Attribs.Add(FAnalyticsEventAttribute(TEXT("MeshOpt CombineToSingle"), CaptureImportOptions->bCombineToSingle));
							Attribs.Add(FAnalyticsEventAttribute(TEXT("MeshOpt BakePivotInVertex"), CaptureImportOptions->bBakePivotInVertex));
							Attribs.Add(FAnalyticsEventAttribute(TEXT("MeshOpt TransformVertexToAbsolute"), CaptureImportOptions->bTransformVertexToAbsolute));
							Attribs.Add(FAnalyticsEventAttribute(TEXT("MeshOpt ImportRigidMesh"), CaptureImportOptions->bImportRigidMesh));
							Attribs.Add(FAnalyticsEventAttribute(TEXT("MeshOpt NormalGenerationMethod"), FBXNormalGenerationMethodEnum->GetNameStringByValue(CaptureImportOptions->NormalGenerationMethod)));
							Attribs.Add(FAnalyticsEventAttribute(TEXT("MeshOpt NormalImportMethod"), FBXNormalImportMethodEnum->GetNameStringByValue(CaptureImportOptions->NormalImportMethod)));
							Attribs.Add(FAnalyticsEventAttribute(TEXT("MeshOpt ComputeWeightedNormals"), CaptureImportOptions->bComputeWeightedNormals));
						};

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

Scope (from outer to inner):

file
namespace    UnFbx
function     FbxAMatrix FFbxImporter::ComputeTotalMatrix

Source code excerpt:

	if (!ImportOptions->bTransformVertexToAbsolute)
	{
		if (ImportOptions->bBakePivotInVertex)
		{
			FbxAMatrix PivotGeometry;
			FbxVector4 RotationPivot = Node->GetRotationPivot(FbxNode::eSourcePivot);
			FbxVector4 FullPivot;
			FullPivot[0] = -RotationPivot[0];
			FullPivot[1] = -RotationPivot[1];

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMeshImportData.cpp:11

Scope (from outer to inner):

file
function     UFbxMeshImportData::UFbxMeshImportData

Source code excerpt:

	NormalGenerationMethod = EFBXNormalGenerationMethod::MikkTSpace;
	bComputeWeightedNormals = true;
	bBakePivotInVertex = false;
	bReorderMaterialToFbxOrder = true;
}

bool UFbxMeshImportData::CanEditChange(const FProperty* InProperty) const
{
	bool bMutable = Super::CanEditChange(InProperty);

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSceneImportData.cpp:82

Scope (from outer to inner):

file
function     UnFbx::FBXImportOptions *JSONToFbxOption

Source code excerpt:

	}
	OptionObj->TryGetBoolField(TEXT("bTransformVertexToAbsolute"), Option->bTransformVertexToAbsolute);
	OptionObj->TryGetBoolField(TEXT("bBakePivotInVertex"), Option->bBakePivotInVertex);
	OptionObj->TryGetBoolField(TEXT("bCombineToSingle"), Option->bCombineToSingle);
	int32 VertexColorImportOption;
	if (OptionObj->TryGetNumberField(TEXT("VertexColorImportOption"), VertexColorImportOption))
	{
		Option->VertexColorImportOption = (EVertexColorImportOption::Type)VertexColorImportOption;
	}

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSceneImportData.cpp:186

Scope (from outer to inner):

file
function     FString FbxOptionToJSON

Source code excerpt:

		(int32)Option->NormalGenerationMethod,
		Option->bTransformVertexToAbsolute ? 1 : 0,
		Option->bBakePivotInVertex ? 1 : 0,
		Option->bCombineToSingle ? 1 : 0,
		(int32)Option->VertexColorImportOption,
		Option->VertexOverrideColor.R,
		Option->VertexOverrideColor.G,
		Option->VertexOverrideColor.B,
		Option->VertexOverrideColor.A

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

Scope (from outer to inner):

file
function     bool GetFbxSceneImportOptions

Source code excerpt:

	GlobalImportSettings->bConvertSceneUnit = true;

	GlobalImportSettings->bBakePivotInVertex = SceneImportOptions->bBakePivotInVertex;
	GlobalImportSettings->bInvertNormalMap = SceneImportOptions->bInvertNormalMaps;

	//TODO this options will be set by the fbxscene UI in the material options tab, it also should be save/load from config file
	//Prefix materials package name to put all material under Material folder (this avoid name clash with meshes)
	GlobalImportSettings->MaterialBasePath = NAME_None;

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

Scope (from outer to inner):

file
function     bool GetFbxSceneImportOptions

Source code excerpt:

	//setup all options
	GlobalImportSettings->bForceFrontXAxis = SceneImportOptions->bForceFrontXAxis;
	GlobalImportSettings->bBakePivotInVertex = SceneImportOptions->bBakePivotInVertex;
	GlobalImportSettings->bImportStaticMeshLODs = SceneImportOptions->bImportStaticMeshLODs;
	GlobalImportSettings->bImportSkeletalMeshLODs = SceneImportOptions->bImportSkeletalMeshLODs;
	GlobalImportSettings->bInvertNormalMap = SceneImportOptions->bInvertNormalMaps;
	GlobalImportSettings->ImportTranslation = SceneImportOptions->ImportTranslation;
	GlobalImportSettings->ImportRotation = SceneImportOptions->ImportRotation;
	GlobalImportSettings->ImportUniformScale = SceneImportOptions->ImportUniformScale;

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

Scope (from outer to inner):

file
function     void UFbxSceneImportFactory::CreateLevelActorHierarchy

Source code excerpt:

				FVector PivotLocation(0.0f);
				FVector ParentPivotAccumulation(0.0f);
				if (!IsSkeletalMesh && GlobalImportSettings->bBakePivotInVertex)
				{
					ParentPivotAccumulation -= GetParentPivotAccumulation(NodeInfo, SceneInfoPtr, RootTransform);
					if (NodeInfo->AttributeInfo.IsValid() && NodeInfo->AttributeInfo->PivotNodeUid != INVALID_UNIQUE_ID)
					{
						for (TSharedPtr<FFbxNodeInfo> NodeInfoIter : SceneInfoPtr->HierarchyInfo)
						{

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

Scope (from outer to inner):

file
function     AActor *UFbxSceneImportFactory::CreateActorComponentsHierarchy

Source code excerpt:

		FVector PivotLocation(0.0f);
		FVector ParentPivotAccumulation(0.0f);
		if (!IsSkeletalMesh && GlobalImportSettings->bBakePivotInVertex)
		{
			ParentPivotAccumulation -= GetParentPivotAccumulation(NodeInfo, SceneInfoPtr, RootTransform);
			if (NodeInfo->AttributeInfo.IsValid() && NodeInfo->AttributeInfo->PivotNodeUid != INVALID_UNIQUE_ID)
			{
				for (TSharedPtr<FFbxNodeInfo> NodeInfoIter : SceneInfoPtr->HierarchyInfo)
				{

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

Scope (from outer to inner):

file
function     void UFbxSceneImportFactory::ApplyTransformToComponent

Source code excerpt:

	check(LocalTransform);
	FTransform LocalTransformAdjusted = (*LocalTransform);
	if (GlobalImportSettings->bBakePivotInVertex && (!PivotLocation.IsNearlyZero() || !ParentPivotAccumulation.IsNearlyZero()))
	{
		FTransform PivotTransform;
		PivotTransform.SetLocation(ParentPivotAccumulation);
		LocalTransformAdjusted = LocalTransformAdjusted * PivotTransform;
		PivotTransform.SetIdentity();
		PivotTransform.SetLocation(PivotLocation);

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

Scope (from outer to inner):

file
function     UObject* UFbxSceneImportFactory::ImportOneSkeletalMesh

Source code excerpt:


	ApplyMeshInfoFbxOptions(MeshInfo);
	//TODO support bBakePivotInVertex
	bool Old_bBakePivotInVertex = GlobalImportSettings->bBakePivotInVertex;
	GlobalImportSettings->bBakePivotInVertex = false;
	GlobalImportSettings->bImportBoneTracks = true;
	//if (GlobalImportSettings->bBakePivotInVertex && RootNodeInfo->AttributeInfo->PivotNodeUid == INVALID_UNIQUE_ID)
	//{
		//GlobalImportSettings->bBakePivotInVertex = false;
	//}

	// check if there is LODGroup for this skeletal mesh
	int32 MaxLODLevel = 1;
	for (int32 j = 0; j < NodeArray.Num(); j++)
	{

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

Scope (from outer to inner):

file
function     UObject* UFbxSceneImportFactory::ImportOneSkeletalMesh

Source code excerpt:

		TArray<FbxNode*> SkelMeshNodePivotArray;
		bool bUseSkelMeshNodePivotArray = false;
		if (GlobalImportSettings->bBakePivotInVertex)
		{
			for (FbxNode *SkelMeshNode : SkelMeshNodeArray)
			{
				TSharedPtr<FFbxNodeInfo> ExportNodeInfo;
				if (FindSceneNodeInfo(SceneInfo, SkelMeshNode->GetUniqueID(), ExportNodeInfo))
				{

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

Scope (from outer to inner):

file
function     UObject* UFbxSceneImportFactory::ImportOneSkeletalMesh

Source code excerpt:

	
	//Put back the options
	GlobalImportSettings->bBakePivotInVertex = Old_bBakePivotInVertex;

	//FScopedSkeletalMeshPostEditChange will call post edit change when going out of scope
	return NewObject;
}

void UFbxSceneImportFactory::ImportAllSkeletalMesh(void* VoidRootNodeToImport, void* VoidFbxImporter, EObjectFlags Flags, int32& NodeIndex, int32& InterestingNodeCount, TSharedPtr<FFbxSceneInfo> SceneInfo)

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

Scope (from outer to inner):

file
function     UObject* UFbxSceneImportFactory::ImportANode

Source code excerpt:

	
	ApplyMeshInfoFbxOptions(MeshInfo);
	bool Old_bBakePivotInVertex = GlobalImportSettings->bBakePivotInVertex;
	if (GlobalImportSettings->bBakePivotInVertex && OutNodeInfo->AttributeInfo->PivotNodeUid == INVALID_UNIQUE_ID)
	{
		GlobalImportSettings->bBakePivotInVertex = false;
	}
	FName StaticMeshFName = FName(*(OutNodeInfo->AttributeInfo->Name));
	//Make sure to bake the pivot the user choose to bake
	if (GlobalImportSettings->bBakePivotInVertex && Nodes.Num() == 1)
	{
		FbxNode *NodePivot = FindFbxNodeById(FFbxImporter, nullptr, OutNodeInfo->AttributeInfo->PivotNodeUid);
		if (NodePivot != nullptr)
		{
			Nodes[0] = NodePivot;
		}

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

Scope (from outer to inner):

file
function     UObject* UFbxSceneImportFactory::ImportANode

Source code excerpt:

	}

	GlobalImportSettings->bBakePivotInVertex = Old_bBakePivotInVertex;
	return NewObject;
}

UnFbx::FBXImportOptions *UFbxSceneImportFactory::GetOptionsFromName(FString OptionsName)
{
	for (auto kvp : NameOptionsMap)

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSceneImportOptions.cpp:9

Scope (from outer to inner):

file
function     UFbxSceneImportOptions::UFbxSceneImportOptions

Source code excerpt:

{
	bTransformVertexToAbsolute = false;
	bBakePivotInVertex = false;
	bCreateContentFolderHierarchy = false;
	bImportAsDynamic = false;
	HierarchyType = EFBXSceneOptionsCreateHierarchyType::FBXSOCHT_CreateBlueprint;
	bForceFrontXAxis = false;
	bImportStaticMeshLODs = false;
	bImportSkeletalMeshLODs = false;

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

Scope (from outer to inner):

file
function     void UFbxSceneImportOptionsSkeletalMesh::FillSkeletalMeshInmportData

Source code excerpt:

	SkeletalMeshImportData->ImportUniformScale = SceneImportOptions->ImportUniformScale;
	SkeletalMeshImportData->bTransformVertexToAbsolute = SceneImportOptions->bTransformVertexToAbsolute;
	SkeletalMeshImportData->bBakePivotInVertex = SceneImportOptions->bBakePivotInVertex;
	
	SkeletalMeshImportData->bImportAsScene = true;

	AnimSequenceImportData->bImportMeshesInBoneHierarchy = bImportMeshesInBoneHierarchy;
	AnimSequenceImportData->AnimationLength = AnimationLength;
	AnimSequenceImportData->bDeleteExistingMorphTargetCurves = bDeleteExistingMorphTargetCurves;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSceneImportOptionsStaticMesh.cpp:57

Scope (from outer to inner):

file
function     void UFbxSceneImportOptionsStaticMesh::FillStaticMeshInmportData

Source code excerpt:

	StaticMeshImportData->ImportUniformScale = SceneImportOptions->ImportUniformScale;
	StaticMeshImportData->bTransformVertexToAbsolute = SceneImportOptions->bTransformVertexToAbsolute;
	StaticMeshImportData->bBakePivotInVertex = SceneImportOptions->bBakePivotInVertex;

	StaticMeshImportData->bImportAsScene = true;
}

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSkeletalMeshImportData.cpp:11

Scope (from outer to inner):

file
function     UFbxSkeletalMeshImportData::UFbxSkeletalMeshImportData

Source code excerpt:

{
	bTransformVertexToAbsolute = true;
	bBakePivotInVertex = false;
	VertexColorImportOption = EVertexColorImportOption::Replace;
	LastImportContentType = EFBXImportContentType::FBXICT_All;
	bKeepSectionsSeparate = false;
}

void UFbxSkeletalMeshImportData::Serialize(FArchive& Ar)

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxStaticMeshImport.cpp:1283

Scope (from outer to inner):

file
function     UStaticMesh* UnFbx::FFbxImporter::ReimportSceneStaticMesh

Source code excerpt:

		for (FbxNode *MeshNode : FbxMeshArray)
		{
			if (FbxNodeUniqueId == INVALID_UNIQUE_ID || ImportOptions->bBakePivotInVertex == false)
			{
				if (FbxUniqueId == MeshNode->GetMesh()->GetUniqueID())
				{
					Node = MeshNode;
					break;
				}

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxStaticMeshImportData.cpp:14

Scope (from outer to inner):

file
function     UFbxStaticMeshImportData::UFbxStaticMeshImportData

Source code excerpt:

	bAutoGenerateCollision = true;
	bTransformVertexToAbsolute = true;
	bBakePivotInVertex = false;
	VertexOverrideColor = FColor(255, 255, 255, 255);
	DistanceFieldResolutionScale = 1.0f;
}

UFbxStaticMeshImportData* UFbxStaticMeshImportData::GetImportDataForStaticMesh(UStaticMesh* StaticMesh, UFbxStaticMeshImportData* TemplateForCreation)
{

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

Scope (from outer to inner):

file
function     bool GetFbxSceneReImportOptions

Source code excerpt:


	//Set the bakepivot option in the SceneImportOptions
	SceneImportOptions->bBakePivotInVertex = GlobalImportSettings->bBakePivotInVertex;
	//setup all options
	GlobalImportSettings->bForceFrontXAxis = SceneImportOptions->bForceFrontXAxis;
	GlobalImportSettings->bImportStaticMeshLODs = SceneImportOptions->bImportStaticMeshLODs;
	GlobalImportSettings->bImportSkeletalMeshLODs = SceneImportOptions->bImportSkeletalMeshLODs;
	SceneImportOptions->bInvertNormalMaps = GlobalImportSettings->bInvertNormalMap;
	GlobalImportSettings->ImportTranslation = SceneImportOptions->ImportTranslation;

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

Scope (from outer to inner):

file
function     EReimportResult::Type UReimportFbxSceneFactory::Reimport

Source code excerpt:

	{
		UnFbx::FBXImportOptions *DefaultOption = *(ReimportData->NameOptionsMap.Find(DefaultOptionName));
		GlobalImportSettings->bBakePivotInVertex = DefaultOption->bBakePivotInVertex;
		GlobalImportSettings->bInvertNormalMap = DefaultOption->bInvertNormalMap;
	}
	bool OriginalForceFrontXAxis = GlobalImportSettings->bForceFrontXAxis;
	//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), true))
	{

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

Scope (from outer to inner):

file
function     EReimportResult::Type UReimportFbxSceneFactory::Reimport

Source code excerpt:

	SFbxSceneOptionWindow::CopyFbxOptionsToStaticMeshOptions(GlobalImportSettings, SceneImportOptionsStaticMesh);
	SFbxSceneOptionWindow::CopyFbxOptionsToSkeletalMeshOptions(GlobalImportSettings, SceneImportOptionsSkeletalMesh);
	SceneImportOptions->bBakePivotInVertex = GlobalImportSettings->bBakePivotInVertex;
	SceneImportOptions->bTransformVertexToAbsolute = GlobalImportSettings->bTransformVertexToAbsolute;
	SceneImportOptions->bImportStaticMeshLODs = GlobalImportSettings->bImportStaticMeshLODs;
	SceneImportOptions->bImportSkeletalMeshLODs = GlobalImportSettings->bImportSkeletalMeshLODs;

	FString PackageName = "";
	Obj->GetOutermost()->GetName(PackageName);

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

Scope (from outer to inner):

file
function     EReimportResult::Type UReimportFbxSceneFactory::ImportSkeletalMesh

Source code excerpt:

	ApplyMeshInfoFbxOptions(MeshInfo);
	
	//TODO support bBakePivotInVertex
	bool Old_bBakePivotInVertex = GlobalImportSettings->bBakePivotInVertex;
	GlobalImportSettings->bBakePivotInVertex = false;
	GlobalImportSettings->bImportBoneTracks = true;
	//if (GlobalImportSettings->bBakePivotInVertex && MeshInfo->PivotNodeUid == INVALID_UNIQUE_ID)
	//{
		//GlobalImportSettings->bBakePivotInVertex = false;
	//}

	TArray< TArray<FbxNode*>* > SkelMeshArray;
	FbxImporter->FillFbxSkelMeshArrayInScene(RootNodeToImport, SkelMeshArray, false, GlobalImportSettings->bImportAsSkeletalGeometry || GlobalImportSettings->bImportAsSkeletalSkinning, true);
	UObject* NewObject = nullptr;
	for (int32 i = 0; i < SkelMeshArray.Num(); i++)

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

Scope (from outer to inner):

file
function     EReimportResult::Type UReimportFbxSceneFactory::ImportSkeletalMesh

Source code excerpt:

	}

	GlobalImportSettings->bBakePivotInVertex = Old_bBakePivotInVertex;

	for (int32 i = 0; i < SkelMeshArray.Num(); i++)
	{
		delete SkelMeshArray[i];
	}

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

Scope (from outer to inner):

file
function     EReimportResult::Type UReimportFbxSceneFactory::ImportStaticMesh

Source code excerpt:

	SceneImportOptionsStaticMesh->FillStaticMeshInmportData(StaticMeshImportData, SceneImportOptions);
	//Override the pivot bake option
	if (GlobalImportSettings->bBakePivotInVertex && MeshInfo->PivotNodeUid == INVALID_UNIQUE_ID)
	{
		GlobalImportSettings->bBakePivotInVertex = false;
	}
	FName StaticMeshFName = FName(*(MeshInfo->Name));

	UStaticMesh *NewObject = nullptr;
	FbxNode* NodeParent = FbxImporter->RecursiveFindParentLodGroup(GeometryParentNode->GetParent());
	if (NodeParent && NodeParent->GetNodeAttribute() && NodeParent->GetNodeAttribute()->GetAttributeType() == FbxNodeAttribute::eLODGroup)

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

Scope (from outer to inner):

file
function     EReimportResult::Type UReimportFbxSceneFactory::ReimportSkeletalMesh

Source code excerpt:


	ApplyMeshInfoFbxOptions(MeshInfo);
	//TODO support bBakePivotInVertex
	bool Old_bBakePivotInVertex = GlobalImportSettings->bBakePivotInVertex;
	GlobalImportSettings->bBakePivotInVertex = false;
	GlobalImportSettings->bImportBoneTracks = true;
	//if (GlobalImportSettings->bBakePivotInVertex && MeshInfo->PivotNodeUid == INVALID_UNIQUE_ID)
	//{
		//GlobalImportSettings->bBakePivotInVertex = false;
	//}
	TArray<FbxNode*> OutSkeletalMeshArray;
	EReimportResult::Type ReimportResult = EReimportResult::Succeeded;
	if (FbxImporter->ReimportSkeletalMesh(Mesh, SkeletalMeshImportData, MeshInfo->UniqueId, &OutSkeletalMeshArray))
	{
		Mesh->GetAssetImportData()->Update(FbxImportFileName);

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

Scope (from outer to inner):

file
function     EReimportResult::Type UReimportFbxSceneFactory::ReimportSkeletalMesh

Source code excerpt:

		ReimportResult = EReimportResult::Failed;
	}
	GlobalImportSettings->bBakePivotInVertex = Old_bBakePivotInVertex;
	return ReimportResult;
}

EReimportResult::Type UReimportFbxSceneFactory::ReimportStaticMesh(void* VoidFbxImporter, TSharedPtr<FFbxMeshInfo> MeshInfo)
{
	UnFbx::FFbxImporter* FbxImporter = (UnFbx::FFbxImporter*)VoidFbxImporter;

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

Scope (from outer to inner):

file
function     EReimportResult::Type UReimportFbxSceneFactory::ReimportStaticMesh

Source code excerpt:

	ApplyMeshInfoFbxOptions(MeshInfo);
	//Override the pivot bake option
	bool Old_bBakePivotInVertex = GlobalImportSettings->bBakePivotInVertex;
	if (GlobalImportSettings->bBakePivotInVertex && MeshInfo->PivotNodeUid == INVALID_UNIQUE_ID)
	{
		GlobalImportSettings->bBakePivotInVertex = false;
	}
	EReimportResult::Type ReimportResult = EReimportResult::Succeeded;

	FbxImporter->ApplyTransformSettingsToFbxNode(FbxImporter->Scene->GetRootNode(), StaticMeshImportData);
	const TArray<UAssetUserData*>* UserData = Mesh->GetAssetUserDataArray();
	TMap<UAssetUserData*, bool> UserDataCopy;

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

Scope (from outer to inner):

file
function     EReimportResult::Type UReimportFbxSceneFactory::ReimportStaticMesh

Source code excerpt:

	const FVector NegativeBoundsExtension = Mesh->GetNegativeBoundsExtension();
	uint64 NodeInfoUid = INVALID_UNIQUE_ID;
	if (GlobalImportSettings->bBakePivotInVertex && MeshInfo->PivotNodeUid != INVALID_UNIQUE_ID)
	{
		NodeInfoUid = MeshInfo->PivotNodeUid;
	}

	Mesh = FbxImporter->ReimportSceneStaticMesh(NodeInfoUid, MeshInfo->UniqueId, Mesh, StaticMeshImportData);
	if (Mesh != nullptr)

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

Scope (from outer to inner):

file
function     EReimportResult::Type UReimportFbxSceneFactory::ReimportStaticMesh

Source code excerpt:

		ReimportResult = EReimportResult::Failed;
	}
	GlobalImportSettings->bBakePivotInVertex = Old_bBakePivotInVertex;
	return ReimportResult;
}

int32 UReimportFbxSceneFactory::GetPriority() const
{
	return ImportPriority;

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

Scope (from outer to inner):

file
function     void SFbxSceneOptionWindow::OnFinishedChangingPropertiesSceneTabDetailView

Source code excerpt:

	//Set the Global Import setting
	GlobalImportSettings->bForceFrontXAxis = SceneImportOptionsDisplay->bForceFrontXAxis;
	GlobalImportSettings->bBakePivotInVertex = SceneImportOptionsDisplay->bBakePivotInVertex;
	GlobalImportSettings->bInvertNormalMap = SceneImportOptionsDisplay->bInvertNormalMaps;
	GlobalImportSettings->ImportTranslation = SceneImportOptionsDisplay->ImportTranslation;
	GlobalImportSettings->ImportRotation = SceneImportOptionsDisplay->ImportRotation;
	GlobalImportSettings->ImportUniformScale = SceneImportOptionsDisplay->ImportUniformScale;
}

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

Scope (from outer to inner):

file
function     void SFbxSceneOptionWindow::OnToggleBakePivotInVertex

Source code excerpt:

	if (GlobalImportSettings != nullptr)
	{
		GlobalImportSettings->bBakePivotInVertex = CheckType == ECheckBoxState::Checked;
	}
}

ECheckBoxState SFbxSceneOptionWindow::IsBakePivotInVertexChecked() const
{
	return  GlobalImportSettings->bBakePivotInVertex ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
}

TSharedRef<SDockTab> SFbxSceneOptionWindow::SpawnStaticMeshReimportTab(const FSpawnTabArgs& Args)
{
	//Create the static mesh listview
	StaticMeshReimportListView = SNew(SFbxSceneStaticMeshReimportListView)

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SSceneBaseMeshListView.cpp:75

Scope (from outer to inner):

file
function     void SFbxSSceneBaseMeshListView::Tick

Source code excerpt:

		}
	}
	if (GlobalImportSettings->bBakePivotInVertex && !bFoundColumn)
	{
		HeaderRow->AddColumn(SHeaderRow::Column(FbxSceneBaseListViewColumn::PivotColumnId)
		.FillWidth(150)
		.HAlignCell(EHorizontalAlignment::HAlign_Left)
		.DefaultLabel(LOCTEXT("PivotNameHeaderName", "Pivot Node")));
	}
	else if(!GlobalImportSettings->bBakePivotInVertex && bFoundColumn)
	{
		HeaderRow->RemoveColumn(FbxSceneBaseListViewColumn::PivotColumnId);
	}

	SListView::Tick(AllottedGeometry, InCurrentTime, InDeltaTime);
}

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SSceneBaseMeshListView.cpp:144

Scope (from outer to inner):

file
function     void SFbxSSceneBaseMeshListView::AddBakePivotMenu

Source code excerpt:

void SFbxSSceneBaseMeshListView::AddBakePivotMenu(class FMenuBuilder& MenuBuilder)
{
	if (GlobalImportSettings->bBakePivotInVertex)
	{
		MenuBuilder.AddMenuSeparator();
		// Add a sub-menu for "Pivot"
		MenuBuilder.AddSubMenu(
			LOCTEXT("PivotBakeSubMenu", "Pivot Options"),
			LOCTEXT("PivotBakeSubMenu_ToolTip", "Choose which pivot to Bake from"),

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SSceneImportStaticMeshListView.cpp:165

Scope (from outer to inner):

file
class        class SFbxMeshItemTableListViewRow : public SMultiColumnTableRow<FbxMeshInfoPtr>
function     FText GetAssetPivotNodeName

Source code excerpt:

	FText GetAssetPivotNodeName() const
	{
		return GlobalImportSettings->bBakePivotInVertex ? FText::FromString(FbxMeshInfo->PivotNodeName) : FText::FromString(TEXT("-"));
	}

	/** The node info to build the tree view row from. */
	FbxMeshInfoPtr FbxMeshInfo;
	UnFbx::FBXImportOptions *GlobalImportSettings;
};

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SSceneReimportSkeletalMeshListView.cpp:270

Scope (from outer to inner):

file
class        class SFbxSkeletalReimportItemTableListViewRow : public SMultiColumnTableRow<FbxMeshInfoPtr>
function     FText GetAssetPivotNodeName

Source code excerpt:

	FText GetAssetPivotNodeName() const
	{
		//TODO support bBakePivotInVertex
		//return GlobalImportSettings->bBakePivotInVertex ? FText::FromString(FbxMeshInfo->PivotNodeName) : FText::FromString(TEXT("-"));
		return FText::FromString(TEXT("-"));
	}

	/** The node info to build the tree view row from. */
	FbxMeshInfoPtr FbxMeshInfo;
	FbxSceneReimportStatusMapPtr MeshStatusMap;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SSceneReimportSkeletalMeshListView.cpp:455

Scope (from outer to inner):

file
function     TSharedPtr<SWidget> SFbxSceneSkeletalMeshReimportListView::OnOpenContextMenu

Source code excerpt:

	MenuBuilder.EndSection();
	
	//TODO support bBakePivotInVertex 
	//AddBakePivotMenu(MenuBuilder);

	bool bShowOptionMenu = false;
	for (FbxMeshInfoPtr MeshInfo : SelectedFbxMeshInfos)
	{
		EFbxSceneReimportStatusFlags ReimportFlags = *MeshStatusMap->Find(MeshInfo->OriginalImportPath);

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SSceneReimportStaticMeshListView.cpp:272

Scope (from outer to inner):

file
class        class SFbxMeshReimportItemTableListViewRow : public SMultiColumnTableRow<FbxMeshInfoPtr>
function     FText GetAssetPivotNodeName

Source code excerpt:

	FText GetAssetPivotNodeName() const
	{
		return GlobalImportSettings->bBakePivotInVertex ? FText::FromString(FbxMeshInfo->PivotNodeName) : FText::FromString(TEXT("-"));
	}

	/** The node info to build the tree view row from. */
	FbxMeshInfoPtr FbxMeshInfo;
	FbxSceneReimportStatusMapPtr MeshStatusMap;
	UnFbx::FBXImportOptions *GlobalImportSettings;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SSceneSkeletalMeshListView.cpp:165

Scope (from outer to inner):

file
class        class SFbxSleletalItemTableListViewRow : public SMultiColumnTableRow<FbxMeshInfoPtr>
function     FText GetAssetPivotNodeName

Source code excerpt:

	FText GetAssetPivotNodeName() const
	{
		return GlobalImportSettings->bBakePivotInVertex ? FText::FromString(FbxMeshInfo->PivotNodeName) : FText::FromString(TEXT("-"));
	}

	/** The node info to build the tree view row from. */
	FbxMeshInfoPtr FbxMeshInfo;
	UnFbx::FBXImportOptions *GlobalImportSettings;
};

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

Scope (from outer to inner):

file
namespace    FbxMeshUtils
function     bool ImportSkeletalMeshLOD

Source code excerpt:

				ReimportUI->SkeletalMeshImportData = ImportData;
				//Some options not supported with skeletal mesh
				ReimportUI->SkeletalMeshImportData->bBakePivotInVertex = false;
				ReimportUI->SkeletalMeshImportData->bTransformVertexToAbsolute = true;
				ApplyImportUIToImportOptions(ReimportUI, *ImportOptions);
			}
			ImportOptions->bImportMaterials = false;
			ImportOptions->bImportTextures = false;
		}

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

Scope (from outer to inner):

file
namespace    UnFbx

Source code excerpt:

	bool bComputeWeightedNormals;
	bool bTransformVertexToAbsolute;
	bool bBakePivotInVertex;
	EFBXImportType ImportType;
	// Static Mesh options
	bool bCombineToSingle;
	EVertexColorImportOption::Type VertexColorImportOption;
	FColor VertexOverrideColor;
	float DistanceFieldResolutionScale;