bCreatePhysicsAsset
bCreatePhysicsAsset
#Overview
name: bCreatePhysicsAsset
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 27 C++ source files.
#Summary
#Usage in the C++ source code
The purpose of bCreatePhysicsAsset is to control whether a physics asset should be automatically created for a skeletal mesh during the import process in Unreal Engine 5.
This setting variable is primarily used in the skeletal mesh import system, which is part of Unreal Engine’s asset import pipeline. It is mainly utilized by the FBX importer and the Interchange system, which are responsible for importing 3D models and animations into the engine.
The value of this variable is typically set through the import UI or programmatically when initiating an import process. It can be found in various classes such as UFbxImportUI, UFbxSceneImportOptionsSkeletalMesh, and UInterchangeGenericMeshPipeline.
This variable interacts with other import settings, particularly those related to skeletal mesh importing. For example, if bCreatePhysicsAsset is true, but the engine cannot import the UPhysicsAsset class, the variable will be set to false.
Developers should be aware that:
- Setting this to true will automatically create a physics asset for the imported skeletal mesh if one doesn’t already exist.
- If set to false, no physics asset will be created automatically, but an existing physics asset can still be assigned.
- This setting might be overridden in certain import scenarios, such as reimporting or importing alternate skinning.
Best practices when using this variable include:
- Consider the performance implications of automatically creating physics assets for all imported skeletal meshes.
- Ensure that the created physics asset is appropriate for the skeletal mesh. You might need to adjust the auto-generated physics asset manually after import.
- If you’re reimporting or doing specialized imports (like alternate skinning), you might want to set this to false to prevent unwanted physics asset creation.
- Be aware of the interaction between this setting and other import options, such as the PhysicsAsset property, which allows specifying a particular physics asset to use.
#Setting Variables
#References In INI files
Location: <Workspace>/Engine/Config/BaseEditorPerProjectUserSettings.ini:621, section: [/Script/UnrealEd.FbxImportUI]
- INI Section:
/Script/UnrealEd.FbxImportUI - Raw value:
True - Is Array:
False
#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:189
Scope (from outer to inner):
file
namespace UE::Interchange::Private
function void FillInterchangeGenericAssetsPipelineFromFbxSkeletalMeshImportData
Source code excerpt:
GenericAssetPipeline->CommonSkeletalMeshesAndAnimationsProperties->bImportMeshesInBoneHierarchy = SkeletalMeshImportData->bImportMeshesInBoneHierarchy;
GenericAssetPipeline->CommonMeshesProperties->bKeepSectionsSeparate = SkeletalMeshImportData->bKeepSectionsSeparate;
GenericAssetPipeline->MeshPipeline->bCreatePhysicsAsset = false;
GenericAssetPipeline->MeshPipeline->bImportMorphTargets = SkeletalMeshImportData->bImportMorphTargets;
GenericAssetPipeline->MeshPipeline->bImportVertexAttributes = SkeletalMeshImportData->bImportVertexAttributes;
GenericAssetPipeline->MeshPipeline->bUpdateSkeletonReferencePose = SkeletalMeshImportData->bUpdateSkeletonReferencePose;
GenericAssetPipeline->CommonSkeletalMeshesAndAnimationsProperties->bUseT0AsRefPose = SkeletalMeshImportData->bUseT0AsRefPose;
if (SkeletalMeshImportData->ImportContentType == EFBXImportContentType::FBXICT_All)
{
#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Import/Private/Mesh/InterchangeSkeletalMeshFactory.cpp:1918
Scope (from outer to inner):
file
function UInterchangeFactoryBase::FImportAssetResult UInterchangeSkeletalMeshFactory::EndImportAsset_GameThread
Source code excerpt:
SkeletalMeshFactoryNode->ApplyAllCustomAttributeToObject(SkeletalMesh);
bool bCreatePhysicsAsset = false;
SkeletalMeshFactoryNode->GetCustomCreatePhysicsAsset(bCreatePhysicsAsset);
if (!bCreatePhysicsAsset)
{
FSoftObjectPath SpecifiedPhysicAsset;
SkeletalMeshFactoryNode->GetCustomPhysicAssetSoftObjectPath(SpecifiedPhysicAsset);
if (SpecifiedPhysicAsset.IsValid())
{
UPhysicsAsset* PhysicsAsset = Cast<UPhysicsAsset>(SpecifiedPhysicAsset.TryLoad());
#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Pipelines/Private/InterchangeGenericAssetsPipeline.cpp:1089
Scope (from outer to inner):
file
function void UInterchangeGenericAssetsPipeline::ExecutePipeline
Source code excerpt:
MaterialPipeline->bImportMaterials = false;
MeshPipeline->bImportStaticMeshes = false;
MeshPipeline->bCreatePhysicsAsset = false;
MeshPipeline->PhysicsAsset = nullptr;
MaterialPipeline->TexturePipeline->bImportTextures = false;
}
//////////////////////////////////////////////////////////////////////////
#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Pipelines/Private/InterchangeGenericMeshPipeline.cpp:42
Scope (from outer to inner):
file
function void UInterchangeGenericMeshPipeline::AdjustSettingsForContext
Source code excerpt:
|| ImportType == EInterchangePipelineContext::AssetAlternateSkinningReimport)
{
bCreatePhysicsAsset = false;
PhysicsAsset = nullptr;
if (ImportType == EInterchangePipelineContext::AssetAlternateSkinningImport
|| ImportType == EInterchangePipelineContext::AssetAlternateSkinningReimport)
{
CommonMeshesProperties->ForceAllMeshAsType = EInterchangeForceMeshType::IFMT_SkeletalMesh;
#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Pipelines/Private/InterchangeGenericMeshPipeline.cpp:82
Scope (from outer to inner):
file
function void UInterchangeGenericMeshPipeline::AdjustSettingsForContext
Source code excerpt:
if (PhysicsAsset.IsValid())
{
bCreatePhysicsAsset = false;
}
bImportStaticMeshes = false;
HideCategories.Add(StaticMeshesCategory);
if(SkeletalMeshImportContentType == EInterchangeSkeletalMeshContentType::Geometry)
{
CommonMeshesProperties->ForceAllMeshAsType = EInterchangeForceMeshType::IFMT_SkeletalMesh;
#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Pipelines/Private/InterchangeGenericSkeletalMeshPipeline.cpp:436
Scope (from outer to inner):
file
function UInterchangeSkeletalMeshFactoryNode* UInterchangeGenericMeshPipeline::CreateSkeletalMeshFactoryNode
Source code excerpt:
//Physic asset dependency, if we must create or use a specialize physic asset let create
//a PhysicsAsset factory node, so the asset will exist when we will setup the skeletalmesh
if (bCreatePhysicsAsset)
{
UInterchangePhysicsAssetFactoryNode* PhysicsAssetFactoryNode = NewObject<UInterchangePhysicsAssetFactoryNode>(BaseNodeContainer, NAME_None);
if (ensure(SkeletalMeshFactoryNode))
{
const FString PhysicsAssetUid = UInterchangeFactoryBaseNode::BuildFactoryNodeUid(SkeletalMeshUid_MeshNamePart + SkeletonUid + TEXT("_PhysicsAsset"));
const FString PhysicsAssetDisplayLabel = DisplayLabel + TEXT("_PhysicsAsset");
#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Pipelines/Private/InterchangeGenericSkeletalMeshPipeline.cpp:448
Scope (from outer to inner):
file
function UInterchangeSkeletalMeshFactoryNode* UInterchangeGenericMeshPipeline::CreateSkeletalMeshFactoryNode
Source code excerpt:
}
}
SkeletalMeshFactoryNode->SetCustomCreatePhysicsAsset(bCreatePhysicsAsset);
if (!bCreatePhysicsAsset && PhysicsAsset.IsValid())
{
FSoftObjectPath PhysicSoftObjectPath(PhysicsAsset.Get());
SkeletalMeshFactoryNode->SetCustomPhysicAssetSoftObjectPath(PhysicSoftObjectPath);
}
const bool bTrueValue = true;
#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Pipelines/Private/InterchangeGenericSkeletalMeshPipeline.cpp:624
Scope (from outer to inner):
file
function void UInterchangeGenericMeshPipeline::PostImportPhysicsAssetImport
Source code excerpt:
LLM_SCOPE_BYNAME(TEXT("Interchange"));
#if WITH_EDITOR
if (!bCreatePhysicsAsset || !BaseNodeContainer)
{
return;
}
UPhysicsAsset* CreatedPhysicsAsset = Cast<UPhysicsAsset>(CreatedAsset);
if (!CreatedPhysicsAsset)
#Loc: <Workspace>/Engine/Plugins/Interchange/Runtime/Source/Pipelines/Public/InterchangeGenericMeshPipeline.h:170
Scope (from outer to inner):
file
class class UInterchangeGenericMeshPipeline : public UInterchangePipelineBase
Source code excerpt:
/** If enabled, create new PhysicsAsset if one doesn't exist. */
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Skeletal Meshes")
bool bCreatePhysicsAsset = true;
/** If set, use the specified PhysicsAsset. If not set and the Create Physics Asset setting is not enabled, the importer will not generate or set any physics asset. */
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Skeletal Meshes", meta = (editcondition = "!bCreatePhysicsAsset"))
TWeakObjectPtr<UPhysicsAsset> PhysicsAsset;
/** If enabled, imported skin weights use 16 bits instead of 8 bits. */
#Loc: <Workspace>/Engine/Source/Editor/DetailCustomizations/Private/FbxImportUIDetails.cpp:437
Scope (from outer to inner):
file
function void FFbxImportUIDetails::CustomizeDetails
Source code excerpt:
if (!bShowPhysicsAssetOptions)
{
TSharedRef<IPropertyHandle> CreatePhysicsAssetProperty = DetailBuilder.GetProperty(GET_MEMBER_NAME_CHECKED(UFbxImportUI, bCreatePhysicsAsset));
DetailBuilder.HideProperty(CreatePhysicsAssetProperty);
ImportUI->bCreatePhysicsAsset = false;
}
TMap<FString, TArray<TSharedPtr<IPropertyHandle>>> SubCategoriesProperties;
TMap<FString, bool > SubCategoriesAdvanced;
TMap<FString, FText > SubCategoriesTooltip;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Classes/Factories/FbxImportUI.h:131
Scope (from outer to inner):
file
class class UFbxImportUI : public UObject, public IImportSettingsParser
Source code excerpt:
/** If checked, create new PhysicsAsset if it doesn't have it */
UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, config, Category=Mesh, meta=(ImportType="SkeletalMesh"))
uint32 bCreatePhysicsAsset:1;
/** If this is set, use this PhysicsAsset. It is possible bCreatePhysicsAsset == false, and PhysicsAsset == NULL. It is possible they do not like to create anything. */
UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category=Mesh, meta=(ImportType="SkeletalMesh", editcondition="!bCreatePhysicsAsset"))
TObjectPtr<class UPhysicsAsset> PhysicsAsset;
/** If checked, the editor will automatically compute screen size values for the static mesh's LODs. If unchecked, the user can enter custom screen size values for each LOD. */
UPROPERTY(EditAnywhere, BlueprintReadWrite, config, Category = LODSettings, meta = (ImportType = "StaticMesh", DisplayName = "Auto Compute LOD Screen Size"))
uint32 bAutoComputeLodDistances : 1;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Classes/Factories/FbxSceneImportOptionsSkeletalMesh.h:24
Scope (from outer to inner):
file
class class UFbxSceneImportOptionsSkeletalMesh : public UObject
Source code excerpt:
/** If checked, create new PhysicsAsset if it doesn't have it */
UPROPERTY(EditAnywhere, config, Category = SkeletalMesh)
uint32 bCreatePhysicsAsset : 1;
/** TODO support T0AsRefPose Enable this option to use frame 0 as reference pose */
UPROPERTY()
uint32 bUseT0AsRefPose : 1;
/** If checked, triangles with non-matching smoothing groups will be physically split. */
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Factories/EditorFactories.cpp:6485
Scope (from outer to inner):
file
function EReimportResult::Type UReimportFbxSkeletalMeshFactory::Reimport
Source code excerpt:
ReimportUI->MeshTypeToImport = FBXIT_SkeletalMesh;
ReimportUI->Skeleton = SkeletalMesh->GetSkeleton();
ReimportUI->bCreatePhysicsAsset = false;
ReimportUI->PhysicsAsset = SkeletalMesh->GetPhysicsAsset();
ReimportUI->bImportAnimations = false;
ReimportUI->OverrideAnimationName = TEXT("");
ReimportUI->bImportRigidMesh = false;
if (!ImportUI)
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Factories/EditorFactories.cpp:6662
Scope (from outer to inner):
file
function EReimportResult::Type UReimportFbxSkeletalMeshFactory::Reimport
Source code excerpt:
// @hack to make sure skeleton is set before opening the dialog
ImportOptions->SkeletonForAnimation = SkeletalMesh->GetSkeleton();
ImportOptions->bCreatePhysicsAsset = false;
ImportOptions->PhysicsAsset = SkeletalMesh->GetPhysicsAsset();
EFBXImportContentType BeforeUIContentType = ReimportUI->SkeletalMeshImportData->ImportContentType;
ImportOptions = GetImportOptions( FFbxImporter, ReimportUI, bShowOptionDialog, bIsAutomated, Obj->GetPathName(), bOperationCanceled, bOutImportAll, bIsObjFormat, Filename, bForceImportType, FBXIT_SkeletalMesh);
//If the import type has change from the UI, assign the filename to the file source index
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxFactory.cpp:407
Scope (from outer to inner):
file
function UObject* UFbxFactory::FactoryCreateFile
Source code excerpt:
if (!FbxImporter->CanImportClass(UPhysicsAsset::StaticClass()))
{
ImportOptions->bCreatePhysicsAsset = false;
}
if ( !FbxImporter->ImportFromFile( *UFactory::CurrentFilename, Type, true ) )
{
// Log the error message and fail the import.
Warn->Log(ELogVerbosity::Error, FbxImporter->GetErrorMessage() );
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:278
Scope (from outer to inner):
file
namespace UnFbx
function FBXImportOptions* GetImportOptions
Source code excerpt:
if (!FbxImporter->CanImportClass(UPhysicsAsset::StaticClass()))
{
ImportUI->bCreatePhysicsAsset = false;
}
UFbxImportUI::SaveOptions(ImportUI);
if( ImportUI->StaticMeshImportData )
{
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:328
Scope (from outer to inner):
file
namespace UnFbx
function FBXImportOptions* GetImportOptions
Source code excerpt:
if (!FbxImporter->CanImportClass(UPhysicsAsset::StaticClass()))
{
ImportOptions->bCreatePhysicsAsset = false;
}
return ImportOptions;
}
else
{
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:338
Scope (from outer to inner):
file
namespace UnFbx
function FBXImportOptions* GetImportOptions
Source code excerpt:
if (!FbxImporter->CanImportClass(UPhysicsAsset::StaticClass()))
{
FbxImporter->GetImportOptions()->bCreatePhysicsAsset = false;
}
return FbxImporter->GetImportOptions();
}
return NULL;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:378
Scope (from outer to inner):
file
namespace UnFbx
function void ApplyImportUIToImportOptions
Source code excerpt:
InOutImportOptions.bImportAnimations = ImportUI->bImportAnimations;
InOutImportOptions.SkeletonForAnimation = ImportUI->Skeleton;
InOutImportOptions.bCreatePhysicsAsset = ImportUI->bCreatePhysicsAsset;
InOutImportOptions.PhysicsAsset = ImportUI->PhysicsAsset;
InOutImportOptions.AnimationName = ImportUI->OverrideAnimationName;
}
//Material options
{
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:1753
Scope (from outer to inner):
file
lambda-function
Source code excerpt:
auto AddSKAnalytic = [&Attribs, &CaptureImportOptions]()
{
Attribs.Add(FAnalyticsEventAttribute(TEXT("SkeletalMeshOpt CreatePhysicsAsset"), CaptureImportOptions->bCreatePhysicsAsset));
Attribs.Add(FAnalyticsEventAttribute(TEXT("SkeletalMeshOpt ImportAnimations"), CaptureImportOptions->bImportAnimations));
Attribs.Add(FAnalyticsEventAttribute(TEXT("SkeletalMeshOpt ImportAsSkeletalGeometry"), CaptureImportOptions->bImportAsSkeletalGeometry));
Attribs.Add(FAnalyticsEventAttribute(TEXT("SkeletalMeshOpt ImportAsSkeletalSkinning"), CaptureImportOptions->bImportAsSkeletalSkinning));
Attribs.Add(FAnalyticsEventAttribute(TEXT("SkeletalMeshOpt ImportMeshesInBoneHierarchy"), CaptureImportOptions->bImportMeshesInBoneHierarchy));
Attribs.Add(FAnalyticsEventAttribute(TEXT("SkeletalMeshOpt ImportMorph"), CaptureImportOptions->bImportMorph));
Attribs.Add(FAnalyticsEventAttribute(TEXT("SkeletalMeshOpt ImportSkeletalMeshLODs"), CaptureImportOptions->bImportSkeletalMeshLODs));
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSceneImportOptionsSkeletalMesh.cpp:13
Scope (from outer to inner):
file
function UFbxSceneImportOptionsSkeletalMesh::UFbxSceneImportOptionsSkeletalMesh
Source code excerpt:
: Super(ObjectInitializer)
, bUpdateSkeletonReferencePose(false)
, bCreatePhysicsAsset(false)
, bUseT0AsRefPose(false)
, bPreserveSmoothingGroups(false)
, bKeepSectionsSeparate(false)
, bImportMeshesInBoneHierarchy(true)
, bImportMorphTargets(false)
, bImportVertexAttributes(false)
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSkeletalMeshImport.cpp:2046
Scope (from outer to inner):
file
function USkeletalMesh* UnFbx::FFbxImporter::ImportSkeletalMesh
Source code excerpt:
EARLY_RETURN_ON_CANCEL(false, CancelCleanup);
if ((!SkeletalMesh->GetResourceForRendering() || !SkeletalMesh->GetResourceForRendering()->LODRenderData.IsValidIndex(0)) && ImportOptions->bCreatePhysicsAsset && CanImportClass(UPhysicsAsset::StaticClass()))
{
//We need to have a valid render data to create physic asset
SkeletalMesh->Build();
}
SkeletalMesh->MarkPackageDirty();
}
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSkeletalMeshImport.cpp:2162
Scope (from outer to inner):
file
function USkeletalMesh* UnFbx::FFbxImporter::ImportSkeletalMesh
Source code excerpt:
// Create PhysicsAsset if requested and if physics asset is null
// We create the physic asset after we create the skeleton since we need the skeleton to correctly build it
if (ImportOptions->bCreatePhysicsAsset)
{
if (SkeletalMesh->GetPhysicsAsset() == NULL && CanImportClass(UPhysicsAsset::StaticClass()))
{
FString ObjectName = FString::Printf(TEXT("%s_PhysicsAsset"), *SkeletalMesh->GetName());
UPhysicsAsset * NewPhysicsAsset = CreateAsset<UPhysicsAsset>(ImportSkeletalMeshArgs.InParent->GetName(), ObjectName, true);
if (!NewPhysicsAsset)
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SFbxSceneOptionWindow.cpp:1493
Scope (from outer to inner):
file
function void SFbxSceneOptionWindow::CopySkeletalMeshOptionsToFbxOptions
Source code excerpt:
void SFbxSceneOptionWindow::CopySkeletalMeshOptionsToFbxOptions(UnFbx::FBXImportOptions *ImportSettings, UFbxSceneImportOptionsSkeletalMesh* SkeletalMeshOptions)
{
ImportSettings->bCreatePhysicsAsset = SkeletalMeshOptions->bCreatePhysicsAsset;
ImportSettings->bImportMeshesInBoneHierarchy = SkeletalMeshOptions->bImportMeshesInBoneHierarchy;
ImportSettings->bImportMorph = SkeletalMeshOptions->bImportMorphTargets;
ImportSettings->bImportVertexAttributes = SkeletalMeshOptions->bImportVertexAttributes;
ImportSettings->OverlappingThresholds.ThresholdPosition = SkeletalMeshOptions->ThresholdPosition;
ImportSettings->OverlappingThresholds.ThresholdTangentNormal = SkeletalMeshOptions->ThresholdTangentNormal;
ImportSettings->OverlappingThresholds.ThresholdUV = SkeletalMeshOptions->ThresholdUV;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SFbxSceneOptionWindow.cpp:1522
Scope (from outer to inner):
file
function void SFbxSceneOptionWindow::CopyFbxOptionsToSkeletalMeshOptions
Source code excerpt:
void SFbxSceneOptionWindow::CopyFbxOptionsToSkeletalMeshOptions(UnFbx::FBXImportOptions *ImportSettings, class UFbxSceneImportOptionsSkeletalMesh* SkeletalMeshOptions)
{
SkeletalMeshOptions->bCreatePhysicsAsset = ImportSettings->bCreatePhysicsAsset;
SkeletalMeshOptions->bImportMeshesInBoneHierarchy = ImportSettings->bImportMeshesInBoneHierarchy;
SkeletalMeshOptions->bImportMorphTargets = ImportSettings->bImportMorph;
SkeletalMeshOptions->bImportVertexAttributes = ImportSettings->bImportVertexAttributes;
SkeletalMeshOptions->ThresholdPosition = ImportSettings->OverlappingThresholds.ThresholdPosition;
SkeletalMeshOptions->ThresholdTangentNormal = ImportSettings->OverlappingThresholds.ThresholdTangentNormal;
SkeletalMeshOptions->ThresholdUV = ImportSettings->OverlappingThresholds.ThresholdUV;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/SkinWeightsUtilities.cpp:176
Scope (from outer to inner):
file
function bool FSkinWeightsUtilities::ImportAlternateSkinWeight
Source code excerpt:
FbxFactory->ImportUI->bImportAnimations = false;
FbxFactory->ImportUI->bAutomatedImportShouldDetectType = false;
FbxFactory->ImportUI->bCreatePhysicsAsset = false;
FbxFactory->ImportUI->bImportMaterials = false;
FbxFactory->ImportUI->bImportTextures = false;
FbxFactory->ImportUI->bImportMesh = true;
FbxFactory->ImportUI->bImportRigidMesh = false;
FbxFactory->ImportUI->bIsObjImport = false;
FbxFactory->ImportUI->bOverrideFullName = true;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Public/FbxImporter.h:187
Scope (from outer to inner):
file
namespace UnFbx
Source code excerpt:
FOverlappingThresholds OverlappingThresholds;
bool bImportMeshesInBoneHierarchy;
bool bCreatePhysicsAsset;
UPhysicsAsset *PhysicsAsset;
bool bImportSkeletalMeshLODs;
// Animation option
USkeleton* SkeletonForAnimation;
EFBXAnimationLengthImportType AnimationLengthImportType;
FIntPoint AnimationRange;