LocalizationPaths

LocalizationPaths

#Overview

name: LocalizationPaths

The value of this variable can be defined or overridden in .ini config files. 7 .ini config files referencing this setting variable.

It is referenced in 10 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of LocalizationPaths is to specify the directories where localization data for different parts of the Unreal Engine (engine, editor, and game) are stored. This setting variable is crucial for the internationalization system of Unreal Engine 5.

LocalizationPaths is primarily used by the internationalization subsystem of Unreal Engine. It is referenced in various modules, including:

  1. LocalizationDashboard (Editor)
  2. UnrealEd (Editor)
  3. Core (Runtime)

The value of this variable is set in configuration files:

These values are typically read using the GConfig->GetArray() function, which populates an array of strings with the specified paths.

LocalizationPaths interacts with other variables and systems, such as:

Developers should be aware of the following when using this variable:

  1. The paths are specific to different parts of the engine (engine, editor, game).
  2. If no paths are specified, warning messages are logged.
  3. The paths are used for finding localization files like .manifest and .archive files.

Best practices when using LocalizationPaths include:

  1. Ensure that the appropriate paths are set in the respective configuration files.
  2. Use the appropriate FPaths functions to retrieve the localization paths rather than accessing the config directly.
  3. Consider the loading policy (Always, Editor, Game, etc.) when working with localization data.
  4. Be aware of the different contexts (engine, editor, game) when dealing with localization to ensure you’re using the correct paths.
  5. When adding new localization content, make sure it’s placed in the correct path as specified by these settings.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Config/BaseEditor.ini:11, section: [Internationalization]

Location: <Workspace>/Engine/Config/BaseEditor.ini:12, section: [Internationalization]

Location: <Workspace>/Engine/Config/BaseEditor.ini:13, section: [Internationalization]

Location: <Workspace>/Engine/Config/BaseEditor.ini:14, section: [Internationalization]

Location: <Workspace>/Engine/Config/BaseEngine.ini:1538, section: [Internationalization]

Location: <Workspace>/Engine/Config/BaseGame.ini:14, section: [Internationalization]

Location: <Workspace>/Projects/Lyra/Config/DefaultEngine.ini:361, section: [Internationalization]

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Source/Editor/LocalizationDashboard/Private/LocalizationTargetDetailCustomization.cpp:116

Scope (from outer to inner):

file
namespace    anonymous
lambda-function

Source code excerpt:

	{
		TArray<FLocalizationTargetLoadingPolicyConfig> Array;
		Array.Emplace(ELocalizationTargetLoadingPolicy::Always,			TEXT("Internationalization"),	TEXT("LocalizationPaths"),				TEXT("Engine"),		GEngineIni);
		Array.Emplace(ELocalizationTargetLoadingPolicy::Editor,			TEXT("Internationalization"),	TEXT("LocalizationPaths"),				TEXT("Editor"),		GEditorIni);
		Array.Emplace(ELocalizationTargetLoadingPolicy::Game,			TEXT("Internationalization"),	TEXT("LocalizationPaths"),				TEXT("Game"),		GGameIni);
		Array.Emplace(ELocalizationTargetLoadingPolicy::PropertyNames,	TEXT("Internationalization"),	TEXT("PropertyNameLocalizationPaths"),	TEXT("Editor"),		GEditorIni);
		Array.Emplace(ELocalizationTargetLoadingPolicy::ToolTips,		TEXT("Internationalization"),	TEXT("ToolTipLocalizationPaths"),		TEXT("Editor"),		GEditorIni);
		return Array;
	}();
}

#Loc: <Workspace>/Engine/Source/Editor/LocalizationDashboard/Private/LocalizationTargetDetailCustomization.cpp:599

Scope (from outer to inner):

file
function     ELocalizationTargetLoadingPolicy FLocalizationTargetDetailCustomization::GetLoadingPolicy

Source code excerpt:

	for (const FLocalizationTargetLoadingPolicyConfig& LoadingPolicyConfig : LoadingPolicyConfigs)
	{
		TArray<FString> LocalizationPaths;
		GConfig->GetArray(*LoadingPolicyConfig.SectionName, *LoadingPolicyConfig.KeyName, LocalizationPaths, LoadingPolicyConfig.ConfigPath);

		if (LocalizationPaths.Contains(DataDirectory))
		{
			return LoadingPolicyConfig.LoadingPolicy;
		}
	}

	return ELocalizationTargetLoadingPolicy::Never;

#Loc: <Workspace>/Engine/Source/Editor/LocalizationDashboard/Private/LocalizationTargetDetailCustomization.cpp:629

Scope (from outer to inner):

file
function     void FLocalizationTargetDetailCustomization::SetLoadingPolicy
lambda-function

Source code excerpt:

	{
		// We test the coalesced config data first, as we may be inheriting this target path from a base config.
		TArray<FString> LocalizationPaths;
		GConfig->GetArray(*LoadingPolicyConfig.SectionName, *LoadingPolicyConfig.KeyName, LocalizationPaths, LoadingPolicyConfig.ConfigPath);
		const bool bHasTargetPath = LocalizationPaths.Contains(DataDirectory);

		// Work out whether we need to do work with the default config...
		switch (OperationToPerform)
		{
		case EDefaultConfigOperation::AddExclusion:
		case EDefaultConfigOperation::RemoveAddition:

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/StabilizeLocalizationKeys.cpp:314

Scope (from outer to inner):

file
function     int32 UStabilizeLocalizationKeysCommandlet::Main

Source code excerpt:

		TArray<FLocArchiveInfo> ForeignLocArchives;
		{
			TArray<FString> LocalizationPaths;
			if (bIncludeEngineContent)
			{
				LocalizationPaths += FPaths::GetEngineLocalizationPaths();
				LocalizationPaths += FPaths::GetEditorLocalizationPaths();
			}
			if (bIncludeGameContent)
			{
				LocalizationPaths += FPaths::GetGameLocalizationPaths();
			}

			TArray<FString> ManifestFilenames;
			for (const FString& LocalizationPath : LocalizationPaths)
			{
				IFileManager::Get().FindFilesRecursive(ManifestFilenames, *LocalizationPath, TEXT("*.manifest"), /*Files*/true, /*Directories*/false, /*bClearFileNames*/false);
			}

			for (const FString& ManifestFilename : ManifestFilenames)
			{

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/StabilizeLocalizationKeys.cpp:341

Scope (from outer to inner):

file
function     int32 UStabilizeLocalizationKeysCommandlet::Main

Source code excerpt:


			TArray<FString> ArchiveFilenames;
			for (const FString& LocalizationPath : LocalizationPaths)
			{
				IFileManager::Get().FindFilesRecursive(ArchiveFilenames, *LocalizationPath, TEXT("*.archive"), /*Files*/true, /*Directories*/false, /*bClearFileNames*/false);
			}

			for (const FString& ArchiveFilename : ArchiveFilenames)
			{

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Internationalization/LocalizationResourceTextSource.cpp:23

Scope (from outer to inner):

file
function     void FLocalizationResourceTextSource::GetLocalizedCultureNames

Source code excerpt:

void FLocalizationResourceTextSource::GetLocalizedCultureNames(const ELocalizationLoadFlags InLoadFlags, TSet<FString>& OutLocalizedCultureNames)
{
	TArray<FString> LocalizationPaths;
	if (EnumHasAnyFlags(InLoadFlags, ELocalizationLoadFlags::Editor))
	{
		LocalizationPaths += FPaths::GetEditorLocalizationPaths();
	}
	if (EnumHasAnyFlags(InLoadFlags, ELocalizationLoadFlags::Game))
	{
		LocalizationPaths += FPaths::GetGameLocalizationPaths();
	}
	if (EnumHasAnyFlags(InLoadFlags, ELocalizationLoadFlags::Engine))
	{
		LocalizationPaths += FPaths::GetEngineLocalizationPaths();
	}
	if (EnumHasAnyFlags(InLoadFlags, ELocalizationLoadFlags::Additional))
	{
		FCoreDelegates::GatherAdditionalLocResPathsCallback.Broadcast(LocalizationPaths);
	}

	TArray<FString> LocalizedCultureNames = TextLocalizationResourceUtil::GetLocalizedCultureNames(LocalizationPaths);
	OutLocalizedCultureNames.Append(MoveTemp(LocalizedCultureNames));
}

void FLocalizationResourceTextSource::LoadLocalizedResources(const ELocalizationLoadFlags InLoadFlags, TArrayView<const FString> InPrioritizedCultures, FTextLocalizationResource& InOutNativeResource, FTextLocalizationResource& InOutLocalizedResource)
{
	auto AppendChunkedLocalizationPaths = [this](TArray<FString>& OutLocalizationPaths)

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Internationalization/LocalizationResourceTextSource.cpp:73

Scope (from outer to inner):

file
function     void FLocalizationResourceTextSource::LoadLocalizedResources
lambda-function

Source code excerpt:

	auto GetGameLocalizationPaths = [&AppendChunkedLocalizationPaths]()
	{
		TArray<FString> LocalizationPaths = FPaths::GetGameLocalizationPaths();
		AppendChunkedLocalizationPaths(LocalizationPaths);
		return LocalizationPaths;
	};

	auto GetCookedEditorLocalizationPaths = [&AppendChunkedLocalizationPaths]()
	{
		TArray<FString> LocalizationPaths = FPaths::GetCookedEditorLocalizationPaths();
		AppendChunkedLocalizationPaths(LocalizationPaths);
		return LocalizationPaths;
	};

	// Collect the localization paths to load from.
	TArray<FString> GameNativePaths;
	TArray<FString> GameLocalizationPaths;
	if (ShouldLoadNativeGameData(InLoadFlags))

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Misc/Paths.cpp:621

Scope (from outer to inner):

file
function     const TArray<FString>& FPaths::GetEngineLocalizationPaths

Source code excerpt:

		if(GConfig && GConfig->IsReadyForUse())
		{
			GConfig->GetArray( TEXT("Internationalization"), TEXT("LocalizationPaths"), StaticData.EngineLocalizationPaths, GEngineIni );
			if(!StaticData.EngineLocalizationPaths.Num())
			{
				UE_LOG(LogInit, Warning, TEXT("No paths for engine localization data were specifed in the engine configuration."));
			}
			StaticData.bEngineLocalizationPathsInitialized = true;
		}

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Misc/Paths.cpp:645

Scope (from outer to inner):

file
function     const TArray<FString>& FPaths::GetEditorLocalizationPaths

Source code excerpt:

		if(GConfig && GConfig->IsReadyForUse())
		{
			GConfig->GetArray( TEXT("Internationalization"), TEXT("LocalizationPaths"), StaticData.EditorLocalizationPaths, GEditorIni );
			if(!StaticData.EditorLocalizationPaths.Num())
			{
				UE_LOG(LogInit, Warning, TEXT("No paths for editor localization data were specifed in the editor configuration."));
			}
			StaticData.bEditorLocalizationPathsInitialized = true;
		}

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Misc/Paths.cpp:733

Scope (from outer to inner):

file
function     const TArray<FString>& FPaths::GetGameLocalizationPaths

Source code excerpt:

		if(GConfig && GConfig->IsReadyForUse())
		{
			GConfig->GetArray( TEXT("Internationalization"), TEXT("LocalizationPaths"), StaticData.GameLocalizationPaths, GGameIni );
			if(!StaticData.GameLocalizationPaths.Num()) // Failed to find localization path.
			{
				UE_LOG(LogPaths, Warning, TEXT("No paths for game localization data were specifed in the game configuration."));
			}
			StaticData.bGameLocalizationPathsInitialized = true;
		}