StaticMeshLODGroup
StaticMeshLODGroup
#Overview
name: StaticMeshLODGroup
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 31 C++ source files.
#Summary
#Usage in the C++ source code
The purpose of StaticMeshLODGroup is to specify the LOD (Level of Detail) group settings for imported static meshes in Unreal Engine 5. This variable is used in the static mesh import process and affects how the engine handles LOD generation and rendering for the imported mesh.
Key points about StaticMeshLODGroup:
-
It is part of the Unreal Engine’s rendering system, specifically for static meshes.
-
The variable is primarily used in the FbxImporter and related modules dealing with static mesh import and LOD management.
-
The value is typically set during the import process, either from user-specified import settings or default values.
-
It affects how the engine generates and manages LODs for the imported static mesh.
-
The StaticMeshLODGroup is of type FName, suggesting it refers to a named LOD group configuration.
-
It interacts with other LOD-related variables like MinimumLodNumber and LodNumber.
-
The value can be None (NAME_None), indicating no specific LOD group is assigned.
-
When reimporting a mesh, the code ensures that the LOD group does not change from the existing mesh’s settings.
Best practices when using this variable:
-
Carefully consider the appropriate LOD group for each static mesh based on its intended use and performance requirements.
-
Maintain consistency in LOD group assignments across related assets for predictable rendering behavior.
-
Be aware that changing the LOD group of an existing mesh may have implications for performance and visual quality.
-
When reimporting meshes, verify that the LOD group settings are maintained as expected.
-
Use in conjunction with other LOD-related settings for fine-tuned control over mesh rendering at different distances.
Developers should be aware that this setting can significantly impact rendering performance and visual quality, especially in scenes with many static meshes. It’s important to balance visual fidelity with performance considerations when choosing LOD group settings.
#Setting Variables
#References In INI files
Location: <Workspace>/Engine/Config/BaseEditorPerProjectUserSettings.ini:655, section: [/Script/UnrealEd.FbxStaticMeshImportData]
- INI Section:
/Script/UnrealEd.FbxStaticMeshImportData - Raw value:
"" - 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:156
Scope (from outer to inner):
file
namespace UE::Interchange::Private
function void FillInterchangeGenericAssetsPipelineFromFbxStaticMeshImportData
Source code excerpt:
GenericAssetPipeline->CommonMeshesProperties->bRemoveDegenerates = StaticMeshImportData->bRemoveDegenerates;
GenericAssetPipeline->MeshPipeline->DistanceFieldResolutionScale = StaticMeshImportData->DistanceFieldResolutionScale;
GenericAssetPipeline->MeshPipeline->LodGroup = StaticMeshImportData->StaticMeshLODGroup;
if (StaticMeshImportData->VertexColorImportOption == EVertexColorImportOption::Ignore)
{
GenericAssetPipeline->CommonMeshesProperties->VertexColorImportOption = EInterchangeVertexColorImportOption::IVCIO_Ignore;
}
else if (StaticMeshImportData->VertexColorImportOption == EVertexColorImportOption::Override)
{
#Loc: <Workspace>/Engine/Plugins/Interchange/Editor/Source/InterchangeEditor/Private/InterchangeFbxAssetImportDataConverter.cpp:321
Scope (from outer to inner):
file
namespace UE::Interchange::Private
function UAssetImportData* ConvertToLegacyFbx
Source code excerpt:
DestinationStaticMeshImportData->bRemoveDegenerates = GenericAssetPipeline->CommonMeshesProperties->bRemoveDegenerates;
DestinationStaticMeshImportData->DistanceFieldResolutionScale = GenericAssetPipeline->MeshPipeline->DistanceFieldResolutionScale;
DestinationStaticMeshImportData->StaticMeshLODGroup = GenericAssetPipeline->MeshPipeline->LodGroup;
if (GenericAssetPipeline->CommonMeshesProperties->VertexColorImportOption == EInterchangeVertexColorImportOption::IVCIO_Ignore)
{
DestinationStaticMeshImportData->VertexColorImportOption = EVertexColorImportOption::Ignore;
}
else if (GenericAssetPipeline->CommonMeshesProperties->VertexColorImportOption == EInterchangeVertexColorImportOption::IVCIO_Override)
{
#Loc: <Workspace>/Engine/Plugins/Tests/EditorTests/Source/EditorTests/Private/UnrealEd/FbxAutomationTests.cpp:379
Scope (from outer to inner):
file
function BEGIN_FUNCTION_BUILD_OPTIMIZATION bool F
Source code excerpt:
//Copy UFbxStaticMeshImportData
ImportData->StaticMeshLODGroup = TestPlan->ImportUI->StaticMeshImportData->StaticMeshLODGroup;
ImportData->VertexColorImportOption = TestPlan->ImportUI->StaticMeshImportData->VertexColorImportOption;
ImportData->VertexOverrideColor = TestPlan->ImportUI->StaticMeshImportData->VertexOverrideColor;
ImportData->bRemoveDegenerates = TestPlan->ImportUI->StaticMeshImportData->bRemoveDegenerates;
ImportData->bBuildReversedIndexBuffer = TestPlan->ImportUI->StaticMeshImportData->bBuildReversedIndexBuffer;
ImportData->bGenerateLightmapUVs = TestPlan->ImportUI->StaticMeshImportData->bGenerateLightmapUVs;
ImportData->bOneConvexHullPerUCX = TestPlan->ImportUI->StaticMeshImportData->bOneConvexHullPerUCX;
#Loc: <Workspace>/Engine/Plugins/Tests/EditorTests/Source/EditorTests/Private/UnrealEd/FbxAutomationTests.cpp:487
Scope (from outer to inner):
file
function BEGIN_FUNCTION_BUILD_OPTIMIZATION bool F
Source code excerpt:
//Copy UFbxStaticMeshImportData
ImportData->StaticMeshLODGroup = TestPlan->ImportUI->StaticMeshImportData->StaticMeshLODGroup;
ImportData->VertexColorImportOption = TestPlan->ImportUI->StaticMeshImportData->VertexColorImportOption;
ImportData->VertexOverrideColor = TestPlan->ImportUI->StaticMeshImportData->VertexOverrideColor;
ImportData->bRemoveDegenerates = TestPlan->ImportUI->StaticMeshImportData->bRemoveDegenerates;
ImportData->bBuildReversedIndexBuffer = TestPlan->ImportUI->StaticMeshImportData->bBuildReversedIndexBuffer;
ImportData->bGenerateLightmapUVs = TestPlan->ImportUI->StaticMeshImportData->bGenerateLightmapUVs;
ImportData->bOneConvexHullPerUCX = TestPlan->ImportUI->StaticMeshImportData->bOneConvexHullPerUCX;
#Loc: <Workspace>/Engine/Source/Editor/DetailCustomizations/Private/FbxImportUIDetails.cpp:495
Scope (from outer to inner):
file
function void FFbxImportUIDetails::CustomizeDetails
Source code excerpt:
if (Property != nullptr)
{
if (Property->GetFName() == GET_MEMBER_NAME_CHECKED(UFbxStaticMeshImportData, StaticMeshLODGroup))
{
//We cannot change the LODGroup when re-importing so hide the option
if (ImportUI->bIsReimport)
{
PropertyRow.Visibility(EVisibility::Collapsed);
}
#Loc: <Workspace>/Engine/Source/Editor/DetailCustomizations/Private/FbxImportUIDetails.h:109
Scope (from outer to inner):
file
class class FFbxImportUIDetails : public IDetailCustomization, public FEditorUndoClient
Source code excerpt:
FFbxImportUIDetails();
/** Sets a custom widget for the StaticMeshLODGroup property */
void SetStaticMeshLODGroupWidget(IDetailPropertyRow& PropertyRow, const TSharedPtr<IPropertyHandle>& Handle);
/** Called when the StaticMeshLODGroup spinbox is changed */
void OnLODGroupChanged(TSharedPtr<FString> NewValue, ESelectInfo::Type SelectInfo, TWeakPtr<IPropertyHandle> HandlePtr);
/** Called to determine the visibility of the VertexOverrideColor property */
bool GetVertexOverrideColorEnabledState() const;
bool GetSkeletalMeshVertexOverrideColorEnabledState() const;
#Loc: <Workspace>/Engine/Source/Editor/DetailCustomizations/Private/FbxImportUIDetails.h:126
Scope (from outer to inner):
file
class class FFbxImportUIDetails : public IDetailCustomization, public FEditorUndoClient
Source code excerpt:
TArray<TSharedPtr<FString>> LODGroupOptions;
/** Cached StaticMeshLODGroup property handle */
TSharedPtr<IPropertyHandle> StaticMeshLODGroupPropertyHandle;
/** Cached VertexColorImportOption property handle */
TSharedPtr<IPropertyHandle> VertexColorImportOptionHandle;
TSharedPtr<IPropertyHandle> SkeletalMeshVertexColorImportOptionHandle;
#Loc: <Workspace>/Engine/Source/Editor/StaticMeshEditor/Private/StaticMeshEditorTools.cpp:4349
Scope (from outer to inner):
file
function void FLevelOfDetailSettingsLayout::OnImportLOD
Source code excerpt:
if (ImportData != nullptr)
{
ImportData->StaticMeshLODGroup = NAME_None;
}
}
}
//Are we a new imported LOD, we want to set some value for new imported LOD.
//This boolean prevent changing the value when the LOD is reimport
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Classes/Factories/FbxSceneImportOptionsStaticMesh.h:51
Scope (from outer to inner):
file
class class UFbxSceneImportOptionsStaticMesh : public UObject
Source code excerpt:
/** For static meshes, enabling this option will combine all meshes in the FBX into a single monolithic mesh in Unreal */
UPROPERTY()
FName StaticMeshLODGroup;
/** If checked, collision will automatically be generated (ignored if custom collision is imported or used). */
UPROPERTY(EditAnywhere, config, Category = StaticMesh, DisplayName = "Generate Missing Collision")
uint32 bAutoGenerateCollision : 1;
/** Specify how vertex colors should be imported */
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Classes/Factories/FbxStaticMeshImportData.h:20
Scope (from outer to inner):
file
class class UFbxStaticMeshImportData : public UFbxMeshImportData
Source code excerpt:
/** The LODGroup to associate with this mesh when it is imported */
UPROPERTY(EditAnywhere, BlueprintReadWrite, config, AdvancedDisplay, Category=Mesh, meta=(ImportType="StaticMesh"))
FName StaticMeshLODGroup;
/** Specify how vertex colors should be imported */
UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, config, Category= Mesh, meta=(OBJRestrict="true", ImportType="StaticMesh"))
TEnumAsByte<EVertexColorImportOption::Type> VertexColorImportOption;
/** Specify override color in the case that VertexColorImportOption is set to Override */
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Factories/EditorFactories.cpp:6210
Scope (from outer to inner):
file
function EReimportResult::Type UReimportFbxStaticMeshFactory::Reimport
Source code excerpt:
ImportOptions->MinimumLodNumber = 0;
//Make sure the LODGroup do not change when re-importing a mesh
ImportOptions->StaticMeshLODGroup = Mesh->LODGroup;
if( !bOperationCanceled && ensure(ImportData) )
{
UE_LOG(LogEditorFactories, Log, TEXT("Performing atomic reimport of [%s]"), *Filename);
bool bImportSucceed = true;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:493
Scope (from outer to inner):
file
namespace UnFbx
function void ApplyImportUIToImportOptions
Source code excerpt:
InOutImportOptions.bOneConvexHullPerUCX = ImportUI->StaticMeshImportData->bOneConvexHullPerUCX;
InOutImportOptions.bAutoGenerateCollision = ImportUI->StaticMeshImportData->bAutoGenerateCollision;
InOutImportOptions.StaticMeshLODGroup = ImportUI->StaticMeshImportData->StaticMeshLODGroup;
}
// animation unshared options
{
InOutImportOptions.AnimationLengthImportType = ImportUI->AnimSequenceImportData->AnimationLength;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:1677
Scope (from outer to inner):
file
namespace UnFbx
function bool FFbxImporter::ImportFromFile
Source code excerpt:
* @EventParam RemoveDegenerates boolean Returns whether the importer should remove the degenerated triangles when building the static mesh
* @EventParam MinimumLodNumber integer Returns the minimum LOD use by the rendering
* @EventParam StaticMeshLODGroup string Returns the LOD Group settings we use to build this imported static mesh
* @EventParam VertexColorImportOption string Returns how the importer should import the vertex color
* @EventParam VertexOverrideColor string Returns the color use if we need to override the vertex color
* @EventParam AnimationLengthImportType string Returns how we choose the animation time span
* @EventParam DeleteExistingMorphTargetCurves boolean Returns whether the importer should delete the existing morph target curves
* @EventParam AnimationRange string Returns the range of animation the importer should sample if the time span is custom
* @EventParam DoNotImportCurveWithZero boolean Returns whether the importer should import curves containing only zero value
* @EventParam ImportBoneTracks boolean Returns whether the importer should import the bone tracks
* @EventParam ImportCustomAttribute boolean Returns whether the importer should import the custom attribute curves
* @EventParam PreserveLocalTransform boolean Returns whether the importer should preserve the local transform when importing the animation
* @EventParam RemoveRedundantKeys boolean Returns whether the importer should remove all redundant key in an animation
* @EventParam Resample boolean Returns whether the importer should re-sample the animation
* @EventParam SetMaterialDriveParameterOnCustomAttribute boolean Returns whether the importer should hook all custom attribute curve to unreal material attribute
* @EventParam SetMaterialDriveParameterOnCustomAttribute boolean Returns whether the importer should hook some custom attribute (having the suffix) curve to unreal material attribute
* @EventParam ResampleRate float Returns the rate the exporter is suppose to re-sample any imported animations
*
* @Owner Alexis.Matte
*/
FbxDocumentInfo* DocInfo = Scene->GetSceneInfo();
if (DocInfo)
{
if( FEngineAnalytics::IsAvailable() )
{
const static UEnum* FBXImportTypeEnum = StaticEnum<EFBXImportType>();
const static UEnum* FBXAnimationLengthImportTypeEnum = StaticEnum<EFBXAnimationLengthImportType>();
const static UEnum* MaterialSearchLocationEnum = StaticEnum<EMaterialSearchLocation>();
const static UEnum* FBXNormalGenerationMethodEnum = StaticEnum<EFBXNormalGenerationMethod::Type>();
const static UEnum* FBXNormalImportMethodEnum = StaticEnum<EFBXNormalImportMethod>();
const static UEnum* VertexColorImportOptionEnum = StaticEnum<EVertexColorImportOption::Type>();
TArray<FAnalyticsEventAttribute> Attribs;
FString LastSavedVendor(UTF8_TO_TCHAR(DocInfo->LastSaved_ApplicationVendor.Get().Buffer()));
FString LastSavedAppName(UTF8_TO_TCHAR(DocInfo->LastSaved_ApplicationName.Get().Buffer()));
FString LastSavedAppVersion(UTF8_TO_TCHAR(DocInfo->LastSaved_ApplicationVersion.Get().Buffer()));
Attribs.Add(FAnalyticsEventAttribute(TEXT("LastSaved Application Vendor"), LastSavedVendor));
Attribs.Add(FAnalyticsEventAttribute(TEXT("LastSaved Application Name"), LastSavedAppName));
Attribs.Add(FAnalyticsEventAttribute(TEXT("LastSaved Application Version"), LastSavedAppVersion));
Attribs.Add(FAnalyticsEventAttribute(TEXT("FBX Version"), FbxFileVersion));
//////////////////////////////////////////////////////////////////////////
//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));
Attribs.Add(FAnalyticsEventAttribute(TEXT("GenOpt UsedAsFullName"), ImportOptions->bUsedAsFullName));
Attribs.Add(FAnalyticsEventAttribute(TEXT("GenOpt ImportTranslation"), ImportOptions->ImportTranslation.ToString()));
Attribs.Add(FAnalyticsEventAttribute(TEXT("GenOpt ImportRotation"), ImportOptions->ImportRotation.ToString()));
Attribs.Add(FAnalyticsEventAttribute(TEXT("GenOpt ImportUniformScale"), ImportOptions->ImportUniformScale));
Attribs.Add(FAnalyticsEventAttribute(TEXT("GenOpt MaterialBasePath"), ImportOptions->MaterialBasePath));
Attribs.Add(FAnalyticsEventAttribute(TEXT("GenOpt MaterialSearchLocation"), MaterialSearchLocationEnum->GetNameStringByValue((uint64)(ImportOptions->MaterialSearchLocation))));
Attribs.Add(FAnalyticsEventAttribute(TEXT("GenOpt ReorderMaterialToFbxOrder"), ImportOptions->bReorderMaterialToFbxOrder));
//We cant capture a this member, so just assign the pointer here
FBXImportOptions* CaptureImportOptions = ImportOptions;
auto AddMeshAnalytic = [&Attribs, &CaptureImportOptions]()
{
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));
};
auto AddSKAnalytic = [&Attribs, &CaptureImportOptions]()
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:1779
Scope (from outer to inner):
file
lambda-function
Source code excerpt:
Attribs.Add(FAnalyticsEventAttribute(TEXT("StaticMeshOpt RemoveDegenerates"), CaptureImportOptions->bRemoveDegenerates));
Attribs.Add(FAnalyticsEventAttribute(TEXT("StaticMeshOpt MinimumLodNumber"), CaptureImportOptions->MinimumLodNumber));
Attribs.Add(FAnalyticsEventAttribute(TEXT("StaticMeshOpt StaticMeshLODGroup"), CaptureImportOptions->StaticMeshLODGroup));
Attribs.Add(FAnalyticsEventAttribute(TEXT("StaticMeshOpt VertexColorImportOption"), VertexColorImportOptionEnum->GetNameStringByValue(CaptureImportOptions->VertexColorImportOption)));
Attribs.Add(FAnalyticsEventAttribute(TEXT("StaticMeshOpt VertexOverrideColor"), CaptureImportOptions->VertexOverrideColor.ToString()));
};
auto AddAnimAnalytic = [&Attribs, &CaptureImportOptions]()
{
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSceneImportData.cpp:109
Scope (from outer to inner):
file
function UnFbx::FBXImportOptions *JSONToFbxOption
Source code excerpt:
if (OptionObj->TryGetStringField(TEXT("StaticMeshLODGroup"), LODGroup))
{
Option->StaticMeshLODGroup = FName(*LODGroup);
}
OptionObj->TryGetBoolField(TEXT("bImportStaticMeshLODs"), Option->bImportStaticMeshLODs);
//Skeletal mesh options
OptionObj->TryGetBoolField(TEXT("bUpdateSkeletonReferencePose"), Option->bUpdateSkeletonReferencePose);
//TODO support T0AsRefPose
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSceneImportData.cpp:201
Scope (from outer to inner):
file
function FString FbxOptionToJSON
Source code excerpt:
Option->bOneConvexHullPerUCX ? 1 : 0,
Option->bAutoGenerateCollision ? 1 : 0,
*(Option->StaticMeshLODGroup.ToString()),
Option->bImportStaticMeshLODs ? 1 : 0
);
JsonString += FString::Printf(TEXT("\"bUpdateSkeletonReferencePose\" : \"%d\", \"bUseT0AsRefPose\" : \"%d\", \"bPreserveSmoothingGroups\" : \"%d\", \"bKeepSectionsSeparate\" : \"%d\", \"bImportMeshesInBoneHierarchy\" : \"%d\", \"bImportMorphTargets\" : \"%d\", , \"bImportVertexAttributes\" : \"%d\", \"OverlappingThresholds\" : {\"ThresholdPosition\" : \"%f\", \"ThresholdTangentNormal\" : \"%f\", \"ThresholdUV\" : \"%f\", \"MorphThresholdPosition\" : \"%f\"},"),
Option->bUpdateSkeletonReferencePose ? 1 : 0,
Option->bUseT0AsRefPose ? 1 : 0,
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSceneImportOptionsStaticMesh.cpp:15
Scope (from outer to inner):
file
function UFbxSceneImportOptionsStaticMesh::UFbxSceneImportOptionsStaticMesh
Source code excerpt:
UFbxSceneImportOptionsStaticMesh::UFbxSceneImportOptionsStaticMesh(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
, StaticMeshLODGroup(NAME_None)
, bAutoGenerateCollision(true)
, bRemoveDegenerates(true)
, bBuildReversedIndexBuffer(true)
, bGenerateLightmapUVs(true)
, bOneConvexHullPerUCX(true)
{
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSceneImportOptionsStaticMesh.cpp:36
Scope (from outer to inner):
file
function void UFbxSceneImportOptionsStaticMesh::FillStaticMeshInmportData
Source code excerpt:
StaticMeshImportData->bOneConvexHullPerUCX = bOneConvexHullPerUCX;
StaticMeshImportData->bRemoveDegenerates = bRemoveDegenerates;
StaticMeshImportData->StaticMeshLODGroup = StaticMeshLODGroup;
switch (VertexColorImportOption)
{
case EFbxSceneVertexColorImportOption::Ignore:
StaticMeshImportData->VertexColorImportOption = EVertexColorImportOption::Ignore;
break;
case EFbxSceneVertexColorImportOption::Override:
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxStaticMeshImport.cpp:2012
Scope (from outer to inner):
file
function UStaticMesh* UnFbx::FFbxImporter::ImportStaticMeshAsSingle
Source code excerpt:
ITargetPlatform* CurrentPlatform = GetTargetPlatformManagerRef().GetRunningTargetPlatform();
check(CurrentPlatform);
const FStaticMeshLODGroup& LODGroup = CurrentPlatform->GetStaticMeshLODSettings().GetLODGroup(ImportOptions->StaticMeshLODGroup);
int32 NumLODs = LODGroup.GetDefaultNumLODs();
while (StaticMesh->GetNumSourceModels() < NumLODs)
{
StaticMesh->AddSourceModel();
}
for (int32 ModelLODIndex = 0; ModelLODIndex < NumLODs; ++ModelLODIndex)
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxStaticMeshImport.cpp:2068
Scope (from outer to inner):
file
function UStaticMesh* UnFbx::FFbxImporter::ImportStaticMeshAsSingle
Source code excerpt:
if (LODIndex == 0 && InStaticMesh == nullptr)
{
StaticMesh->LODGroup = ImportOptions->StaticMeshLODGroup;
}
//Set the Imported version before calling the build
//We set it here because the remap index is build in RestoreExistingMeshSettings call before the build
StaticMesh->ImportVersion = EImportStaticMeshVersion::LastVersion;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxStaticMeshImport.cpp:2338
Scope (from outer to inner):
file
function void UnFbx::FFbxImporter::PostImportStaticMesh
Source code excerpt:
//In case we plan to change the LodNumber we will build the static mesh 2 time
//We have to disable the distance field calculation so it get calculated only during the second build
bool bSpecifiedLodGroup = ImportOptions->StaticMeshLODGroup != NAME_None;
if (bSpecifiedLodGroup)
{
//Avoid building the distance field when we prebuild
if (OriginalCVarDistanceFieldValue != 0 && CVarDistanceFieldInterface)
{
//Hack we change the distance field user console variable to control the build, but we put back the value after the first build
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxStaticMeshImportData.cpp:6
Scope (from outer to inner):
file
function UFbxStaticMeshImportData::UFbxStaticMeshImportData
Source code excerpt:
: Super(ObjectInitializer)
{
StaticMeshLODGroup = NAME_None;
bRemoveDegenerates = true;
bBuildReversedIndexBuffer = true;
bBuildNanite = false;
bGenerateLightmapUVs = true;
bOneConvexHullPerUCX = true;
bAutoGenerateCollision = true;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SFbxSceneOptionWindow.cpp:1406
Scope (from outer to inner):
file
function void SFbxSceneOptionWindow::CopyStaticMeshOptionsToFbxOptions
Source code excerpt:
ImportSettings->bOneConvexHullPerUCX = StaticMeshOptions->bOneConvexHullPerUCX;
ImportSettings->bRemoveDegenerates = StaticMeshOptions->bRemoveDegenerates;
ImportSettings->StaticMeshLODGroup = StaticMeshOptions->StaticMeshLODGroup;
switch (StaticMeshOptions->VertexColorImportOption)
{
case EFbxSceneVertexColorImportOption::Replace:
ImportSettings->VertexColorImportOption = EVertexColorImportOption::Type::Replace;
break;
case EFbxSceneVertexColorImportOption::Override:
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SFbxSceneOptionWindow.cpp:1452
Scope (from outer to inner):
file
function void SFbxSceneOptionWindow::CopyFbxOptionsToStaticMeshOptions
Source code excerpt:
StaticMeshOptions->bOneConvexHullPerUCX = ImportSettings->bOneConvexHullPerUCX;
StaticMeshOptions->bRemoveDegenerates = ImportSettings->bRemoveDegenerates;
StaticMeshOptions->StaticMeshLODGroup = ImportSettings->StaticMeshLODGroup;
switch (ImportSettings->VertexColorImportOption)
{
case EVertexColorImportOption::Type::Replace:
StaticMeshOptions->VertexColorImportOption = EFbxSceneVertexColorImportOption::Replace;
break;
case EVertexColorImportOption::Type::Override:
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SSceneImportStaticMeshListView.cpp:208
Scope (from outer to inner):
file
function void SFbxSceneStaticMeshListView::Construct
Source code excerpt:
//Set the default options to the current global import settings
GlobalImportSettings->bTransformVertexToAbsolute = false;
GlobalImportSettings->StaticMeshLODGroup = NAME_None;
CurrentMeshImportOptions = GlobalImportSettings;
bool bNameExist = false;
for (TSharedPtr<FString> OverrideName : (*OverrideNameOptions))
{
if (OverrideName.Get()->Compare(UFbxSceneImportFactory::DefaultOptionName) == 0)
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SSceneReimportSkeletalMeshListView.cpp:349
Scope (from outer to inner):
file
function void SFbxSceneSkeletalMeshReimportListView::Construct
Source code excerpt:
//Set the default options to the current global import settings
GlobalImportSettings->bTransformVertexToAbsolute = false;
GlobalImportSettings->StaticMeshLODGroup = NAME_None;
CurrentMeshImportOptions = GlobalImportSettings;
FbxMeshesArray.Empty();
FilterFbxMeshesArray.Empty();
FilterAddContent = false;
FilterDeleteContent = false;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SSceneReimportStaticMeshListView.cpp:349
Scope (from outer to inner):
file
function void SFbxSceneStaticMeshReimportListView::Construct
Source code excerpt:
//Set the default options to the current global import settings
GlobalImportSettings->bTransformVertexToAbsolute = false;
GlobalImportSettings->StaticMeshLODGroup = NAME_None;
CurrentMeshImportOptions = GlobalImportSettings;
FbxMeshesArray.Empty();
FilterFbxMeshesArray.Empty();
FilterAddContent = false;
FilterDeleteContent = false;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SSceneSkeletalMeshListView.cpp:207
Scope (from outer to inner):
file
function void SFbxSceneSkeletalMeshListView::Construct
Source code excerpt:
//Set the default options to the current global import settings
GlobalImportSettings->bTransformVertexToAbsolute = false;
GlobalImportSettings->StaticMeshLODGroup = NAME_None;
CurrentMeshImportOptions = GlobalImportSettings;
bool bNameExist = false;
for (TSharedPtr<FString> OverrideName : (*OverrideNameOptions))
{
if (OverrideName.Get()->Compare(UFbxSceneImportFactory::DefaultOptionName) == 0)
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/FbxMeshUtils.cpp:85
Scope (from outer to inner):
file
namespace FbxMeshUtils
namespace Private
function void SetupFbxImportOptions
Source code excerpt:
// Set a couple of settings that shouldn't change while importing a lod
ImportOptions->bBuildNanite = BaseStaticMesh->IsNaniteEnabled();
ImportOptions->StaticMeshLODGroup = BaseStaticMesh->LODGroup;
ImportOptions->bIsImportCancelable = false;
ImportOptions->bImportMaterials = false;
ImportOptions->bImportTextures = false;
ImportOptions->bAutoComputeLodDistances = true; //Setting auto compute distance to true will avoid changing the staticmesh flag
}
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/FbxMeshUtils.cpp:412
Scope (from outer to inner):
file
namespace FbxMeshUtils
function bool ImportStaticMeshHiResSourceModel
Source code excerpt:
UnFbx::FBXImportOptions* ImportOptions = FFbxImporter->GetImportOptions();
Private::SetupFbxImportOptions(BaseStaticMesh, ImportOptions);
ImportOptions->StaticMeshLODGroup = NAME_None;
ImportOptions->bImportLOD = false;
UFbxStaticMeshImportData* ImportData = Cast<UFbxStaticMeshImportData>(BaseStaticMesh->AssetImportData);
const bool bPreventMaterialNameClash = true;
if (!FFbxImporter->ImportFromFile(*Filename, FPaths::GetExtension(Filename), bPreventMaterialNameClash))
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Public/FbxImporter.h:155
Scope (from outer to inner):
file
namespace UnFbx
Source code excerpt:
bool bOneConvexHullPerUCX;
bool bAutoGenerateCollision;
FName StaticMeshLODGroup;
bool bImportStaticMeshLODs;
bool bAutoComputeLodDistances;
TArray<float> LodDistances;
int32 MinimumLodNumber;
int32 LodNumber;
// Material import options