NormalImportMethod
NormalImportMethod
#Overview
name: NormalImportMethod
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 26 C++ source files.
#Summary
#Usage in the C++ source code
The purpose of NormalImportMethod is to control how normal vectors are imported or generated for 3D meshes in Unreal Engine 5. This setting is primarily used in the rendering system, specifically for the import and processing of 3D models.
NormalImportMethod is part of the FBX import system in Unreal Engine 5. It’s primarily used by the Editor’s import subsystem, particularly for importing static meshes and skeletal meshes from FBX files.
The value of this variable is typically set during the import process, either through user interface options or programmatically when importing assets. It can be set in the FBX import options or in the reimport settings for meshes.
This variable interacts closely with other import settings, particularly:
- NormalGenerationMethod: Determines how normals are generated if they’re not imported.
- bRecomputeNormals and bRecomputeTangents: These are often set based on the NormalImportMethod value.
Developers should be aware that:
- The choice of normal import method can significantly affect the appearance of imported meshes.
- Different import methods may be more suitable for different types of models or different source software.
- This setting can impact performance and memory usage, especially for high-polygon models.
Best practices when using this variable include:
- Use FBXNIM_ImportNormalsAndTangents when you trust the normals and tangents from your source file.
- Use FBXNIM_ComputeNormals if you want Unreal to calculate the normals, which can be useful for optimizing or standardizing normal data across models.
- Consider the source of your models and the requirements of your project when choosing the import method.
- Be consistent in your choice across similar assets to ensure uniform rendering quality.
#Setting Variables
#References In INI files
Location: <Workspace>/Engine/Config/BaseEditorPerProjectUserSettings.ini:650, section: [/Script/UnrealEd.FbxMeshImportData]
- INI Section:
/Script/UnrealEd.FbxMeshImportData - Raw value:
FBXNIM_ComputeNormals - Is Array:
False
Location: <Workspace>/Engine/Config/BaseEditorPerProjectUserSettings.ini:665, section: [/Script/UnrealEd.FbxStaticMeshImportData]
- INI Section:
/Script/UnrealEd.FbxStaticMeshImportData - Raw value:
FBXNIM_ImportNormals - 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:82
Scope (from outer to inner):
file
namespace UE::Interchange::Private
function void FillFbxMeshImportData
Source code excerpt:
if (GenericAssetPipeline->CommonMeshesProperties->bRecomputeNormals)
{
MeshImportData->NormalImportMethod = EFBXNormalImportMethod::FBXNIM_ComputeNormals;
}
else
{
if (GenericAssetPipeline->CommonMeshesProperties->bRecomputeTangents)
{
MeshImportData->NormalImportMethod = EFBXNormalImportMethod::FBXNIM_ImportNormals;
}
else
{
MeshImportData->NormalImportMethod = EFBXNormalImportMethod::FBXNIM_ImportNormalsAndTangents;
}
}
}
void FillInterchangeGenericAssetsPipelineFromFbxMeshImportData(UInterchangeGenericAssetsPipeline* GenericAssetPipeline, const UFbxMeshImportData* LegacyMeshImportData)
{
#Loc: <Workspace>/Engine/Plugins/Interchange/Editor/Source/InterchangeEditor/Private/InterchangeFbxAssetImportDataConverter.cpp:117
Scope (from outer to inner):
file
namespace UE::Interchange::Private
function void FillInterchangeGenericAssetsPipelineFromFbxMeshImportData
Source code excerpt:
}
if (LegacyMeshImportData->NormalImportMethod == EFBXNormalImportMethod::FBXNIM_ComputeNormals)
{
GenericAssetPipeline->CommonMeshesProperties->bRecomputeNormals = true;
}
else
{
if (LegacyMeshImportData->NormalImportMethod == EFBXNormalImportMethod::FBXNIM_ImportNormals)
{
GenericAssetPipeline->CommonMeshesProperties->bRecomputeTangents = true;
}
else
{
GenericAssetPipeline->CommonMeshesProperties->bRecomputeTangents = false;
#Loc: <Workspace>/Engine/Plugins/Tests/EditorTests/Source/EditorTests/Private/UnrealEd/FbxAutomationTests.cpp:391
Scope (from outer to inner):
file
function BEGIN_FUNCTION_BUILD_OPTIMIZATION bool F
Source code excerpt:
ImportData->bBakePivotInVertex = TestPlan->ImportUI->StaticMeshImportData->bBakePivotInVertex;
ImportData->bImportMeshLODs = TestPlan->ImportUI->StaticMeshImportData->bImportMeshLODs;
ImportData->NormalImportMethod = TestPlan->ImportUI->StaticMeshImportData->NormalImportMethod;
ImportData->NormalGenerationMethod = TestPlan->ImportUI->StaticMeshImportData->NormalGenerationMethod;
ImportData->bComputeWeightedNormals = TestPlan->ImportUI->StaticMeshImportData->bComputeWeightedNormals;
//Copy UFbxAssetImportData
ImportData->ImportTranslation = TestPlan->ImportUI->StaticMeshImportData->ImportTranslation;
ImportData->ImportRotation = TestPlan->ImportUI->StaticMeshImportData->ImportRotation;
ImportData->ImportUniformScale = TestPlan->ImportUI->StaticMeshImportData->ImportUniformScale;
#Loc: <Workspace>/Engine/Plugins/Tests/EditorTests/Source/EditorTests/Private/UnrealEd/FbxAutomationTests.cpp:434
Scope (from outer to inner):
file
function BEGIN_FUNCTION_BUILD_OPTIMIZATION bool F
Source code excerpt:
ImportData->bBakePivotInVertex = TestPlan->ImportUI->SkeletalMeshImportData->bBakePivotInVertex;
ImportData->bImportMeshLODs = TestPlan->ImportUI->SkeletalMeshImportData->bImportMeshLODs;
ImportData->NormalImportMethod = TestPlan->ImportUI->SkeletalMeshImportData->NormalImportMethod;
ImportData->NormalGenerationMethod = TestPlan->ImportUI->SkeletalMeshImportData->NormalGenerationMethod;
//Copy UFbxAssetImportData
ImportData->ImportTranslation = TestPlan->ImportUI->SkeletalMeshImportData->ImportTranslation;
ImportData->ImportRotation = TestPlan->ImportUI->SkeletalMeshImportData->ImportRotation;
ImportData->ImportUniformScale = TestPlan->ImportUI->SkeletalMeshImportData->ImportUniformScale;
ImportData->bImportAsScene = TestPlan->ImportUI->SkeletalMeshImportData->bImportAsScene;
#Loc: <Workspace>/Engine/Plugins/Tests/EditorTests/Source/EditorTests/Private/UnrealEd/FbxAutomationTests.cpp:499
Scope (from outer to inner):
file
function BEGIN_FUNCTION_BUILD_OPTIMIZATION bool F
Source code excerpt:
ImportData->bBakePivotInVertex = TestPlan->ImportUI->StaticMeshImportData->bBakePivotInVertex;
ImportData->bImportMeshLODs = TestPlan->ImportUI->StaticMeshImportData->bImportMeshLODs;
ImportData->NormalImportMethod = TestPlan->ImportUI->StaticMeshImportData->NormalImportMethod;
ImportData->NormalGenerationMethod = TestPlan->ImportUI->StaticMeshImportData->NormalGenerationMethod;
ImportData->bComputeWeightedNormals = TestPlan->ImportUI->StaticMeshImportData->bComputeWeightedNormals;
//Copy UFbxAssetImportData
ImportData->ImportTranslation = TestPlan->ImportUI->StaticMeshImportData->ImportTranslation;
ImportData->ImportRotation = TestPlan->ImportUI->StaticMeshImportData->ImportRotation;
ImportData->ImportUniformScale = TestPlan->ImportUI->StaticMeshImportData->ImportUniformScale;
#Loc: <Workspace>/Engine/Plugins/Tests/EditorTests/Source/EditorTests/Private/UnrealEd/FbxAutomationTests.cpp:532
Scope (from outer to inner):
file
function BEGIN_FUNCTION_BUILD_OPTIMIZATION bool F
Source code excerpt:
ImportData->bBakePivotInVertex = TestPlan->ImportUI->SkeletalMeshImportData->bBakePivotInVertex;
ImportData->bImportMeshLODs = TestPlan->ImportUI->SkeletalMeshImportData->bImportMeshLODs;
ImportData->NormalImportMethod = TestPlan->ImportUI->SkeletalMeshImportData->NormalImportMethod;
ImportData->NormalGenerationMethod = TestPlan->ImportUI->SkeletalMeshImportData->NormalGenerationMethod;
//Copy UFbxAssetImportData
ImportData->ImportTranslation = TestPlan->ImportUI->SkeletalMeshImportData->ImportTranslation;
ImportData->ImportRotation = TestPlan->ImportUI->SkeletalMeshImportData->ImportRotation;
ImportData->ImportUniformScale = TestPlan->ImportUI->SkeletalMeshImportData->ImportUniformScale;
ImportData->bImportAsScene = TestPlan->ImportUI->SkeletalMeshImportData->bImportAsScene;
#Loc: <Workspace>/Engine/Source/Editor/Persona/Private/PersonaMeshDetails.cpp:4045
Scope (from outer to inner):
file
function FReply FPersonaMeshDetails::ApplyLODChanges
Source code excerpt:
if (!LODInfo->BuildSettings.bRecomputeNormals && !LODInfo->BuildSettings.bRecomputeTangents)
{
SKImportData->NormalImportMethod = EFBXNormalImportMethod::FBXNIM_ImportNormalsAndTangents;
}
else
{
SKImportData->NormalImportMethod = LODInfo->BuildSettings.bRecomputeNormals ? EFBXNormalImportMethod::FBXNIM_ComputeNormals : EFBXNormalImportMethod::FBXNIM_ImportNormals;
SKImportData->NormalGenerationMethod = LODInfo->BuildSettings.bUseMikkTSpace ? EFBXNormalGenerationMethod::MikkTSpace : EFBXNormalGenerationMethod::BuiltIn;
}
SKImportData->bComputeWeightedNormals = LODInfo->BuildSettings.bComputeWeightedNormals;
SKImportData->ThresholdPosition = LODInfo->BuildSettings.ThresholdPosition;
SKImportData->ThresholdTangentNormal = LODInfo->BuildSettings.ThresholdTangentNormal;
SKImportData->ThresholdUV = LODInfo->BuildSettings.ThresholdUV;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Classes/Factories/FbxMeshImportData.h:76
Scope (from outer to inner):
file
class class UFbxMeshImportData : public UFbxAssetImportData
Source code excerpt:
/** Enabling this option will read the tangents(tangent,binormal,normal) from FBX file instead of generating them automatically. */
UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, config, Category= Mesh, meta=(ImportType="Mesh|GeoOnly"))
TEnumAsByte<enum EFBXNormalImportMethod> NormalImportMethod;
/** Use the MikkTSpace tangent space generator for generating normals and tangents on the mesh */
UPROPERTY(EditAnywhere, BlueprintReadWrite, config, AdvancedDisplay, Category = Mesh, meta=(ImportType="Mesh|GeoOnly"))
TEnumAsByte<enum EFBXNormalGenerationMethod::Type> NormalGenerationMethod;
/** Enabling this option will use weighted normals algorithm (area and angle) when computing normals or tangents */
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Classes/Factories/FbxSceneImportOptionsStaticMesh.h:81
Scope (from outer to inner):
file
class class UFbxSceneImportOptionsStaticMesh : public UObject
Source code excerpt:
/** Enabling this option will read the tangents(tangent,binormal,normal) from FBX file instead of generating them automatically. */
UPROPERTY(EditAnywhere, config, Category = StaticMesh)
EFBXSceneNormalImportMethod NormalImportMethod;
/** Use the MikkTSpace tangent space generator for generating normals and tangents on the mesh */
UPROPERTY(EditAnywhere, config, Category = StaticMesh)
EFBXSceneNormalGenerationMethod NormalGenerationMethod;
void FillStaticMeshInmportData(class UFbxStaticMeshImportData* StaticMeshImportData, class UFbxSceneImportOptions* SceneImportOptions);
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Factories/EditorFactories.cpp:6704
Scope (from outer to inner):
file
function EReimportResult::Type UReimportFbxSkeletalMeshFactory::Reimport
Source code excerpt:
//Set the build settings
LODInfo->BuildSettings.bComputeWeightedNormals = SKImportData->bComputeWeightedNormals;
LODInfo->BuildSettings.bRecomputeNormals = SKImportData->NormalImportMethod == EFBXNormalImportMethod::FBXNIM_ComputeNormals;
LODInfo->BuildSettings.bRecomputeTangents = SKImportData->NormalImportMethod != EFBXNormalImportMethod::FBXNIM_ImportNormalsAndTangents;
LODInfo->BuildSettings.bUseMikkTSpace = SKImportData->NormalGenerationMethod == EFBXNormalGenerationMethod::MikkTSpace;
LODInfo->BuildSettings.ThresholdPosition = SKImportData->ThresholdPosition;
LODInfo->BuildSettings.ThresholdTangentNormal = SKImportData->ThresholdTangentNormal;
LODInfo->BuildSettings.ThresholdUV = SKImportData->ThresholdUV;
LODInfo->BuildSettings.MorphThresholdPosition = SKImportData->MorphThresholdPosition;
}
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:406
Scope (from outer to inner):
file
namespace UnFbx
function void ApplyImportUIToImportOptions
Source code excerpt:
{
UFbxStaticMeshImportData* StaticMeshData = ImportUI->StaticMeshImportData;
InOutImportOptions.NormalImportMethod = StaticMeshData->NormalImportMethod;
InOutImportOptions.NormalGenerationMethod = StaticMeshData->NormalGenerationMethod;
InOutImportOptions.bComputeWeightedNormals = StaticMeshData->bComputeWeightedNormals;
InOutImportOptions.ImportTranslation = StaticMeshData->ImportTranslation;
InOutImportOptions.ImportRotation = StaticMeshData->ImportRotation;
InOutImportOptions.ImportUniformScale = StaticMeshData->ImportUniformScale;
InOutImportOptions.bTransformVertexToAbsolute = StaticMeshData->bTransformVertexToAbsolute;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:426
Scope (from outer to inner):
file
namespace UnFbx
function void ApplyImportUIToImportOptions
Source code excerpt:
{
UFbxSkeletalMeshImportData* SkeletalMeshData = ImportUI->SkeletalMeshImportData;
InOutImportOptions.NormalImportMethod = SkeletalMeshData->NormalImportMethod;
InOutImportOptions.NormalGenerationMethod = SkeletalMeshData->NormalGenerationMethod;
InOutImportOptions.bComputeWeightedNormals = SkeletalMeshData->bComputeWeightedNormals;
InOutImportOptions.ImportTranslation = SkeletalMeshData->ImportTranslation;
InOutImportOptions.ImportRotation = SkeletalMeshData->ImportRotation;
InOutImportOptions.ImportUniformScale = SkeletalMeshData->ImportUniformScale;
InOutImportOptions.bTransformVertexToAbsolute = SkeletalMeshData->bTransformVertexToAbsolute;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:458
Scope (from outer to inner):
file
namespace UnFbx
function void ApplyImportUIToImportOptions
Source code excerpt:
{
UFbxAnimSequenceImportData* AnimData = ImportUI->AnimSequenceImportData;
InOutImportOptions.NormalImportMethod = FBXNIM_ComputeNormals;
InOutImportOptions.bComputeWeightedNormals = true;
InOutImportOptions.ImportTranslation = AnimData->ImportTranslation;
InOutImportOptions.ImportRotation = AnimData->ImportRotation;
InOutImportOptions.ImportUniformScale = AnimData->ImportUniformScale;
InOutImportOptions.bConvertScene = AnimData->bConvertScene;
InOutImportOptions.bForceFrontXAxis = AnimData->bForceFrontXAxis;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:1654
Scope (from outer to inner):
file
namespace UnFbx
function bool FFbxImporter::ImportFromFile
Source code excerpt:
* @EventParam TransformVertexToAbsolute boolean Returns whether the importer should bake the global fbx node transform into the vertex position
* @EventParam ImportRigidMesh boolean Returns whether the importer should try to create a rigid mesh (static mesh import as skeletal mesh)
* @EventParam NormalImportMethod string Return if the tangents or normal should be imported or compute
* @EventParam NormalGenerationMethod string Return tangents generation method
* @EventParam CreatePhysicsAsset boolean Returns whether the importer should create the physic asset
* @EventParam ImportAnimations boolean Returns whether the importer should import also the animation
* @EventParam ImportAsSkeletalGeometry boolean Returns whether the importer should import only the geometry
* @EventParam ImportAsSkeletalSkinning boolean Returns whether the importer should import only the skinning
* @EventParam ImportMeshesInBoneHierarchy boolean Returns whether the importer should import also the mesh found in the bone hierarchy
* @EventParam ImportMorph boolean Returns whether the importer should import the morph targets
* @EventParam ImportSkeletalMeshLODs boolean Returns whether the importer should import the LODs
* @EventParam PreserveSmoothingGroups boolean Returns whether the importer should import the smoothing groups
* @EventParam UpdateSkeletonReferencePose boolean Returns whether the importer should update the skeleton reference pose
* @EventParam UseT0AsRefPose boolean Returns whether the importer should use the the animation 0 time has the reference pose
* @EventParam ThresholdPosition float Returns the threshold delta to weld vertices
* @EventParam ThresholdTangentNormal float Returns the threshold delta to weld tangents and normals
* @EventParam ThresholdUV float Returns the threshold delta to weld UVs
* @EventParam MorphThresholdPosition float Returns the morph target threshold delta to compute deltas
* @EventParam AutoComputeLodDistances boolean Returns whether the importer should set the auto compute LOD distance
* @EventParam LodNumber integer Returns the LOD number we should have after the import
* @EventParam BuildReversedIndexBuffer boolean Returns whether the importer should fill the reverse index buffer when building the static mesh
* @EventParam GenerateLightmapUVs boolean Returns whether the importer should generate light map UVs
* @EventParam ImportStaticMeshLODs boolean Returns whether the importer should import the LODs
* @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));
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMainImport.cpp:1747
Scope (from outer to inner):
file
lambda-function
Source code excerpt:
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]()
{
Attribs.Add(FAnalyticsEventAttribute(TEXT("SkeletalMeshOpt CreatePhysicsAsset"), CaptureImportOptions->bCreatePhysicsAsset));
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMeshImportData.cpp:8
Scope (from outer to inner):
file
function UFbxMeshImportData::UFbxMeshImportData
Source code excerpt:
: Super(ObjectInitializer)
{
NormalImportMethod = FBXNIM_ComputeNormals;
NormalGenerationMethod = EFBXNormalGenerationMethod::MikkTSpace;
bComputeWeightedNormals = true;
bBakePivotInVertex = false;
bReorderMaterialToFbxOrder = true;
}
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxMeshImportData.cpp:30
Scope (from outer to inner):
file
function bool UFbxMeshImportData::CanEditChange
Source code excerpt:
{
// Normal generation method is ignored if we are importing both tangents and normals
return NormalImportMethod == FBXNIM_ImportNormalsAndTangents ? false : true;
}
return bMutable;
}
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSceneImportData.cpp:71
Scope (from outer to inner):
file
function UnFbx::FBXImportOptions *JSONToFbxOption
Source code excerpt:
Option->ImportUniformScale = (float)ImportUniformScale;
}
int32 NormalImportMethod;
if (OptionObj->TryGetNumberField(TEXT("NormalImportMethod"), NormalImportMethod))
{
Option->NormalImportMethod = (EFBXNormalImportMethod)NormalImportMethod;
}
int32 NormalGenerationMethod;
if (OptionObj->TryGetNumberField(TEXT("NormalGenerationMethod"), NormalGenerationMethod))
{
Option->NormalGenerationMethod = (EFBXNormalGenerationMethod::Type)NormalGenerationMethod;
}
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSceneImportData.cpp:183
Scope (from outer to inner):
file
function FString FbxOptionToJSON
Source code excerpt:
JsonString += FString::Printf(TEXT("\"NormalImportMethod\" : \"%d\", \"NormalGenerationMethod\" : \"%d\", \"bTransformVertexToAbsolute\" : \"%d\", \"bBakePivotInVertex\" : \"%d\", \"bCombineToSingle\" : \"%d\", \"VertexColorImportOption\" : \"%d\", \"VertexOverrideColor\" : {\"R\" : \"%d\", \"G\" : \"%d\", \"B\" : \"%d\", \"A\" : \"%d\" }, "),
(int32)Option->NormalImportMethod,
(int32)Option->NormalGenerationMethod,
Option->bTransformVertexToAbsolute ? 1 : 0,
Option->bBakePivotInVertex ? 1 : 0,
Option->bCombineToSingle ? 1 : 0,
(int32)Option->VertexColorImportOption,
Option->VertexOverrideColor.R,
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSceneImportOptionsStaticMesh.cpp:23
Scope (from outer to inner):
file
function UFbxSceneImportOptionsStaticMesh::UFbxSceneImportOptionsStaticMesh
Source code excerpt:
{
VertexOverrideColor = FColor(255, 255, 255, 255);
NormalImportMethod = EFBXSceneNormalImportMethod::FBXSceneNIM_ComputeNormals;
NormalGenerationMethod = EFBXSceneNormalGenerationMethod::MikkTSpace;
}
void UFbxSceneImportOptionsStaticMesh::FillStaticMeshInmportData(UFbxStaticMeshImportData* StaticMeshImportData, UFbxSceneImportOptions* SceneImportOptions)
{
check(StaticMeshImportData != nullptr);
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxSkeletalMeshImport.cpp:2449
Scope (from outer to inner):
file
function USkeletalMesh* UnFbx::FFbxImporter::ReimportSkeletalMesh
Source code excerpt:
//Set the build settings
LODInfo->BuildSettings.bComputeWeightedNormals = SKImportData->bComputeWeightedNormals;
LODInfo->BuildSettings.bRecomputeNormals = SKImportData->NormalImportMethod == EFBXNormalImportMethod::FBXNIM_ComputeNormals;
LODInfo->BuildSettings.bRecomputeTangents = SKImportData->NormalImportMethod != EFBXNormalImportMethod::FBXNIM_ImportNormalsAndTangents;
LODInfo->BuildSettings.bRemoveDegenerates = true;
LODInfo->BuildSettings.bUseMikkTSpace = SKImportData->NormalGenerationMethod == EFBXNormalGenerationMethod::MikkTSpace;
LODInfo->BuildSettings.ThresholdPosition = SKImportData->ThresholdPosition;
LODInfo->BuildSettings.ThresholdTangentNormal = SKImportData->ThresholdTangentNormal;
LODInfo->BuildSettings.ThresholdUV = SKImportData->ThresholdUV;
LODInfo->BuildSettings.MorphThresholdPosition = SKImportData->MorphThresholdPosition;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxStaticMeshImport.cpp:2046
Scope (from outer to inner):
file
function UStaticMesh* UnFbx::FFbxImporter::ImportStaticMeshAsSingle
Source code excerpt:
SrcModel.BuildSettings.bRemoveDegenerates = ImportOptions->bRemoveDegenerates;
SrcModel.BuildSettings.bBuildReversedIndexBuffer = ImportOptions->bBuildReversedIndexBuffer;
SrcModel.BuildSettings.bRecomputeNormals = ImportOptions->NormalImportMethod == FBXNIM_ComputeNormals;
SrcModel.BuildSettings.bRecomputeTangents = ImportOptions->NormalImportMethod != FBXNIM_ImportNormalsAndTangents;
SrcModel.BuildSettings.bUseMikkTSpace = (ImportOptions->NormalGenerationMethod == EFBXNormalGenerationMethod::MikkTSpace) && (!ImportOptions->ShouldImportNormals() || !ImportOptions->ShouldImportTangents());
SrcModel.BuildSettings.bComputeWeightedNormals = ImportOptions->bComputeWeightedNormals;
StaticMesh->NaniteSettings.bEnabled = ImportOptions->bBuildNanite;
SrcModel.BuildSettings.DistanceFieldResolutionScale = ImportOptions->DistanceFieldResolutionScale;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SFbxSceneOptionWindow.cpp:1422
Scope (from outer to inner):
file
function void SFbxSceneOptionWindow::CopyStaticMeshOptionsToFbxOptions
Source code excerpt:
}
ImportSettings->VertexOverrideColor = StaticMeshOptions->VertexOverrideColor;
switch (StaticMeshOptions->NormalImportMethod)
{
case EFBXSceneNormalImportMethod::FBXSceneNIM_ComputeNormals:
ImportSettings->NormalImportMethod = FBXNIM_ComputeNormals;
break;
case EFBXSceneNormalImportMethod::FBXSceneNIM_ImportNormals:
ImportSettings->NormalImportMethod = FBXNIM_ImportNormals;
break;
case EFBXSceneNormalImportMethod::FBXSceneNIM_ImportNormalsAndTangents:
ImportSettings->NormalImportMethod = FBXNIM_ImportNormalsAndTangents;
break;
}
switch (StaticMeshOptions->NormalGenerationMethod)
{
case EFBXSceneNormalGenerationMethod::BuiltIn:
ImportSettings->NormalGenerationMethod = EFBXNormalGenerationMethod::BuiltIn;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Fbx/SFbxSceneOptionWindow.cpp:1468
Scope (from outer to inner):
file
function void SFbxSceneOptionWindow::CopyFbxOptionsToStaticMeshOptions
Source code excerpt:
}
StaticMeshOptions->VertexOverrideColor = ImportSettings->VertexOverrideColor;
switch (ImportSettings->NormalImportMethod)
{
case FBXNIM_ComputeNormals:
StaticMeshOptions->NormalImportMethod = EFBXSceneNormalImportMethod::FBXSceneNIM_ComputeNormals;
break;
case FBXNIM_ImportNormals:
StaticMeshOptions->NormalImportMethod = EFBXSceneNormalImportMethod::FBXSceneNIM_ImportNormals;
break;
case FBXNIM_ImportNormalsAndTangents:
StaticMeshOptions->NormalImportMethod = EFBXSceneNormalImportMethod::FBXSceneNIM_ImportNormalsAndTangents;
break;
}
switch (ImportSettings->NormalGenerationMethod)
{
case EFBXNormalGenerationMethod::BuiltIn:
StaticMeshOptions->NormalGenerationMethod = EFBXSceneNormalGenerationMethod::BuiltIn;
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Public/FbxImporter.h:138
Scope (from outer to inner):
file
namespace UnFbx
Source code excerpt:
FRotator ImportRotation;
float ImportUniformScale;
EFBXNormalImportMethod NormalImportMethod;
EFBXNormalGenerationMethod::Type NormalGenerationMethod;
bool bComputeWeightedNormals;
bool bTransformVertexToAbsolute;
bool bBakePivotInVertex;
EFBXImportType ImportType;
// Static Mesh options
#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Public/FbxImporter.h:220
Scope (from outer to inner):
file
namespace UnFbx
function bool ShouldImportNormals
Source code excerpt:
bool ShouldImportNormals() const
{
return NormalImportMethod == FBXNIM_ImportNormals || NormalImportMethod == FBXNIM_ImportNormalsAndTangents;
}
bool ShouldImportTangents() const
{
return NormalImportMethod == FBXNIM_ImportNormalsAndTangents;
}
void ResetForReimportAnimation()
{
bImportMorph = true;
AnimationLengthImportType = FBXALIT_ExportedTime;