CookOnTheFly.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Modules/ModuleInterface.h"
#include "Async/Future.h"
#include "Misc/Timespan.h"
#include "Serialization/MemoryReader.h"
#include "Serialization/MemoryWriter.h"
#include "Delegates/Delegate.h"
 
class FArrayReader;
class FInternetAddr;
 
COOKONTHEFLY_API DECLARE_LOG_CATEGORY_EXTERN(LogCookOnTheFly, Log, All);
 
namespace UE { namespace Cook
{
 
enum class ECookOnTheFlyMessage : uint32
{
    /* Represents no message. */
    None                = 0x00,
    
    /* A request message. */
    Request             = 0x02,
    /* A response message. */
    Response            = 0x04,
    TypeFlags           = 0x0F,
 
    /* Request to cook a package. */
    CookPackage         = 0x20,
    /* Get all currenlty cooked packages. */
    GetCookedPackages   = 0x30,
    /* Request to recompile shaders. */
    RecompileShaders    = 0x40,
    /* One way message indicating that one or more packages has been cooked. */
    PackagesCooked      = 0x50,
    /* One way message indicating that one or more files has been added. */
    FilesAdded          = 0x60,
    /* Request to recook packages. */
    RecookPackages      = 0x70,
    /* Legacy message for NetworkPlatformFile */
    NetworkPlatformFile = 0x80,
    /* Request for a list of on-disk packages, which may or may not be cooked or cookable for a given platform */
    GetAllOnDiskPackages = 0x90
};
ENUM_CLASS_FLAGS(ECookOnTheFlyMessage);
 
inline const TCHAR* LexToString(ECookOnTheFlyMessage Message)
{
    EnumRemoveFlags(Message, ECookOnTheFlyMessage::TypeFlags);
 
    switch (Message)
    {
        case ECookOnTheFlyMessage::None:
            return TEXT("None");
        case ECookOnTheFlyMessage::CookPackage:
            return TEXT("CookPackage");
        case ECookOnTheFlyMessage::GetCookedPackages:
            return TEXT("GetCookedPackages");
        case ECookOnTheFlyMessage::RecompileShaders:
            return TEXT("RecompileShaders");
        case ECookOnTheFlyMessage::PackagesCooked:
            return TEXT("PackagesCooked");
        case ECookOnTheFlyMessage::FilesAdded:
            return TEXT("FilesAdded");
        case ECookOnTheFlyMessage::RecookPackages:
            return TEXT("RecookPackages");
        case ECookOnTheFlyMessage::NetworkPlatformFile:
            return TEXT("NetworkPlatformFile");
        default:
            return TEXT("Unknown");
    };
}
 
enum class ECookOnTheFlyMessageStatus : uint32
{
    None,
    Ok,
    Error
};
 
inline const TCHAR* LexToString(ECookOnTheFlyMessageStatus Status)
{
    switch (Status)
    {
        case ECookOnTheFlyMessageStatus::None:
            return TEXT("None");
        case ECookOnTheFlyMessageStatus::Ok:
            return TEXT("Ok");
        case ECookOnTheFlyMessageStatus::Error:
            return TEXT("Error");
        default:
            return TEXT("Unknown");
    }
}
 
struct FCookOnTheFlyMessageHeader
{
    ECookOnTheFlyMessage MessageType = ECookOnTheFlyMessage::None;
    ECookOnTheFlyMessageStatus MessageStatus = ECookOnTheFlyMessageStatus::Ok;
    uint32 CorrelationId = 0;
    int64 Timestamp = 0;
 
    COOKONTHEFLY_API FString ToString() const;
 
    COOKONTHEFLY_API friend FArchive& operator<<(FArchive& Ar, FCookOnTheFlyMessageHeader& Header);
};
 
class FCookOnTheFlyMessage
{
public:
    FCookOnTheFlyMessage() = default;
 
    explicit FCookOnTheFlyMessage(ECookOnTheFlyMessage MessageType)
    {
        Header.MessageType = MessageType;
    }
 
    ECookOnTheFlyMessage GetMessageType() const
    {
        ECookOnTheFlyMessage MessageType = Header.MessageType;
        EnumRemoveFlags(MessageType, ECookOnTheFlyMessage::TypeFlags);
        return MessageType;
    }
 
    FCookOnTheFlyMessageHeader& GetHeader()
    {
        return Header;
    }
 
    const FCookOnTheFlyMessageHeader& GetHeader() const
    {
        return Header;
    }
 
    void SetHeader(const FCookOnTheFlyMessageHeader& InHeader)
    {
        Header = InHeader;
    }
 
    void SetStatus(ECookOnTheFlyMessageStatus InStatus)
    {
        Header.MessageStatus = InStatus;
    }
 
    ECookOnTheFlyMessageStatus GetStatus() const
    {
        return Header.MessageStatus;
    }
 
    bool IsOk() const
    {
        return Header.MessageStatus == ECookOnTheFlyMessageStatus::Ok;
    }
 
    COOKONTHEFLY_API void SetBody(TArray<uint8> InBody);
 
    template<typename BodyType>
    void SetBodyTo(BodyType InBody)
    {
        Body.Empty();
        FMemoryWriter Ar(Body);
        Ar << InBody;
    }
    
    TArray<uint8>& GetBody()
    {
        return Body;
    }
 
    const TArray<uint8>& GetBody() const
    {
        return Body;
    }
 
    template<typename BodyType>
    BodyType GetBodyAs() const
    {
        BodyType Type;
        FMemoryReader Ar(Body);
        Ar << Type;
 
        return MoveTemp(Type);
    }
 
    int64 TotalSize() const
    {
        return sizeof(FCookOnTheFlyMessageHeader) + Body.Num();
    }
 
    COOKONTHEFLY_API TUniquePtr<FArchive> ReadBody() const;
 
    COOKONTHEFLY_API TUniquePtr<FArchive> WriteBody();
 
    COOKONTHEFLY_API friend FArchive& operator<<(FArchive& Ar, FCookOnTheFlyMessage& Message);
 
protected:
    FCookOnTheFlyMessageHeader Header;
    TArray<uint8> Body;
};
 
class FCookOnTheFlyRequest
    : public FCookOnTheFlyMessage
{
public:
    FCookOnTheFlyRequest() = default;
 
    explicit FCookOnTheFlyRequest(ECookOnTheFlyMessage MessageType)
        : FCookOnTheFlyMessage(MessageType | ECookOnTheFlyMessage::Request)
    {
    }
};
 
class FCookOnTheFlyResponse
    : public FCookOnTheFlyMessage
{
public:
    FCookOnTheFlyResponse() = default;
 
    explicit FCookOnTheFlyResponse(ECookOnTheFlyMessage MessageType)
        : FCookOnTheFlyMessage(MessageType | ECookOnTheFlyMessage::Response)
    {
    }
 
    explicit FCookOnTheFlyResponse(const FCookOnTheFlyRequest& Request)
        : FCookOnTheFlyMessage(Request.GetMessageType())
    {
        Header.MessageType |= ECookOnTheFlyMessage::Response;
        Header.CorrelationId = Request.GetHeader().CorrelationId;
    }
};
 
struct FCookOnTheFlyHostOptions
{
    TArray<FString> Hosts;
    FTimespan ServerStartupWaitTime;
};
 
class ICookOnTheFlyServerConnection
{
public:
    virtual ~ICookOnTheFlyServerConnection() { }
 
    virtual const FString& GetHost() const = 0;
 
    virtual const FString& GetZenProjectName() const = 0;
 
    virtual const FString& GetPlatformName() const = 0;
 
    virtual const TArray<FString> GetZenHostNames() const = 0;
 
    virtual const uint16 GetZenHostPort() const = 0;
 
    virtual bool IsConnected() const = 0;
 
    virtual bool IsSingleThreaded() const = 0;
 
    virtual TFuture<FCookOnTheFlyResponse> SendRequest(FCookOnTheFlyRequest& Request) = 0;
 
    DECLARE_EVENT_OneParam(ICookOnTheFlyServerConnection, FMessageEvent, const FCookOnTheFlyMessage&);
    virtual FMessageEvent& OnMessage() = 0;
};
 
class ICookOnTheFlyModule
    : public IModuleInterface
{
public:
    virtual ~ICookOnTheFlyModule() { }
 
    virtual TSharedPtr<ICookOnTheFlyServerConnection> GetDefaultServerConnection() = 0;
 
    virtual TUniquePtr<ICookOnTheFlyServerConnection> ConnectToServer(const FCookOnTheFlyHostOptions& HostOptions) = 0;
};
 
}} // namespace UE::Cook