bConvertScene

bConvertScene

#Overview

name: bConvertScene

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

It is referenced in 40 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of bConvertScene is to control whether the FBX scene’s coordinate system should be converted to Unreal Engine’s coordinate system during import. Here are the key points about this variable:

  1. The variable is used primarily in the FBX import system, which is part of Unreal Engine’s asset import pipeline.

  2. It’s mainly used in the Interchange module and the FBX importer subsystem.

  3. The value is typically set in the import options, either programmatically or through user interface settings.

  4. When set to true (which is the default in most cases), it triggers the conversion of the FBX scene’s coordinate system to match Unreal Engine’s coordinate system.

  5. This variable often interacts with bForceFrontXAxis and bConvertSceneUnit, which provide additional control over the conversion process.

  6. The conversion process typically involves adjusting the scene’s axis system and potentially scaling to match Unreal Engine’s conventions.

  7. Developers should be aware that changing this setting can affect the orientation and scale of imported assets.

  8. Best practices include:

    • Keeping this set to true unless you have a specific reason to maintain the original FBX coordinate system.
    • Ensuring consistency across imports by using the same settings for related assets.
    • Documenting any non-standard import settings used in a project to avoid confusion.

  9. The variable is often exposed in import dialogs and can be saved in asset import data for future reimports.

  10. When working with this variable, developers should also consider the impact on animations, skeletal rigs, and any custom import logic that might depend on the scene’s coordinate system.

#Setting Variables

#References In INI files

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

Location: <Workspace>/Engine/Plugins/Interchange/Runtime/Config/BaseInterchange.ini:67, section: [/Script/InterchangeImport.InterchangeFbxTranslatorProjectSettings]

#References in C++ code

#Callsites

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

#Loc: <Workspace>/Engine/Plugins/Animation/ControlRig/Source/ControlRigEditor/Private/ControlRigDrawingDetails.cpp:132

Scope (from outer to inner):

file
function     void FControlRigDrawContainerDetails::ImportCurvesFromFBX

Source code excerpt:

	UnFbx::FBXImportOptions* ImportOptions = Importer->GetImportOptions();
	UnFbx::FBXImportOptions::ResetOptions(ImportOptions);
	ImportOptions->bConvertScene = false;
	ImportOptions->bForceFrontXAxis = false;
	ImportOptions->bConvertSceneUnit = false;
	
	const FString FileExtension = FPaths::GetExtension(InFilePath);
	if (!Importer->ImportFromFile(*InFilePath, FileExtension, true))
	{

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

Scope (from outer to inner):

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

Source code excerpt:

		if (InterchangeFbxTranslatorSettings)
		{
			AssetImportData->bConvertScene = InterchangeFbxTranslatorSettings->bConvertScene;
			AssetImportData->bConvertSceneUnit = InterchangeFbxTranslatorSettings->bConvertSceneUnit;
			AssetImportData->bForceFrontXAxis = InterchangeFbxTranslatorSettings->bForceFrontXAxis;
			
		}
		else if(UInterchangeFbxTranslatorSettings* InterchangeFbxTranslatorSettingsCDO = UInterchangeFbxTranslatorSettings::StaticClass()->GetDefaultObject<UInterchangeFbxTranslatorSettings>())
		{
			AssetImportData->bConvertScene = InterchangeFbxTranslatorSettingsCDO->bConvertScene;
			AssetImportData->bConvertSceneUnit = InterchangeFbxTranslatorSettingsCDO->bConvertSceneUnit;
			AssetImportData->bForceFrontXAxis = InterchangeFbxTranslatorSettingsCDO->bForceFrontXAxis;
		}
		else
		{
			AssetImportData->bConvertScene = true;
			AssetImportData->bConvertSceneUnit = true;
			AssetImportData->bForceFrontXAxis = false;
		}
		AssetImportData->bImportAsScene = false;
		AssetImportData->ImportRotation = GenericAssetPipeline->ImportOffsetRotation;
		AssetImportData->ImportTranslation = GenericAssetPipeline->ImportOffsetTranslation;

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

Scope (from outer to inner):

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

Source code excerpt:

		UInterchangeFbxTranslatorSettings* InterchangeFbxTranslatorSettings = NewObject<UInterchangeFbxTranslatorSettings>(DestinationData);
		InterchangeFbxTranslatorSettings->ClearInternalFlags(EInternalObjectFlags::Async);
		InterchangeFbxTranslatorSettings->bConvertScene = FbxAssetImportData->bConvertScene;
		InterchangeFbxTranslatorSettings->bForceFrontXAxis = FbxAssetImportData->bForceFrontXAxis;
		InterchangeFbxTranslatorSettings->bConvertSceneUnit = FbxAssetImportData->bConvertSceneUnit;
		DestinationData->SetTranslatorSettings(InterchangeFbxTranslatorSettings);

		if (const UFbxStaticMeshImportData* LegacyStaticMeshImportData = Cast<UFbxStaticMeshImportData>(FbxAssetImportData))
		{

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

Scope (from outer to inner):

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

Source code excerpt:

				UInterchangeFbxTranslatorSettings* InterchangeFbxTranslatorSettings = NewObject<UInterchangeFbxTranslatorSettings>(DestinationData);
				InterchangeFbxTranslatorSettings->ClearInternalFlags(EInternalObjectFlags::Async);
				InterchangeFbxTranslatorSettings->bConvertScene = FbxAssetImportData->bConvertScene;
				InterchangeFbxTranslatorSettings->bForceFrontXAxis = FbxAssetImportData->bForceFrontXAxis;
				InterchangeFbxTranslatorSettings->bConvertSceneUnit = FbxAssetImportData->bConvertSceneUnit;
				DestinationData->SetTranslatorSettings(InterchangeFbxTranslatorSettings);
			};

		//General Options

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Dispatcher/Private/InterchangeDispatcherTask.cpp:78

Scope (from outer to inner):

file
namespace    UE
namespace    Interchange
function     bool FJsonLoadSourceCmd::FromJson

Source code excerpt:

				return false;
			}
			if (!((*ActionDataObject)->TryGetBoolField(GetDoesConvertSceneJsonKey(), bConvertScene)))
			{
				return false;
			}
			if (!((*ActionDataObject)->TryGetBoolField(GetDoesForceFrontXAxisJsonKey(), bForceFrontXAxis)))
			{
				return false;

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Dispatcher/Public/InterchangeDispatcherTask.h:98

Scope (from outer to inner):

file
namespace    UE
namespace    Interchange
class        class FJsonLoadSourceCmd : public IJsonCmdBase
function     FJsonLoadSourceCmd

Source code excerpt:

				: TranslatorID(InTranslatorID)
				, SourceFilename(InSourceFilename)
				, bConvertScene(InbConvertScene)
				, bForceFrontXAxis(InbForceFrontXAxis)
				, bConvertSceneUnit(InbConvertSceneUnit)
			{
				bIsDataInitialize = true;
			}

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Dispatcher/Public/InterchangeDispatcherTask.h:138

Scope (from outer to inner):

file
namespace    UE
namespace    Interchange
class        class FJsonLoadSourceCmd : public IJsonCmdBase
function     bool GetDoesConvertScene

Source code excerpt:

				//Code should not do query data if the data was not set before
				ensure(bIsDataInitialize);
				return bConvertScene;
			}

			static FString GetDoesConvertSceneJsonKey()
			{
				static const FString Key = TEXT("ConvertScene");
				return Key;

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Dispatcher/Public/InterchangeDispatcherTask.h:202

Scope (from outer to inner):

file
namespace    UE
namespace    Interchange
class        class FJsonLoadSourceCmd : public IJsonCmdBase

Source code excerpt:

			FString TranslatorID = FString();
			FString SourceFilename = FString();
			bool bConvertScene = true;
			bool bForceFrontXAxis = false;
			bool bConvertSceneUnit = true;
		};

		class INTERCHANGEDISPATCHER_API FJsonFetchPayloadCmd : public IJsonCmdBase
		{

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Import/Private/Fbx/InterchangeFbxTranslator.cpp:189

Scope (from outer to inner):

file
function     bool UInterchangeFbxTranslator::Translate

Source code excerpt:

	GetSettings();
	ensure(CacheFbxTranslatorSettings);
	const bool bConvertScene = CacheFbxTranslatorSettings ? CacheFbxTranslatorSettings->bConvertScene : true;
	const bool bForceFrontXAxis = CacheFbxTranslatorSettings ? CacheFbxTranslatorSettings->bForceFrontXAxis : false;
	const bool bConvertSceneUnit = CacheFbxTranslatorSettings ? CacheFbxTranslatorSettings->bConvertSceneUnit : true;

	if (bUseWorkerImport)
	{
		if (!Dispatcher.IsValid())

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Import/Private/Fbx/InterchangeFbxTranslator.cpp:200

Scope (from outer to inner):

file
function     bool UInterchangeFbxTranslator::Translate

Source code excerpt:

		}
		//Create a json command to read the fbx file
		FString JsonCommand = CreateLoadFbxFileCommand(Filename, bConvertScene, bForceFrontXAxis, bConvertSceneUnit);
		int32 TaskIndex = Dispatcher->AddTask(JsonCommand);

		//Blocking call until all tasks are executed
		Dispatcher->WaitAllTaskToCompleteExecution();

		FString WorkerFatalError = Dispatcher->GetInterchangeWorkerFatalError();

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Import/Private/Fbx/InterchangeFbxTranslator.cpp:240

Scope (from outer to inner):

file
function     bool UInterchangeFbxTranslator::Translate

Source code excerpt:

		FbxParser.Reset();
		FbxParser.SetResultContainer(Results);
		FbxParser.SetConvertSettings(bConvertScene, bForceFrontXAxis, bConvertSceneUnit);
		FbxParser.LoadFbxFile(Filename, BaseNodeContainer);
#endif
	}
	return true;
}

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Import/Private/Fbx/InterchangeFbxTranslator.cpp:604

Scope (from outer to inner):

file
function     FString UInterchangeFbxTranslator::CreateLoadFbxFileCommand

Source code excerpt:

}

FString UInterchangeFbxTranslator::CreateLoadFbxFileCommand(const FString& FbxFilePath, const bool bConvertScene, const bool bForceFrontXAxis, const bool bConvertSceneUnit) const
{
	UE::Interchange::FJsonLoadSourceCmd LoadSourceCommand(TEXT("FBX"), FbxFilePath, bConvertScene, bForceFrontXAxis, bConvertSceneUnit);
	return LoadSourceCommand.ToJson();
}

FString UInterchangeFbxTranslator::CreateFetchPayloadFbxCommand(const FString& FbxPayloadKey) const
{
	UE::Interchange::FJsonFetchPayloadCmd PayloadCommand(TEXT("FBX"), FbxPayloadKey);

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Import/Public/Fbx/InterchangeFbxTranslator.h:30

Scope (from outer to inner):

file
class        class UInterchangeFbxTranslatorSettings : public UInterchangeTranslatorSettings

Source code excerpt:

	/** Whether to convert FBX scene axis system to Unreal axis system. */
	UPROPERTY(EditAnywhere, Category = "Fbx Translator")
	bool bConvertScene = true;

	/** Whether to force the front axis to be align with X instead of -Y default. */
	UPROPERTY(EditAnywhere, Category = "Fbx Translator", meta = (EditCondition = "bConvertScene"))
	bool bForceFrontXAxis = false;

	/** Whether to convert the scene from FBX unit to UE unit (centimeter). */

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Import/Public/Fbx/InterchangeFbxTranslator.h:102

Scope (from outer to inner):

file
class        class UInterchangeFbxTranslator : public UInterchangeTranslatorBase , public IInterchangeTexturePayloadInterface , public IInterchangeMeshPayloadInterface , public IInterchangeAnimationPayloadInterface

Source code excerpt:

	/* IInterchangeAnimationPayloadInterface End */
private:
	FString CreateLoadFbxFileCommand(const FString& FbxFilePath, const bool bConvertScene, const bool bForceFrontXAxis, const bool bConvertSceneUnit) const;

	FString CreateFetchMeshPayloadFbxCommand(const FString& FbxPayloadKey, const FTransform& MeshGlobalTransform) const;

	FString CreateFetchPayloadFbxCommand(const FString& FbxPayloadKey) const;

	FString CreateFetchAnimationBakeTransformPayloadFbxCommand(const FString& FbxPayloadKey, const double BakeFrequency, const double RangeStartTime, const double RangeEndTime) const;

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Parsers/Fbx/Private/FbxAPI.cpp:130

Scope (from outer to inner):

file
namespace    UE
namespace    Interchange
namespace    Private
function     bool FFbxParser::LoadFbxFile

Source code excerpt:


				//We always convert scene to UE axis and units
				FFbxConvert::ConvertScene(SDKScene, bConvertScene, bForceFrontXAxis, bConvertSceneUnit);

				FrameRate = FbxTime::GetFrameRate(SDKScene->GetGlobalSettings().GetTimeMode());

				return true;
			}

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Parsers/Fbx/Private/FbxAPI.h:51

Scope (from outer to inner):

file
namespace    UE
namespace    Interchange
namespace    Private
class        class FFbxParser
function     void SetConvertSettings

Source code excerpt:

				void SetConvertSettings(const bool InbConvertScene, const bool InbForceFrontXAxis, const bool InbConvertSceneUnit)
				{
					bConvertScene = InbConvertScene;
					bForceFrontXAxis = InbForceFrontXAxis;
					bConvertSceneUnit = InbConvertSceneUnit;
				}

				//return the fbx helper for this parser
				const TSharedPtr<FFbxHelper> GetFbxHelper();

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Parsers/Fbx/Private/FbxAPI.h:124

Scope (from outer to inner):

file
namespace    UE
namespace    Interchange
namespace    Private
class        class FFbxParser

Source code excerpt:


				//Convert settings
				bool bConvertScene = true;
				bool bForceFrontXAxis = false;
				bool bConvertSceneUnit = true;
			};
		}//ns Private
	}//ns Interchange
}//ns UE

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Parsers/Fbx/Private/FbxConvert.cpp:13

Scope (from outer to inner):

file
namespace    UE
namespace    Interchange
namespace    Private
function     void FFbxConvert::ConvertScene

Source code excerpt:

		namespace Private
		{
			void FFbxConvert::ConvertScene(FbxScene* SDKScene, const bool bConvertScene, const bool bForceFrontXAxis, const bool bConvertSceneUnit)
			{
				if (!ensure(SDKScene))
				{
					//Cannot convert a null scene
					return;
				}

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Parsers/Fbx/Private/FbxConvert.cpp:43

Scope (from outer to inner):

file
namespace    UE
namespace    Interchange
namespace    Private
function     void FFbxConvert::ConvertScene

Source code excerpt:



				if (bConvertScene)
				{
					//Set the original file information
					FbxAxisSystem FileAxisSystem = SDKScene->GetGlobalSettings().GetAxisSystem();


					//UE is: z up, front x, left handed

#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Parsers/Fbx/Private/FbxConvert.h:156

Scope (from outer to inner):

file
namespace    UE
namespace    Interchange
namespace    Private

Source code excerpt:

				 * Convert a fbx scene 
				 */
				static void ConvertScene(FbxScene* SDKScene, const bool bConvertScene, const bool bForceFrontXAxis, const bool bConvertSceneUnit);
				
				/** Scene Conversion API End */
				//////////////////////////////////////////////////////////////////////////


				//////////////////////////////////////////////////////////////////////////

#Loc: <Workspace>/Engine/Source/Editor/MovieSceneTools/Private/MovieSceneToolHelpers.cpp:2265

Scope (from outer to inner):

file
function     bool MovieSceneToolHelpers::ImportFBXIntoControlRigChannels

Source code excerpt:


	UnFbx::FBXImportOptions* ImportOptions = FbxImporter->GetImportOptions();
	bool bOldbConvertScene = ImportOptions->bConvertScene;
	bool bOldbConvertSceneUnit = ImportOptions->bConvertSceneUnit;
	bool bOldbForceFrontXAxis = ImportOptions->bForceFrontXAxis;
	float OldUniformScale = ImportOptions->ImportUniformScale;
	EFBXAnimationLengthImportType OldAnimLengthType = ImportOptions->AnimationLengthImportType;


	ImportOptions->bConvertScene = true;
	ImportOptions->bConvertSceneUnit = ImportFBXControlRigSettings->bConvertSceneUnit;
	ImportOptions->bForceFrontXAxis = ImportFBXControlRigSettings->bForceFrontXAxis;
	ImportOptions->ImportUniformScale = ImportFBXControlRigSettings->ImportUniformScale;
	ImportOptions->AnimationLengthImportType = FBXALIT_ExportedTime;

	const FString FileExtension = FPaths::GetExtension(ImportFilename);

#Loc: <Workspace>/Engine/Source/Editor/MovieSceneTools/Private/MovieSceneToolHelpers.cpp:2452

Scope (from outer to inner):

file
function     bool MovieSceneToolHelpers::ImportFBXIntoControlRigChannels

Source code excerpt:


	ImportOptions->AnimationLengthImportType = OldAnimLengthType;
	ImportOptions->bConvertScene = bOldbConvertScene;
	ImportOptions->bConvertSceneUnit = bOldbConvertSceneUnit;
	ImportOptions->bForceFrontXAxis = bOldbForceFrontXAxis;
	ImportOptions->ImportUniformScale = OldUniformScale;;
	return bValid;
}

#Loc: <Workspace>/Engine/Source/Editor/MovieSceneTools/Private/MovieSceneToolHelpers.cpp:3407

Scope (from outer to inner):

file
function     bool MovieSceneToolHelpers::ReadyFBXForImport

Source code excerpt:


	UnFbx::FBXImportOptions* ImportOptions = FbxImporter->GetImportOptions();
	OutParams.bConvertSceneBackup = ImportOptions->bConvertScene;
	OutParams.bConvertSceneUnitBackup = ImportOptions->bConvertSceneUnit;
	OutParams.bForceFrontXAxisBackup = ImportOptions->bForceFrontXAxis;
	OutParams.ImportUniformScaleBackup = ImportOptions->ImportUniformScale;

	ImportOptions->bIsImportCancelable = false;
	ImportOptions->bConvertScene = true;
	ImportOptions->bConvertSceneUnit = ImportFBXSettings->bConvertSceneUnit;
	ImportOptions->bForceFrontXAxis = ImportFBXSettings->bForceFrontXAxis;
	ImportOptions->ImportUniformScale = ImportFBXSettings->ImportUniformScale;

	const FString FileExtension = FPaths::GetExtension(ImportFilename);
	if (!FbxImporter->ImportFromFile(*ImportFilename, FileExtension, true))

#Loc: <Workspace>/Engine/Source/Editor/MovieSceneTools/Private/MovieSceneToolHelpers.cpp:3423

Scope (from outer to inner):

file
function     bool MovieSceneToolHelpers::ReadyFBXForImport

Source code excerpt:

		// Log the error message and fail the import.
		FbxImporter->ReleaseScene();
		ImportOptions->bConvertScene = OutParams.bConvertSceneBackup;
		ImportOptions->bConvertSceneUnit = OutParams.bConvertSceneUnitBackup;
		ImportOptions->bForceFrontXAxis = OutParams.bForceFrontXAxisBackup;
		ImportOptions->ImportUniformScale = OutParams.ImportUniformScaleBackup;
		return false;
	}
	return true;

#Loc: <Workspace>/Engine/Source/Editor/MovieSceneTools/Private/MovieSceneToolHelpers.cpp:3552

Scope (from outer to inner):

file
function     bool MovieSceneToolHelpers::ImportFBXIfReady

Source code excerpt:

	FbxImporter->ReleaseScene();
	UnFbx::FBXImportOptions* ImportOptions = FbxImporter->GetImportOptions();
	ImportOptions->bConvertScene = InParams.bConvertSceneBackup;
	ImportOptions->bConvertSceneUnit = InParams.bConvertSceneUnitBackup;
	ImportOptions->bForceFrontXAxis = InParams.bForceFrontXAxisBackup;
	ImportOptions->ImportUniformScale = InParams.ImportUniformScaleBackup;
	return true;
}

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Classes/Factories/FbxAssetImportData.h:28

Scope (from outer to inner):

file
class        class UFbxAssetImportData : public UAssetImportData

Source code excerpt:

	/** Whether to convert scene from FBX scene. */
	UPROPERTY(EditAnywhere, BlueprintReadWrite, config, Category = Miscellaneous, meta = (ImportType = "StaticMesh|SkeletalMesh|Animation", ImportCategory = "Miscellaneous", ToolTip = "Convert the scene from FBX coordinate system to UE coordinate system"))
	bool bConvertScene;

	/** Whether to force the front axis to be align with X instead of -Y. */
	UPROPERTY(EditAnywhere, BlueprintReadWrite, config, Category = Miscellaneous, meta = (editcondition = "bConvertScene", ImportType = "StaticMesh|SkeletalMesh|Animation", ImportCategory = "Miscellaneous", ToolTip = "Convert the scene from FBX coordinate system to UE coordinate system with front X axis instead of -Y"))
	bool bForceFrontXAxis;

	/** Whether to convert the scene from FBX unit to UE unit (centimeter). */

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxAssetImportData.cpp:18

Scope (from outer to inner):

file
function     UFbxAssetImportData::UFbxAssetImportData

Source code excerpt:

	, ImportRotation(0)
	, ImportUniformScale(1.0f)
	, bConvertScene(true)
	, bForceFrontXAxis(false)
	, bConvertSceneUnit(false)
	, bImportAsScene(false)
	, FbxSceneImportDataReference(nullptr)
{

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

Scope (from outer to inner):

file
namespace    UnFbx
function     void ApplyImportUIToImportOptions

Source code excerpt:

		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;
		InOutImportOptions.bReorderMaterialToFbxOrder = StaticMeshData->bReorderMaterialToFbxOrder;
		InOutImportOptions.DistanceFieldResolutionScale = StaticMeshData->DistanceFieldResolutionScale;

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

Scope (from outer to inner):

file
namespace    UnFbx
function     void ApplyImportUIToImportOptions

Source code excerpt:

		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;
		InOutImportOptions.bReorderMaterialToFbxOrder	= SkeletalMeshData->bReorderMaterialToFbxOrder;
		InOutImportOptions.bImportVertexAttributes		= SkeletalMeshData->bImportVertexAttributes;

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

Scope (from outer to inner):

file
namespace    UnFbx
function     void ApplyImportUIToImportOptions

Source code excerpt:

			AnimData->ImportRotation				= SkeletalMeshData->ImportRotation;
			AnimData->ImportUniformScale			= SkeletalMeshData->ImportUniformScale;
			AnimData->bConvertScene					= SkeletalMeshData->bConvertScene;
			AnimData->bForceFrontXAxis				= SkeletalMeshData->bForceFrontXAxis;
			AnimData->bConvertSceneUnit				= SkeletalMeshData->bConvertSceneUnit;
		}
	}
	else
	{

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

Scope (from outer to inner):

file
namespace    UnFbx
function     void ApplyImportUIToImportOptions

Source code excerpt:

		InOutImportOptions.ImportRotation		= AnimData->ImportRotation;
		InOutImportOptions.ImportUniformScale	= AnimData->ImportUniformScale;
		InOutImportOptions.bConvertScene		= AnimData->bConvertScene;
		InOutImportOptions.bForceFrontXAxis		= AnimData->bForceFrontXAxis;
		InOutImportOptions.bConvertSceneUnit	= AnimData->bConvertSceneUnit;
	}

	//Skeletal mesh unshared options
	{

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

Scope (from outer to inner):

file
namespace    UnFbx
function     void FFbxImporter::ConvertScene

Source code excerpt:

	JointOrientationMatrix.SetIdentity();

	if (GetImportOptions()->bConvertScene)
	{
		// we use -Y as forward axis here when we import. This is odd considering our forward axis is technically +X
		// but this is to mimic Maya/Max behavior where if you make a model facing +X facing, 
		// when you import that mesh, you want +X facing in engine. 
		// only thing that doesn't work is hand flipping because Max/Maya is RHS but UE is LHS
		// On the positive note, we now have import transform set up you can do to rotate mesh if you don't like default setting

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

Scope (from outer to inner):

file
namespace    UnFbx
function     bool FFbxImporter::ImportFromFile

Source code excerpt:

						//FBX import options
						Attribs.Add(FAnalyticsEventAttribute(TEXT("GenOpt ImportType"), FBXImportTypeEnum->GetNameStringByValue(ImportOptions->ImportType)));
						Attribs.Add(FAnalyticsEventAttribute(TEXT("GenOpt ConvertScene"), ImportOptions->bConvertScene));
						Attribs.Add(FAnalyticsEventAttribute(TEXT("GenOpt ConvertSceneUnit"), ImportOptions->bConvertSceneUnit));
						Attribs.Add(FAnalyticsEventAttribute(TEXT("GenOpt ForceFrontXAxis"), ImportOptions->bForceFrontXAxis));
						Attribs.Add(FAnalyticsEventAttribute(TEXT("GenOpt ImportMaterials"), ImportOptions->bImportMaterials));
						Attribs.Add(FAnalyticsEventAttribute(TEXT("GenOpt ImportTextures"), ImportOptions->bImportTextures));
						Attribs.Add(FAnalyticsEventAttribute(TEXT("GenOpt InvertNormalMap"), ImportOptions->bInvertNormalMap));
						Attribs.Add(FAnalyticsEventAttribute(TEXT("GenOpt RemoveNameSpace"), ImportOptions->bRemoveNameSpace));

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

Scope (from outer to inner):

file
function     UnFbx::FBXImportOptions *JSONToFbxOption

Source code excerpt:

	OptionObj->TryGetBoolField(TEXT("bImportLOD"), Option->bImportLOD);
	OptionObj->TryGetBoolField(TEXT("bUsedAsFullName"), Option->bUsedAsFullName);
	OptionObj->TryGetBoolField(TEXT("bConvertScene"), Option->bConvertScene);
	OptionObj->TryGetBoolField(TEXT("bForceFrontXAxis"), Option->bForceFrontXAxis);
	OptionObj->TryGetBoolField(TEXT("bConvertSceneUnit"), Option->bConvertSceneUnit);
	OptionObj->TryGetBoolField(TEXT("bRemoveNameSpace"), Option->bRemoveNameSpace);
	double X, Y, Z, Pitch, Yaw, Roll;
	const TSharedPtr<FJsonObject> *DataObj = nullptr;
	if (OptionObj->TryGetObjectField(TEXT("ImportTranslation"), DataObj))

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

Scope (from outer to inner):

file
function     FString FbxOptionToJSON

Source code excerpt:

		Option->bImportLOD ? 1 : 0,
		Option->bUsedAsFullName ? 1 : 0,
		Option->bConvertScene ? 1 : 0,
		Option->bForceFrontXAxis ? 1 : 0,
		Option->bConvertSceneUnit ? 1 : 0,
		Option->bRemoveNameSpace ? 1 : 0
		);

	JsonString += FString::Printf(TEXT("\"ImportTranslation\" : {\"X\" : \"%f\", \"Y\" : \"%f\", \"Z\" : \"%f\"}, \"ImportRotation\" : {\"P\" : \"%f\", \"Y\" : \"%f\", \"R\" : \"%f\"}, \"ImportUniformScale\" : \"%f\", "),

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

Scope (from outer to inner):

file
function     bool GetFbxSceneImportOptions

Source code excerpt:

	GlobalImportSettings->DistanceFieldResolutionScale = 1.0f;

	GlobalImportSettings->bConvertScene = true;
	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

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

Scope (from outer to inner):

file
function     UObject* UFbxSceneImportFactory::FactoryCreateBinary

Source code excerpt:

	
	//Always convert the scene
	GlobalImportSettings->bConvertScene = true;
	GlobalImportSettings->bConvertSceneUnit = true;

	//Set the import option in importscene mode
	GlobalImportSettings->bImportScene = true;
	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

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

Scope (from outer to inner):

file
function     bool GetFbxSceneReImportOptions

Source code excerpt:

	GlobalImportSettings->ImportUniformScale = 1.0f;

	GlobalImportSettings->bConvertScene = true;
	GlobalImportSettings->bConvertSceneUnit = true;

	GlobalImportSettings->OverrideMaterials.Reset();

	if (!GIsRunningUnattendedScript)
	{

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

Scope (from outer to inner):

file
function     EReimportResult::Type UReimportFbxSceneFactory::Reimport

Source code excerpt:


	//Always convert the scene
	GlobalImportSettings->bConvertScene = true;
	GlobalImportSettings->bConvertSceneUnit = true;
	GlobalImportSettings->bImportScene = ReimportData->bImportScene;
	if (ReimportData->NameOptionsMap.Contains(DefaultOptionName))
	{
		UnFbx::FBXImportOptions *DefaultOption = *(ReimportData->NameOptionsMap.Find(DefaultOptionName));
		GlobalImportSettings->bBakePivotInVertex = DefaultOption->bBakePivotInVertex;

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

Scope (from outer to inner):

file
namespace    UnFbx

Source code excerpt:

	bool bImportLOD;
	bool bUsedAsFullName;
	bool bConvertScene;
	bool bForceFrontXAxis;
	bool bConvertSceneUnit;
	bool bRemoveNameSpace;
	FVector ImportTranslation;
	FRotator ImportRotation;
	float ImportUniformScale;