CulturesToGenerate

CulturesToGenerate

#Overview

name: CulturesToGenerate

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

It is referenced in 45 C++ source files. Also referenced in 1 C# build file meaning it may affect the build system logic.

#Summary

#Usage in the C++ source code

The purpose of CulturesToGenerate is to specify which cultures (languages) should be generated or processed for localization in Unreal Engine 5. This setting variable is used across various localization-related systems and tools within the engine. Here’s a detailed breakdown:

  1. The CulturesToGenerate variable is primarily used by the localization system, specifically for tasks related to generating, importing, exporting, and managing localized content.

  2. Multiple Unreal Engine subsystems and modules rely on this setting variable, including:

    • Localization module
    • UnrealEd module (various commandlets)
    • TranslationEditor module
    • InternationalizationSettings module

  3. The value of this variable is typically set in configuration files or through the engine’s localization settings. It can also be dynamically populated based on project settings or user input in some cases.

  4. This variable often interacts with other localization-related variables, such as:

    • NativeCulture (the source language)
    • DestinationPath (where localized files are stored)
    • SourcePath (where source files are located)

  5. Developers should be aware that:

    • The list of cultures in CulturesToGenerate should be valid culture codes recognized by the engine.
    • Changes to this variable can affect the performance and resource usage of localization tasks, as more cultures mean more data to process.
    • It’s important to keep this list synchronized with the project’s actual localization needs to avoid unnecessary work or missing translations.

  6. Best practices when using this variable include:

    • Regularly reviewing and updating the list of cultures to match the project’s localization requirements.
    • Ensuring that all specified cultures have corresponding localized content or are intended to be localized.
    • Using this variable consistently across different localization tools and processes to maintain coherence in the project’s localization workflow.
    • Considering performance implications when working with a large number of cultures, especially for runtime localization tasks.

By carefully managing the CulturesToGenerate variable, developers can efficiently control which languages are included in the localization process, ensuring that the game or application supports the intended set of languages without unnecessary overhead.

#Setting Variables

#References In INI files

<Workspace>/Engine/Config/Localization/Category.ini:9, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Category.ini:10, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Category.ini:11, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Category.ini:12, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Category.ini:13, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Category.ini:14, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Category.ini:15, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Category.ini:16, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Category.ini:17, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Category.ini:18, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Category.ini:19, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Category.ini:20, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Category.ini:21, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Category.ini:22, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Editor.ini:9, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Editor.ini:10, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Editor.ini:11, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Editor.ini:12, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Editor.ini:13, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Editor.ini:14, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Editor.ini:15, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Editor.ini:16, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Editor.ini:17, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Editor.ini:18, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Editor.ini:19, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Editor.ini:20, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Editor.ini:21, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Editor.ini:22, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/EditorTutorials.ini:14, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/EditorTutorials.ini:15, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/EditorTutorials.ini:16, section: [CommonSettings]


... omitting 453 locations ...

#References in C++ code

#Callsites

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

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:318

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateGatherTextConfigFile

Source code excerpt:

			for (const FCultureStatistics& CultureStatistics : Target->Settings.SupportedCulturesStatistics)
			{
				ConfigSection.Add( TEXT("CulturesToGenerate"), CultureStatistics.CultureName );
			}
			
			Script.AddCommonSettings(MoveTemp(ConfigSection));
		}

		uint32 GatherTextStepIndex = 0;

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:547

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateImportTextConfigFile
lambda-function

Source code excerpt:

			const auto& AddCultureToGenerate = [&](const int32 Index)
			{
				ConfigSection.Add( TEXT("CulturesToGenerate"), Target->Settings.SupportedCulturesStatistics[Index].CultureName );
			};

			// Import for a specific culture.
			if (CultureName.IsSet())
			{
				ConfigSection.Add( TEXT("CulturesToGenerate"), CultureName.GetValue() );
			}
			// Import for all cultures.
			else
			{
				for (const FCultureStatistics& CultureStatistics : Target->Settings.SupportedCulturesStatistics)
				{
					ConfigSection.Add( TEXT("CulturesToGenerate"), CultureStatistics.CultureName );
				}
			}

			// Do not use culture subdirectories if importing a single culture from a specific directory.
			if (CultureName.IsSet() && ImportPathOverride.IsSet())
			{

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:675

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateExportTextConfigFile
lambda-function

Source code excerpt:

			const auto& AddCultureToGenerate = [&](const int32 Index)
			{
				ConfigSection.Add( TEXT("CulturesToGenerate"), Target->Settings.SupportedCulturesStatistics[Index].CultureName );
			};

			// Export for a specific culture.
			if (CultureName.IsSet())
			{
				const int32 CultureIndex = Target->Settings.SupportedCulturesStatistics.IndexOfByPredicate([CultureName](const FCultureStatistics& Culture) { return Culture.CultureName == CultureName.GetValue(); });

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:807

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateImportDialogueScriptConfigFile
lambda-function

Source code excerpt:

			const auto& AddCultureToGenerate = [&](const int32 Index)
			{
				ConfigSection.Add(TEXT("CulturesToGenerate"), Target->Settings.SupportedCulturesStatistics[Index].CultureName);
			};

			// Import for a specific culture.
			if (CultureName.IsSet())
			{
				ConfigSection.Add(TEXT("CulturesToGenerate"), CultureName.GetValue());
			}
			// Import for all cultures.
			else
			{
				for (const FCultureStatistics& CultureStatistics : Target->Settings.SupportedCulturesStatistics)
				{
					ConfigSection.Add(TEXT("CulturesToGenerate"), CultureStatistics.CultureName);
				}
			}

			// Do not use culture subdirectories if importing a single culture from a specific directory.
			if (CultureName.IsSet() && ImportPathOverride.IsSet())
			{

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:922

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateExportDialogueScriptConfigFile
lambda-function

Source code excerpt:

			const auto& AddCultureToGenerate = [&](const int32 Index)
			{
				ConfigSection.Add(TEXT("CulturesToGenerate"), Target->Settings.SupportedCulturesStatistics[Index].CultureName);
			};

			// Export for a specific culture.
			if (CultureName.IsSet())
			{
				const int32 CultureIndex = Target->Settings.SupportedCulturesStatistics.IndexOfByPredicate([CultureName](const FCultureStatistics& Culture) { return Culture.CultureName == CultureName.GetValue(); });

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:1019

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateImportDialogueConfigFile
lambda-function

Source code excerpt:

			const auto& AddCultureToGenerate = [&](const int32 Index)
			{
				ConfigSection.Add(TEXT("CulturesToGenerate"), Target->Settings.SupportedCulturesStatistics[Index].CultureName);
			};

			if (CultureName.IsSet())
			{
				const int32 CultureIndex = Target->Settings.SupportedCulturesStatistics.IndexOfByPredicate([CultureName](const FCultureStatistics& Culture) { return Culture.CultureName == CultureName.GetValue(); });
				AddCultureToGenerate(CultureIndex);

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:1093

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateWordCountReportConfigFile

Source code excerpt:

			for (const FCultureStatistics& CultureStatistics : Target->Settings.SupportedCulturesStatistics)
			{
				ConfigSection.Add( TEXT("CulturesToGenerate"), CultureStatistics.CultureName );
			}

			Script.AddCommonSettings(MoveTemp(ConfigSection));
		}

		// GatherTextStep0 - GenerateTextLocalizationReport

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:1154

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateCompileTextConfigFile
lambda-function

Source code excerpt:

			const auto& AddCultureToGenerate = [&](const int32 Index)
			{
				ConfigSection.Add( TEXT("CulturesToGenerate"), Target->Settings.SupportedCulturesStatistics[Index].CultureName );
			};

			// Compile a specific culture.
			if (CultureName.IsSet())
			{
				const int32 CultureIndex = Target->Settings.SupportedCulturesStatistics.IndexOfByPredicate([CultureName](const FCultureStatistics& Culture) { return Culture.CultureName == CultureName.GetValue(); });

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/TextLocalizationResourceGenerator.cpp:195

Scope (from outer to inner):

file
function     bool FTextLocalizationResourceGenerator::GenerateLocResAndUpdateLiveEntriesFromConfig

Source code excerpt:

	}

	TArray<FString> CulturesToGenerate;
	{
		const FString CultureName = I18N.GetCurrentCulture()->GetName();
		const TArray<FString> PrioritizedCultures = I18N.GetPrioritizedCultureNames(CultureName);
		for (const FString& PrioritizedCulture : PrioritizedCultures)
		{
			if (FPaths::FileExists(SourcePath / PrioritizedCulture / ArchiveName))
			{
				CulturesToGenerate.Add(PrioritizedCulture);
			}
		}
	}

	if (CulturesToGenerate.Num() == 0)
	{
		UE_LOG(LogTextLocalizationResourceGenerator, Error, TEXT("No cultures to generate were specified."));
		return false;
	}

	// Load the manifest and all archives

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/TextLocalizationResourceGenerator.cpp:227

Scope (from outer to inner):

file
function     bool FTextLocalizationResourceGenerator::GenerateLocResAndUpdateLiveEntriesFromConfig

Source code excerpt:

	FTextLocalizationResource TextLocalizationResource;
	TMap<FName, TSharedRef<FTextLocalizationResource>> Unused_PerPlatformLocRes;
	for (int32 CultureIndex = 0; CultureIndex < CulturesToGenerate.Num(); ++CultureIndex)
	{
		const FString& CultureName = CulturesToGenerate[CultureIndex];

		const FString CulturePath = DestinationPath / CultureName;
		const FString ResourceFilePath = FPaths::ConvertRelativePathToFull(CulturePath / ResourceName);

		if (!GenerateLocRes(LocTextHelper, CultureName, InGenerateFlags, FTextKey(ResourceFilePath), TextLocalizationResource, Unused_PerPlatformLocRes, CultureIndex))
		{

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/UserGeneratedContentLocalization.cpp:60

Scope (from outer to inner):

file
function     void FUserGeneratedContentLocalizationDescriptor::InitializeFromProject

Source code excerpt:

		NativeCulture = TEXT("en");
	}
	CulturesToGenerate = FTextLocalizationManager::Get().GetLocalizedCultureNames(LoadFlags);

	// Filter any cultures that are disabled in shipping or via UGC loc settings
	{
		const FCultureFilter CultureFilter(EBuildConfiguration::Shipping, ELocalizationLoadFlags::Engine | LoadFlags);
		CulturesToGenerate.RemoveAll([&CultureFilter](const FString& Culture)
		{
			return !CultureFilter.IsCultureAllowed(Culture)
				|| GetDefault<UUserGeneratedContentLocalizationSettings>()->CulturesToDisable.Contains(Culture);
		});
	}
}

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/UserGeneratedContentLocalization.cpp:77

Scope (from outer to inner):

file
function     bool FUserGeneratedContentLocalizationDescriptor::Validate

Source code excerpt:

	int32 NumCulturesFixed = 0;

	if (!DefaultDescriptor.CulturesToGenerate.Contains(NativeCulture))
	{
		++NumCulturesFixed;
		NativeCulture = DefaultDescriptor.NativeCulture;
	}

	NumCulturesFixed += CulturesToGenerate.RemoveAll([&DefaultDescriptor](const FString& Culture)
	{
		return !DefaultDescriptor.CulturesToGenerate.Contains(Culture);
	});

	return NumCulturesFixed == 0;
}

bool FUserGeneratedContentLocalizationDescriptor::ToJsonObject(TSharedPtr<FJsonObject>& OutJsonObject) const

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/UserGeneratedContentLocalization.cpp:199

Scope (from outer to inner):

file
namespace    UserGeneratedContentLocalization
function     bool ExportLocalization

Source code excerpt:


	// Make sure we're also exporting localization for the native culture
	TArray<FString> CulturesToGenerate = ExportOptions.UGCLocDescriptor.CulturesToGenerate;
	CulturesToGenerate.AddUnique(ExportOptions.UGCLocDescriptor.NativeCulture);

	// Localization data stored per-plugin
	TArray<FString, TInlineAllocator<1>> GatherConfigFilenames;
	for (const TSharedRef<IPlugin>& Plugin : Plugins)
	{
		const FString PluginLocalizationScratchDirectory = GetLocalizationScratchDirectory(Plugin);

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/UserGeneratedContentLocalization.cpp:264

Scope (from outer to inner):

file
namespace    UserGeneratedContentLocalization
function     bool ExportLocalization

Source code excerpt:


				ConfigSection.Add(TEXT("NativeCulture"), ExportOptions.UGCLocDescriptor.NativeCulture);
				for (const FString& CultureToGenerate : CulturesToGenerate)
				{
					ConfigSection.Add(TEXT("CulturesToGenerate"), *CultureToGenerate);
				}
				
				GatherConfig.AddCommonSettings(MoveTemp(ConfigSection));
			}

			// Gather source

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/UserGeneratedContentLocalization.cpp:726

Scope (from outer to inner):

file
namespace    UserGeneratedContentLocalization
function     ELoadLocalizationResult LoadLocalization

Source code excerpt:


	// Create in-memory versions of the manifest/archives that we will populate below
	OutLocTextHelper = MakeShared<FLocTextHelper>(PluginLocalizationTargetDirectory, FString::Printf(TEXT("%s.manifest"), *PluginName), FString::Printf(TEXT("%s.archive"), *PluginName), UGCLocDescriptor.NativeCulture, UGCLocDescriptor.CulturesToGenerate, nullptr);
	OutLocTextHelper->LoadAll(ELocTextHelperLoadFlags::Create);

	// Import each PO file data, as we'll use it to generate the LocRes (via FLocTextHelper)
	// We always process the native culture first as it's also used to populate the manifest with the source texts
	if (!ImportPortableObject(PluginLocalizationTargetDirectory, OutLocTextHelper->GetNativeCulture(), UGCLocDescriptor.PoFormat, *OutLocTextHelper))
	{

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/UserGeneratedContentLocalization.cpp:756

Scope (from outer to inner):

file
namespace    UserGeneratedContentLocalization
function     void CleanupLocalization

Source code excerpt:

{
	// Make sure we also consider localization for the native culture
	TArray<FString> CulturesToGenerate = DefaultDescriptor.CulturesToGenerate;
	if (!DefaultDescriptor.NativeCulture.IsEmpty())
	{
		CulturesToGenerate.AddUnique(DefaultDescriptor.NativeCulture);
	}

	TArray<FString> LocalizationFilesToCleanup;
	for (const TSharedRef<IPlugin>& Plugin : Plugins)
	{
		const FString PluginLocalizationTargetDirectory = GetLocalizationTargetDirectory(Plugin);

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/UserGeneratedContentLocalization.cpp:769

Scope (from outer to inner):

file
namespace    UserGeneratedContentLocalization
function     void CleanupLocalization
lambda-function

Source code excerpt:

		// Find any leftover PO files to cleanup
		const FString PluginPOFilename = Plugin->GetName() + TEXT(".po");
		IFileManager::Get().IterateDirectory(*PluginLocalizationTargetDirectory, [&LocalizationFilesToCleanup, &PluginPOFilename, &CulturesToGenerate](const TCHAR* FilenameOrDirectory, bool bIsDirectory) -> bool
		{
			if (bIsDirectory)
			{
				// Note: This looks for PO files rather than the folders, as the folders may just be empty vestiges from a P4 sync without rmdir set
				const FString PluginPOFile = FilenameOrDirectory / PluginPOFilename;
				if (FPaths::FileExists(PluginPOFile))

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/UserGeneratedContentLocalization.cpp:779

Scope (from outer to inner):

file
namespace    UserGeneratedContentLocalization
function     void CleanupLocalization
lambda-function

Source code excerpt:

					const FString LocalizationFolder = FPaths::GetCleanFilename(FilenameOrDirectory);
					const FString CanonicalName = FCulture::GetCanonicalName(LocalizationFolder);
					if (!CulturesToGenerate.Contains(CanonicalName))
					{
						LocalizationFilesToCleanup.Add(PluginPOFile);
					}
				}
			}
			return true;

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/UserGeneratedContentLocalization.cpp:789

Scope (from outer to inner):

file
namespace    UserGeneratedContentLocalization
function     void CleanupLocalization

Source code excerpt:


		// If we aren't exporting any cultures, then also cleanup any existing descriptor file
		if (CulturesToGenerate.Num() == 0)
		{
			const FString PluginUGCLocFilename = FPaths::Combine(PluginLocalizationTargetDirectory, FString::Printf(TEXT("%s.ugcloc"), *Plugin->GetName()));
			if (FPaths::FileExists(PluginUGCLocFilename))
			{
				LocalizationFilesToCleanup.Add(PluginUGCLocFilename);
			}

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/UserGeneratedContentLocalization.cpp:835

Scope (from outer to inner):

file
namespace    UserGeneratedContentLocalization
function     void CleanupLocalization

Source code excerpt:


			// If we aren't exporting any cultures, then also cleanup any plugin references to the localization data
			if (CulturesToGenerate.Num() == 0)
			{
				for (const TSharedRef<IPlugin>& Plugin : Plugins)
				{
					FPluginDescriptor PluginDescriptor = Plugin->GetDescriptor();
					if (PluginDescriptor.LocalizationTargets.RemoveAll([&Plugin](const FLocalizationTargetDescriptor& LocalizationTargetDescriptor) { return LocalizationTargetDescriptor.Name == Plugin->GetName(); }) > 0)
					{

#Loc: <Workspace>/Engine/Source/Developer/Localization/Public/UserGeneratedContentLocalization.h:58

Scope (from outer to inner):

file
function     struct LOCALIZATION_API FUserGeneratedContentLocalizationDescriptor { GENERATED_BODY

Source code excerpt:

public:
	/**
	 * Initialize the NativeCulture and CulturesToGenerate values based on the settings of the currently loaded Unreal project.
	 * @param LocalizationCategory What category is the localization targets being used with this descriptor?
	 */
	void InitializeFromProject(const ELocalizedTextSourceCategory LocalizationCategory = ELocalizedTextSourceCategory::Game);
	
	/**
	 * Validate that this descriptor isn't using cultures that aren't present in the CulturesToGenerate of the given default.
	 *   - If the NativeCulture is invalid, reset it to the value from the default.
	 *   - If CulturesToGenerate contains invalid entries then remove those from the array.
	 * 
	 * @return True if this descriptor was valid and no changes were made. False if this descriptor was invalid and had default changes applied.
	 */
	bool Validate(const FUserGeneratedContentLocalizationDescriptor& DefaultDescriptor);

	/**
	 * Save the settings to a JSON object/file.
	 */
	bool ToJsonObject(TSharedPtr<FJsonObject>& OutJsonObject) const;
	bool ToJsonString(FString& OutJsonString) const;
	bool ToJsonFile(const TCHAR* InFilename) const;

#Loc: <Workspace>/Engine/Source/Developer/Localization/Public/UserGeneratedContentLocalization.h:98

Scope: file

Source code excerpt:

	 */
	UPROPERTY(EditAnywhere, Category=Localization)
	TArray<FString> CulturesToGenerate;

	/**
	 * What format of PO file should we use?
	 * @note You can adjust this later and we'll attempt to preserve any existing localization data by importing with the old setting prior to export.
	 */
	UPROPERTY(EditAnywhere, AdvancedDisplay, Category=Localization, meta=(DisplayName="PO Format"))

#Loc: <Workspace>/Engine/Source/Editor/InternationalizationSettings/Private/UserGeneratedContentLocalizationDescriptorDetails.cpp:42

Scope (from outer to inner):

file
function     void FUserGeneratedContentLocalizationDescriptorDetails::CustomizeChildren

Source code excerpt:

		DefaultUGCLocDescriptor.InitializeFromProject();

		const TArray<FCultureRef> LocalizedCultureList = FInternationalization::Get().GetAvailableCultures(DefaultUGCLocDescriptor.CulturesToGenerate, false);

		AvailableCultures.Reset(LocalizedCultureList.Num());
		Algo::Transform(LocalizedCultureList, AvailableCultures, [](const FCultureRef Culture) -> FCulturePtr { return Culture; });

		// Sort by the current display name so that the order in the "native language" picker and the "cultures to generate" list matches
		AvailableCultures.StableSort([](FCulturePtr One, FCulturePtr Two)

#Loc: <Workspace>/Engine/Source/Editor/InternationalizationSettings/Private/UserGeneratedContentLocalizationDescriptorDetails.cpp:65

Scope (from outer to inner):

file
function     void FUserGeneratedContentLocalizationDescriptorDetails::CustomizeChildren

Source code excerpt:

				CustomizeNativeCulture(ChildPropertyHandle.ToSharedRef(), StructBuilder, StructCustomizationUtils);
			}
			else if(ChildPropertyName == GET_MEMBER_NAME_CHECKED(FUserGeneratedContentLocalizationDescriptor, CulturesToGenerate))
			{
				CustomizeCulturesToGenerate(ChildPropertyHandle.ToSharedRef(), StructBuilder, StructCustomizationUtils);
			}
			else
			{
				StructBuilder.AddProperty(ChildPropertyHandle.ToSharedRef());

#Loc: <Workspace>/Engine/Source/Editor/TranslationEditor/Private/InternationalizationExportSettings.h:17

Scope (from outer to inner):

file
class        class UInternationalizationExportSettings : public UObject

Source code excerpt:

	/** Which cultures should be exported */
	UPROPERTY(Category = CommonSettings, EditAnywhere, config)
	TArray<FString> CulturesToGenerate;

	/** The commandlet to run */
	UPROPERTY(Category = GatherTextStep, EditAnywhere, config)
	FString CommandletClass;

	/** Source for the localization data */

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/ExportDialogueScriptCommandlet.cpp:122

Scope (from outer to inner):

file
function     int32 UExportDialogueScriptCommandlet::Main

Source code excerpt:


	// Get cultures to generate
	TArray<FString> CulturesToGenerate;
	if (GetStringArrayFromConfig(*SectionName, TEXT("CulturesToGenerate"), CulturesToGenerate, ConfigPath) == 0)
	{
		UE_LOG(LogExportDialogueScriptCommandlet, Error, TEXT("No cultures specified for import."));
		return -1;
	}

	// Get the manifest name

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/ExportDialogueScriptCommandlet.cpp:154

Scope (from outer to inner):

file
function     int32 UExportDialogueScriptCommandlet::Main

Source code excerpt:


	// We may only have a single culture if using this setting
	if (!bUseCultureDirectory && CulturesToGenerate.Num() > 1)
	{
		UE_LOG(LogExportDialogueScriptCommandlet, Error, TEXT("bUseCultureDirectory may only be used with a single culture."));
		return false;
	}

	// Load the manifest and all archives
	FLocTextHelper LocTextHelper(SourcePath, ManifestName, ArchiveName, NativeCulture, CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
	LocTextHelper.SetCopyrightNotice(GatherManifestHelper->GetCopyrightNotice());
	{
		FText LoadError;
		if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
		{
			UE_LOG(LogExportDialogueScriptCommandlet, Error, TEXT("%s"), *LoadError.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/ExportDialogueScriptCommandlet.cpp:187

Scope (from outer to inner):

file
function     int32 UExportDialogueScriptCommandlet::Main

Source code excerpt:

	}

	for (const FString& CultureName : CulturesToGenerate)
	{
		const bool bIsNativeCulture = CultureName == NativeCulture;
		const FString CultureSourcePath = SourcePath / CultureName;
		const FString CultureDestinationPath = DestinationPath / (bUseCultureDirectory ? CultureName : TEXT(""));

		TArray<TSharedPtr<FDialogueScriptEntry>> ExportedDialogueLines;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GenerateGatherArchiveCommandlet.cpp:199

Scope (from outer to inner):

file
function     int32 UGenerateGatherArchiveCommandlet::Main

Source code excerpt:


	// Get cultures to generate.
	TArray<FString> CulturesToGenerate;
	GetStringArrayFromConfig(*SectionName, TEXT("CulturesToGenerate"), CulturesToGenerate, GatherTextConfigPath);
	
	if( CulturesToGenerate.Num() == 0 )
	{
		UE_LOG(LogGenerateArchiveCommandlet, Error, TEXT("No cultures specified for generation."));
		return -1;
	}

	// Get destination path.

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GenerateGatherArchiveCommandlet.cpp:217

Scope (from outer to inner):

file
function     int32 UGenerateGatherArchiveCommandlet::Main

Source code excerpt:


	// Load the manifest and all archives
	FLocTextHelper LocTextHelper(DestinationPath, ManifestName, ArchiveName, NativeCulture, CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
	LocTextHelper.SetCopyrightNotice(GatherManifestHelper->GetCopyrightNotice());
	{
		FText LoadError;
		if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
		{
			UE_LOG(LogGenerateArchiveCommandlet, Error, TEXT("%s"), *LoadError.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GenerateGatherArchiveCommandlet.cpp:229

Scope (from outer to inner):

file
function     int32 UGenerateGatherArchiveCommandlet::Main

Source code excerpt:


	// We need to make sure the native culture is processed first
	if (CulturesToGenerate.RemoveSingle(NativeCulture) > 0)
	{
		CulturesToGenerate.Insert(NativeCulture, 0);
	}

	for (const FString& CultureName : CulturesToGenerate)
	{
		// Add any missing manifest entries to the archive for this culture
		const bool bIsNativeCulture = CultureName == NativeCulture;
		LocTextHelper.EnumerateSourceTexts([&LocTextHelper, &CultureName, &NativeCulture, &bIsNativeCulture](TSharedRef<FManifestEntry> InManifestEntry) -> bool
		{
			for (const FManifestContext& Context : InManifestEntry->Contexts)

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GenerateTextLocalizationReportCommandlet.cpp:145

Scope (from outer to inner):

file
function     bool UGenerateTextLocalizationReportCommandlet::ProcessWordCountReport

Source code excerpt:


	// Get cultures to generate.
	TArray<FString> CulturesToGenerate;
	GetStringArrayFromConfig( *SectionName, TEXT("CulturesToGenerate"), CulturesToGenerate, GatherTextConfigPath );

	for(int32 i = 0; i < CulturesToGenerate.Num(); ++i)
	{
		if( FInternationalization::Get().GetCulture( CulturesToGenerate[i] ).IsValid() )
		{
			UE_LOG(LogGenerateTextLocalizationReportCommandlet, Verbose, TEXT("Specified culture is not a valid runtime culture, but may be a valid base language: %s"), *(CulturesToGenerate[i]));
		}
	}

	// Load the manifest and all archives
	FLocTextHelper LocTextHelper(SourcePath, ManifestName, ArchiveName, FString(), CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
	LocTextHelper.SetCopyrightNotice(GatherManifestHelper->GetCopyrightNotice());
	{
		FText LoadError;
		if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
		{
			UE_LOG(LogGenerateTextLocalizationReportCommandlet, Error, TEXT("%s"), *LoadError.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GenerateTextLocalizationResourceCommandlet.cpp:97

Scope (from outer to inner):

file
function     int32 UGenerateTextLocalizationResourceCommandlet::Main

Source code excerpt:


	// Get cultures to generate.
	TArray<FString> CulturesToGenerate;
	GetStringArrayFromConfig( *SectionName, TEXT("CulturesToGenerate"), CulturesToGenerate, GatherTextConfigPath );

	if( CulturesToGenerate.Num() == 0 )
	{
		UE_LOG(LogGenerateTextLocalizationResourceCommandlet, Error, TEXT("No cultures specified for generation."));
		return -1;
	}

	for(int32 i = 0; i < CulturesToGenerate.Num(); ++i)
	{
		if( FInternationalization::Get().GetCulture( CulturesToGenerate[i] ).IsValid() )
		{
			UE_LOG(LogGenerateTextLocalizationResourceCommandlet, Verbose, TEXT("Specified culture is not a valid runtime culture, but may be a valid base language: %s"), *(CulturesToGenerate[i]));
		}
	}

	// Get destination path.
	FString DestinationPath;
	if( !( GetPathFromConfig( *SectionName, TEXT("DestinationPath"), DestinationPath, GatherTextConfigPath ) ) )

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GenerateTextLocalizationResourceCommandlet.cpp:154

Scope (from outer to inner):

file
function     int32 UGenerateTextLocalizationResourceCommandlet::Main

Source code excerpt:


	// Load the manifest and all archives
	FLocTextHelper LocTextHelper(SourcePath, ManifestName, ArchiveName, NativeCultureName, CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
	LocTextHelper.SetCopyrightNotice(GatherManifestHelper->GetCopyrightNotice());
	{
		FText LoadError;
		if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
		{
			UE_LOG(LogGenerateTextLocalizationResourceCommandlet, Error, TEXT("%s"), *LoadError.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GenerateTextLocalizationResourceCommandlet.cpp:183

Scope (from outer to inner):

file
function     int32 UGenerateTextLocalizationResourceCommandlet::Main

Source code excerpt:


	// Generate the LocRes file for each culture
	for (const FString& CultureName : CulturesToGenerate)
	{
		auto GenerateSingleLocRes = [this, &DestinationPath, &CultureName, &ResourceName](const FTextLocalizationResource& InLocRes, const FName InPlatformName) -> bool
		{
			FString TextLocalizationResourcePath;
			if (InPlatformName.IsNone())
			{

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/ImportDialogueScriptCommandlet.cpp:95

Scope (from outer to inner):

file
function     int32 UImportDialogueScriptCommandlet::Main

Source code excerpt:


	// Get cultures to generate
	TArray<FString> CulturesToGenerate;
	if (GetStringArrayFromConfig(*SectionName, TEXT("CulturesToGenerate"), CulturesToGenerate, ConfigPath) == 0)
	{
		UE_LOG(LogImportDialogueScriptCommandlet, Error, TEXT("No cultures specified for import."));
		return -1;
	}

	// Get the manifest name

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/ImportDialogueScriptCommandlet.cpp:127

Scope (from outer to inner):

file
function     int32 UImportDialogueScriptCommandlet::Main

Source code excerpt:


	// We may only have a single culture if using this setting
	if (!bUseCultureDirectory && CulturesToGenerate.Num() > 1)
	{
		UE_LOG(LogImportDialogueScriptCommandlet, Error, TEXT("bUseCultureDirectory may only be used with a single culture."));
		return false;
	}

	// Load the manifest and all archives
	FLocTextHelper LocTextHelper(DestinationPath, ManifestName, ArchiveName, NativeCulture, CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
	LocTextHelper.SetCopyrightNotice(GatherManifestHelper->GetCopyrightNotice());
	{
		FText LoadError;
		if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
		{
			UE_LOG(LogImportDialogueScriptCommandlet, Error, TEXT("%s"), *LoadError.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/ImportDialogueScriptCommandlet.cpp:153

Scope (from outer to inner):

file
function     int32 UImportDialogueScriptCommandlet::Main

Source code excerpt:


	// Import any remaining cultures
	for (const FString& CultureName : CulturesToGenerate)
	{
		// Skip the native culture as we already processed it above
		if (CultureName == NativeCulture)
		{
			continue;
		}

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/ImportLocalizedDialogueCommandlet.cpp:79

Scope (from outer to inner):

file
function     int32 UImportLocalizedDialogueCommandlet::Main

Source code excerpt:


	// Get cultures to generate
	TArray<FString> CulturesToGenerate;
	if (GetStringArrayFromConfig(*SectionName, TEXT("CulturesToGenerate"), CulturesToGenerate, ConfigPath) == 0)
	{
		UE_LOG(LogImportLocalizedDialogueCommandlet, Error, TEXT("No cultures specified for import."));
		return -1;
	}

	// Get the manifest name

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/ImportLocalizedDialogueCommandlet.cpp:136

Scope (from outer to inner):

file
function     int32 UImportLocalizedDialogueCommandlet::Main

Source code excerpt:


	// Load the manifest and all archives
	FLocTextHelper LocTextHelper(SourcePath, ManifestName, ArchiveName, NativeCulture, CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
	LocTextHelper.SetCopyrightNotice(GatherManifestHelper->GetCopyrightNotice());
	{
		FText LoadError;
		if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
		{
			UE_LOG(LogImportLocalizedDialogueCommandlet, Error, TEXT("%s"), *LoadError.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/ImportLocalizedDialogueCommandlet.cpp:165

Scope (from outer to inner):

file
function     int32 UImportLocalizedDialogueCommandlet::Main

Source code excerpt:

	// Build up the culture specific import info
	TMap<FString, FCultureImportInfo> CultureImportInfoMap;
	for (const FString& CultureName : CulturesToGenerate)
	{
		FCultureImportInfo& CultureImportInfo = CultureImportInfoMap.Add(CultureName);
		CultureImportInfo.Name = CultureName;
		CultureImportInfo.AudioPath = RawAudioPath / CultureName;
		CultureImportInfo.ArchiveFileName = SourcePath / CultureName / ArchiveName;
		CultureImportInfo.LocalizedRootContentPath = RootContentDir / TEXT("L10N") / CultureName;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/InternationalizationExportCommandlet.cpp:101

Scope (from outer to inner):

file
function     int32 UInternationalizationExportCommandlet::Main

Source code excerpt:


	// Get cultures to generate.
	TArray<FString> CulturesToGenerate;
	if (GetStringArrayFromConfig(*SectionName, TEXT("CulturesToGenerate"), CulturesToGenerate, ConfigPath) == 0)
	{
		UE_LOG(LogInternationalizationExportCommandlet, Error, TEXT("No cultures specified for generation."));
		return -1;
	}

	// Get culture directory setting, default to true if not specified (used to allow picking of import directory with file open dialog from Translation Editor)

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/InternationalizationExportCommandlet.cpp:160

Scope (from outer to inner):

file
function     int32 UInternationalizationExportCommandlet::Main

Source code excerpt:

	{
		// Load the manifest and all archives
		FLocTextHelper LocTextHelper(DestinationPath, ManifestName, ArchiveName, NativeCultureName, CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
		LocTextHelper.SetCopyrightNotice(GatherManifestHelper->GetCopyrightNotice());
		{
			FText LoadError;
			if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
			{
				UE_LOG(LogInternationalizationExportCommandlet, Error, TEXT("%s"), *LoadError.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/InternationalizationExportCommandlet.cpp:185

Scope (from outer to inner):

file
function     int32 UInternationalizationExportCommandlet::Main

Source code excerpt:


		// Load the manifest and all archives
		FLocTextHelper LocTextHelper(SourcePath, ManifestName, ArchiveName, NativeCultureName, CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
		LocTextHelper.SetCopyrightNotice(GatherManifestHelper->GetCopyrightNotice());
		{
			FText LoadError;
			if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
			{
				UE_LOG(LogInternationalizationExportCommandlet, Error, TEXT("%s"), *LoadError.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/CookOnTheFlyServer.cpp:12621

Scope (from outer to inner):

file
function     void UCookOnTheFlyServer::CompileDLCLocalization

Source code excerpt:


	// Also filter the validation list by the cultures we're cooking against
	DefaultUGCLocDescriptor.CulturesToGenerate.RemoveAll([this](const FString& Culture)
	{
		return !CookByTheBookOptions->AllCulturesToCook.Contains(Culture);
	});

	// Compile UGC localization (if available) for this DLC plugin
	const FString InputContentDirectory = GetContentDirectoryForDLC();

#References in C# build files

This variable is referenced in the following C# build files:

Location: <Workspace>/Engine/Source/Programs/AutomationTool/Scripts/Localisation.Automation.cs:1031


		List<string> CulturesToGenerate;
		if (!LocalizationConfig.GetArray("CommonSettings", "CulturesToGenerate", out CulturesToGenerate))
		{
			throw new AutomationException("Failed to find a required config key! Section: 'CommonSettings', Key: 'CulturesToGenerate', File: '{0}'", LocalizationConfigFile);
		}

		bool bUseCultureDirectory;
		if (!LocalizationConfig.GetBool("CommonSettings", "bUseCultureDirectory", out bUseCultureDirectory))