DerivedData.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/StringFwd.h"
#include "CoreTypes.h"
#include "Math/NumericLimits.h"
#include "Memory/MemoryFwd.h"
#include "Memory/MemoryView.h"
#include "Misc/EnumClassFlags.h"
#include "Templates/PimplPtr.h"
 
#define UE_API COREUOBJECT_API
 
class FArchive;
class FCompressedBuffer;
class UObject;
struct FIoHash;
template <typename FuncType> class TUniqueFunction;
 
namespace UE::DerivedData { struct FCacheKey; }
namespace UE::DerivedData { struct FValueId; }
namespace UE::DerivedData::Private { class FCookedData; }
namespace UE::DerivedData::Private { class FEditorData; }
namespace UE::DerivedData::Private { class FIoResponse; }
 
namespace UE
{
 
enum class EDerivedDataFlags : uint32
{
    None            = 0,
    Required        = 1 << 0,
    Optional        = 1 << 1,
    MemoryMapped    = 1 << 2,
};
 
ENUM_CLASS_FLAGS(EDerivedDataFlags);
 
class DerivedData::Private::FCookedData
{
public:
    inline explicit operator bool() const
    {
        // Check the last byte of ChunkId, which is type of the FIoChunkId, where 0 is EIoChunkType::Invalid.
        return ChunkId[11] != 0;
    }
 
    bool ReferenceEquals(const FCookedData& Other) const;
    uint32 ReferenceHash() const;
 
    void Serialize(FArchive& Ar);
 
    uint64 ChunkOffset = 0;
    uint64 ChunkSize = 0;
    uint8 ChunkId[12]{};
 
    EDerivedDataFlags Flags = EDerivedDataFlags::None;
};
 
class FDerivedData
{
public:
    static const FDerivedData Null;
 
    FDerivedData() = default;
 
    inline explicit FDerivedData(const DerivedData::Private::FCookedData& CookedData);
 
    inline void Reset() { *this = FDerivedData(); }
 
    inline bool IsNull() const;
 
    inline explicit operator bool() const { return !IsNull(); }
 
    inline bool HasData() const { return !IsNull(); }
 
    inline bool IsCooked() const { return !!CookedData; }
 
    inline EDerivedDataFlags GetFlags() const { return CookedData.Flags; }
 
    UE_API friend FStringBuilderBase& operator<<(FStringBuilderBase& Builder, const FDerivedData& DerivedData);
 
    UE_API bool ReferenceEquals(const FDerivedData& Other) const;
 
    UE_API uint32 ReferenceHash() const;
 
    UE_API void Serialize(FArchive& Ar, UObject* Owner);
 
#if WITH_EDITORONLY_DATA
    UE_API FDerivedData(const FSharedString& Name, const FSharedBuffer& Data);
    UE_API FDerivedData(const FSharedString& Name, const FCompositeBuffer& Data);
    UE_API FDerivedData(const FSharedString& Name, const FCompressedBuffer& Data);
 
    UE_API FDerivedData(const FSharedString& Name, const DerivedData::FCacheKey& Key);
    UE_API FDerivedData(const FSharedString& Name, const DerivedData::FCacheKey& Key, const DerivedData::FValueId& ValueId);
 
    UE_API const FSharedString& GetName() const;
 
    UE_API void SetFlags(EDerivedDataFlags Flags);
 
private:
    TPimplPtr<DerivedData::Private::FEditorData, EPimplPtrMode::DeepCopy> EditorData;
#endif // WITH_EDITORONLY_DATA
 
private:
    DerivedData::Private::FCookedData CookedData;
 
    friend DerivedData::Private::FIoResponse;
};
 
inline const FDerivedData FDerivedData::Null;
 
inline FDerivedData::FDerivedData(const DerivedData::Private::FCookedData& InCookedData)
    : CookedData(InCookedData)
{
}
 
inline bool FDerivedData::IsNull() const
{
#if WITH_EDITORONLY_DATA
    return !EditorData && !CookedData;
#else
    return !CookedData;
#endif
}
 
 
struct FDerivedDataIoPriority
{
    constexpr FDerivedDataIoPriority InterpolateTo(const FDerivedDataIoPriority Target, const float Alpha) const
    {
        // Blocking input produces Blocking output.
        if (*this == Blocking() || Target == Blocking())
        {
            return Blocking();
        }
        return {Value + int32((int64(Target.Value) - int64(Value)) * double(Alpha))};
    }
 
    static constexpr FDerivedDataIoPriority Lowest()   { return {MIN_int32}; }
    static constexpr FDerivedDataIoPriority Low()      { return {MIN_int32 / 2}; }
    static constexpr FDerivedDataIoPriority Normal()   { return {0}; }
    static constexpr FDerivedDataIoPriority High()     { return {MAX_int32 / 2}; }
    static constexpr FDerivedDataIoPriority Highest()  { return {MAX_int32 - 1}; }
    static constexpr FDerivedDataIoPriority Blocking() { return {MAX_int32}; }
 
    friend constexpr bool operator==(FDerivedDataIoPriority A, FDerivedDataIoPriority B) { return A.Value == B.Value; }
    friend constexpr bool operator!=(FDerivedDataIoPriority A, FDerivedDataIoPriority B) { return A.Value != B.Value; }
    friend constexpr bool operator<(FDerivedDataIoPriority A, FDerivedDataIoPriority B) { return A.Value < B.Value; }
 
    int32 Value = 0;
};
 
enum class EDerivedDataIoStatus : uint8
{
    Ok,
    Error,
    Canceled,
    Unknown,
};
 
class FDerivedDataIoRequest
{
public:
    constexpr inline void Reset() { Index = -1; }
 
    constexpr inline bool IsNull() const { return Index == -1; }
 
    constexpr inline explicit operator bool() const { return !IsNull(); }
 
private:
    int32 Index = -1;
 
    friend DerivedData::Private::FIoResponse;
};
 
class FDerivedDataIoResponse
{
public:
    inline void Reset() { Response.Reset(); }
 
    inline bool IsNull() const { return !Response; }
 
    inline explicit operator bool() const { return !IsNull(); }
 
    UE_API void SetPriority(FDerivedDataIoPriority Priority);
 
    UE_API bool Cancel();
 
    UE_API bool Poll() const;
 
    UE_API EDerivedDataIoStatus GetOverallStatus() const;
 
    UE_API EDerivedDataIoStatus GetStatus(FDerivedDataIoRequest Handle) const;
 
    UE_API FSharedBuffer GetData(FDerivedDataIoRequest Handle) const;
 
    UE_API uint64 GetSize(FDerivedDataIoRequest Handle) const;
 
#if WITH_EDITORONLY_DATA
    UE_API const FIoHash* GetHash(FDerivedDataIoRequest Handle) const;
 
    UE_API const DerivedData::FCacheKey* GetCacheKey(FDerivedDataIoRequest Handle) const;
 
    UE_API const DerivedData::FValueId* GetCacheValueId(FDerivedDataIoRequest Handle) const;
 
    UE_API const FCompressedBuffer* GetCompressedData(FDerivedDataIoRequest Handle) const;
#endif // WITH_EDITORONLY_DATA
 
private:
    TPimplPtr<DerivedData::Private::FIoResponse> Response;
 
    friend DerivedData::Private::FIoResponse;
};
 
class FDerivedDataIoOptions
{
public:
    FDerivedDataIoOptions() = default;
 
    constexpr explicit FDerivedDataIoOptions(FMutableMemoryView TargetView, uint64 SourceOffset = 0)
        : Target(TargetView.GetData())
        , Size(TargetView.GetSize())
        , Offset(SourceOffset)
    {
    }
 
    constexpr explicit FDerivedDataIoOptions(uint64 SourceOffset, uint64 SourceSize = MAX_uint64)
        : Size(SourceSize)
        , Offset(SourceOffset)
    {
    }
 
    constexpr void* GetTarget() const { return Target; }
    constexpr uint64 GetSize() const { return Size; }
    constexpr uint64 GetOffset() const { return Offset; }
 
private:
    void* Target = nullptr;
 
    uint64 Size = MAX_uint64;
 
    uint64 Offset = 0;
};
 
using FDerivedDataIoComplete = TUniqueFunction<void ()>;
 
class FDerivedDataIoBatch
{
public:
    inline void Reset() { Response.Reset(); }
 
    inline bool IsEmpty() const { return !Response; }
 
    UE_API FDerivedDataIoRequest Read(const FDerivedData& Data, const FDerivedDataIoOptions& Options = {});
 
    UE_API FDerivedDataIoRequest Cache(const FDerivedData& Data, const FDerivedDataIoOptions& Options = {});
 
    UE_API FDerivedDataIoRequest Exists(const FDerivedData& Data, const FDerivedDataIoOptions& Options = {});
 
#if WITH_EDITORONLY_DATA
    UE_API FDerivedDataIoRequest Compress(const FDerivedData& Data);
#endif // WITH_EDITORONLY_DATA
 
    UE_API void Dispatch(FDerivedDataIoResponse& OutResponse);
    UE_API void Dispatch(FDerivedDataIoResponse& OutResponse, FDerivedDataIoPriority Priority);
    UE_API void Dispatch(FDerivedDataIoResponse& OutResponse, FDerivedDataIoPriority Priority, FDerivedDataIoComplete&& OnComplete);
    UE_API void Dispatch(FDerivedDataIoResponse& OutResponse, FDerivedDataIoComplete&& OnComplete);
 
private:
    TPimplPtr<DerivedData::Private::FIoResponse> Response;
 
    constexpr uint32 GetTypeHash(const FDerivedDataIoPriority& Priority)
    {
        return uint32(Priority.Value);
    }
};
 
} // UE
 
namespace UE::DerivedData::IoStore
{
 
inline void InitializeIoDispatcher()
{
}
 
inline void TearDownIoDispatcher()
{
}
 
} // UE::DerivedData::IoStore
 
#undef UE_API