BuildConfiguration

BuildConfiguration

#Overview

name: BuildConfiguration

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 68 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of BuildConfiguration is to specify the build configuration of the Unreal Engine project or application. It represents different compilation and optimization settings used during the build process.

BuildConfiguration is used across various Unreal Engine subsystems and modules, including:

  1. Launcher and deployment services
  2. Packaging and build systems
  3. Performance profiling and analytics
  4. Crash reporting and debugging
  5. Platform-specific processes

The value of this variable is typically set based on the current build configuration of the project, which can be Development, Shipping, Test, or Debug. It is often retrieved using FApp::GetBuildConfiguration() or set explicitly in certain contexts.

BuildConfiguration interacts with other variables and settings, such as:

  1. CookConfiguration: Often set to the same value as BuildConfiguration
  2. BuildMode: Determines how the project should be built
  3. Other platform-specific settings

Developers should be aware that:

  1. Different build configurations have varying levels of optimization and debugging capabilities.
  2. Certain features or behaviors may change depending on the build configuration.
  3. Performance metrics and crash reports are often tagged with the build configuration for context.

Best practices when using this variable include:

  1. Ensure the appropriate build configuration is used for different development stages (e.g., Shipping for release builds).
  2. Be consistent in how BuildConfiguration is set and used across different systems.
  3. Consider the implications of the build configuration on performance, debugging, and feature availability.
  4. Use the correct build configuration when packaging and deploying the project to various platforms.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Config/BaseGame.ini:89, section: [/Script/UnrealEd.ProjectPackagingSettings]

Location: <Workspace>/Projects/Lyra/Config/DefaultGame.ini:84, section: [/Script/UnrealEd.ProjectPackagingSettings]

#References in C++ code

#Callsites

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

#Loc: <Workspace>/Engine/Plugins/Editor/MobileLauncherProfileWizard/Source/MobileLauncherProfileWizard/Private/AndroidProfileWizard.cpp:35

Scope (from outer to inner):

file
function     static void SetupAndroidAppProfile

Source code excerpt:

	// App build configuration
	AppProfile->SetBuildMode(ELauncherProfileBuildModes::Auto);
	AppProfile->SetBuildConfiguration(Params.BuildConfiguration);
	
	//// Cooking
	AppProfile->SetCookMode(ELauncherProfileCookModes::ByTheBook);
	AppProfile->SetCookConfiguration(Params.BuildConfiguration);
	for (const FString& MapName : Params.AppMaps)
	{
		AppProfile->AddCookedMap(MapName);
	}
	AppProfile->AddCookedPlatform(AndroidProfileConstants::AppPlatformName);

#Loc: <Workspace>/Engine/Plugins/Editor/MobileLauncherProfileWizard/Source/MobileLauncherProfileWizard/Private/AndroidProfileWizard.cpp:85

Scope (from outer to inner):

file
function     static void SetupAndroidDLCProfile

Source code excerpt:

	// App build configuration
	DLCProfile->SetBuildMode(ELauncherProfileBuildModes::DoNotBuild);
	DLCProfile->SetBuildConfiguration(Params.BuildConfiguration);
		
	//// Cooking
	DLCProfile->SetCookMode(ELauncherProfileCookModes::ByTheBook);
	DLCProfile->SetCookConfiguration(Params.BuildConfiguration);
	for (const FString& MapName : Params.DLCMaps)
	{
		DLCProfile->AddCookedMap(MapName);
	}
	
	for (const FString& CookFlavor : Params.DLCCookFlavors)

#Loc: <Workspace>/Engine/Plugins/Editor/MobileLauncherProfileWizard/Source/MobileLauncherProfileWizard/Private/IOSProfileWizard.cpp:35

Scope (from outer to inner):

file
function     static void SetupIOSAppProfile

Source code excerpt:

	// App build configuration
	AppProfile->SetBuildMode(ELauncherProfileBuildModes::Auto);
	AppProfile->SetBuildConfiguration(Params.BuildConfiguration);
	
	//// Cooking
	AppProfile->SetCookMode(ELauncherProfileCookModes::ByTheBook);
	AppProfile->SetCookConfiguration(Params.BuildConfiguration);
	for (const FString& MapName : Params.AppMaps)
	{
		AppProfile->AddCookedMap(MapName);
	}
	AppProfile->AddCookedPlatform(IOSProfileConstants::AppPlatformName);

#Loc: <Workspace>/Engine/Plugins/Editor/MobileLauncherProfileWizard/Source/MobileLauncherProfileWizard/Private/IOSProfileWizard.cpp:85

Scope (from outer to inner):

file
function     static void SetupIOSDLCProfile

Source code excerpt:

	// App build configuration
	DLCProfile->SetBuildMode(ELauncherProfileBuildModes::DoNotBuild);
	DLCProfile->SetBuildConfiguration(Params.BuildConfiguration);
	
	//// Cooking
	DLCProfile->SetCookMode(ELauncherProfileCookModes::ByTheBook);
	DLCProfile->SetCookConfiguration(Params.BuildConfiguration);
	for (const FString& MapName : Params.DLCMaps)
	{
		DLCProfile->AddCookedMap(MapName);
	}
	
	DLCProfile->AddCookedPlatform(IOSProfileConstants::AppPlatformName);

#Loc: <Workspace>/Engine/Plugins/Editor/MobileLauncherProfileWizard/Source/MobileLauncherProfileWizard/Private/SProfileWizardUI.cpp:30

Scope (from outer to inner):

file
function     SProfileWizardUI::SProfileWizardUI

Source code excerpt:

SProfileWizardUI::SProfileWizardUI()
	: ProfilePlatform(EProfilePlatform::Android)
	, BuildConfiguration(EBuildConfiguration::Development)
{
}

BEGIN_SLATE_FUNCTION_BUILD_OPTIMIZATION
void SProfileWizardUI::Construct(const FArguments& InArgs)
{

#Loc: <Workspace>/Engine/Plugins/Editor/MobileLauncherProfileWizard/Source/MobileLauncherProfileWizard/Private/SProfileWizardUI.cpp:501

Scope (from outer to inner):

file
function     void SProfileWizardUI::HandleBuildConfigurationMenuEntryClicked

Source code excerpt:

void SProfileWizardUI::HandleBuildConfigurationMenuEntryClicked(EBuildConfiguration InConfiguration)
{
	BuildConfiguration = InConfiguration;
}

FText SProfileWizardUI::GetBuildConfigurationSelectorText() const
{
	return EBuildConfigurations::ToText(BuildConfiguration);
}

TSharedRef<ITableRow> SProfileWizardUI::HandleMapListViewGenerateRow(TSharedPtr<FString> InItem, const TSharedRef<STableViewBase>& OwnerTable, EProfileTarget::Type InProfileTarget)
{
	return 
		SNew(STableRow<TSharedPtr<FString>>, OwnerTable)

#Loc: <Workspace>/Engine/Plugins/Editor/MobileLauncherProfileWizard/Source/MobileLauncherProfileWizard/Private/SProfileWizardUI.cpp:687

Scope (from outer to inner):

file
function     void SProfileWizardUI::FinishClicked

Source code excerpt:


	FProfileParameters Parameters;
	Parameters.BuildConfiguration = BuildConfiguration;
	Parameters.ArchiveDirectory = ArchiveDirectory;
	Parameters.AppMaps = SelectedMaps[EProfileTarget::Application].Array();
	Parameters.DLCMaps = SelectedMaps[EProfileTarget::DLC].Array();
	Parameters.DLCCookFlavors = DLCSelectedFlavors.Array();
		
	OnCreateProfileEvent.Execute(Parameters);

#Loc: <Workspace>/Engine/Plugins/Editor/MobileLauncherProfileWizard/Source/MobileLauncherProfileWizard/Private/SProfileWizardUI.h:34

Scope: file

Source code excerpt:

struct FProfileParameters
{
	EBuildConfiguration BuildConfiguration;
	FString	ArchiveDirectory;
	TArray<FString>	AppMaps;
	TArray<FString>	DLCMaps;
	TArray<FString>	DLCCookFlavors;
};

#Loc: <Workspace>/Engine/Plugins/Editor/MobileLauncherProfileWizard/Source/MobileLauncherProfileWizard/Private/SProfileWizardUI.h:177

Scope (from outer to inner):

file
class        class SProfileWizardUI : public SCompoundWidget

Source code excerpt:


	/** Selected project build configuration */
	EBuildConfiguration BuildConfiguration;

	/** Cached list of project maps */
	TArray<TSharedPtr<FString>> ProjectMapList;
	
	/** Selected maps for each profile: Application and DLC */
	TSet<FString> SelectedMaps[EProfileTarget::Num];

#Loc: <Workspace>/Engine/Source/Developer/DeveloperToolSettings/Classes/Settings/ProjectPackagingSettings.h:162

Scope: file

Source code excerpt:

	 *   {iniif:-iostore:bUseIoStore}
	 * Additionally, the ini settings can have an optional search and replace modifier, to easily modify the string. The Replace can be blank:
	 *   {inivalue:BuildConfiguration|PPBC_=} - This will get the BuildConfiguration from the settings, and then remove the PPBC_ enum prefix from the string, to just get say Development
	 */
	UPROPERTY(EditAnywhere, Category="Packaging")
	FString BuildCookRunParams;
};

/**
 * Implements the Editor's user settings.
 */
UCLASS(config=Game, defaultconfig)
class DEVELOPERTOOLSETTINGS_API UProjectPackagingSettings
	: public UObject
{
	GENERATED_UCLASS_BODY()

	
	/**

#Loc: <Workspace>/Engine/Source/Developer/DeveloperToolSettings/Classes/Settings/ProjectPackagingSettings.h:211

Scope (from outer to inner):

file
class        class UProjectPackagingSettings : public UObject

Source code excerpt:

	/** The build configuration for which the project is packaged. */
	UPROPERTY(config, EditAnywhere, Category=Project)
	EProjectPackagingBuildConfigurations BuildConfiguration;

	/** Name of the target to build */
	UPROPERTY(config, EditAnywhere, Category=Project)
	FString BuildTarget;

	/**

#Loc: <Workspace>/Engine/Source/Developer/DeveloperToolSettings/Private/ProjectPackagingSettings.cpp:104

Scope (from outer to inner):

file
function     void UProjectPackagingSettings::PostEditChangeProperty

Source code excerpt:

	else if (Name == FName(TEXT("ForDistribution")))
	{
		if (ForDistribution && BuildConfiguration != EProjectPackagingBuildConfigurations::PPBC_Shipping)
		{
			BuildConfiguration = EProjectPackagingBuildConfigurations::PPBC_Shipping;
			// force serialization for "Build COnfiguration"
			UpdateSinglePropertyInConfigFile(GetClass()->FindPropertyByName(GET_MEMBER_NAME_CHECKED(UProjectPackagingSettings, BuildConfiguration)), GetDefaultConfigFilename());
		}
	}
	else if (Name == FName(TEXT("bGenerateChunks")))
	{
		if (bGenerateChunks)
		{

#Loc: <Workspace>/Engine/Source/Developer/IOS/IOSTargetPlatform/Private/IOSTargetDevice.h:155

Scope (from outer to inner):

file
class        class FIOSTargetDevice : public ITargetDevice

Source code excerpt:


	/** Contains the build configuration of the app to deploy */
	EBuildConfiguration BuildConfiguration;

	/** Lets us know whether the thing is a sim device or a physical device. */
	bool bIsSimulated;

private:

#Loc: <Workspace>/Engine/Source/Developer/IOS/IOSTargetPlatform/Private/IOSTargetDevice.h:306

Scope (from outer to inner):

file
class        class FIOSTargetDevice : public ITargetDevice
function     void SetAppConfiguration

Source code excerpt:

	void SetAppConfiguration(EBuildConfiguration Configuration)
	{
		BuildConfiguration = Configuration;
	}

	void SetIsSimulated(bool IsSimulated)
	{
		bIsSimulated = IsSimulated;
	}

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:113

Scope (from outer to inner):

file
class        class FLauncherSimpleProfile final : public ILauncherSimpleProfile
function     virtual EBuildConfiguration GetBuildConfiguration

Source code excerpt:

	virtual EBuildConfiguration GetBuildConfiguration() const override
	{
		return BuildConfiguration;
	}

	virtual ELauncherProfileCookModes::Type GetCookMode() const override
	{
		return CookMode;
	}

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:136

Scope (from outer to inner):

file
class        class FLauncherSimpleProfile final : public ILauncherSimpleProfile
function     virtual void SetBuildConfiguration

Source code excerpt:

	virtual void SetBuildConfiguration(EBuildConfiguration InConfiguration) override
	{
		BuildConfiguration = InConfiguration;
	}

	virtual void SetCookMode(ELauncherProfileCookModes::Type InMode) override
	{
		CookMode = InMode;
	}

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:158

Scope (from outer to inner):

file
class        class FLauncherSimpleProfile final : public ILauncherSimpleProfile
function     virtual bool Serialize

Source code excerpt:

		Archive << DeviceName
			<< Variant
			<< BuildConfiguration
			<< CookMode;

		return true;
	}

	virtual void Save(TJsonWriter<>& Writer) override

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:172

Scope (from outer to inner):

file
class        class FLauncherSimpleProfile final : public ILauncherSimpleProfile
function     virtual void Save

Source code excerpt:

		Writer.WriteValue(TEXT("DeviceName"), DeviceName);
		Writer.WriteValue(TEXT("Variant"), Variant.ToString());
		Writer.WriteValue(TEXT("BuildConfiguration"), (int32)BuildConfiguration);
		Writer.WriteValue(TEXT("CookMode"), CookMode);
		Writer.WriteObjectEnd();
	}

	virtual bool Load(const FJsonObject& Object) override
	{

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:187

Scope (from outer to inner):

file
class        class FLauncherSimpleProfile final : public ILauncherSimpleProfile
function     virtual bool Load

Source code excerpt:

		DeviceName = Object.GetStringField(TEXT("DeviceName"));
		Variant = *(Object.GetStringField(TEXT("Variant")));
		BuildConfiguration = (EBuildConfiguration)((int32)Object.GetNumberField(TEXT("BuildConfiguration")));
		CookMode = (TEnumAsByte<ELauncherProfileCookModes::Type>)((int32)Object.GetNumberField(TEXT("CookMode")));

		return true;
	}

	virtual void SetDefaults() override

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:200

Scope (from outer to inner):

file
class        class FLauncherSimpleProfile final : public ILauncherSimpleProfile
function     virtual void SetDefaults

Source code excerpt:

		// I don't use FApp::GetBuildConfiguration() because i don't want the act of running in debug the first time to cause the simple
		// profiles created for your persistent devices to be in debug. The user might not see this if they don't expand the Advanced options.
		BuildConfiguration = EBuildConfiguration::Development;
		
		CookMode = ELauncherProfileCookModes::OnTheFly;
	}

private:

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:214

Scope (from outer to inner):

file
class        class FLauncherSimpleProfile final : public ILauncherSimpleProfile

Source code excerpt:


	// Holds the desired build configuration (only used if creating new builds).
	EBuildConfiguration BuildConfiguration;

	// Holds the cooking mode.
	TEnumAsByte<ELauncherProfileCookModes::Type> CookMode;
};

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:402

Scope (from outer to inner):

file
class        class FLauncherProfile final : public ILauncherProfile
function     virtual EBuildConfiguration GetBuildConfiguration

Source code excerpt:

	virtual EBuildConfiguration GetBuildConfiguration( ) const override
	{
		return BuildConfiguration;
	}

	virtual bool HasBuildTargetSpecified() const override
	{
		return BuildTargetSpecified;
	}

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:758

Scope (from outer to inner):

file
class        class FLauncherProfile final : public ILauncherProfile
function     virtual bool ShouldBuild

Source code excerpt:

					{
						FText Reason;
						if (TargetPlatform->RequiresTempTarget(false, BuildConfiguration, false, Reason))
						{
							UE_LOG(LogLauncherProfile, Log, TEXT("Project requires temp target (%s)"), *Reason.ToString());
							ReceiptDir = FPaths::GetPath(FPaths::GetProjectFilePath());
						}
						else
						{

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:778

Scope (from outer to inner):

file
class        class FLauncherProfile final : public ILauncherProfile
function     virtual bool ShouldBuild

Source code excerpt:

					// Check if the existing target is valid
					FString BuildPlatform = PlatformInfo.DataDrivenPlatformInfo->UBTPlatformString;
					if (!HasPromotedTarget(*ReceiptDir, *TargetName, *BuildPlatform, BuildConfiguration, nullptr))
					{
						bBuild = true;
						break;
					}
				}
			}

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:959

Scope: file

Source code excerpt:

				<< Name
				<< Description
				<< BuildConfiguration
				<< ProjectSpecified
				<< ShareableProjectPath
				<< CookConfiguration
				<< CookIncremental
				<< CookOptions
				<< CookMode

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:1167

Scope (from outer to inner):

file
class        class FLauncherProfile final : public ILauncherProfile
function     virtual void Save

Source code excerpt:

		Writer.WriteValue("Name", Name);
		Writer.WriteValue("Description", Description);
		Writer.WriteValue("BuildConfiguration", (int32)BuildConfiguration);
		Writer.WriteValue("ProjectSpecified", ProjectSpecified);
		Writer.WriteValue("ShareableProjectPath", ShareableProjectPath);
		Writer.WriteValue("CookConfiguration", (int32)CookConfiguration);
		Writer.WriteValue("CookIncremental", CookIncremental);
		Writer.WriteValue("CookOptions", CookOptions);
		Writer.WriteValue("CookMode", CookMode);

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:1292

Scope (from outer to inner):

file
class        class FLauncherProfile final : public ILauncherProfile
function     void SaveUATParams

Source code excerpt:

		// client configurations
		Writer.WriteArrayStart("clientconfig");
		Writer.WriteValue(LexToString(BuildConfiguration));
		Writer.WriteArrayEnd();

		// server configurations
		Writer.WriteArrayStart("serverconfig");
		Writer.WriteValue(LexToString(BuildConfiguration));
		Writer.WriteArrayEnd();

		// platforms
		TArray<FString> ServerPlatforms;
		TArray<FString> ClientPlatforms;
		FString OptionalParams;

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:1791

Scope (from outer to inner):

file
class        class FLauncherProfile final : public ILauncherProfile
function     virtual bool Load

Source code excerpt:

		Name = Object.GetStringField(TEXT("Name"));
		Description = Object.GetStringField(TEXT("Description"));
		BuildConfiguration = (EBuildConfiguration)((int32)Object.GetNumberField(TEXT("BuildConfiguration")));
		ProjectSpecified = Object.GetBoolField(TEXT("ProjectSpecified"));
		ShareableProjectPath = Object.GetStringField(TEXT("ShareableProjectPath"));
		CookConfiguration = (EBuildConfiguration)((int32)Object.GetNumberField(TEXT("CookConfiguration")));
		CookIncremental = Object.GetBoolField(TEXT("CookIncremental"));
		CookOptions = Object.GetStringField(TEXT("CookOptions"));
		CookMode = (TEnumAsByte<ELauncherProfileCookModes::Type>)((int32)Object.GetNumberField(TEXT("CookMode")));

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:2022

Scope (from outer to inner):

file
class        class FLauncherProfile final : public ILauncherProfile
function     virtual void SetDefaults

Source code excerpt:

		// I don't use FApp::GetBuildConfiguration() because i don't want the act of running in debug the first time to cause 
		// profiles the user creates to be in debug. This will keep consistency.
		BuildConfiguration = EBuildConfiguration::Development;

		FInternationalization& I18N = FInternationalization::Get();

		// default build settings
		BuildMode = ELauncherProfileBuildModes::Auto;
		BuildUAT = !FApp::GetEngineIsPromotedBuild() && !FApp::IsEngineInstalled();

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:2140

Scope (from outer to inner):

file
class        class FLauncherProfile final : public ILauncherProfile
function     virtual void SetBuildConfiguration

Source code excerpt:

	virtual void SetBuildConfiguration( EBuildConfiguration Configuration ) override
	{
		if (BuildConfiguration != Configuration)
		{
			BuildConfiguration = Configuration;

			Validate();
		}
	}

	virtual void SetBuildTargetSpecified(bool Specified) override

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:2683

Scope (from outer to inner):

file
class        class FLauncherProfile final : public ILauncherProfile
function     void Validate

Source code excerpt:


		// Build: a build configuration must be selected
		if (BuildConfiguration == EBuildConfiguration::Unknown)
		{
			ValidationErrors.Add(ELauncherProfileValidationErrors::NoBuildConfigurationSelected);
		}

		// Build: a project must be selected
		if (GetProjectPath().IsEmpty())

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:2799

Scope (from outer to inner):

file
class        class FLauncherProfile final : public ILauncherProfile
function     void Validate

Source code excerpt:

		if ((CookMode == ELauncherProfileCookModes::OnTheFly) || (CookMode == ELauncherProfileCookModes::OnTheFlyInEditor))
		{
			if (BuildConfiguration == EBuildConfiguration::Shipping)
			{
				// shipping doesn't support commandline options
				ValidationErrors.Add(ELauncherProfileValidationErrors::ShippingDoesntSupportCommandlineOptionsCantUseCookOnTheFly);
			}

		}

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:3061

Scope (from outer to inner):

file
class        class FLauncherProfile final : public ILauncherProfile

Source code excerpt:


	// Holds the desired build configuration (only used if creating new builds).
	EBuildConfiguration BuildConfiguration;

	// Holds a flag indicating whether the build target is specified by this profile.
	bool BuildTargetSpecified;

	// Holds the name of the target (matching a .cs file) to build. Needed when multiple targets of a type exist
	FString BuildTargetName;

#Loc: <Workspace>/Engine/Source/Editor/LevelEditor/Private/LevelEditor.cpp:136

Scope (from outer to inner):

file
class        class SProjectBadge : public SBox
function     void Construct

Source code excerpt:

		TooltipArgs.Add(TEXT("Version"), FText::FromString(TooltipVersionStr));
		TooltipArgs.Add(TEXT("Branch"), FText::FromString(FEngineVersion::Current().GetBranch()));
		TooltipArgs.Add(TEXT("BuildConfiguration"), EBuildConfigurations::ToText(BuildConfig));
		TooltipArgs.Add(TEXT("BuildDate"), FText::FromString(FApp::GetBuildDate()));
		TooltipArgs.Add(TEXT("GraphicsRHI"), FText::FromString(FApp::GetGraphicsRHI()));

		RightContentTooltip = FText::Format(NSLOCTEXT("UnrealEditor", "TitleBarRightContentTooltip", "Version: {Version}\nBranch: {Branch}\nBuild Configuration: {BuildConfiguration}\nBuild Date: {BuildDate}\nGraphics RHI: {GraphicsRHI}"), TooltipArgs);

		SetToolTipText(RightContentTooltip);

#Loc: <Workspace>/Engine/Source/Editor/TurnkeySupport/Private/TurnkeySupportModule.cpp:139

Scope (from outer to inner):

file
class        class FTurnkeySupportCallbacks
function     static bool ShouldBuildProject

Source code excerpt:

	static bool ShouldBuildProject(const UProjectPackagingSettings* PackagingSettings, const ITargetPlatform* TargetPlatform)
	{
		const UProjectPackagingSettings::FConfigurationInfo& ConfigurationInfo = UProjectPackagingSettings::ConfigurationInfo[(int)PackagingSettings->BuildConfiguration];

		// Get the target to build
		const FTargetInfo* Target = PackagingSettings->GetBuildTargetInfo();

		// Only build if the user elects to do so
		bool bBuild = false;

#Loc: <Workspace>/Engine/Source/Editor/TurnkeySupport/Private/TurnkeySupportModule.cpp:486

Scope (from outer to inner):

file
class        class FTurnkeySupportCallbacks
function     static void CookOrPackage

Source code excerpt:

			if (BuildConfig == EProjectPackagingBuildConfigurations::PPBC_MAX)
			{
				BuildConfig = PackagingSettings->BuildConfiguration;
			}

			// when distribution is set, always package in shipping, which overrides the per platform build config
			if (PackagingSettings->ForDistribution)
			{
				BuildConfig = EProjectPackagingBuildConfigurations::PPBC_Shipping;

#Loc: <Workspace>/Engine/Source/Editor/TurnkeySupport/Private/TurnkeySupportModule.cpp:621

Scope (from outer to inner):

file
class        class FTurnkeySupportCallbacks
function     static FString GetCustomBuildCommandLine

Source code excerpt:

			if (BuildConfig == EProjectPackagingBuildConfigurations::PPBC_MAX)
			{
				BuildConfig = PlatformPackagingSettings->BuildConfiguration;
			}
			const UProjectPackagingSettings::FConfigurationInfo& ConfigurationInfo = UProjectPackagingSettings::ConfigurationInfo[(int)BuildConfig];
			CommandLine.Appendf(TEXT(" -overrideconfiguration=%s"), LexToString(ConfigurationInfo.Configuration));


			// get the chosen cook flavor (texture format, etc)

#Loc: <Workspace>/Engine/Source/Editor/TurnkeySupport/Private/TurnkeySupportModule.cpp:707

Scope (from outer to inner):

file
class        class FTurnkeySupportCallbacks
function     static void SetPackageBuildConfiguration

Source code excerpt:

	}

	static void SetPackageBuildConfiguration(const PlatformInfo::FTargetPlatformInfo* Info, EProjectPackagingBuildConfigurations BuildConfiguration)
	{
		UPlatformsMenuSettings* PlatformsSettings = GetMutableDefault<UPlatformsMenuSettings>();
		PlatformsSettings->SetBuildConfigurationForPlatform(Info->IniPlatformName, BuildConfiguration);
		PlatformsSettings->SaveConfig();
	}

	static bool PackageBuildConfigurationIsChecked(const PlatformInfo::FTargetPlatformInfo* Info, EProjectPackagingBuildConfigurations BuildConfiguration)
	{
		return GetDefault<UPlatformsMenuSettings>()->GetBuildConfigurationForPlatform(Info->IniPlatformName) == BuildConfiguration;
	}	
	
	static void SetActiveFlavor(const PlatformInfo::FTargetPlatformInfo* Info)
	{
		UPlatformsMenuSettings* PlatformsSettings = GetMutableDefault<UPlatformsMenuSettings>();
		PlatformsSettings->SetTargetFlavorForPlatform(Info->IniPlatformName, Info->Name);

#Loc: <Workspace>/Engine/Source/Editor/TurnkeySupport/Private/TurnkeySupportModule.cpp:1265

Scope (from outer to inner):

file
function     static void MakeTurnkeyPlatformMenu

Source code excerpt:

		if (BuildConfig == EProjectPackagingBuildConfigurations::PPBC_MAX)
		{
			BuildConfig = PackagingSettings->BuildConfiguration;
		}

		const UProjectPackagingSettings::FConfigurationInfo& ConfigInfo = UProjectPackagingSettings::ConfigurationInfo[static_cast<int32>(BuildConfig)];
		ConfigSection.AddMenuEntry(
			NAME_None,
			FText::Format(LOCTEXT("DefaultConfiguration",  "Use Project Setting ({0})"), ConfigInfo.Name),

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/PlayLevelViaLauncher.cpp:139

Scope (from outer to inner):

file
function     void UEditorEngine::StartPlayUsingLauncherSession

Source code excerpt:


	// set the build/launch configuration 
	EBuildConfiguration BuildConfiguration = EBuildConfiguration::Development;
	const ULevelEditorPlaySettings* EditorPlaySettings = PlaySessionRequest->EditorPlaySettings;
	switch (EditorPlaySettings->LaunchConfiguration)
	{
	case LaunchConfig_Debug:
		BuildConfiguration = EBuildConfiguration::Debug;
		break;
	case LaunchConfig_Development:
		BuildConfiguration = EBuildConfiguration::Development;
		break;
	case LaunchConfig_Test:
		BuildConfiguration = EBuildConfiguration::Test;
		break;
	case LaunchConfig_Shipping:
		BuildConfiguration = EBuildConfiguration::Shipping;
		break;
	default:
	{
		const UProjectPackagingSettings* AllPlatformPackagingSettings = GetDefault<UProjectPackagingSettings>();
		const UPlatformsMenuSettings* PlatformsSettings = GetDefault<UPlatformsMenuSettings>();

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/PlayLevelViaLauncher.cpp:164

Scope (from outer to inner):

file
function     void UEditorEngine::StartPlayUsingLauncherSession

Source code excerpt:

		if (BuildConfig == EProjectPackagingBuildConfigurations::PPBC_MAX)
		{
			BuildConfig = AllPlatformPackagingSettings->BuildConfiguration;
		}

		switch (BuildConfig)
		{
		case EProjectPackagingBuildConfigurations::PPBC_Debug:
		case EProjectPackagingBuildConfigurations::PPBC_DebugGame:
			BuildConfiguration = EBuildConfiguration::Debug;
			break;
		case EProjectPackagingBuildConfigurations::PPBC_Development:
			BuildConfiguration = EBuildConfiguration::Development;
			break;
		case EProjectPackagingBuildConfigurations::PPBC_Test:
			BuildConfiguration = EBuildConfiguration::Test;
			break;
		case EProjectPackagingBuildConfigurations::PPBC_Shipping:
			BuildConfiguration = EBuildConfiguration::Shipping;
			break;
		}

		break;
	}
	}

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/PlayLevelViaLauncher.cpp:213

Scope (from outer to inner):

file
function     void UEditorEngine::StartPlayUsingLauncherSession

Source code excerpt:

	ILauncherProfileRef LauncherProfile = LauncherServicesModule.CreateProfile(TEXT("Launch On Device"));
	LauncherProfile->SetBuildMode(BuildMode);
	LauncherProfile->SetBuildConfiguration(BuildConfiguration);
	if (InRequestParams.EditorPlaySettings && !InRequestParams.EditorPlaySettings->AdditionalLaunchParameters.IsEmpty())
	{
		LauncherProfile->SetAdditionalCommandLineParameters(InRequestParams.EditorPlaySettings->AdditionalLaunchParameters);
	}

	LauncherProfile->AddCookedPlatform(LaunchPlatformName);

#Loc: <Workspace>/Engine/Source/Programs/CrashReportClient/Private/CrashReportClientApp.cpp:908

Scope (from outer to inner):

file
function     static bool LoadTempCrashContextFromFile

Source code excerpt:

	FindAndCopyValue(ContextProperties, TEXT("GameName"), SessionContext.GameName);
	FindAndCopyValue(ContextProperties, TEXT("ExecutableName"), SessionContext.ExecutableName);
	FindAndCopyValue(ContextProperties, TEXT("BuildConfiguration"), SessionContext.BuildConfigurationName);
	FindAndCopyValue(ContextProperties, TEXT("GameSessionID"), SessionContext.GameSessionID);
	FindAndCopyValue(ContextProperties, TEXT("PlatformName"), SessionContext.PlatformName);
	FindAndCopyValue(ContextProperties, TEXT("PlatformNameIni"), SessionContext.PlatformNameIni);
	FindAndCopyValue(ContextProperties, TEXT("EngineMode"), SessionContext.EngineMode);
	FindAndCopyValue(ContextProperties, TEXT("EngineModeEx"), SessionContext.EngineModeEx);
	FindAndCopyValue(ContextProperties, TEXT("DeploymentName"), SessionContext.DeploymentName);

#Loc: <Workspace>/Engine/Source/Programs/SwitchboardListener/SblSlate/Private/SblMainWindow.cpp:70

Scope (from outer to inner):

file
class        class SSblWindow : public SWindow
function     void Construct

Source code excerpt:

		TooltipArgs.Add(TEXT("EngineVersion"), FText::FromString(EngineVersionTooltipString));
		TooltipArgs.Add(TEXT("Branch"), FText::FromString(FEngineVersion::Current().GetBranch()));
		TooltipArgs.Add(TEXT("BuildConfiguration"), EBuildConfigurations::ToText(BuildConfig));
		TooltipArgs.Add(TEXT("BuildDate"), FText::FromString(FApp::GetBuildDate()));

		const FText TitleToolTip = FText::Format(
			LOCTEXT("TitleBarTooltip", "Switchboard Listener Version: {AppVersion}\nEngine Version: {EngineVersion}\nBranch: {Branch}\nBuild Configuration: {BuildConfiguration}\nBuild Date: {BuildDate}"), TooltipArgs);

		AddOverlaySlot()

#Loc: <Workspace>/Engine/Source/Runtime/AutomationWorker/Private/AutomationAnalyticParams.h:25

Scope (from outer to inner):

file
namespace    EAutomationAnalyticParam

Source code excerpt:

		CL,
		FPS,
		BuildConfiguration,
		AverageFrameTime,
		AverageGameThreadTime,
		AverageRenderThreadTime,
		AverageGPUTime,
		PercentOfFramesAtLeast30FPS,
		PercentOfFramesAtLeast60FPS,

#Loc: <Workspace>/Engine/Source/Runtime/AutomationWorker/Private/AutomationAnalytics.cpp:116

Scope (from outer to inner):

file
function     void FAutomationAnalytics::InititalizeAnalyticParameterNames

Source code excerpt:

	AutomationParamNames[EAutomationAnalyticParam::CL] = TEXT("CL");
	AutomationParamNames[EAutomationAnalyticParam::FPS] = TEXT("FPS");
	AutomationParamNames[EAutomationAnalyticParam::BuildConfiguration] = TEXT("BuildConfiguration");
	AutomationParamNames[EAutomationAnalyticParam::AverageFrameTime] = TEXT("AverageFrameTime");
	AutomationParamNames[EAutomationAnalyticParam::AverageGameThreadTime] = TEXT("AverageGameThreadTime");
	AutomationParamNames[EAutomationAnalyticParam::AverageRenderThreadTime] = TEXT("AverageRenderThreadTime");
	AutomationParamNames[EAutomationAnalyticParam::AverageGPUTime] = TEXT("AverageGPUTime");
	AutomationParamNames[EAutomationAnalyticParam::PercentOfFramesAtLeast30FPS] = TEXT("PercentOfFramesAtLeast30FPS");
	AutomationParamNames[EAutomationAnalyticParam::PercentOfFramesAtLeast60FPS] = TEXT("PercentOfFramesAtLeast60FPS");

#Loc: <Workspace>/Engine/Source/Runtime/AutomationWorker/Private/AutomationAnalytics.cpp:169

Scope (from outer to inner):

file
function     void FAutomationAnalytics::FireEvent_FPSCapture

Source code excerpt:

	// @EventParam MapName string The map that the test was run on
	// @EventParam FPS string 
	// @EventParam BuildConfiguration string Debug/Development/Test/Shipping
	// @EventParam AverageFrameTime string Time for a frame in ms
	// @EventParam AverageGameThreadTime string Time for the game thread in ms
	// @EventParam AverageRenderThreadTime string Time for the rendering thread in ms
	// @EventParam AverageGPUTime string Time for the GPU to flush in ms
	// @EventParam PercentOfFramesAtLeast30FPS string 
	// @EventParam PercentOfFramesAtLeast60FPS string

#Loc: <Workspace>/Engine/Source/Runtime/AutomationWorker/Private/AutomationAnalytics.cpp:188

Scope (from outer to inner):

file
function     void FAutomationAnalytics::FireEvent_FPSCapture

Source code excerpt:

		ParamArray.Add(FAnalyticsEventAttribute(GetAutomationParamName(EAutomationAnalyticParam::FPS), PerfSnapshot.AverageFPS));

		ParamArray.Add(FAnalyticsEventAttribute(GetAutomationParamName(EAutomationAnalyticParam::BuildConfiguration), PerfSnapshot.BuildConfiguration));
		ParamArray.Add(FAnalyticsEventAttribute(GetAutomationParamName(EAutomationAnalyticParam::AverageFrameTime), PerfSnapshot.AverageFrameTime));
		ParamArray.Add(FAnalyticsEventAttribute(GetAutomationParamName(EAutomationAnalyticParam::AverageGameThreadTime), PerfSnapshot.AverageGameThreadTime));
		ParamArray.Add(FAnalyticsEventAttribute(GetAutomationParamName(EAutomationAnalyticParam::AverageRenderThreadTime), PerfSnapshot.AverageRenderThreadTime));
		ParamArray.Add(FAnalyticsEventAttribute(GetAutomationParamName(EAutomationAnalyticParam::AverageGPUTime), PerfSnapshot.AverageGPUTime));
		ParamArray.Add(FAnalyticsEventAttribute(GetAutomationParamName(EAutomationAnalyticParam::PercentOfFramesAtLeast30FPS), PerfSnapshot.PercentOfFramesAtLeast30FPS));
		ParamArray.Add(FAnalyticsEventAttribute(GetAutomationParamName(EAutomationAnalyticParam::PercentOfFramesAtLeast60FPS), PerfSnapshot.PercentOfFramesAtLeast60FPS));

#Loc: <Workspace>/Engine/Source/Runtime/AutomationWorker/Public/IAutomationWorkerModule.h:12

Scope: file

Source code excerpt:

{
	FString Changelist;
	FString BuildConfiguration;
	FString MapName;
	FString SequenceName;
	FString AverageFPS;
	FString AverageFrameTime;
	FString AverageGameThreadTime;
	FString AverageRenderThreadTime;

#Loc: <Workspace>/Engine/Source/Runtime/AutomationWorker/Public/IAutomationWorkerModule.h:29

Scope: file

Source code excerpt:

		return
			Changelist + TEXT( "," ) +
			BuildConfiguration + TEXT( "," ) +
			MapName + TEXT( "," ) +
			SequenceName + TEXT( "," ) +
			AverageFPS + TEXT( "," ) +
			AverageFrameTime + TEXT( "," ) +
			AverageGameThreadTime + TEXT( "," ) +
			AverageRenderThreadTime + TEXT( "," ) +

#Loc: <Workspace>/Engine/Source/Runtime/AutomationWorker/Public/IAutomationWorkerModule.h:50

Scope (from outer to inner):

file
function     void FromCommaDelimitedString

Source code excerpt:

		int32 NextValue = 0;
		Changelist = Values[ NextValue++ ];
		BuildConfiguration = Values[ NextValue++ ];
		MapName = Values[ NextValue++ ];
		SequenceName = Values[ NextValue++ ];
		AverageFPS = Values[ NextValue++ ];
		AverageFrameTime = Values[ NextValue++ ];
		AverageGameThreadTime = Values[ NextValue++ ];
		AverageRenderThreadTime = Values[ NextValue++ ];

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/GenericPlatform/GenericPlatformCrashContext.cpp:922

Scope (from outer to inner):

file
function     void FGenericCrashContext::SerializeSessionContext

Source code excerpt:

	}
	AddCrashPropertyInternal(Buffer, TEXT("ExecutableName"), NCached::Session.ExecutableName);
	AddCrashPropertyInternal(Buffer, TEXT("BuildConfiguration"), NCached::Session.BuildConfigurationName);
	AddCrashPropertyInternal(Buffer, TEXT("GameSessionID"), NCached::Session.GameSessionID);

	AddCrashPropertyInternal(Buffer, TEXT("PlatformName"), NCached::Session.PlatformName);
	AddCrashPropertyInternal(Buffer, TEXT("PlatformFullName"), NCached::Session.PlatformName);
	AddCrashPropertyInternal(Buffer, TEXT("PlatformNameIni"), NCached::Session.PlatformNameIni);
	AddCrashPropertyInternal(Buffer, TEXT("EngineMode"), NCached::Session.EngineMode);

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/GenericPlatform/GenericPlatformProcess.cpp:203

Scope (from outer to inner):

file
function     FString FGenericPlatformProcess::GenerateApplicationPath

Source code excerpt:

}

FString FGenericPlatformProcess::GenerateApplicationPath( const FString& AppName, EBuildConfiguration BuildConfiguration)
{
	UE_LOG(LogHAL, Fatal, TEXT("FGenericPlatformProcess::GenerateApplicationPath not implemented on this platform"));
	return FString();
}

const TCHAR* FGenericPlatformProcess::GetModulePrefix()

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/IOS/IOSPlatformProcess.cpp:146

Scope (from outer to inner):

file
function     FString FIOSPlatformProcess::GenerateApplicationPath

Source code excerpt:

}

FString FIOSPlatformProcess::GenerateApplicationPath( const FString& AppName, EBuildConfiguration BuildConfiguration)
{
    SCOPED_AUTORELEASE_POOL;
    
    FString PlatformName = TEXT("IOS");
    FString ExecutableName = AppName;
    if (BuildConfiguration != EBuildConfiguration::Development && BuildConfiguration != EBuildConfiguration::DebugGame)
    {
        ExecutableName += FString::Printf(TEXT("-%s-%s"), *PlatformName, LexToString(BuildConfiguration));
    }
    
    NSURL* CurrentBundleURL = [[NSBundle mainBundle] bundleURL];
    NSString* CurrentBundleName = [[CurrentBundleURL lastPathComponent] stringByDeletingPathExtension];
    if(FString(CurrentBundleName) == ExecutableName)
    {

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Mac/MacPlatformProcess.cpp:93

Scope (from outer to inner):

file
function     FString FMacPlatformProcess::GenerateApplicationPath

Source code excerpt:

}

FString FMacPlatformProcess::GenerateApplicationPath( const FString& AppName, EBuildConfiguration BuildConfiguration)
{
	SCOPED_AUTORELEASE_POOL;
	
	FString PlatformName = TEXT("Mac");
	FString ExecutableName = AppName;
	if (BuildConfiguration != EBuildConfiguration::Development)
	{
		ExecutableName += FString::Printf(TEXT("-%s-%s"), *PlatformName, LexToString(BuildConfiguration));
	}

	NSURL* CurrentBundleURL = [[NSBundle mainBundle] bundleURL];
	NSString* CurrentBundleName = [[CurrentBundleURL lastPathComponent] stringByDeletingPathExtension];
	if (FString(CurrentBundleName) == ExecutableName)
	{

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Unix/UnixPlatformProcess.cpp:434

Scope (from outer to inner):

file
function     FString FUnixPlatformProcess::GenerateApplicationPath

Source code excerpt:



FString FUnixPlatformProcess::GenerateApplicationPath( const FString& AppName, EBuildConfiguration BuildConfiguration)
{
	FString PlatformName = FPlatformProcess::GetBinariesSubdirectory();
	FString ExecutablePath = FPaths::EngineDir() / FString::Printf(TEXT("Binaries/%s/%s"), *PlatformName, *AppName);
	
	if (BuildConfiguration != EBuildConfiguration::Development)
	{
		ExecutablePath += FString::Printf(TEXT("-%s-%s"), *PlatformName, LexToString(BuildConfiguration));
	}
	return ExecutablePath;
}


FString FUnixPlatformProcess::GetApplicationName( uint32 ProcessId )

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Windows/WindowsPlatformProcess.cpp:175

Scope (from outer to inner):

file
function     FString FWindowsPlatformProcess::GenerateApplicationPath

Source code excerpt:

}

FString FWindowsPlatformProcess::GenerateApplicationPath( const FString& AppName, EBuildConfiguration BuildConfiguration)
{
	FString PlatformName = GetBinariesSubdirectory();
	FString ExecutablePath = FPaths::EngineDir() / FString::Printf(TEXT("Binaries/%s/%s"), *PlatformName, *AppName);
	FPaths::MakePlatformFilename(ExecutablePath);

	if (BuildConfiguration != EBuildConfiguration::Development)
	{
		ExecutablePath += FString::Printf(TEXT("-%s-%s"), *PlatformName, LexToString(BuildConfiguration));
	}

	ExecutablePath += TEXT(".exe");

	return ExecutablePath;
}

#Loc: <Workspace>/Engine/Source/Runtime/Core/Public/GenericPlatform/GenericPlatformProcess.h:376

Scope: file

Source code excerpt:

	 *
	 * @param AppName The name of the application or game.
	 * @param BuildConfiguration The build configuration of the game.
	 * @return The generated application path.
	 */
	static CORE_API FString GenerateApplicationPath( const FString& AppName, EBuildConfiguration BuildConfiguration);

	/**
	 * Return the prefix of dynamic library (e.g. lib)
	 *
	 * @return The prefix string.
	 * @see GetModuleExtension, GetModulesDirectory
	 */
	static CORE_API const TCHAR* GetModulePrefix();

	/**
	 * Return the extension of dynamic library
	 *
	 * @return Extension of dynamic library.

#Loc: <Workspace>/Engine/Source/Runtime/Core/Public/IOS/IOSPlatformProcess.h:40

Scope: file

Source code excerpt:

	static const TCHAR* ExecutablePath();
	static const TCHAR* ExecutableName(bool bRemoveExtension = true);
    static FString GenerateApplicationPath( const FString& AppName, EBuildConfiguration BuildConfiguration);

private:
	static void SetupThread(int Priority);
};

typedef FIOSPlatformProcess FPlatformProcess;

#Loc: <Workspace>/Engine/Source/Runtime/Core/Public/Mac/MacPlatformProcess.h:231

Scope: file

Source code excerpt:

	static const TCHAR* ExecutablePath();
	static const TCHAR* ExecutableName(bool bRemoveExtension = true);
	static FString GenerateApplicationPath( const FString& AppName, EBuildConfiguration BuildConfiguration);
	static const TCHAR* GetModuleExtension();
	static const TCHAR* GetBinariesSubdirectory();
	static const FString GetModulesDirectory();
	static bool CanLaunchURL(const TCHAR* URL);
	static void LaunchURL(const TCHAR* URL, const TCHAR* Parms, FString* Error);
	static FString GetGameBundleId();

#Loc: <Workspace>/Engine/Source/Runtime/Core/Public/Unix/UnixPlatformProcess.h:276

Scope: file

Source code excerpt:

	static CORE_API void SetCurrentWorkingDirectoryToBaseDir();
	static CORE_API FString GetCurrentWorkingDirectory();
	static CORE_API FString GenerateApplicationPath(const FString& AppName, EBuildConfiguration BuildConfiguration);
	static CORE_API FString GetApplicationName( uint32 ProcessId );
	static CORE_API bool SetProcessLimits(EProcessResource::Type Resource, uint64 Limit);
	static CORE_API const TCHAR* ExecutablePath();
	static CORE_API const TCHAR* ExecutableName(bool bRemoveExtension = true);
	static CORE_API const TCHAR* GetModulePrefix();
	static CORE_API const TCHAR* GetModuleExtension();

#Loc: <Workspace>/Engine/Source/Runtime/Core/Public/Windows/WindowsPlatformProcess.h:150

Scope: file

Source code excerpt:

	static CORE_API const TCHAR* ExecutablePath();
	static CORE_API const TCHAR* ExecutableName(bool bRemoveExtension = true);
	static CORE_API FString GenerateApplicationPath( const FString& AppName, EBuildConfiguration BuildConfiguration);
	static CORE_API const TCHAR* GetModuleExtension();
	static CORE_API const TCHAR* GetBinariesSubdirectory();
	static CORE_API const FString GetModulesDirectory();
	static CORE_API bool CanLaunchURL(const TCHAR* URL);
	static CORE_API void LaunchURL( const TCHAR* URL, const TCHAR* Parms, FString* Error );
	static CORE_API FProcHandle CreateProc( const TCHAR* URL, const TCHAR* Parms, bool bLaunchDetached, bool bLaunchHidden, bool bLaunchReallyHidden, uint32* OutProcessID, int32 PriorityModifier, const TCHAR* OptionalWorkingDirectory, void* PipeWriteChild, void* PipeReadChild = nullptr);

#Loc: <Workspace>/Engine/Source/Runtime/CrashReportCore/Public/CrashDescription.h:31

Scope: file

Source code excerpt:

	"GameName"
	"ExecutableName"
	"BuildConfiguration"
	"PlatformName"
	"PlatformNameIni"
	"PlatformFullName"
	"EngineMode"
	"EngineModeEx"
	"EngineVersion"
	"BuildVersion"
	"CommandLine"
	"LanguageLCID"
	"AppDefaultLocale"
	"IsUERelease"
	"UserName"
	"BaseDir"
	"RootDir"
	"MachineId"
	"LoginId"
	"EpicAccountId"
	"CallStack"
	"SourceContext"
	"UserDescription"
	"UserActivityHint"
	"ErrorMessage"
	"CrashDumpMode"
	"CrashReporterMessage"
	"Misc.NumberOfCores"
	"Misc.NumberOfCoresIncludingHyperthreads"
	"Misc.Is64bitOperatingSystem"
	"Misc.CPUVendor"
	"Misc.CPUBrand"
	"Misc.PrimaryGPUBrand"
	"Misc.OSVersionMajor"
	"Misc.OSVersionMinor"
	"Misc.AppDiskTotalNumberOfBytes"
	"Misc.AppDiskNumberOfFreeBytes"
	"MemoryStats.TotalPhysical"
	"MemoryStats.TotalVirtual"
	"MemoryStats.PageSize"
	"MemoryStats.TotalPhysicalGB"
	"MemoryStats.AvailablePhysical"
	"MemoryStats.AvailableVirtual"
	"MemoryStats.UsedPhysical"
	"MemoryStats.PeakUsedPhysical"
	"MemoryStats.UsedVirtual"
	"MemoryStats.PeakUsedVirtual"
	"MemoryStats.bIsOOM"
	"MemoryStats.OOMAllocationSize"
	"MemoryStats.OOMAllocationAlignment"
	"TimeofCrash"
	"bAllowToBeContacted"
 */

inline void LexFromString( ECrashDescVersions& OutValue, const TCHAR* Buffer )
{
	OutValue = (ECrashDescVersions)FCString::Atoi( Buffer );
}

inline void LexFromString( ECrashDumpMode& OutValue, const TCHAR* Buffer )
{
	OutValue = (ECrashDumpMode)FCString::Atoi( Buffer );
}

inline void LexFromString( FEngineVersion& OutValue, const TCHAR* Buffer )
{
	FEngineVersion::Parse( Buffer, OutValue );
}

/** Simple crash property. Only for string values. */

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/GameEngine.cpp:513

Scope: file

Source code excerpt:

	Args.Add( TEXT("PlatformArchitecture"), PlatformBits );
	Args.Add( TEXT("RHIName"), FText::FromName( LegacyShaderPlatformToShaderFormat( GMaxRHIShaderPlatform ) ) );
	Args.Add( TEXT("BuildConfiguration"), FText::FromString(LexToString(FApp::GetBuildConfiguration()) ) );

	/************************************************************************/
	/************************ Add device name to window title****************/
	/************************************************************************/
	const FText WindowTitleVar = FText::Format( FText::FromString(TEXT("{0} {1} {2}")), WindowTitleComponent, WindowDebugInfoComponent, FGlobalTabmanager::Get()->GetApplicationTitle() );
	const FText WindowTitle = FText::Format(WindowTitleVar, Args);

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/UnrealEngine.cpp:11670

Scope (from outer to inner):

file
function     void UEngine::LogPerformanceCapture

Source code excerpt:

		FAutomationPerformanceSnapshot PerfSnapshot;
		PerfSnapshot.Changelist = FString::FromInt(ChangeList);
		PerfSnapshot.BuildConfiguration = LexToString(FApp::GetBuildConfiguration());
		PerfSnapshot.MapName = MapName;
		PerfSnapshot.SequenceName = SequenceName;
		PerfSnapshot.AverageFPS = FString::Printf(TEXT("%0.2f"), GAverageFPS);
		PerfSnapshot.AverageFrameTime = FString::Printf(TEXT("%0.2f"), StatUnitData->FrameTime);
		PerfSnapshot.AverageGameThreadTime = FString::Printf(TEXT("%0.2f"), StatUnitData->GameThreadTime);
		PerfSnapshot.AverageRenderThreadTime = FString::Printf(TEXT("%0.2f"), StatUnitData->RenderThreadTime);

#Loc: <Workspace>/Engine/Source/Runtime/EngineSettings/Classes/GeneralProjectSettings.h:59

Scope (from outer to inner):

file
class        class UGeneralProjectSettings : public UObject

Source code excerpt:

	FString SupportContact;

	/** The project's title as displayed on the window title bar (can include the tokens {GameName}, {PlatformArchitecture}, {BuildConfiguration} or {RHIName}, which will be replaced with the specified text) */
	UPROPERTY(config, EditAnywhere, Category=Displayed)
	FText ProjectDisplayedTitle;

	/** Additional data to be displayed on the window title bar in non-shipping configurations (can include the tokens {GameName}, {PlatformArchitecture}, {BuildConfiguration} or {RHIName}, which will be replaced with the specified text) */
	UPROPERTY(config, EditAnywhere, Category=Displayed)
	FText ProjectDebugTitleInfo;

	/** Should the game's window preserve its aspect ratio when resized by user. */
	UPROPERTY(config, EditAnywhere, Category = Settings)
	bool bShouldWindowPreserveAspectRatio;

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/DumpGPU.cpp:2193

Scope (from outer to inner):

file
function     void FRDGResourceDumpContext::Start

Source code excerpt:

		const TCHAR* BuildVersion = BuildSettings::GetBuildVersion();

		FString BuildConfiguration = LexToString(FApp::GetBuildConfiguration());
		FString BuildTarget = LexToString(FApp::GetBuildTargetType());

		FString OSLabel, OSVersion;
		FPlatformMisc::GetOSVersions(OSLabel, OSVersion);
		if (!OSVersion.IsEmpty())
		{

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/DumpGPU.cpp:2214

Scope (from outer to inner):

file
function     void FRDGResourceDumpContext::Start

Source code excerpt:

		JsonObject->SetStringField(TEXT("BuildVersion"), BuildVersion ? BuildVersion : TEXT(""));
		JsonObject->SetStringField(TEXT("BuildTarget"), BuildTarget);
		JsonObject->SetStringField(TEXT("BuildConfiguration"), BuildConfiguration);
		JsonObject->SetNumberField(TEXT("Build64Bits"), (PLATFORM_64BITS ? 1 : 0));
		JsonObject->SetStringField(TEXT("Platform"), FPlatformProperties::IniPlatformName());
		JsonObject->SetStringField(TEXT("OS"), OSLabel);
		JsonObject->SetStringField(TEXT("DeviceName"), FPlatformProcess::ComputerName());
		JsonObject->SetStringField(TEXT("CPUVendor"), FPlatformMisc::GetCPUVendor());
		JsonObject->SetStringField(TEXT("CPUBrand"), FPlatformMisc::GetCPUBrand());