ICookInfo.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "HAL/Platform.h"
#include "Misc/CoreMiscDefines.h"
 
#if WITH_EDITOR
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "Delegates/Delegate.h"
#include "UObject/CookEnums.h"
#include "UObject/NameTypes.h"
#include "Templates/Tuple.h"
#endif
 
#if WITH_EDITOR
 
enum class EDataValidationResult : uint8;
class FDataValidationContext;
class ITargetPlatform;
class IPlugin;
class UPackage;
 
namespace UE::Cook { class ICookArtifact; }
namespace UE::Cook { class IMPCollector; }
#endif
 
enum class ECookLoadType : uint8
{
    Unspecified,
    EditorOnly,
    UsedInGame,
 
    Unexpected UE_DEPRECATED(5.6, "Use ECookLoadType::Unspecified") = Unspecified,
};
 
#if WITH_EDITOR
 
namespace UE::Cook
{
 
#define EINSTIGATOR_VALUES(CallbackMacro) \
 \
    CallbackMacro(InvalidCategory, true) \
    CallbackMacro(NotYetRequested, true) \
    CallbackMacro(Unspecified, false) \
    CallbackMacro(StartupPackage, true) \
    CallbackMacro(StartupPackageCookLoadScope, true) \
    CallbackMacro(AlwaysCookMap, true) \
    CallbackMacro(IniMapSection, false) \
    CallbackMacro(IniAllMaps, true) \
    CallbackMacro(CommandLinePackage, true) \
    CallbackMacro(CommandLineDirectory, true) \
    CallbackMacro(DirectoryToAlwaysCook, false) \
    CallbackMacro(FullDepotSearch, true) \
    CallbackMacro(GameDefaultObject, false) \
    CallbackMacro(InputSettingsIni, true) \
    CallbackMacro(StartupSoftObjectPath, true) \
    CallbackMacro(PackagingSettingsMapToCook, true) \
    CallbackMacro(ModifyCookDelegate, true) \
    CallbackMacro(AssetManagerModifyCook, true) \
    CallbackMacro(AssetManagerModifyDLCCook, true) \
    CallbackMacro(TargetPlatformExtraPackagesToCook, true) \
    CallbackMacro(ConsoleCommand, true) \
    CallbackMacro(CookOnTheFly, true) \
    CallbackMacro(LegacyIterativeCook, true) \
    CallbackMacro(PreviousAssetRegistry, true) \
    CallbackMacro(RequestPackageFunction, true) \
    CallbackMacro(Dependency, false) \
    CallbackMacro(HardDependency, false) \
    CallbackMacro(HardEditorOnlyDependency, false) \
    CallbackMacro(SoftDependency, false) \
    CallbackMacro(Unsolicited, false) \
    CallbackMacro(EditorOnlyLoad, false) \
    CallbackMacro(SaveTimeHardDependency, false) \
    CallbackMacro(SaveTimeSoftDependency, false) \
    CallbackMacro(ForceExplorableSaveTimeSoftDependency, false) \
    CallbackMacro(GeneratedPackage, false) \
    CallbackMacro(BuildDependency, false) \
 
 
enum class EInstigator : uint8
{
#define EINSTIGATOR_VALUE_CALLBACK(Name, bAllowUnparameterized) Name,
    EINSTIGATOR_VALUES(EINSTIGATOR_VALUE_CALLBACK)
#undef EINSTIGATOR_VALUE_CALLBACK
    Count,
};
COREUOBJECT_API const TCHAR* LexToString(EInstigator Value);
 
struct FInstigator
{
    FName Referencer;
    EInstigator Category;
 
    FInstigator() : Category(EInstigator::InvalidCategory)
    {
    }
    FInstigator(EInstigator InCategory, FName InReferencer = NAME_None) : Referencer(InReferencer), Category(InCategory)
    {
    }
 
    COREUOBJECT_API FString ToString() const;
};
 
enum class EPackageCookRule
{
    /* No action specified, the rule will be ignored. */
    None,
    AddToCook,
    NeverCook,
 
    // IgnoreStartupPackage is not yet implemented, coming in a future version. For now, only FCookLoadScope
    // provides this functionality.
    // IgnoreStartupPackage,
};
 
struct FPackageCookRule
{
    FName PackageName;
 
    FName InstigatorName;
 
    // TargetPlatform is not yet implemented, coming in a future version. For now, TargetPlatform is ignored and
    // all rules apply to all platforms.
    //  const ITargetPlatform* TargetPlatform = nullptr;
 
    EPackageCookRule CookRule = EPackageCookRule::None;
};
 
class ICookInfo
{
public:
    virtual FInstigator GetInstigator(FName PackageName) = 0;
    virtual TArray<FInstigator> GetInstigatorChain(FName PackageName) = 0;
 
    virtual UE::Cook::ECookType GetCookType() = 0;
    virtual UE::Cook::ECookingDLC GetCookingDLC() = 0;
    virtual FString GetDLCName() = 0;
    virtual FString GetBasedOnReleaseVersion() = 0;
    virtual FString GetCreateReleaseVersion() = 0;
 
    virtual UE::Cook::EProcessType GetProcessType() = 0;
    virtual UE::Cook::ECookValidationOptions GetCookValidationOptions() = 0;
    virtual bool IsIncremental() = 0;
    UE_DEPRECATED(5.6, "Use IsIncremental instead.")
    bool IsIterative()
    {
        return IsIncremental();
    }
 
    virtual TArray<const ITargetPlatform*> GetSessionPlatforms() = 0;
    virtual FString GetCookOutputFolder(const ITargetPlatform* TargetPlatform) = 0;
 
    virtual const TSet<IPlugin*>* GetEnabledPlugins(const ITargetPlatform* TargetPlatform) = 0;
 
    virtual void RegisterCollector(IMPCollector* Collector,
        UE::Cook::EProcessType ProcessType=UE::Cook::EProcessType::AllMPCook) = 0;
    virtual void UnregisterCollector(IMPCollector* Collector) = 0;
 
    virtual void RegisterArtifact(ICookArtifact* Artifact) = 0;
    virtual void UnregisterArtifact(ICookArtifact* Artifact) = 0;
 
    virtual void GetCulturesToCook(TArray<FString>& OutCulturesToCook) const = 0;
};
 
DECLARE_MULTICAST_DELEGATE_OneParam(FCookInfoEvent, ICookInfo&);
DECLARE_DELEGATE_RetVal_TwoParams(EDataValidationResult, FValidateSourcePackage, UPackage* /*Package*/,
    FDataValidationContext& /*ValidationContext*/);
DECLARE_MULTICAST_DELEGATE_TwoParams(FPackageBlockedEvent, const UObject* /* Object */, FStringBuilderBase& OutDebugInfo)
DECLARE_MULTICAST_DELEGATE_TwoParams(FCookInfoModifyCookDelegate, ICookInfo& /* CookInfo */,
    TArray<FPackageCookRule>& /* InOutPackageCookRules */);
DECLARE_MULTICAST_DELEGATE_ThreeParams(FCookUpdateDisplayEvent, ICookInfo& /* CookInfo */, int32 /* CookedPackagesCount */, int32 /* CookPendingCount */)
DECLARE_MULTICAST_DELEGATE_FourParams(FCookSaveIdleEvent, ICookInfo& /* CookInfo */, int32 /* NumPackagesInSaveQueue */, int32 /* NumPendingCookedPlatformData */, bool /* bExpectedDueToSlowBuildOperations */)
DECLARE_MULTICAST_DELEGATE_TwoParams(FCookLoadIdleEvent, ICookInfo& /* CookInfo */, int32 /* NumPackagesInLoadQueue */)
 
 
struct FDelegates
{
public:
    UE_DEPRECATED(5.5, "Use CookStarted, possibly restricting to the case CookInfo.GetCookType() == ECookType::ByTheBook.")
    static COREUOBJECT_API FCookInfoEvent CookByTheBookStarted;
    UE_DEPRECATED(5.5, "Use CookFinished, possibly restricting to the case CookInfo.GetCookType() == ECookType::ByTheBook.")
    static COREUOBJECT_API FCookInfoEvent CookByTheBookFinished;
    static COREUOBJECT_API FCookInfoEvent CookStarted;
    static COREUOBJECT_API FCookInfoEvent CookFinished;
    static COREUOBJECT_API FValidateSourcePackage ValidateSourcePackage;
    static COREUOBJECT_API FPackageBlockedEvent PackageBlocked;
    static COREUOBJECT_API FCookInfoModifyCookDelegate ModifyCook;
    static COREUOBJECT_API FCookUpdateDisplayEvent CookUpdateDisplay;
    static COREUOBJECT_API FCookSaveIdleEvent CookSaveIdle;
    static COREUOBJECT_API FCookLoadIdleEvent CookLoadIdle;
};
 
 
COREUOBJECT_API const TCHAR* GetReferencedSetFilename();
COREUOBJECT_API const TCHAR* GetReferencedSetOpName();
 
COREUOBJECT_API void InitializeCookGlobals();
 
} // namespace UE::Cook
 
struct FCookLoadScope
{
    COREUOBJECT_API explicit FCookLoadScope(ECookLoadType ScopeType);
    COREUOBJECT_API ~FCookLoadScope();
 
    COREUOBJECT_API static ECookLoadType GetCurrentValue();
    COREUOBJECT_API static void GetCookerStartupPackages(TMap<FName, UE::Cook::FInstigator>& OutStartupPackages);
 
private:
    static void SetCookerStartupComplete(TArray<TPair<FName, ECookLoadType>>& OutStartupPackageLoadTypes);
    ECookLoadType PreviousScope;
};
 
#else // WITH_EDITOR
 
struct FCookLoadScope
{
    UE_FORCEINLINE_HINT explicit FCookLoadScope(ECookLoadType ScopeType)
    {
    }
 
    UE_FORCEINLINE_HINT ~FCookLoadScope()
    {
    }
};
 
// Provide a forward declare but no definition for ICookInfo, to remove the need to have WITH_EDITOR around some types that include a pointer to it
namespace UE::Cook { class ICookInfo; }
 
#endif // WITH_EDITOR