// Copyright Epic Games, Inc. All Rights Reserved. #pragma once #include "CoreMinimal.h" #include "Common/TargetPlatformBase.h" #include "Interfaces/IPluginManager.h" #include "GenericWindowsTargetPlatformControls.h" #include "Windows/WindowsPlatformProperties.h" #if COOKEDEDITOR_WITH_LINUXTARGETPLATFORM #include "LinuxTargetPlatformSettings.h" #include "LinuxTargetPlatformControls.h" #endif #if COOKEDEDITOR_WITH_MACTARGETPLATFORM #include "GenericMacTargetPlatformSettings.h" #include "GenericMacTargetPlatformControls.h" #endif typedef TGenericWindowsTargetPlatformSettings> FWindowsEditorTargetPlatformSettingsParent; typedef TGenericWindowsTargetPlatformControls> FWindowsEditorTargetPlatformControlsParent; #if COOKEDEDITOR_WITH_LINUXTARGETPLATFORM typedef TLinuxTargetPlatformSettings> FLinuxEditorTargetPlatformSettingsParent; typedef TLinuxTargetPlatformControls> FLinuxEditorTargetPlatformControlsParent; #endif #if COOKEDEDITOR_WITH_MACTARGETPLATFORM typedef TGenericMacTargetPlatformSettings FMacEditorTargetPlatformSettingsParent; typedef TGenericMacTargetPlatformControls FMacEditorTargetPlatformControlsParent; #endif #if PLATFORM_WINDOWS typedef FWindowsEditorTargetPlatformSettingsParent FHostPlatformEditorTargetPlatformSettingsParent; typedef FWindowsEditorTargetPlatformControlsParent FHostPlatformEditorTargetPlatformControlsParent; #elif PLATFORM_LINUX typedef FLinuxEditorTargetPlatformSettingsParent FHostPlatformEditorTargetPlatformSettingsParent; typedef FLinuxEditorTargetPlatformControlsParent FHostPlatformEditorTargetPlatformControlsParent; #elif PLATFORM_MAC typedef FMacEditorTargetPlatformSettingsParent FHostPlatformEditorTargetPlatformSettingsParent; typedef FMacEditorTargetPlatformControlsParent FHostPlatformEditorTargetPlatformControlsParent; #endif /** * Allows a project to control how packages are cooked when making a cooked editor. * * Unlike a runtime game, a cooked editor typically needs to include all engine and plugin content, to make all * resources available for the crafting of future games in the cooked editor with asset needs that are not yet known. * When cooking a cooked editor target platform, an instance of this class adds the requests for all of that extra content. * * The default implementation is FIniCookedEditorPackageManager which allows for Game.ini settings to control most * functionality. By default (as set in BaseGame.ini) all content is cooked with a few class types and plugns that * are not due to incompatibility with having been cooked and loaded by the editor. * * If "Cook Against Release" mode is enabled, then making the cooked editor will act like "DLC" where it uses an already * created Game or Client release and will not cook pacakges that are already in the release. * * To override this class, generally you will want to override the Project functions in the first public section. * In GetProjectPackagesToCook(), you can call AddPackagesFromPath to cook spefic project content subdirectories as needed * * You likely can use just this class without needing to subclass TCookedEditorTargetPlatform at all, but you can do that * if needed. */ class COOKEDEDITOR_API ICookedEditorPackageManager { public: /** * Construct a package manager for the given TP */ static TUniquePtr FactoryForTargetPlatform(bool bIsCookedCooker); virtual ~ICookedEditorPackageManager() { } /** * Hook called when the manager's TargetPlatform is selected for cooking. Load any required assets or data. * May be called multiple times per process; it is called each time a cook starts for the platform. */ virtual void InitializeForCook() = 0; /** * Override to control engine packages to cook */ virtual void GetEnginePackagesToCook(TArray& PackagesToCook) const = 0; /** * Override to add project specific packages to cook */ virtual void GetProjectPackagesToCook(TArray& PackagesToCook) const = 0; /** * Allows the subclass to exclude specific objects in packages discovered during the cook. * By default, will disallow UBlueprint objects */ virtual bool AllowObjectToBeCooked(const class UObject* Obj) const = 0; /** * Allows the subclass to disallow some assets to be gathered during AddPackagesFromPath, for instance * This is similar to AllowObjectToBeCooked, but it can help with, for instance, removing maps from * subdirectories, while still allowing the normal maps that come from the standard cooking process */ virtual bool AllowAssetToBeGathered(const struct FAssetData& AssetData) const = 0; /** * Should the given enabled engine plugin be cooked? */ virtual bool AllowEnginePluginContentToBeCooked(const TSharedRef) const = 0; /** * Should the given enabled project plugin be cooked? */ virtual bool AllowProjectPluginContentToBeCooked(const TSharedRef) const = 0; /** * Gathers the packages this PackageManager wants to manage (ie cook) */ virtual void GatherAllPackages(TArray& PackageNames) const = 0; protected: enum class EPackageSearchMode { TopDirectoryOnly, Recurse, }; /** * Use the asset registry to find packages to be cooked * @param Packages output array of paths * @param Path rooted path to look in ("/Engine", etc) * @param SeachMode Recurse or TopDirectoryOnly */ void AddPackagesFromPath(TArray& Packages, const TCHAR* Path, EPackageSearchMode SearchMode) const; /** * Allow a subclass to remove packages found in GatherAllPackages */ virtual void FilterGatheredPackages(TArray& PackageNames) const; protected: /** * Meat of this class, this calls other functions that generally will be overridden - subclass needs to pass in disabled plugins */ void GatherAllPackagesExceptDisabled(TArray& PackageNames, const TArray& DisabledPlugins) const; }; /** * An implentation of ICookedEditorPackageManager that uses BaseGame.ini / DefaultGame.ini to control cooked editor packaging setup * */ class COOKEDEDITOR_API FIniCookedEditorPackageManager : public ICookedEditorPackageManager { TArray EngineAssetPaths; TArray ProjectAssetPaths; TArray DisabledPlugins; TSet DisallowedObjectClassesToLoad; TArray DisallowedAssetClassesToGather; TArray DisallowedPathsToGather; // true if this is a cooked cooker (false for cooker editor) bool bIsCookedCooker; // Guard to prevent multiple InitializeClasses calls bool bClassesInitialized = false; // Used to control logging of certain warnings. int32 CookProgressDisplayMode = 0; // gets an array from two sections, depending on bIsCookedCooker setting TArray GetConfigArray(const TCHAR* Key) const; // Load the classes specified from config settings that we need to reference void InitializeClasses(); public: FIniCookedEditorPackageManager(bool bIsCookedCooker); // gets an array from two sections, depending on bIsCookedCooker setting static TArray GetConfigArray(const TCHAR* Key, bool bIsCookedCooker); virtual void FilterGatheredPackages(TArray& PackageNames) const override; virtual void InitializeForCook() override; virtual void GetEnginePackagesToCook(TArray& PackagesToCook) const override; virtual void GetProjectPackagesToCook(TArray& PackagesToCook) const override; virtual bool AllowObjectToBeCooked(const class UObject* Obj) const override; virtual bool AllowAssetToBeGathered(const struct FAssetData& AssetData) const override; virtual bool AllowEnginePluginContentToBeCooked(const TSharedRef) const override; virtual bool AllowProjectPluginContentToBeCooked(const TSharedRef) const override; virtual void GatherAllPackages(TArray& PackageNames) const override; };