CommandletClass

CommandletClass

#Overview

name: CommandletClass

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

It is referenced in 32 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of CommandletClass is to specify the class of a commandlet to be executed within the Unreal Engine environment. Commandlets are command-line tools that can be run using the Unreal Engine executable to perform various tasks related to game development, content processing, and engine operations.

This setting variable is primarily used by the engine’s core systems, particularly the launch process and various editor and development tools. It’s referenced in multiple subsystems and modules, including:

  1. Localization system
  2. World Partition editor
  3. Game Project Generation
  4. Engine launch process

The value of this variable is typically set in configuration files or through command-line arguments when launching the engine or a specific commandlet. It’s often set dynamically based on the task being performed.

CommandletClass interacts with other variables and systems, such as command-line arguments, engine initialization parameters, and specific commandlet settings.

Developers should be aware that:

  1. The specified class must be a valid UCommandlet subclass.
  2. Different commandlets may require different engine configurations or additional parameters.
  3. Some commandlets are editor-only and cannot be run in non-editor builds.

Best practices when using this variable include:

  1. Ensure the correct commandlet class is specified for the intended task.
  2. Provide all necessary additional parameters required by the specific commandlet.
  3. Use the appropriate engine configuration (editor vs. non-editor) for the chosen commandlet.
  4. Be cautious when using commandlets that modify project or engine data, as they can have significant impacts.

#Setting Variables

#References In INI files

<Workspace>/Engine/Config/Localization/Category.ini:26, section: [GatherTextStep0]
<Workspace>/Engine/Config/Localization/Category.ini:44, section: [GatherTextStep1]
<Workspace>/Engine/Config/Localization/Category.ini:48, section: [GatherTextStep2]
<Workspace>/Engine/Config/Localization/Category.ini:53, section: [GatherTextStep3]
<Workspace>/Engine/Config/Localization/Category.ini:58, section: [GatherTextStep4]
<Workspace>/Engine/Config/Localization/Category.ini:63, section: [GatherTextStep5]
<Workspace>/Engine/Config/Localization/Category.ini:68, section: [GatherTextStep6]
<Workspace>/Engine/Config/Localization/Editor.ini:26, section: [GatherTextStep0]
<Workspace>/Engine/Config/Localization/Editor.ini:43, section: [GatherTextStep1]
<Workspace>/Engine/Config/Localization/Editor.ini:53, section: [GatherTextStep2]
<Workspace>/Engine/Config/Localization/Editor.ini:88, section: [GatherTextStep3]
<Workspace>/Engine/Config/Localization/Editor.ini:92, section: [GatherTextStep4]
<Workspace>/Engine/Config/Localization/Editor.ini:97, section: [GatherTextStep5]
<Workspace>/Engine/Config/Localization/Editor.ini:102, section: [GatherTextStep6]
<Workspace>/Engine/Config/Localization/Editor.ini:107, section: [GatherTextStep7]
<Workspace>/Engine/Config/Localization/Editor.ini:112, section: [GatherTextStep8]
<Workspace>/Engine/Config/Localization/EditorTutorials.ini:34, section: [GatherTextStep0]
<Workspace>/Engine/Config/Localization/EditorTutorials.ini:44, section: [GatherTextStep1]
<Workspace>/Engine/Config/Localization/EditorTutorials.ini:48, section: [GatherTextStep2]
<Workspace>/Engine/Config/Localization/EditorTutorials.ini:53, section: [GatherTextStep3]
<Workspace>/Engine/Config/Localization/EditorTutorials.ini:58, section: [GatherTextStep4]
<Workspace>/Engine/Config/Localization/EditorTutorials.ini:63, section: [GatherTextStep5]
<Workspace>/Engine/Config/Localization/EditorTutorials.ini:68, section: [GatherTextStep6]
<Workspace>/Engine/Config/Localization/Engine.ini:25, section: [GatherTextStep0]
<Workspace>/Engine/Config/Localization/Engine.ini:49, section: [GatherTextStep1]
<Workspace>/Engine/Config/Localization/Engine.ini:66, section: [GatherTextStep2]
<Workspace>/Engine/Config/Localization/Engine.ini:70, section: [GatherTextStep3]
<Workspace>/Engine/Config/Localization/Engine.ini:75, section: [GatherTextStep4]
<Workspace>/Engine/Config/Localization/Engine.ini:80, section: [GatherTextStep5]
<Workspace>/Engine/Config/Localization/Engine.ini:85, section: [GatherTextStep6]
<Workspace>/Engine/Config/Localization/Engine.ini:90, section: [GatherTextStep7]


... omitting 132 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:330

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateGatherTextConfigFile

Source code excerpt:

			FConfigSection ConfigSection;

			// CommandletClass
			ConfigSection.Add( TEXT("CommandletClass"), TEXT("GatherTextFromSource") );

			// Include Paths
			for (const auto& IncludePath : Target->Settings.GatherFromTextFiles.SearchDirectories)
			{
				ConfigSection.Add( TEXT("SearchDirectoryPaths"), FString::Printf(TEXT("%s%s"), *FLocalizationGatherPathRootUtil::GetResolvedPathRootToken(IncludePath.PathRoot), *IncludePath.Path) );
			}

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

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateGatherTextConfigFile

Source code excerpt:

			FConfigSection ConfigSection;

			// CommandletClass
			ConfigSection.Add( TEXT("CommandletClass"), TEXT("GatherTextFromAssets") );

			// Include Paths
			for (const auto& IncludePath : Target->Settings.GatherFromPackages.IncludePathWildcards)
			{
				ConfigSection.Add( TEXT("IncludePathFilters"), FString::Printf(TEXT("%s%s"), *FLocalizationGatherPathRootUtil::GetResolvedPathRootToken(IncludePath.PathRoot), *IncludePath.Pattern) );
			}

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

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateGatherTextConfigFile

Source code excerpt:

			FConfigSection ConfigSection;

			// CommandletClass
			ConfigSection.Add( TEXT("CommandletClass"), TEXT("GatherTextFromMetadata") );

			// Include Paths
			for (const auto& IncludePath : Target->Settings.GatherFromMetaData.IncludePathWildcards)
			{
				ConfigSection.Add( TEXT("IncludePathFilters"), FString::Printf(TEXT("%s%s"), *FLocalizationGatherPathRootUtil::GetResolvedPathRootToken(IncludePath.PathRoot), *IncludePath.Pattern) );
			}

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

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateGatherTextConfigFile

Source code excerpt:

			FConfigSection ConfigSection;

			// CommandletClass
			ConfigSection.Add( TEXT("CommandletClass"), TEXT("GenerateGatherManifest") );

			Script.AddGatherTextStep(GatherTextStepIndex++, MoveTemp(ConfigSection));
		}

		// GenerateGatherArchive
		{
			FConfigSection ConfigSection;

			// CommandletClass
			ConfigSection.Add( TEXT("CommandletClass"), TEXT("GenerateGatherArchive") );

			Script.AddGatherTextStep(GatherTextStepIndex++, MoveTemp(ConfigSection));
		}

		// GenerateTextLocalizationReport
		{
			FConfigSection ConfigSection;

			// CommandletClass
			ConfigSection.Add( TEXT("CommandletClass"), TEXT("GenerateTextLocalizationReport") );

			ConfigSection.Add( TEXT("bWordCountReport"), TEXT("true") );
			ConfigSection.Add( TEXT("WordCountReportName"), GetWordCountCSVFileName(Target) );

			ConfigSection.Add( TEXT("bConflictReport"), TEXT("true") );
			ConfigSection.Add( TEXT("ConflictReportName"), GetConflictReportFileName(Target) );

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

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateImportTextConfigFile

Source code excerpt:

			FConfigSection ConfigSection;

			// CommandletClass
			ConfigSection.Add( TEXT("CommandletClass"), TEXT("InternationalizationExport") );

			ConfigSection.Add( TEXT("bImportLoc"), TEXT("true") );

			// Import-specific settings.
			{
				UEnum* LocalizedTextCollapseModeEnum = FindObjectChecked<UEnum>(nullptr, TEXT("/Script/Localization.ELocalizedTextCollapseMode"));

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

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateExportTextConfigFile

Source code excerpt:

			FConfigSection ConfigSection;

			// CommandletClass
			ConfigSection.Add( TEXT("CommandletClass"), TEXT("InternationalizationExport") );

			ConfigSection.Add(TEXT("bExportLoc"), TEXT("true"));

			// Export-specific settings.
			{
				UEnum* LocalizedTextCollapseModeEnum = FindObjectChecked<UEnum>(nullptr, TEXT("/Script/Localization.ELocalizedTextCollapseMode"));

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

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateImportDialogueScriptConfigFile

Source code excerpt:

			FConfigSection ConfigSection;

			// CommandletClass
			ConfigSection.Add(TEXT("CommandletClass"), TEXT("ImportDialogueScript"));
			
			Script.AddGatherTextStep(0, MoveTemp(ConfigSection));
		}

		Script.Dirty = true;

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

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateExportDialogueScriptConfigFile

Source code excerpt:

			FConfigSection ConfigSection;

			// CommandletClass
			ConfigSection.Add(TEXT("CommandletClass"), TEXT("ExportDialogueScript"));
			
			Script.AddGatherTextStep(0, MoveTemp(ConfigSection));
		}

		Script.Dirty = true;

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

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateImportDialogueConfigFile

Source code excerpt:

			FConfigSection ConfigSection;

			// CommandletClass
			ConfigSection.Add(TEXT("CommandletClass"), TEXT("ImportLocalizedDialogue"));

			ConfigSection.Add(TEXT("RawAudioPath"), Target->Settings.ImportDialogueSettings.RawAudioPath.Path);
			ConfigSection.Add(TEXT("ImportedDialogueFolder"), Target->Settings.ImportDialogueSettings.ImportedDialogueFolder);
			ConfigSection.Add(TEXT("bImportNativeAsSource"), Target->Settings.ImportDialogueSettings.bImportNativeAsSource ? TEXT("true") : TEXT("false"));

			Script.AddGatherTextStep(0, MoveTemp(ConfigSection));

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

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateWordCountReportConfigFile

Source code excerpt:

			FConfigSection ConfigSection;

			// CommandletClass
			ConfigSection.Add( TEXT("CommandletClass"), TEXT("GenerateTextLocalizationReport") );

			ConfigSection.Add( TEXT("bWordCountReport"), TEXT("true") );

			ConfigSection.Add( TEXT("WordCountReportName"), GetWordCountCSVFileName(Target) );

			Script.AddGatherTextStep(0, MoveTemp(ConfigSection));

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

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateCompileTextConfigFile

Source code excerpt:

			FConfigSection ConfigSection;

			// CommandletClass
			ConfigSection.Add( TEXT("CommandletClass"), TEXT("GenerateTextLocalizationResource") );
			
			Script.AddGatherTextStep(0, MoveTemp(ConfigSection));
		}

		Script.Dirty = true;

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

Scope (from outer to inner):

file
namespace    UserGeneratedContentLocalization
function     bool ExportLocalization

Source code excerpt:

				{
					FConfigSection ConfigSection;
					ConfigSection.Add(TEXT("CommandletClass"), TEXT("GatherTextFromSource"));

					ConfigSection.Add(TEXT("FileNameFilters"), TEXT("*.h"));
					ConfigSection.Add(TEXT("FileNameFilters"), TEXT("*.cpp"));
					ConfigSection.Add(TEXT("FileNameFilters"), TEXT("*.inl"));
					ConfigSection.Add(TEXT("FileNameFilters"), TEXT("*.ini"));

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

Scope (from outer to inner):

file
namespace    UserGeneratedContentLocalization
function     bool ExportLocalization

Source code excerpt:

			{
				FConfigSection ConfigSection;
				ConfigSection.Add(TEXT("CommandletClass"), TEXT("GatherTextFromAssets"));

				ConfigSection.Add(TEXT("PackageFileNameFilters"), TEXT("*.uasset"));
				ConfigSection.Add(TEXT("PackageFileNameFilters"), TEXT("*.umap"));

				ConfigSection.Add(TEXT("IncludePathFilters"), FPaths::ConvertRelativePathToFull(FPaths::Combine(Plugin->GetContentDir(), TEXT("*"))));

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

Scope (from outer to inner):

file
namespace    UserGeneratedContentLocalization
function     bool ExportLocalization

Source code excerpt:

			{
				FConfigSection ConfigSection;
				ConfigSection.Add(TEXT("CommandletClass"), TEXT("GatherTextFromVerse"));

				ConfigSection.Add(TEXT("IncludePathFilters"), FPaths::ConvertRelativePathToFull(FPaths::Combine(Plugin->GetBaseDir(), TEXT("*"))));

				ConfigSection.Add(TEXT("ExcludePathFilters"), FPaths::ConvertRelativePathToFull(FPaths::Combine(Plugin->GetContentDir(), TEXT("Localization"), TEXT("*"))));
				ConfigSection.Add(TEXT("ExcludePathFilters"), FPaths::ConvertRelativePathToFull(FPaths::Combine(Plugin->GetContentDir(), TEXT("L10N"), TEXT("*"))));

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

Scope (from outer to inner):

file
namespace    UserGeneratedContentLocalization
function     bool ExportLocalization

Source code excerpt:

			{
				FConfigSection ConfigSection;
				ConfigSection.Add(TEXT("CommandletClass"), TEXT("GenerateGatherManifest"));
				GatherConfig.AddGatherTextStep(GatherStepIndex++, MoveTemp(ConfigSection));
			}

			// Generate archive
			{
				FConfigSection ConfigSection;
				ConfigSection.Add(TEXT("CommandletClass"), TEXT("GenerateGatherArchive"));
				GatherConfig.AddGatherTextStep(GatherStepIndex++, MoveTemp(ConfigSection));
			}

			// Import PO
			{
				// Read the UGC localization descriptor settings that were used to generate this localization data, as we should import against those

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

Scope (from outer to inner):

file
namespace    UserGeneratedContentLocalization
function     bool ExportLocalization

Source code excerpt:


				FConfigSection ConfigSection;
				ConfigSection.Add(TEXT("CommandletClass"), TEXT("InternationalizationExport"));

				ConfigSection.Add(TEXT("bImportLoc"), TEXT("true"));

				ConfigSection.Add(TEXT("POFormat"), StaticEnum<EPortableObjectFormat>()->GetNameStringByValue((int64)UGCLocDescriptorForImport.PoFormat));

				GatherConfig.AddGatherTextStep(GatherStepIndex++, MoveTemp(ConfigSection));

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

Scope (from outer to inner):

file
namespace    UserGeneratedContentLocalization
function     bool ExportLocalization

Source code excerpt:

			{
				FConfigSection ConfigSection;
				ConfigSection.Add(TEXT("CommandletClass"), TEXT("InternationalizationExport"));

				ConfigSection.Add(TEXT("bExportLoc"), TEXT("true"));

				ConfigSection.Add(TEXT("POFormat"), StaticEnum<EPortableObjectFormat>()->GetNameStringByValue((int64)ExportOptions.UGCLocDescriptor.PoFormat));

				ConfigSection.Add(TEXT("ShouldPersistCommentsOnExport"), TEXT("true"));

#Loc: <Workspace>/Engine/Source/Editor/GameProjectGeneration/Private/GameProjectUtils.cpp:210

Scope (from outer to inner):

file
namespace    anonymous
function     void AddWorldPartitionConfigValues

Source code excerpt:

			ConfigValues.Emplace(TEXT("DefaultEngine.ini"),
				TEXT("/Script/WorldPartitionEditor.WorldPartitionEditorSettings"),
				TEXT("CommandletClass"),
				TEXT("Class'/Script/UnrealEd.WorldPartitionConvertCommandlet'"),
				true /* ShouldReplaceExistingValue */);
		}
	}

	void AddUserInterfaceConfigValues(const FProjectInformation& InProjectInfo, TArray<FTemplateConfigValue>& ConfigValues)
	{
		if (InProjectInfo.bIsBlankTemplate)
		{
			ConfigValues.Emplace(TEXT("DefaultEngine.ini"),

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

Scope (from outer to inner):

file
class        class UInternationalizationExportSettings : public UObject

Source code excerpt:

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

	/** Source for the localization data */
	UPROPERTY(Category = GatherTextStep, EditAnywhere, config)
	FString SourcePath;

	/** Destination for the localization data */

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GatherTextCommandlet.cpp:252

Scope (from outer to inner):

file
function     int32 UGatherTextCommandlet::ProcessGatherConfig

Source code excerpt:

	for (const FString& StepName : StepNames)
	{
		FString CommandletClassName = GConfig->GetStr( *StepName, TEXT("CommandletClass"), GatherTextConfigPath ) + TEXT("Commandlet");

		UClass* CommandletClass = FindFirstObject<UClass>(*CommandletClassName, EFindFirstObjectOptions::None, ELogVerbosity::Warning, TEXT("UGatherTextCommandlet::ProcessGatherConfig"));
		if (!CommandletClass)
		{
			UE_LOG(LogGatherTextCommandlet, Error, TEXT("The commandlet name %s in section %s is invalid."), *CommandletClassName, *StepName);
			continue;
		}

		UGatherTextCommandletBase* Commandlet = NewObject<UGatherTextCommandletBase>(GetTransientPackage(), CommandletClass);
		check(Commandlet);
		FGCObjectScopeGuard CommandletGCGuard(Commandlet);
		Commandlet->Initialize( CommandletGatherManifestHelper, CommandletSourceControlInfo );
		// As of now, all params and switches (with the exception of config) is passed on to child commandlets
		// Instead of parsing in child commandlets, we'll just pass the params and switches along to determine if we need to run the child commandlet 
		// If we are running in preview mode, then most commandlets should be skipped as ShouldRunInPreview() defaults to false in the base class.

#Loc: <Workspace>/Engine/Source/Editor/WorldPartitionEditor/Private/WorldPartition/SWorldPartitionConvertDialog.cpp:75

Scope (from outer to inner):

file
function     bool SWorldPartitionConvertDialog::IsOkEnabled

Source code excerpt:

bool SWorldPartitionConvertDialog::IsOkEnabled() const
{
	return ConvertOptions->CommandletClass != nullptr;
}

FReply SWorldPartitionConvertDialog::OnOkClicked()
{
	bClickedOk = true;
	ParentWindowPtr.Pin()->RequestDestroyWindow();

#Loc: <Workspace>/Engine/Source/Editor/WorldPartitionEditor/Private/WorldPartition/WorldPartitionEditorSettings.cpp:5

Scope (from outer to inner):

file
function     UWorldPartitionEditorSettings::UWorldPartitionEditorSettings

Source code excerpt:

UWorldPartitionEditorSettings::UWorldPartitionEditorSettings()
{
	CommandletClass = UWorldPartitionConvertCommandlet::StaticClass();
	InstancedFoliageGridSize = 25600;
	MinimapLowQualityWorldUnitsPerPixelThreshold = 12800;
	bEnableLoadingInEditor = true;
	bEnableStreamingGenerationLogOnPIE = true;
	bShowHLODsInEditor = true;
	bShowHLODsOverLoadedRegions = false;

#Loc: <Workspace>/Engine/Source/Editor/WorldPartitionEditor/Private/WorldPartitionEditorModule.cpp:698

Scope (from outer to inner):

file
function     bool FWorldPartitionEditorModule::ConvertMap

Source code excerpt:


	UWorldPartitionConvertOptions* DefaultConvertOptions = GetMutableDefault<UWorldPartitionConvertOptions>();
	DefaultConvertOptions->CommandletClass = GetDefault<UWorldPartitionEditorSettings>()->CommandletClass;
	DefaultConvertOptions->bInPlace = false;
	DefaultConvertOptions->bSkipStableGUIDValidation = false;
	DefaultConvertOptions->LongPackageName = InLongPackageName;

	TSharedPtr<SWindow> DlgWindow =
		SNew(SWindow)

#Loc: <Workspace>/Engine/Source/Editor/WorldPartitionEditor/Private/WorldPartitionEditorModule.cpp:969

Scope (from outer to inner):

file
function     FString UWorldPartitionConvertOptions::ToCommandletArgs

Source code excerpt:

{
	TStringBuilder<1024> CommandletArgsBuilder;
	CommandletArgsBuilder.Appendf(TEXT("-run=%s %s -AllowCommandletRendering"), *CommandletClass->GetName(), *LongPackageName);
	
	if (!bInPlace)
	{
		CommandletArgsBuilder.Append(TEXT(" -ConversionSuffix"));
	}

#Loc: <Workspace>/Engine/Source/Editor/WorldPartitionEditor/Public/WorldPartition/WorldPartitionConvertOptions.h:15

Scope (from outer to inner):

file
class        class UWorldPartitionConvertOptions : public UObject

Source code excerpt:


	UPROPERTY(EditAnywhere, AdvancedDisplay, Category=Convert)
	TSubclassOf<UWorldPartitionConvertCommandlet> CommandletClass;
		
	UPROPERTY(EditAnywhere, Category=Convert, meta = (ToolTip = "Wether the conversion should create a new map with a _WP suffix or overwrite the source map"))
	bool bInPlace;

	UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Convert)
	bool bDeleteSourceLevels;

#Loc: <Workspace>/Engine/Source/Editor/WorldPartitionEditor/Public/WorldPartition/WorldPartitionEditorSettings.h:18

Scope (from outer to inner):

file
class        class UWorldPartitionEditorSettings : public UDeveloperSettings

Source code excerpt:


	UPROPERTY(Config, EditAnywhere, Category = MapConversion, Meta = (ToolTip = "Commandlet class to use for World Partition conversion"))
	TSubclassOf<UWorldPartitionConvertCommandlet> CommandletClass;

	UPROPERTY(Config, EditAnywhere, Category = Foliage, Meta = (ClampMin = 3200, ToolTip= "Editor grid size used for instance foliage actors in World Partition worlds"))
	int32 InstancedFoliageGridSize;

	UPROPERTY(Config, EditAnywhere, Category = MiniMap, Meta = (ClampMin = 100, ToolTip = "Threshold from which minimap generates a warning if its WorldUnitsPerPixel is above this value"))
	int32 MinimapLowQualityWorldUnitsPerPixelThreshold;

#Loc: <Workspace>/Engine/Source/Runtime/Launch/Private/LaunchEngineLoop.cpp:4030

Scope (from outer to inner):

file
function     int32 FEngineLoop::PreInitPostStartupScreen

Source code excerpt:

	if (!bHasEditorToken && !IsRunningDedicatedServer())
	{
		UClass* CommandletClass = nullptr;

		if (!bIsRegularClient)
		{
			checkf(PRIVATE_GIsRunningCommandlet, TEXT("This should have been set in PreInitPreStartupScreen"));

			CommandletClass = Cast<UClass>(StaticFindFirstObject(UClass::StaticClass(), *Token, EFindFirstObjectOptions::None, ELogVerbosity::Warning, TEXT("looking for commandlet")));
			int32 PeriodIdx;
			if (!CommandletClass && Token.FindChar('.', PeriodIdx))
			{
				// try to load module for commandlet specified before a period.
				FModuleManager::Get().LoadModule(*Token.Left(PeriodIdx));
				CommandletClass = FindFirstObject<UClass>(*Token, EFindFirstObjectOptions::None, ELogVerbosity::Warning, TEXT("Looking for commandlet class"));
			}
			if (!CommandletClass)
			{
				if (GLogConsole && !GIsSilent)
				{
					GLogConsole->Show(true);
				}
				UE_LOG(LogInit, Error, TEXT("%s looked like a commandlet, but we could not find the class."), *Token);

#Loc: <Workspace>/Engine/Source/Runtime/Launch/Private/LaunchEngineLoop.cpp:4078

Scope (from outer to inner):

file
function     int32 FEngineLoop::PreInitPostStartupScreen

Source code excerpt:

			setvbuf(stdout, nullptr, _IONBF, 0);

			UE_LOG(LogInit, Log,  TEXT("Executing %s"), *CommandletClass->GetFullName() );

			// Allow commandlets to individually override those settings.
			UCommandlet* Default = CastChecked<UCommandlet>(CommandletClass->GetDefaultObject());

			if ( IsEngineExitRequested() )
			{
				// commandlet set IsEngineExitRequested() during construction
				return 1;
			}

#Loc: <Workspace>/Engine/Source/Runtime/Launch/Private/LaunchEngineLoop.cpp:4096

Scope (from outer to inner):

file
function     int32 FEngineLoop::PreInitPostStartupScreen

Source code excerpt:

			if (Default->IsEditor)
			{
				UE_LOG(LogInit, Error, TEXT("Cannot run editor commandlet %s with game executable."), *CommandletClass->GetFullName());
				RequestEngineExit(TEXT("Tried to run commandlet in non-editor build"));
				return 1;
			}
#endif
			// Reset aux log if we don't want to log to the console window.
			if( !Default->LogToConsole )

#Loc: <Workspace>/Engine/Source/Runtime/Launch/Private/LaunchEngineLoop.cpp:4108

Scope (from outer to inner):

file
function     int32 FEngineLoop::PreInitPostStartupScreen

Source code excerpt:


			// allow the commandlet the opportunity to create a custom engine
			CommandletClass->GetDefaultObject<UCommandlet>()->CreateCustomEngine(CommandletCommandLine);
			if ( GEngine == nullptr )
			{
#if WITH_EDITOR
				if ( GIsEditor )
				{
					FString EditorEngineClassName;

#Loc: <Workspace>/Engine/Source/Runtime/Launch/Private/LaunchEngineLoop.cpp:4168

Scope (from outer to inner):

file
function     int32 FEngineLoop::PreInitPostStartupScreen

Source code excerpt:

			FAutomationTestFramework::Get().RunSmokeTests();

			UCommandlet* Commandlet = NewObject<UCommandlet>(GetTransientPackage(), CommandletClass);
			check(Commandlet);
			Commandlet->AddToRoot();

			// Execute the commandlet.
			double CommandletExecutionStartTime = FPlatformTime::Seconds();

#Loc: <Workspace>/Engine/Source/Runtime/Launch/Private/LaunchEngineLoop.cpp:4185

Scope (from outer to inner):

file
function     int32 FEngineLoop::PreInitPostStartupScreen

Source code excerpt:


#if WITH_ENGINE
			PRIVATE_GRunningCommandletClass = CommandletClass;
#endif
			FCoreDelegates::OnCommandletPreMain.Broadcast();
			int32 ErrorLevel;
			{
				TRACE_CPUPROFILER_EVENT_SCOPE_TEXT(*WriteToString<512>(TEXT("Commandlet Main "), Commandlet->GetFName()));
				FTrackedActivityScope CommandletActivity(FTrackedActivity::GetEngineActivity(), *FString::Printf(TEXT("Running %s"), *Commandlet->GetName()), false, FTrackedActivity::ELight::Green);