MovieSceneNumericVariant.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "MovieSceneNumericVariant.generated.h"
 
class UMovieSceneNumericVariantGetter;
 
#ifndef UE_MOVIESCENE_WEAKNUMERICVARIANT_CHECKS
    #define UE_MOVIESCENE_WEAKNUMERICVARIANT_CHECKS DO_CHECK
#endif
 
 
USTRUCT(BlueprintType)
struct FMovieSceneNumericVariant
{
    static_assert(PLATFORM_LITTLE_ENDIAN, "This class does not currently support big-endian platforms");
 
    GENERATED_BODY()
 
    
    FMovieSceneNumericVariant(ENoInit)
    {
    }
 
 
    MOVIESCENE_API FMovieSceneNumericVariant();
 
 
    MOVIESCENE_API explicit FMovieSceneNumericVariant(double InValue);
 
 
    MOVIESCENE_API explicit FMovieSceneNumericVariant(UMovieSceneNumericVariantGetter* InGetter);
 
 
    FMovieSceneNumericVariant(FMovieSceneNumericVariant&& In) = default;
    FMovieSceneNumericVariant& operator=(FMovieSceneNumericVariant&& In) = default;
 
 
    MOVIESCENE_API friend bool operator==(const FMovieSceneNumericVariant& A, const FMovieSceneNumericVariant& B);
 
 
    MOVIESCENE_API friend bool operator!=(const FMovieSceneNumericVariant& A, const FMovieSceneNumericVariant& B);
 
 
public:
 
    MOVIESCENE_API void Set(double InLiteralValue);
 
 
    MOVIESCENE_API void Set(UMovieSceneNumericVariantGetter* InDynamicValue);
 
 
    MOVIESCENE_API void SetWeakUnsafe(UMovieSceneNumericVariantGetter* InDynamicValue);
 
 
    MOVIESCENE_API void MakeWeakUnsafe();
 
 
    MOVIESCENE_API double Get() const;
 
 
    MOVIESCENE_API UMovieSceneNumericVariantGetter* GetCustomPtr() const;
 
 
    bool IsLiteral() const;
 
 
    double GetLiteral() const;
 
 
    float GetLiteralAsFloat() const;
 
 
    bool IsCustomPtr() const;
 
 
public:
 
 
    MOVIESCENE_API FMovieSceneNumericVariant ShallowCopy() const;
 
 
    MOVIESCENE_API FMovieSceneNumericVariant DeepCopy(UObject* NewOuter) const;
 
 
public:
 
 
    bool Serialize(FArchive& Ar);
    bool Identical(const FMovieSceneNumericVariant* Other, uint32 PortFlags) const;
    void AddStructReferencedObjects(FReferenceCollector& Collector);
    bool SerializeFromMismatchedTag(const FPropertyTag& Tag, FStructuredArchive::FSlot Slot);
    bool ExportTextItem(FString& ValueStr, const FMovieSceneNumericVariant& DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope) const;
    bool ImportTextItem(const TCHAR*& Buffer, int32 PortFlags, UObject* Parent, FOutputDevice* ErrorText, FArchive* InSerializingArchive = nullptr);
    void GetPreloadDependencies(TArray<UObject*>& OutDeps);
 
    bool SerializeCustom(FArchive& Ar, TFunctionRef<void(FArchive&, uint8&, void*)>);
 
 
public:
 
 
    template<typename T>
    void SetTypedData(const T& InValue, uint8 InType);
 
 
    template<typename T>
    T UnsafePayloadCast() const;
 
 
    MOVIESCENE_API void SetTypeBits(uint8 InType);
 
 
    MOVIESCENE_API uint8 GetTypeBits() const;
 
 
private:
 
    // Flags specifying different regions on an IEEE 754 double
    static constexpr uint64 HIGH_Bits      = 0xFFF0000000000000u; // All high bits (eg, Sign + exponent bits)
    static constexpr uint64 EXP_Bits       = 0x7FF0000000000000u; // Exponent bits 
    static constexpr uint64 SIGN_Bit       = 0x8000000000000000u; // Sign bit
    static constexpr uint64 QUIET_Bit      = 0x0008000000000000u; // Quiet NaN bit
    static constexpr uint64 TYPE_Bits      = 0x0007000000000000u; // Unused NaN bits that we repurpose for variant type information
    static constexpr uint64 TYPE_CustomPtr = 0x0000000000000000u; // INTENTIONALLY ZERO: Special value for TYPE_Bits when our data points to a UMovieSceneNumericVariantGetter*. 
    static constexpr uint64 PAYLOAD_Bits   = 0x0000FFFFFFFFFFFFu; // Bitmask specifying valid bits that can be used for custom payloads when any of TAGGED_Bits is set
 
    static constexpr uint64 CUSTOMPTR_FlagBits = 0x0000000000000003u; // Low bitmask that (ab)uses the alignment of UMovieSceneNumericVariantGetter to encode additional flags
    static constexpr uint64 CUSTOMPTR_Weak     = 0x0000000000000001u; // Low bit that signifies the wrapped custom pointer should not be reported to the reference graph.
 
    static constexpr uint64 TAGGED_Bits   = SIGN_Bit | EXP_Bits | QUIET_Bit;
 
 
    double& GetLiteralRef()
    {
        checkSlow(IsLiteral());
        return *reinterpret_cast<double*>(Data);
    }
 
 
    bool HasCustomWeakPtrFlag() const;
 
public:
 
    FMovieSceneNumericVariant(const FMovieSceneNumericVariant& Other) = default;
    FMovieSceneNumericVariant& operator=(const FMovieSceneNumericVariant& Other) = default;
 
private:
 
    alignas(8) uint8 Data[8];
 
#if UE_MOVIESCENE_WEAKNUMERICVARIANT_CHECKS
    TWeakObjectPtr<UMovieSceneNumericVariantGetter> WeakCustomGetter;
#endif
};
 
template<>
struct TStructOpsTypeTraits<FMovieSceneNumericVariant> : public TStructOpsTypeTraitsBase2<FMovieSceneNumericVariant>
{
    enum
    {
        WithCopy                       = true,
        WithIdenticalViaEquality       = true,
        WithSerializer                 = true,
        WithExportTextItem             = true,
        WithImportTextItem             = true,
        WithAddStructReferencedObjects = true,
        WithGetPreloadDependencies     = true,
        WithStructuredSerializeFromMismatchedTag = true,
    };
};
 
 
inline bool FMovieSceneNumericVariant::IsLiteral() const
{
    const uint64 Value = *reinterpret_cast<const uint64*>(Data);
 
    // Literal if the double is a quiet nan
    return (Value & TAGGED_Bits) != TAGGED_Bits;
}
 
inline double FMovieSceneNumericVariant::GetLiteral() const
{
    checkSlow(IsLiteral());
    return *reinterpret_cast<const double*>(Data);
}
 
inline float FMovieSceneNumericVariant::GetLiteralAsFloat() const
{
    return static_cast<float>(
        FMath::Clamp<double>(
            GetLiteral(),
            std::numeric_limits<float>::lowest(),
            std::numeric_limits<float>::max()
        )
    );
}
 
inline bool FMovieSceneNumericVariant::IsCustomPtr() const
{
    return !IsLiteral() && (GetTypeBits() == TYPE_CustomPtr);
}
 
 
template<typename T>
void FMovieSceneNumericVariant::SetTypedData(const T& InValue, uint8 InType)
{
    check(InType > TYPE_CustomPtr && (InType <= TYPE_Bits >> 48) );
    static_assert(sizeof(T) <= 6, "Type too big. Maximum supported size is 48 bits");
 
    uint64 NewValue = 0;
 
    void*  NewValueAddr  = &NewValue;
    uint8* NewValueBytes = static_cast<uint8*>(NewValueAddr);
 
    FMemory::Memcpy(NewValueBytes, &InValue, sizeof(T));
 
    *reinterpret_cast<uint64*>(Data) = TAGGED_Bits | NewValue;
    SetTypeBits(InType);
}
 
template<typename T>
T FMovieSceneNumericVariant::UnsafePayloadCast() const
{
    check(!IsLiteral());
    const uint64 PtrValue = *reinterpret_cast<const uint64*>(Data) & PAYLOAD_Bits;
    const void* ValuePtr = &PtrValue;
    return *reinterpret_cast<const T*>(ValuePtr);
}