file
function     void FSkeletalMeshReductionSettingsDetails::CustomizeChildren
lambda-function

		{
			if (StructPropertyHandle->GetParentHandle()->GetProperty()->GetFName() == GET_MEMBER_NAME_CHECKED(FSkeletalMeshObject, LODInfo) ||
				StructPropertyHandle->GetParentHandle()->GetProperty()->GetFName() == GET_MEMBER_NAME_CHECKED(USkeletalMeshLODSettings, LODGroups))
			{
				return StructPropertyHandle->GetParentHandle()->GetIndexInArray();
			}
		}

		return INDEX_NONE;

file
function     bool UStaticMeshEditorSubsystem::SetLODGroup

{
	
	TArray<FName> LODGroups;
	UStaticMesh::GetLODGroups(LODGroups);
	
	if(LODGroups.Contains(LODGroup))
	{
		GWarn->BeginSlowTask(FText::Format(FText::FromString("SetLODGroup: Applying changes to %s"), FText::FromString(StaticMesh->GetName())), true, false);
		// Close the mesh editor to prevent crashing. If changes are applied, reopen it after the mesh has been built.
		
		bool bStaticMeshIsEdited = false;
		UAssetEditorSubsystem* AssetEditorSubsystem = GEditor->GetEditorSubsystem<UAssetEditorSubsystem>();

										FbxImporter->FindAllLODGroupNode(NodeInLod, Node, LODIndex);
									}
									else // in less some LODGroups have less level, use the last level
									{
										FbxImporter->FindAllLODGroupNode(NodeInLod, Node, Node->GetChildCount() - 1);
									}

									for (FbxNode *MeshNode : NodeInLod)
									{

file
function     UObject* UFbxSceneImportFactory::ImportOneSkeletalMesh

					FbxImporter->FindAllLODGroupNode(NodeInLod, Node, LODIndex);
				}
				else // in less some LODGroups have less level, use the last level
				{
					FbxImporter->FindAllLODGroupNode(NodeInLod, Node, Node->GetChildCount() - 1);
				}
				for (FbxNode *MeshNode : NodeInLod)
				{
					SkelMeshNodeArray.Add(MeshNode);

file
function     USkeletalMesh* UnFbx::FFbxImporter::ReimportSkeletalMesh

						FindAllLODGroupNode(NodeInLod, Node, LODIndex);
					}
					else // in less some LODGroups have less level, use the last level
					{
						FindAllLODGroupNode(NodeInLod, Node, Node->GetChildCount() - 1);
					}
					for (FbxNode *MeshNode : NodeInLod)
					{
						SkelMeshNodeArray.Add(MeshNode);

file
namespace    FbxMeshUtils
function     bool ImportSkeletalMeshLOD

								FFbxImporter->FindAllLODGroupNode(NodeInLod, Node, SelectedLOD);
							}
							else // in less some LODGroups have less level, use the last level
							{
								FFbxImporter->FindAllLODGroupNode(NodeInLod, Node, Node->GetChildCount() - 1);
							}

							for (FbxNode *MeshNode : NodeInLod)
							{

file
class        class USkeletalMeshLODSettings : public UDataAsset

	UPROPERTY(globalconfig, EditAnywhere, Category=LODGroups)
	TArray<FSkeletalMeshLODGroupSettings> LODGroups;

	friend class FSkeletalMeshReductionSettingsDetails;
public:
	/** Retrieves the Skeletal mesh LOD group settings for the given name */
	ENGINE_API const FSkeletalMeshLODGroupSettings& GetSettingsForLODLevel(const int32 LODIndex) const;

file
class        class USkeletalMeshLODSettings : public UDataAsset
function     const bool HasValidSettings

	const bool HasValidSettings() const
	{
		return LODGroups.Num() > 0;
	}

	/** Returns the number of settings parsed from the ini file */
	ENGINE_API int32 GetNumberOfSettings() const;

	/*

file
function     UDeviceProfile* UDeviceProfileManager::CreateProfile

		}

		// make sure the DP has all the LODGroups it needs
		DeviceProfile->ValidateProfile();

		// if the config didn't specify a DeviceType, use the passed in one
		if (DeviceProfile->DeviceType.IsEmpty())
		{
			DeviceProfile->DeviceType = ProfileType;

file
class        class FPlatformCVarExec : public FSelfRegisteringExec
function     virtual bool Exec_Runtime

				}

				// log out the LODGroups fully
				FArrayProperty* LODGroupsProperty = FindFProperty<FArrayProperty>(UDeviceProfile::StaticClass(), GET_MEMBER_NAME_CHECKED(UTextureLODSettings, TextureLODGroups));
				FScriptArrayHelper_InContainer ArrayHelper(LODGroupsProperty, DeviceProfile);
				for (int32 Index = 0; Index < ArrayHelper.Num(); Index++)
				{
					FString	Buffer;
					LODGroupsProperty->Inner->ExportTextItem_Direct(Buffer, ArrayHelper.GetRawPtr(Index), ArrayHelper.GetRawPtr(Index), DeviceProfile, 0);

file
function     const FSkeletalMeshLODGroupSettings& USkeletalMeshLODSettings::GetSettingsForLODLevel

const FSkeletalMeshLODGroupSettings& USkeletalMeshLODSettings::GetSettingsForLODLevel(const int32 LODIndex) const
{
	if (LODIndex < LODGroups.Num())
	{
		return LODGroups[LODIndex];
	}

	// This should not happen as of right now, since the function is only called with 'Default' as name
	ensureMsgf(false, TEXT("Invalid Skeletal mesh default settings LOD Level"));

	// Default return value to prevent compile issue

file
function     int32 USkeletalMeshLODSettings::GetNumberOfSettings

int32 USkeletalMeshLODSettings::GetNumberOfSettings() const
{
	return LODGroups.Num();
}

bool USkeletalMeshLODSettings::SetLODSettingsToMesh(USkeletalMesh* InMesh, int32 LODIndex) const
{
	if (InMesh->IsValidLODIndex(LODIndex) && LODGroups.IsValidIndex(LODIndex))
	{
		FSkeletalMeshLODInfo* LODInfo = InMesh->GetLODInfo(LODIndex);
		const FSkeletalMeshLODGroupSettings& Setting = LODGroups[LODIndex];
		LODInfo->ReductionSettings = Setting.ReductionSettings;
		LODInfo->ScreenSize = Setting.ScreenSize;
		LODInfo->LODHysteresis = Setting.LODHysteresis;
		LODInfo->WeightOfPrioritization = Setting.WeightOfPrioritization;
		LODInfo->bAllowMeshDeformer = Setting.bAllowMeshDeformer;
		// if we have available bake pose

file
function     int32 USkeletalMeshLODSettings::SetLODSettingsToMesh

#endif
		// we only fill up until we have enough LODs
		const int32 NumSettings = FMath::Min(LODGroups.Num(), InMesh->GetLODNum());
		for (int32 Index = 0; Index < NumSettings; ++Index)
		{
			SetLODSettingsToMesh(InMesh, Index);
		}

		return NumSettings;

file
function     int32 USkeletalMeshLODSettings::SetLODSettingsFromMesh

		// we only fill up until we have enough LODs
		const int32 NumSettings = InMesh->GetLODNum();
		LODGroups.Reset(NumSettings);
		LODGroups.AddDefaulted(NumSettings);

		for (int32 Index = 0; Index < NumSettings; ++Index)
		{
			FSkeletalMeshLODInfo* LODInfo = InMesh->GetLODInfo(Index);
			FSkeletalMeshLODGroupSettings& Setting = LODGroups[Index];
			Setting.ReductionSettings = LODInfo->ReductionSettings;
			Setting.ScreenSize = LODInfo->ScreenSize;
			Setting.LODHysteresis = LODInfo->LODHysteresis;
			// copy mesh setting to shared setting
			Setting.BonesToPrioritize.Reset();
			for (auto& Bone : LODInfo->BonesToPrioritize)

file
function     void USkeletalMeshLODSettings::Serialize

	if (Ar.CustomVer(FFortniteMainBranchObjectVersion::GUID) < FFortniteMainBranchObjectVersion::ConvertReductionSettingOptions)
	{
		for (int32 Index = 0; Index < LODGroups.Num(); ++Index)
		{
			FSkeletalMeshOptimizationSettings& ReductionSettings = LODGroups[Index].ReductionSettings;
			// prior to this version, both of them were used
			ReductionSettings.ReductionMethod = SMOT_TriangleOrDeviation;
			if (ReductionSettings.MaxDeviationPercentage == 0.f)
			{
				// 0.f and 1.f should produce same result. However, it is bad to display 0.f in the slider
				// as 0.01 and 0.f causes extreme confusion. 

	}
	else if (FParse::Command(&Cmd,TEXT("TextureGroups"))
		|| FParse::Command(&Cmd, TEXT("LODGroups")))
	{
		return HandleLODGroupsCommand( Cmd, Ar );
	}
	else if (FParse::Command(&Cmd,TEXT("InvestigateTexture"))
		|| FParse::Command(&Cmd, TEXT("InvestigateRenderAsset")))
	{

file
function     FPrimitiveSceneProxy* ULandscapeMeshProxyComponent::CreateSceneProxy

	if ((LODGroupKey != 0) && (ComponentResolution == 0))
	{
		// this is an OLD HLOD not built with the new resolution/x/y/center information, which we need if LODGroups are used.
		UE_LOG(LogLandscape, Warning, TEXT("HLOD for Landscape needs to be rebuilt!  Landscape Mesh Proxy Component '%s' is using LODGroups but does not have the position and orientation information necessary to register it with the Landscape renderer.  This HLOD will not render until it is fixed."),
			*GetName());
		return nullptr;
	}

	return new FLandscapeMeshProxySceneProxy(this, LandscapeGuid, ProxyComponentBases, ProxyComponentCentersObjectSpace, ComponentXVectorObjectSpace, ComponentYVectorObjectSpace, GetComponentTransform(), ComponentResolution, ProxyLOD, LODGroupKey, ALandscapeProxy::ComputeLandscapeKey(GetWorld(), LODGroupKey, LandscapeGuid));