EnabledPlugins

EnabledPlugins

#Overview

name: EnabledPlugins

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

It is referenced in 35 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of EnabledPlugins is to manage and track the list of plugins that are currently enabled in an Unreal Engine project. This variable is crucial for various subsystems and modules within the engine to determine which plugins are active and should be loaded or considered during different operations.

Several Unreal Engine subsystems and modules rely on this setting variable, including:

  1. Asset Registry
  2. Plugin Manager
  3. Game Features Subsystem
  4. Cook On The Fly Server
  5. Crash Reporting System
  6. Blueprint System

The value of this variable is typically set by the Plugin Manager during the engine’s initialization process. It’s populated based on various sources such as command-line arguments, project settings, and engine configuration files.

EnabledPlugins often interacts with other variables like DisabledPlugins, ConfiguredPluginNames, and AllPlugins. These variables work together to manage the plugin ecosystem within the engine.

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

  1. Modifying the list of enabled plugins at runtime can have significant impacts on the engine’s behavior.
  2. Some plugins may have dependencies on others, which the Plugin Manager handles automatically.
  3. Enabling or disabling certain plugins may affect performance, available features, or even project compatibility.

Best practices when using this variable include:

  1. Avoid directly modifying the EnabledPlugins list; instead, use the proper Plugin Manager APIs to enable or disable plugins.
  2. When developing new systems that need to be aware of active plugins, query the Plugin Manager rather than accessing EnabledPlugins directly.
  3. Be cautious when enabling plugins via command-line arguments, as this can override project settings and potentially cause conflicts.
  4. Always test thoroughly after changing the enabled plugins list, as it can have wide-ranging effects on the project.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Config/IOS/BaseIOSEngine.ini:90, section: [Plugins]

#References in C++ code

#Callsites

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

#Loc: <Workspace>/Engine/Plugins/Editor/AssetReferenceRestrictions/Source/AssetReferenceRestrictions/Private/AssetReferencingDomains.cpp:243

Scope (from outer to inner):

file
function     void FDomainDatabase::RebuildFromScratch

Source code excerpt:

	// Create the domains for plugins that contain content
	DomainsDefinedByPlugins.Reset();
	TArray<TSharedRef<IPlugin>> EnabledPlugins = IPluginManager::Get().GetEnabledPlugins();
	for (const TSharedRef<IPlugin>& Plugin : EnabledPlugins)
	{
		// Temporary until NoGameFeatureContent is removed. Don't add dependencies for GFPs that have no content
		// other than the GameFeatureData
		bool bNoGameFeatureContent = false;
		Plugin->GetDescriptorJson()->TryGetBoolField(TEXT("NoGameFeatureContent"), bNoGameFeatureContent);

#Loc: <Workspace>/Engine/Plugins/Editor/PluginBrowser/Source/PluginBrowser/Private/SPluginTile.cpp:592

Scope (from outer to inner):

file
function     void SPluginTile::OnEnablePluginCheckboxChanged

Source code excerpt:

	{
		// Get all the plugins we know about
		TArray<TSharedRef<IPlugin>> EnabledPlugins = IPluginManager::Get().GetEnabledPlugins();

		// Build a map of plugin by name
		TMap<FString, IPlugin*> NameToPlugin;
		for (TSharedRef<IPlugin>& EnabledPlugin : EnabledPlugins)
		{
			NameToPlugin.FindOrAdd(EnabledPlugin->GetName()) = &(EnabledPlugin.Get());
		}

		// Find all the plugins which are dependent on this plugin
		TArray<FString> DependentPluginNames;
		for (TSharedRef<IPlugin>& EnabledPlugin : EnabledPlugins)
		{
			FString EnabledPluginName = EnabledPlugin->GetName();

			TSet<FString> Dependencies;
			FindPluginDependencies(EnabledPluginName, Dependencies, NameToPlugin);

#Loc: <Workspace>/Engine/Plugins/Runtime/GameFeatures/Source/GameFeatures/Private/GameFeaturesSubsystem.cpp:1919

Scope (from outer to inner):

file
function     void UGameFeaturesSubsystem::LoadBuiltInGameFeaturePlugins

Source code excerpt:


	FBuiltInPluginLoadTimeTracker PluginLoadTimeTracker;
	TArray<TSharedRef<IPlugin>> EnabledPlugins = IPluginManager::Get().GetEnabledPlugins();

	LoadContext->Results.Reserve(EnabledPlugins.Num());
	for (const TSharedRef<IPlugin>& Plugin : EnabledPlugins)
	{
		LoadContext->Results.Add(Plugin->GetName(), MakeError("Pending"));
	}

	const int32 NumPluginsToLoad = EnabledPlugins.Num();
	UE_LOG(LogGameFeatures, Log, TEXT("Loading %i builtins"), NumPluginsToLoad);

	// Sort the plugins so we can more accurately track how long it takes to load rather than have inconsistent dependency timings.
	TArray<TSharedRef<IPlugin>> Dependencies;
	auto GetPluginDependencies =
		[&Dependencies](TSharedRef<IPlugin> CurrentPlugin)

#Loc: <Workspace>/Engine/Plugins/Runtime/GameFeatures/Source/GameFeatures/Private/GameFeaturesSubsystem.cpp:1951

Scope (from outer to inner):

file
function     void UGameFeaturesSubsystem::LoadBuiltInGameFeaturePlugins

Source code excerpt:

		return Dependencies;
	};
	Algo::TopologicalSort(EnabledPlugins, GetPluginDependencies);

	for (const TSharedRef<IPlugin>& Plugin : EnabledPlugins)
	{
		FBuiltInPluginLoadTimeTrackerScope TrackerScope(PluginLoadTimeTracker, Plugin);
		LoadBuiltInGameFeaturePlugin(Plugin, AdditionalFilter, FGameFeaturePluginLoadComplete::CreateLambda([LoadContext, Plugin](const UE::GameFeatures::FResult& Result)
		{
			LoadContext->Results.Add(Plugin->GetName(), Result);
			++LoadContext->NumPluginsLoaded;

#Loc: <Workspace>/Engine/Plugins/Runtime/GameFeatures/Source/GameFeatures/Public/GameFeaturesSubsystemSettings.h:26

Scope (from outer to inner):

file
class        class UGameFeaturesSubsystemSettings : public UDeveloperSettings

Source code excerpt:

	/** List of plugins that are forcibly enabled (e.g., via a hotfix) */
	UPROPERTY(config, EditAnywhere, Category = GameFeatures)
	TArray<FString> EnabledPlugins;

	/** List of plugins that are forcibly disabled (e.g., via a hotfix) */
	UPROPERTY(config, EditAnywhere, Category=GameFeatures)
	TArray<FString> DisabledPlugins;

	/** List of metadata (additional keys) to try parsing from the .uplugin to provide to FGameFeaturePluginDetails */

#Loc: <Workspace>/Engine/Plugins/Tests/PythonAutomationTest/Source/PythonAutomationTest/Private/PythonAutomationTest.cpp:156

Scope (from outer to inner):

file
function     void FPythonAutomationTest::GetTests

Source code excerpt:


	// Find all files under each plugin dir under /Content/Python
	TArray<TSharedRef<IPlugin>> EnabledPlugins = IPluginManager::Get().GetEnabledPlugins();
	for (const TSharedRef<IPlugin>& Plugin : EnabledPlugins)
	{
		const FString PluginContentDir = FPaths::Combine(
			FPaths::ConvertRelativePathToFull(Plugin->GetContentDir()),
			TEXT("Python"));

		SearchForPythonTests(Plugin->GetName(), PluginContentDir, OutBeautifiedNames, OutTestCommands);

#Loc: <Workspace>/Engine/Source/Developer/AssetTools/Private/AssetTools.cpp:4807

Scope (from outer to inner):

file
function     void UAssetToolsImpl::PerformMigratePackages

Source code excerpt:

	// Fetch the enabled plugins and their mount points
	TMap<FName, EPluginLoadedFrom> EnabledPluginToLoadedFrom;
	TArray<TSharedRef<IPlugin>> EnabledPlugins = IPluginManager::Get().GetEnabledPluginsWithContent();
	for (const TSharedRef<IPlugin>& EnabledPlugin : EnabledPlugins)
	{
		EnabledPluginToLoadedFrom.Add(FName(EnabledPlugin->GetMountedAssetPath()), EnabledPlugin->GetLoadedFrom());
	}

	// Find assets in non-Project Plugins
	TSet<FName> ShouldMigratePackage;

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

Scope (from outer to inner):

file
function     void UCookOnTheFlyServer::WriteCookMetadata

Source code excerpt:

	// so we just always write the entire set.
	//
	TArray<TSharedRef<IPlugin>> EnabledPlugins = IPluginManager::Get().GetEnabledPlugins();

	// NOTE: We can't use IsEnabledForPlugin because it has an issue with the AllowTargets list where preventing a plugin on
	// a target at the uproject level doesn't get overridden by a dependent plugins' reference. This manifests as packages
	// on disk during stage existing but the plugin isn't in the cook manifest. I wasn't able to find a way to fix this
	// with the current plugin system, so we include all enabled plugins.

	constexpr int32 AdditionalPseudoPlugins = 2; // /Engine and /Game.
	if (IntFitsIn<uint16>(EnabledPlugins.Num() + AdditionalPseudoPlugins) == false)
	{
		UE_LOG(LogCook, Warning, TEXT("Number of plugins exceeds 64k, unable to write cook metadata file (count = %d)"), EnabledPlugins.Num() + AdditionalPseudoPlugins);
	}
	else
	{
		TArray<UE::Cook::FCookMetadataPluginEntry> PluginsToAdd;
		TMap<FString, uint16> IndexForPlugin;
		TArray<uint16> PluginChildArray;

		PluginsToAdd.AddDefaulted(EnabledPlugins.Num());
		uint16 AddIndex = 0;
		for (TSharedRef<IPlugin>& EnabledPlugin : EnabledPlugins)
		{
			UE::Cook::FCookMetadataPluginEntry& NewEntry = PluginsToAdd[AddIndex];
			NewEntry.Name = EnabledPlugin->GetName();
			IndexForPlugin.Add(NewEntry.Name, AddIndex);
			AddIndex++;
		}

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

Scope (from outer to inner):

file
function     void UCookOnTheFlyServer::WriteCookMetadata

Source code excerpt:

		// Construct the dependency list.
		TArray<uint16> RootPlugins;
		for (TSharedRef<IPlugin>& EnabledPlugin : EnabledPlugins)
		{
			uint16 SelfIndex = IndexForPlugin[EnabledPlugin->GetName()];
			UE::Cook::FCookMetadataPluginEntry& Entry = PluginsToAdd[SelfIndex];
			Entry.Type = UE::Cook::ECookMetadataPluginType::Normal;

			// We detect if this would overflow below and cancel the write - so while this could store

#Loc: <Workspace>/Engine/Source/Runtime/AssetRegistry/Private/AssetRegistry.cpp:1139

Scope (from outer to inner):

file
namespace    UE::AssetRegistry
function     void FAssetRegistryImpl::InitRedirectors

Source code excerpt:

	}

	TArray<TSharedRef<IPlugin>> EnabledPlugins = IPluginManager::Get().GetEnabledPlugins();
	for (const TSharedRef<IPlugin>& Plugin : EnabledPlugins)
	{
		FString PluginConfigFilename = FString::Printf(TEXT("%s%s/%s.ini"), *FPaths::GeneratedConfigDir(), ANSI_TO_TCHAR(FPlatformProperties::PlatformName()), *Plugin->GetName() );
		
		bool bShouldRemap = false;
		
		if ( !GConfig->GetBool(TEXT("PluginSettings"), TEXT("RemapPluginContentToGame"), bShouldRemap, PluginConfigFilename) )

#Loc: <Workspace>/Engine/Source/Runtime/Core/Internal/GenericPlatform/GenericPlatformCrashContextEx.h:33

Scope: file

Source code excerpt:


CORE_API void CopyGPUBreadcrumbsToSharedCrashContext(FSharedCrashContextEx& InOutSharedContext);
CORE_API void InitializeFromCrashContextEx(const FSessionContext& Context, const TCHAR* EnabledPlugins, const TCHAR* EngineData, const TCHAR* GameData, const FGPUBreadcrumbsSharedContext* GPUBreadcrumbs);

#Loc: <Workspace>/Engine/Source/Runtime/Core/Public/GenericPlatform/GenericPlatformCrashContext.h:392

Scope: file

Source code excerpt:


	/** Initialized crash context, using a crash context (e.g. shared from another process). */
	CORE_API static void InitializeFromContext(const FSessionContext& Context, const TCHAR* EnabledPlugins, const TCHAR* EngineData, const TCHAR* GameData);

	/** Get the current cached session context */
	CORE_API static const FSessionContext& GetCachedSessionContext();

	/** Gets the current standardized game name for use in a Crash Reporter report. */
	CORE_API static FString GetGameName();

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/PluginBlueprintLibrary.cpp:34

Scope (from outer to inner):

file
function     TArray<FString> UPluginBlueprintLibrary::GetEnabledPluginNames

Source code excerpt:

TArray<FString> UPluginBlueprintLibrary::GetEnabledPluginNames()
{
	const TArray<TSharedRef<IPlugin>> EnabledPlugins =
		IPluginManager::Get().GetEnabledPlugins();

	TArray<FString> PluginNames;
	PluginNames.Reserve(EnabledPlugins.Num());

	for (const TSharedRef<IPlugin>& Plugin : EnabledPlugins)
	{
		PluginNames.Add(Plugin->GetName());
	}

	return PluginNames;
}

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

Scope (from outer to inner):

file
function     void UEngine::Init

Source code excerpt:

	if(!FEngineBuildSettings::IsInternalBuild())
	{
		TArray<TSharedRef<IPlugin>> EnabledPlugins = IPluginManager::Get().GetEnabledPlugins();

		for (auto Plugin : EnabledPlugins)
		{
			const FPluginDescriptor& Desc = Plugin->GetDescriptor();

			// encode a minimal plugin description for the crash reporter
			FString DescStr;
			TSharedRef< TJsonWriter<> > WriterRef = TJsonWriterFactory<>::Create(&DescStr);

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:1399

Scope (from outer to inner):

file
function     bool FPluginManager::ConfigureEnabledPlugins

Source code excerpt:


		// Set of all the plugins which have been enabled
		TMap<FString, FPlugin*> EnabledPlugins;

		// Keep a set of all the plugin names that have been configured. We read configuration data from different places, but only configure a plugin from the first place that it's referenced.
		TSet<FString> ConfiguredPluginNames;

		// Keep the list of newly available localization targets
		TArray<FString> AdditionalLocResPaths;

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:1558

Scope (from outer to inner):

file
function     bool FPluginManager::ConfigureEnabledPlugins

Source code excerpt:

					if (!ConfiguredPluginNames.Contains(EnablePluginName) && !ExceptPlugins.Contains(EnablePluginName) && (!bExceptRestrictedPlugins || !IsRestrictedPlugin(EnablePluginName)))
					{
						if (!ConfigureEnabledPluginForCurrentTarget(FPluginReferenceDescriptor(EnablePluginName, true), EnabledPlugins,
							bAllPluginsEnabledViaCommandLine ? TEXTVIEW("Commandline EnableAllPlugins") : TEXTVIEW("CommandLine EnablePlugins="), AllowedOptionalDependencies))
						{
							if (bAllPluginsEnabledViaCommandLine)
							{
								// Plugins may legitimately fail to enable when running with -EnableAllPlugins, but this shouldn't be considered a fatal error
								continue;

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:1580

Scope (from outer to inner):

file
function     bool FPluginManager::ConfigureEnabledPlugins

Source code excerpt:

				if (!ConfiguredPluginNames.Contains(DisablePluginName))
				{
					if (!ConfigureEnabledPluginForCurrentTarget(FPluginReferenceDescriptor(DisablePluginName, false), EnabledPlugins,
						TEXTVIEW("CommandLine DisablePlugins="), AllowedOptionalDependencies))
					{
						return false;
					}
					ConfiguredPluginNames.Add(DisablePluginName);
				}

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:1596

Scope (from outer to inner):

file
function     bool FPluginManager::ConfigureEnabledPlugins
lambda-function

Source code excerpt:

#if READ_TARGET_ENABLED_PLUGINS_FROM_RECEIPT
			// Configure the plugins that were enabled or disabled from the target file using the target receipt file
			auto ConfigurePluginsFromFirstMatchingTargetFile = [this, &FindFirstMatchingTargetFile, &ConfiguredPluginNames, &EnabledPlugins, &AllowedOptionalDependencies](const TCHAR* BaseDir, bool& bOutError) -> bool
			{
				const FString ReceiptWildcard = FTargetReceipt::GetDefaultPath(BaseDir, TEXT("*"), FPlatformProcess::GetBinariesSubdirectory(), FApp::GetBuildConfiguration(), nullptr);
				FString SourceDescription = FString::Printf(TEXT("Receipt files %s"), *ReceiptWildcard);

				TUniquePtr<FTargetReceipt> Receipt = FindFirstMatchingTargetFile(ReceiptWildcard);
				if (Receipt.IsValid())

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:1610

Scope (from outer to inner):

file
lambda-function

Source code excerpt:

						if (!ConfiguredPluginNames.Contains(PluginName))
						{
							if (!ConfigureEnabledPluginForCurrentTarget(FPluginReferenceDescriptor(PluginName, bEnabled), EnabledPlugins,
								SourceDescription, AllowedOptionalDependencies))
							{
								bOutError = true;
								break;
							}
							ConfiguredPluginNames.Add(PluginName);

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:1648

Scope (from outer to inner):

file
function     bool FPluginManager::ConfigureEnabledPlugins

Source code excerpt:

					if (!ConfiguredPluginNames.Contains(TargetEnabledPlugin))
					{
						if (!ConfigureEnabledPluginForCurrentTarget(FPluginReferenceDescriptor(TargetEnabledPlugin, true), EnabledPlugins,
							TEXTVIEW("UBT_TARGET_ENABLED_PLUGINS"), AllowedOptionalDependencies))
						{
							return false;
						}
						ConfiguredPluginNames.Add(TargetEnabledPlugin);
					}

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:1666

Scope (from outer to inner):

file
function     bool FPluginManager::ConfigureEnabledPlugins

Source code excerpt:

					if (!ConfiguredPluginNames.Contains(TargetDisabledPlugin))
					{
						if (!ConfigureEnabledPluginForCurrentTarget(FPluginReferenceDescriptor(TargetDisabledPlugin, false), EnabledPlugins,
							TEXTVIEW("UBT_TARGET_ENABLED_PLUGINS"), AllowedOptionalDependencies))
						{
							return false;
						}
						ConfiguredPluginNames.Add(TargetDisabledPlugin);
					}

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:1678

Scope (from outer to inner):

file
function     bool FPluginManager::ConfigureEnabledPlugins
lambda-function

Source code excerpt:


			auto ProcessPluginConfigurations =
				[&ConfiguredPluginNames, &EnabledPlugins, &AllowedOptionalDependencies, this]
				(const TArray<FPluginReferenceDescriptor>& PluginReferences, FStringView SourceDescription)->bool
			{
				for (const FPluginReferenceDescriptor& PluginReference : PluginReferences)
				{
					if (!ConfiguredPluginNames.Contains(PluginReference.Name))
					{
						if (!ConfigureEnabledPluginForCurrentTarget(PluginReference, EnabledPlugins, SourceDescription, AllowedOptionalDependencies))
						{
							return false;
						}
						ConfiguredPluginNames.Add(PluginReference.Name);
					}
				}

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:1726

Scope (from outer to inner):

file
function     bool FPluginManager::ConfigureEnabledPlugins

Source code excerpt:

					{
						if (!ConfigureEnabledPluginForCurrentTarget(FPluginReferenceDescriptor(PluginName, true),
							EnabledPlugins, SourceDescription, AllowedOptionalDependencies))
						{
							return false;
						}
						ConfiguredPluginNames.Add(PluginName);
					}
				}

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:1737

Scope (from outer to inner):

file
function     bool FPluginManager::ConfigureEnabledPlugins
lambda-function

Source code excerpt:


#if IS_PROGRAM
		auto EnableProgramPlugin = [this, &ConfiguredPluginNames, &EnabledPlugins, &AllowedOptionalDependencies](const TCHAR* ConfigEntry, bool bOptionalPlugin) mutable
		{
			TArray<FString> ProgramPluginNames;
			GConfig->GetArray(TEXT("Plugins"), ConfigEntry, ProgramPluginNames, GEngineIni);
			FString SourceDescription = FString::Printf(TEXT("Engine.ini:[%s]:ProgramEnabledPlugins"), ConfigEntry);

			for (const FString& PluginName : ProgramPluginNames)

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:1750

Scope (from outer to inner):

file
function     bool FPluginManager::ConfigureEnabledPlugins
lambda-function

Source code excerpt:

					PluginReference.bOptional = bOptionalPlugin;
					if (!ConfigureEnabledPluginForCurrentTarget(PluginReference,
						EnabledPlugins, SourceDescription, AllowedOptionalDependencies))
					{
						return false;
					}
					ConfiguredPluginNames.Add(PluginName);
				}
			}

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:1805

Scope (from outer to inner):

file
function     bool FPluginManager::ConfigureEnabledPlugins

Source code excerpt:

#endif

			for (TPair<FString, FPlugin*>& Pair : EnabledPlugins)
			{
				FPlugin& Plugin = *Pair.Value;

#if !IS_MONOLITHIC
				// Mount the binaries directory, and check the modules are valid
				if (Plugin.Descriptor.Modules.Num() > 0)

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:1865

Scope (from outer to inner):

file
function     bool FPluginManager::ConfigureEnabledPlugins

Source code excerpt:


						// look for the existing plugin
						FPlugin* FoundPlugin = EnabledPlugins.FindRef(PluginName);
						if (FoundPlugin != nullptr)
						{
							PluginsWithPakFile.AddUnique(TSharedRef<IPlugin>(FoundPlugin));
							// and finally mount the plugin's pak
							FCoreDelegates::MountPak.Execute(PakPath, 0);
						}

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:2176

Scope (from outer to inner):

file
function     bool FPluginManager::GetCodePluginsForProject

Source code excerpt:


	// Map of all enabled plugins
	TMap<FString, FPlugin*> EnabledPlugins;

	// Keep a set of all the plugin names that have been configured. We read configuration data from different places, but only configure a plugin from the first place that it's referenced.
	TSet<FString> ConfiguredPluginNames;

	// Find all the plugin references in the project file
	bool bAllowEnginePluginsEnabledByDefault = true;

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:2194

Scope (from outer to inner):

file
function     bool FPluginManager::GetCodePluginsForProject

Source code excerpt:

			{
				if (!ConfigureEnabledPluginForTarget(PluginReference, ProjectDescriptor, FString(), Platform,
					Configuration, TargetType, bLoadPluginsForTargetPlatforms, AllPlugins, EnabledPlugins,
					AllowedOptionalDependencies, OutResultInfo))
				{
					return false;
				}
				ConfiguredPluginNames.Add(PluginReference.Name);
			}

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:2211

Scope (from outer to inner):

file
function     bool FPluginManager::GetCodePluginsForProject

Source code excerpt:

			if (!ConfigureEnabledPluginForTarget(FPluginReferenceDescriptor(PluginPair.Key, true), ProjectDescriptor,
				FString(), Platform, Configuration, TargetType, bLoadPluginsForTargetPlatforms, AllPlugins,
				EnabledPlugins, AllowedOptionalDependencies, OutResultInfo))
			{
				return false;
			}
			ConfiguredPluginNames.Add(PluginPair.Key);
		}
	}

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:2222

Scope (from outer to inner):

file
function     bool FPluginManager::GetCodePluginsForProject

Source code excerpt:

	bool bBuildDeveloperTools = (TargetType == EBuildTargetType::Editor || TargetType == EBuildTargetType::Program || (Configuration != EBuildConfiguration::Test && Configuration != EBuildConfiguration::Shipping));
	bool bRequiresCookedData = (TargetType != EBuildTargetType::Editor);
	for (const TPair<FString, FPlugin*>& Pair : EnabledPlugins)
	{
		for (const FModuleDescriptor& Module : Pair.Value->GetDescriptor().Modules)
		{
			if (Module.IsCompiledInConfiguration(Platform, Configuration, FString(), TargetType, bBuildDeveloperTools, bRequiresCookedData))
			{
				CodePluginNames.Add(Pair.Key);

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:2238

Scope (from outer to inner):

file
function     bool FPluginManager::ConfigureEnabledPluginForCurrentTarget

Source code excerpt:


bool FPluginManager::ConfigureEnabledPluginForCurrentTarget(const FPluginReferenceDescriptor& FirstReference,
	TMap<FString, FPlugin*>& EnabledPlugins, FStringView SourceOfPluginRequest, const TSet<FString>& AllowedOptionalDependencies)
{
	SCOPED_BOOT_TIMING("ConfigureEnabledPluginForCurrentTarget");

	FConfigurePluginResultInfo ResultInfo;

	if (ConfigureEnabledPluginForTarget(FirstReference, IProjectManager::Get().GetCurrentProject(), UE_APP_NAME,
		FPlatformMisc::GetUBTPlatform(), FApp::GetBuildConfiguration(), FApp::GetBuildTargetType(),
		(bool)LOAD_PLUGINS_FOR_TARGET_PLATFORMS, AllPlugins, EnabledPlugins, AllowedOptionalDependencies, ResultInfo))
	{
		return true;
	}

#if !IS_MONOLITHIC
	// If we're in unattended mode, don't open any windows

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:2406

Scope (from outer to inner):

file
function     bool FPluginManager::ConfigureEnabledPluginForTarget

Source code excerpt:

	const FProjectDescriptor* ProjectDescriptor, const FString& TargetName, const FString& Platform,
	EBuildConfiguration Configuration, EBuildTargetType TargetType, bool bLoadPluginsForTargetPlatforms,
	FDiscoveredPluginMap& AllPlugins, TMap<FString, FPlugin*>& EnabledPlugins,
	const TSet<FString>& AllowedOptionalDependencies,
	FConfigurePluginResultInfo& OutResultInfo)
{
	if (EnabledPlugins.Contains(FirstReference.Name))
	{
		// Already enabled. Just verify the version
		if (FirstReference.RequestedVersion.IsSet())
		{
			UE_CLOG(
				(*EnabledPlugins.Find(FirstReference.Name))->GetDescriptor().Version != FirstReference.RequestedVersion.GetValue(),
				LogPluginManager, Error,
				TEXT("Requested explicit version (v%d) of plugin '%s', but a different version (v%d) was already enabled by another source."),
				FirstReference.RequestedVersion.GetValue(), *FirstReference.Name,
				(*EnabledPlugins.Find(FirstReference.Name))->GetDescriptor().Version
			);
		}
		return true;
	}

	// Set of plugin names we've added to the queue for processing, and the plugin that referenced

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.cpp:2617

Scope (from outer to inner):

file
function     bool FPluginManager::ConfigureEnabledPluginForTarget

Source code excerpt:

#endif

			if (!EnabledPlugins.Contains(NextReference.Name) && bIsNewlySeen)
			{
				NewPluginQueue.Add(&NextReference);
			}
		}

		// Add the plugin
		EnabledPlugins.Add(Plugin.GetName(), &Plugin);
	}
	return true;
}

bool FPluginManager::PromptToDownloadPlugin(const FString& PluginName, const FString& MarketplaceURL)
{

#Loc: <Workspace>/Engine/Source/Runtime/Projects/Private/PluginManager.h:247

Scope (from outer to inner):

file
class        class FPluginManager final : public IPluginManager

Source code excerpt:

	/** Adds a single enabled plugin, and all its dependencies. If AllowedOptionalDependencies is not empty, only enable optional dependencies that are listed */
	bool ConfigureEnabledPluginForCurrentTarget(const FPluginReferenceDescriptor& FirstReference,
		TMap<FString, FPlugin*>& EnabledPlugins, FStringView SourceOfPluginRequest, const TSet<FString>& AllowedOptionalDependencies);

	/** Adds a single enabled plugin and all its dependencies. If AllowedOptionalDependencies is not empty, only enable optional dependencies that are listed */
	static bool ConfigureEnabledPluginForTarget(const FPluginReferenceDescriptor& FirstReference, const FProjectDescriptor* ProjectDescriptor, const FString& TargetName, const FString& Platform, EBuildConfiguration Configuration, EBuildTargetType TargetType, bool bLoadPluginsForTargetPlatforms, FDiscoveredPluginMap& AllPlugins, TMap<FString, FPlugin*>& EnabledPlugins, const TSet<FString>& AllowedOptionalDependencies, FConfigurePluginResultInfo& OutResultInfo);

	/** Prompts the user to download a missing plugin from the given URL */
	static bool PromptToDownloadPlugin(const FString& PluginName, const FString& MarketplaceURL);

	/** Prompts the user to disable a plugin */
	static bool PromptToDisableSealedPlugin(const FString& PluginName, const FString& SealedPluginName);