bConvertSceneUnit

bConvertSceneUnit

#Overview

name: bConvertSceneUnit

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

#Summary

#Usage in the C++ source code

The purpose of bConvertSceneUnit is to control whether the FBX import process should convert the scene’s unit scale from the FBX file’s native units to Unreal Engine’s default unit (centimeters). Here’s a detailed breakdown:

  1. Purpose: It’s used in the FBX import process to determine if the scene’s unit scale should be converted to match Unreal Engine’s standard unit (centimeters).

  2. Subsystems relying on this variable: The FBX import system, particularly the parts dealing with scene conversion and asset import (static meshes, skeletal meshes, animations).

  3. Value setting: The value is typically set in the import options, either through the UI when importing FBX files or programmatically when scripting imports.

  4. Interaction with other variables: It often works in conjunction with other import settings like bConvertScene and ImportUniformScale to determine how the imported scene should be transformed.

  5. Special considerations:

    • When true, it ensures that assets imported from FBX files with different unit scales (e.g., meters, millimeters) are correctly scaled to match Unreal’s centimeter scale.
    • It’s particularly important for maintaining consistent scale across different assets and scenes.

  6. Best practices:

    • Generally, it’s recommended to keep this option enabled (true) to ensure consistent scaling across all imported assets.
    • If you’re working with a pipeline where all assets are already in the correct scale for Unreal Engine, you might disable this option to preserve the exact measurements from the source files.
    • When reimporting assets or working with a specific pipeline, ensure this setting is consistent to avoid unexpected scale changes.

Developers should be aware that changing this setting can affect the scale of imported assets, which can impact gameplay, physics, and visual consistency in the game world. It’s crucial to maintain a consistent approach to unit conversion across all assets in a project.

#Setting Variables

#References In INI files

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

Location: <Workspace>/Engine/Plugins/Interchange/Runtime/Config/BaseInterchange.ini:69, 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:134

Scope (from outer to inner):

file
function     void FControlRigDrawContainerDetails::ImportCurvesFromFBX

Source code excerpt:

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

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

Scope (from outer to inner):

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

Source code excerpt:

		{
			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;
		AssetImportData->ImportUniformScale = GenericAssetPipeline->ImportOffsetUniformScale;

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

Scope (from outer to inner):

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

Source code excerpt:

		InterchangeFbxTranslatorSettings->bConvertScene = FbxAssetImportData->bConvertScene;
		InterchangeFbxTranslatorSettings->bForceFrontXAxis = FbxAssetImportData->bForceFrontXAxis;
		InterchangeFbxTranslatorSettings->bConvertSceneUnit = FbxAssetImportData->bConvertSceneUnit;
		DestinationData->SetTranslatorSettings(InterchangeFbxTranslatorSettings);

		if (const UFbxStaticMeshImportData* LegacyStaticMeshImportData = Cast<UFbxStaticMeshImportData>(FbxAssetImportData))
		{
			UInterchangeStaticMeshFactoryNode* MeshNode = NewObject<UInterchangeStaticMeshFactoryNode>(DestinationContainer);
			MeshNode->InitializeStaticMeshNode(NodeUniqueId, NodeDisplayLabel, UStaticMesh::StaticClass()->GetName());

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

Scope (from outer to inner):

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

Source code excerpt:

				InterchangeFbxTranslatorSettings->bConvertScene = FbxAssetImportData->bConvertScene;
				InterchangeFbxTranslatorSettings->bForceFrontXAxis = FbxAssetImportData->bForceFrontXAxis;
				InterchangeFbxTranslatorSettings->bConvertSceneUnit = FbxAssetImportData->bConvertSceneUnit;
				DestinationData->SetTranslatorSettings(InterchangeFbxTranslatorSettings);
			};

		//General Options
		GenericAssetPipeline->bUseSourceNameForAsset = FbxImportUI->bOverrideFullName;
		GenericAssetPipeline->ReimportStrategy = EReimportStrategyFlags::ApplyNoProperties;

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

Scope (from outer to inner):

file
namespace    UE
namespace    Interchange
function     bool FJsonLoadSourceCmd::FromJson

Source code excerpt:

				return false;
			}
			if (!((*ActionDataObject)->TryGetBoolField(GetDoesConvertSceneUnitJsonKey(), bConvertSceneUnit)))
			{
				return false;
			}

			//Since we filled the data from the json file, set the data has been initialize.
			bIsDataInitialize = true;

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

Scope (from outer to inner):

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

Source code excerpt:

				, bConvertScene(InbConvertScene)
				, bForceFrontXAxis(InbForceFrontXAxis)
				, bConvertSceneUnit(InbConvertSceneUnit)
			{
				bIsDataInitialize = true;
			}

			virtual FString GetAction() const override
			{

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

Scope (from outer to inner):

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

Source code excerpt:

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

			static FString GetDoesConvertSceneUnitJsonKey()
			{
				static const FString Key = TEXT("ConvertSceneUnit");
				return Key;

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

Scope (from outer to inner):

file
namespace    UE
namespace    Interchange
class        class FJsonLoadSourceCmd : public IJsonCmdBase

Source code excerpt:

			bool bConvertScene = true;
			bool bForceFrontXAxis = false;
			bool bConvertSceneUnit = true;
		};

		class INTERCHANGEDISPATCHER_API FJsonFetchPayloadCmd : public IJsonCmdBase
		{
		public:
			FJsonFetchPayloadCmd()

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

Scope (from outer to inner):

file
function     bool UInterchangeFbxTranslator::Translate

Source code excerpt:

	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())
		{
			return false;
		}
		//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:38

Scope (from outer to inner):

file
class        class UInterchangeFbxTranslatorSettings : public UInterchangeTranslatorSettings

Source code excerpt:

	/** Whether to convert the scene from FBX unit to UE unit (centimeter). */
	UPROPERTY(EditAnywhere, Category = "Fbx Translator")
	bool bConvertSceneUnit = true;
};

UCLASS(BlueprintType)
class INTERCHANGEIMPORT_API UInterchangeFbxTranslator : public UInterchangeTranslatorBase
, public IInterchangeTexturePayloadInterface
, public IInterchangeMeshPayloadInterface

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

Scope (from outer to inner):

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

Source code excerpt:

					bConvertScene = InbConvertScene;
					bForceFrontXAxis = InbForceFrontXAxis;
					bConvertSceneUnit = InbConvertSceneUnit;
				}

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

				/* Load an fbx file into the fbx sdk, return false if the file could not be load. */

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

Scope (from outer to inner):

file
namespace    UE
namespace    Interchange
namespace    Private
class        class FFbxParser

Source code excerpt:

				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:62

Scope (from outer to inner):

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

Source code excerpt:

				}

				if (bConvertSceneUnit)
				{
					FbxSystemUnit FileUnitSystem = SDKScene->GetGlobalSettings().GetSystemUnit();
					if (FileUnitSystem != FbxSystemUnit::cm)
					{
						FbxSystemUnit::cm.ConvertScene(SDKScene);
					}

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

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);
	if (!FbxImporter->ImportFromFile(*ImportFilename, FileExtension, true))

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

Scope (from outer to inner):

file
function     bool MovieSceneToolHelpers::ImportFBXIntoControlRigChannels

Source code excerpt:


		CurrentImportFBXSettings->bMatchByNameOnly = false;
		CurrentImportFBXSettings->bConvertSceneUnit = ImportFBXControlRigSettings->bConvertSceneUnit;
		CurrentImportFBXSettings->bForceFrontXAxis = ImportFBXControlRigSettings->bForceFrontXAxis;
		CurrentImportFBXSettings->ImportUniformScale = ImportFBXControlRigSettings->ImportUniformScale;
		CurrentImportFBXSettings->bCreateCameras = false;
		CurrentImportFBXSettings->bReduceKeys = false;
		CurrentImportFBXSettings->ReduceKeysTolerance = 0.01f;

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

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;
}

bool MovieSceneToolHelpers::ExportFBXFromControlRigChannels(const UMovieSceneSection* Section,

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

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:3424

Scope (from outer to inner):

file
function     bool MovieSceneToolHelpers::ReadyFBXForImport

Source code excerpt:

		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:3445

Scope (from outer to inner):

file
function     bool ImportFBXOntoControlRigs

Source code excerpt:

	CurrentImportFBXSettings->bReduceKeys = ImportFBXSettings->bReduceKeys;
	CurrentImportFBXSettings->ReduceKeysTolerance = ImportFBXSettings->ReduceKeysTolerance;
	CurrentImportFBXSettings->bConvertSceneUnit = ImportFBXSettings->bConvertSceneUnit;
	CurrentImportFBXSettings->ImportUniformScale = ImportFBXSettings->ImportUniformScale;


	UnFbx::FFbxImporter* FbxImporter = UnFbx::FFbxImporter::GetInstance();

	return true;

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

Scope (from outer to inner):

file
function     bool MovieSceneToolHelpers::ImportFBXIfReady

Source code excerpt:

	CurrentImportFBXSettings->bReduceKeys = ImportFBXSettings->bReduceKeys;
	CurrentImportFBXSettings->ReduceKeysTolerance = ImportFBXSettings->ReduceKeysTolerance;
	CurrentImportFBXSettings->bConvertSceneUnit = ImportFBXSettings->bConvertSceneUnit;
	CurrentImportFBXSettings->ImportUniformScale = ImportFBXSettings->ImportUniformScale;
	UnFbx::FFbxImporter* FbxImporter = UnFbx::FFbxImporter::GetInstance();

	UnFbx::FFbxCurvesAPI CurveAPI;
	FbxImporter->PopulateAnimatedCurveData(CurveAPI);
	TArray<FString> AllNodeNames;

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

Scope (from outer to inner):

file
function     bool MovieSceneToolHelpers::ImportFBXIfReady

Source code excerpt:

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

bool MovieSceneToolHelpers::ImportFBXWithDialog(UMovieSceneSequence* InSequence, ISequencer& InSequencer, const TMap<FGuid, FString>& InObjectBindingMap, TOptional<bool> bCreateCameras)

#Loc: <Workspace>/Engine/Source/Editor/MovieSceneTools/Private/MovieSceneToolsUserSettings.cpp:37

Scope (from outer to inner):

file
function     UMovieSceneUserImportFBXSettings::UMovieSceneUserImportFBXSettings

Source code excerpt:

	bReduceKeys = true;
	ReduceKeysTolerance = 0.001f;
	bConvertSceneUnit = true;
	ImportUniformScale = 1.0f;
}


void SetControlRigIOChannelMappingPresets(TArray<FControlToTransformMappings>& ControlChannelMappings, const bool bMetaHuman)
{

#Loc: <Workspace>/Engine/Source/Editor/MovieSceneTools/Private/MovieSceneToolsUserSettings.cpp:137

Scope (from outer to inner):

file
function     UMovieSceneUserImportFBXControlRigSettings::UMovieSceneUserImportFBXControlRigSettings

Source code excerpt:

{
	bForceFrontXAxis = false;
	bConvertSceneUnit = true;
	ImportUniformScale = 1.0f;
	bSpecifyTimeRange = false;
	StartTimeRange = 0;
	EndTimeRange = 0;
	TimeToInsertOrReplaceAnimation = 0;
	bInsertAnimation = true;

#Loc: <Workspace>/Engine/Source/Editor/MovieSceneTools/Public/MovieSceneToolsUserSettings.h:75

Scope (from outer to inner):

file
class        class UMovieSceneUserImportFBXSettings : public UObject

Source code excerpt:

	/** Convert the scene from FBX unit to UE unit(centimeter)*/
	UPROPERTY(EditAnywhere, config, Category = Import, meta = (ToolTip = "Convert the scene from FBX unit to UE unit(centimeter)"))
	bool bConvertSceneUnit;

	/** Import Uniform Scale*/
	UPROPERTY(EditAnywhere, config, Category = Import, meta = (ToolTip = "Import Uniform Scale"))
	float ImportUniformScale;

	/** Whether to create cameras if they don't already exist in the level. */

#Loc: <Workspace>/Engine/Source/Editor/MovieSceneTools/Public/MovieSceneToolsUserSettings.h:229

Scope (from outer to inner):

file
class        class UMovieSceneUserImportFBXControlRigSettings : public UObject

Source code excerpt:

	/** Convert the scene from FBX unit to UE unit(centimeter)*/
	UPROPERTY(EditAnywhere, config, Category = Import, meta = (ToolTip = "Convert the scene from FBX unit to UE unit(centimeter)"))
	bool bConvertSceneUnit;

	/** Import Uniform Scale*/
	UPROPERTY(EditAnywhere, config, Category = Import, meta = (ToolTip = "Import Uniform Scale"))
	float ImportUniformScale;

	/** Whether or not import onto selected controls or all controls*/

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

Scope (from outer to inner):

file
class        class UFbxAssetImportData : public UAssetImportData

Source code excerpt:

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

	/* Use by the reimport factory to answer CanReimport, if true only factory for scene reimport will return true */
	UPROPERTY()
	bool bImportAsScene;

	/* Use by the reimport factory to answer CanReimport, if true only factory for scene reimport will return true */

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

Scope (from outer to inner):

file
function     UFbxAssetImportData::UFbxAssetImportData

Source code excerpt:

	, bConvertScene(true)
	, bForceFrontXAxis(false)
	, bConvertSceneUnit(false)
	, bImportAsScene(false)
	, FbxSceneImportDataReference(nullptr)
{
	
}

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

Scope (from outer to inner):

file
namespace    UnFbx
function     void ApplyImportUIToImportOptions

Source code excerpt:

		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;
	}
	else if ( ImportUI->MeshTypeToImport == FBXIT_SkeletalMesh )

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

Scope (from outer to inner):

file
namespace    UnFbx
function     void ApplyImportUIToImportOptions

Source code excerpt:

		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;

		if(ImportUI->bImportAnimations)

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

Scope (from outer to inner):

file
namespace    UnFbx
function     void ApplyImportUIToImportOptions

Source code excerpt:

			AnimData->bConvertScene					= SkeletalMeshData->bConvertScene;
			AnimData->bForceFrontXAxis				= SkeletalMeshData->bForceFrontXAxis;
			AnimData->bConvertSceneUnit				= SkeletalMeshData->bConvertSceneUnit;
		}
	}
	else
	{
		UFbxAnimSequenceImportData* AnimData	= ImportUI->AnimSequenceImportData;
		InOutImportOptions.NormalImportMethod	= FBXNIM_ComputeNormals;

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

Scope (from outer to inner):

file
namespace    UnFbx
function     void ApplyImportUIToImportOptions

Source code excerpt:

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

	//Skeletal mesh unshared options
	{
		InOutImportOptions.bImportAsSkeletalGeometry	= ImportUI->SkeletalMeshImportData->ImportContentType == EFBXImportContentType::FBXICT_Geometry;
		InOutImportOptions.bImportAsSkeletalSkinning	= ImportUI->SkeletalMeshImportData->ImportContentType == EFBXImportContentType::FBXICT_SkinningWeights;

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

Scope (from outer to inner):

file
namespace    UnFbx
function     void FFbxImporter::ConvertScene

Source code excerpt:

	// The base unit used in both FBX and Unreal is centimeters.  So unless the units 
	// are already in centimeters (ie: scalefactor 1.0) then it needs to be converted
	if (GetImportOptions()->bConvertSceneUnit && Scene->GetGlobalSettings().GetSystemUnit() != FbxSystemUnit::cm)
	{
		FbxSystemUnit::cm.ConvertScene(Scene);
	}

	//Reset all the transform evaluation cache since we change some node transform
	Scene->GetAnimationEvaluator()->Reset();

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

Scope (from outer to inner):

file
namespace    UnFbx
function     bool FFbxImporter::ImportFromFile

Source code excerpt:

						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));
						Attribs.Add(FAnalyticsEventAttribute(TEXT("GenOpt UsedAsFullName"), ImportOptions->bUsedAsFullName));

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

Scope (from outer to inner):

file
function     UnFbx::FBXImportOptions *JSONToFbxOption

Source code excerpt:

	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))
	{
		(*DataObj)->TryGetNumberField(TEXT("X"), X);

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

Scope (from outer to inner):

file
function     FString FbxOptionToJSON

Source code excerpt:

		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\", "),
		Option->ImportTranslation.X,
		Option->ImportTranslation.Y,

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

Scope (from outer to inner):

file
function     bool GetFbxSceneImportOptions

Source code excerpt:


	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
	//Prefix materials package name to put all material under Material folder (this avoid name clash with meshes)

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

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
	if (!FbxImporter->ImportFromFile(*FbxImportFileName, Type, true))

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

Scope (from outer to inner):

file
function     bool GetFbxSceneReImportOptions

Source code excerpt:


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

	GlobalImportSettings->OverrideMaterials.Reset();

	if (!GIsRunningUnattendedScript)
	{
		TSharedPtr<SWindow> ParentWindow;

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

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;
		GlobalImportSettings->bInvertNormalMap = DefaultOption->bInvertNormalMap;

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

Scope (from outer to inner):

file
namespace    UnFbx

Source code excerpt:

	bool bConvertScene;
	bool bForceFrontXAxis;
	bool bConvertSceneUnit;
	bool bRemoveNameSpace;
	FVector ImportTranslation;
	FRotator ImportRotation;
	float ImportUniformScale;
	EFBXNormalImportMethod NormalImportMethod;
	EFBXNormalGenerationMethod::Type NormalGenerationMethod;