file
function     void FDomainDatabase::RebuildFromScratch

	// 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);
		

file
function     void SPluginTile::OnEnablePluginCheckboxChanged

	{
		// 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);

file
function     void UGameFeaturesSubsystem::LoadBuiltInGameFeaturePlugins

	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)

file
function     void UGameFeaturesSubsystem::LoadBuiltInGameFeaturePlugins

		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;

file
class        class UGameFeaturesSubsystemSettings : public UDeveloperSettings

	/** 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 */

file
function     void FPythonAutomationTest::GetTests

	// 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);

file
function     void UAssetToolsImpl::PerformMigratePackages

	// 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;

file
function     void UCookOnTheFlyServer::WriteCookMetadata

	// 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++;
		}

file
function     void UCookOnTheFlyServer::WriteCookMetadata

		// 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

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

	}

	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) )

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);

	/** 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();

file
function     TArray<FString> UPluginBlueprintLibrary::GetEnabledPluginNames

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;
}

file
function     void UEngine::Init

	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);

file
function     bool FPluginManager::ConfigureEnabledPlugins

		// 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;

file
function     bool FPluginManager::ConfigureEnabledPlugins

					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;

file
function     bool FPluginManager::ConfigureEnabledPlugins

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

file
function     bool FPluginManager::ConfigureEnabledPlugins
lambda-function

#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())

file
lambda-function

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

file
function     bool FPluginManager::ConfigureEnabledPlugins

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

file
function     bool FPluginManager::ConfigureEnabledPlugins

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

file
function     bool FPluginManager::ConfigureEnabledPlugins
lambda-function

			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);
					}
				}

file
function     bool FPluginManager::ConfigureEnabledPlugins

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

file
function     bool FPluginManager::ConfigureEnabledPlugins
lambda-function

#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)

file
function     bool FPluginManager::ConfigureEnabledPlugins
lambda-function

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

file
function     bool FPluginManager::ConfigureEnabledPlugins

#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)

file
function     bool FPluginManager::ConfigureEnabledPlugins

						// 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);
						}

file
function     bool FPluginManager::GetCodePluginsForProject

	// 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;

file
function     bool FPluginManager::GetCodePluginsForProject

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

file
function     bool FPluginManager::GetCodePluginsForProject

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

file
function     bool FPluginManager::GetCodePluginsForProject

	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);

file
function     bool FPluginManager::ConfigureEnabledPluginForCurrentTarget

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

file
function     bool FPluginManager::ConfigureEnabledPluginForTarget

	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

file
function     bool FPluginManager::ConfigureEnabledPluginForTarget

#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)
{

file
class        class FPluginManager final : public IPluginManager

	/** 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);