498 lines
17 KiB
C++
498 lines
17 KiB
C++
|
// Copyright Epic Games, Inc. All Rights Reserved.
|
||
|
|
|
||
|
|
#include "UObject/EnumProperty.h"
|
||
|
|
#include "UObject/PropertyPortFlags.h"
|
||
|
|
#include "UObject/UObjectThreadContext.h"
|
||
|
|
#include "UObject/PropertyTag.h"
|
||
|
|
#include "UObject/UnrealTypePrivate.h"
|
||
|
|
#include "Templates/ChooseClass.h"
|
||
|
|
#include "Templates/IsSigned.h"
|
||
|
|
#include "Algo/Find.h"
|
||
|
|
#include "UObject/LinkerLoad.h"
|
||
|
|
#include "Misc/NetworkVersion.h"
|
||
|
|
|
||
|
|
// WARNING: This should always be the last include in any file that needs it (except .generated.h)
|
||
|
|
#include "UObject/UndefineUPropertyMacros.h"
|
||
|
|
|
||
|
|
namespace UE4EnumProperty_Private
|
||
|
|
{
|
||
|
|
template <typename OldIntType>
|
||
|
|
void ConvertIntToEnumProperty(FStructuredArchive::FSlot Slot, FEnumProperty* EnumProp, FNumericProperty* UnderlyingProp, UEnum* Enum, void* Obj)
|
||
|
|
{
|
||
|
|
OldIntType OldValue;
|
||
|
|
Slot << OldValue;
|
||
|
|
|
||
|
|
using LargeIntType = typename TChooseClass<TIsSigned<OldIntType>::Value, int64, uint64>::Result;
|
||
|
|
|
||
|
|
LargeIntType NewValue = OldValue;
|
||
|
|
if (!UnderlyingProp->CanHoldValue(NewValue) || !Enum->IsValidEnumValue(NewValue))
|
||
|
|
{
|
||
|
|
UE_LOG(
|
||
|
|
LogClass,
|
||
|
|
Warning,
|
||
|
|
TEXT("Failed to find valid enum value '%s' for enum type '%s' when converting property '%s' during property loading - setting to '%s'"),
|
||
|
|
*LexToString(OldValue),
|
||
|
|
*Enum->GetName(),
|
||
|
|
*EnumProp->GetName(),
|
||
|
|
*Enum->GetNameByValue(Enum->GetMaxEnumValue()).ToString());
|
||
|
|
|
||
|
|
NewValue = Enum->GetMaxEnumValue();
|
||
|
|
}
|
||
|
|
|
||
|
|
UnderlyingProp->SetIntPropertyValue(Obj, NewValue);
|
||
|
|
}
|
||
|
|
} // namespace UE4EnumProperty_Private
|
||
|
|
|
||
|
|
IMPLEMENT_FIELD(FEnumProperty)
|
||
|
|
|
||
|
|
FEnumProperty::FEnumProperty(FFieldVariant InOwner, const FName& InName, EObjectFlags InObjectFlags)
|
||
|
|
: FProperty(InOwner, InName, InObjectFlags), UnderlyingProp(nullptr), Enum(nullptr)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
FEnumProperty::FEnumProperty(FFieldVariant InOwner, const FName& InName, EObjectFlags InObjectFlags, UEnum* InEnum)
|
||
|
|
: FProperty(InOwner, InName, InObjectFlags, 0, CPF_HasGetValueTypeHash), Enum(InEnum)
|
||
|
|
{
|
||
|
|
// This is expected to be set post-construction by AddCppProperty
|
||
|
|
UnderlyingProp = nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
FEnumProperty::FEnumProperty(FFieldVariant InOwner, const FName& InName, EObjectFlags InObjectFlags, int32 InOffset, EPropertyFlags InFlags, UEnum* InEnum)
|
||
|
|
: FProperty(InOwner, InName, InObjectFlags, InOffset, InFlags | CPF_HasGetValueTypeHash), Enum(InEnum)
|
||
|
|
{
|
||
|
|
// This is expected to be set post-construction by AddCppProperty
|
||
|
|
UnderlyingProp = nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
#if WITH_EDITORONLY_DATA
|
||
|
|
FEnumProperty::FEnumProperty(UField* InField)
|
||
|
|
: FProperty(InField)
|
||
|
|
{
|
||
|
|
UEnumProperty* SourceProperty = CastChecked<UEnumProperty>(InField);
|
||
|
|
Enum = SourceProperty->Enum;
|
||
|
|
|
||
|
|
UnderlyingProp = CastField<FNumericProperty>(SourceProperty->UnderlyingProp->GetAssociatedFField());
|
||
|
|
if (!UnderlyingProp)
|
||
|
|
{
|
||
|
|
UnderlyingProp = CastField<FNumericProperty>(CreateFromUField(SourceProperty->UnderlyingProp));
|
||
|
|
SourceProperty->UnderlyingProp->SetAssociatedFField(UnderlyingProp);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif // WITH_EDITORONLY_DATA
|
||
|
|
|
||
|
|
FEnumProperty::~FEnumProperty()
|
||
|
|
{
|
||
|
|
delete UnderlyingProp;
|
||
|
|
UnderlyingProp = nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
void FEnumProperty::PostDuplicate(const FField& InField)
|
||
|
|
{
|
||
|
|
const FEnumProperty& Source = static_cast<const FEnumProperty&>(InField);
|
||
|
|
Enum = Source.Enum;
|
||
|
|
UnderlyingProp = CastFieldChecked<FNumericProperty>(FField::Duplicate(Source.UnderlyingProp, this));
|
||
|
|
Super::PostDuplicate(InField);
|
||
|
|
}
|
||
|
|
|
||
|
|
void FEnumProperty::AddCppProperty(FProperty* Inner)
|
||
|
|
{
|
||
|
|
check(!UnderlyingProp);
|
||
|
|
UnderlyingProp = CastFieldChecked<FNumericProperty>(Inner);
|
||
|
|
check(UnderlyingProp->GetOwner<FEnumProperty>() == this);
|
||
|
|
if (UnderlyingProp->HasAnyPropertyFlags(CPF_HasGetValueTypeHash))
|
||
|
|
{
|
||
|
|
PropertyFlags |= CPF_HasGetValueTypeHash;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void FEnumProperty::SerializeItem(FStructuredArchive::FSlot Slot, void* Value, void const* Defaults) const
|
||
|
|
{
|
||
|
|
FArchive& UnderlyingArchive = Slot.GetUnderlyingArchive();
|
||
|
|
|
||
|
|
check(UnderlyingProp);
|
||
|
|
|
||
|
|
if (Enum && UnderlyingArchive.UseToResolveEnumerators())
|
||
|
|
{
|
||
|
|
Slot.EnterStream();
|
||
|
|
int64 IntValue = UnderlyingProp->GetSignedIntPropertyValue(Value);
|
||
|
|
int64 ResolvedIndex = Enum->ResolveEnumerator(UnderlyingArchive, IntValue);
|
||
|
|
UnderlyingProp->SetIntPropertyValue(Value, ResolvedIndex);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Loading
|
||
|
|
if (UnderlyingArchive.IsLoading())
|
||
|
|
{
|
||
|
|
FName EnumValueName;
|
||
|
|
Slot << EnumValueName;
|
||
|
|
|
||
|
|
int64 NewEnumValue = 0;
|
||
|
|
|
||
|
|
if (Enum)
|
||
|
|
{
|
||
|
|
// Make sure enum is properly populated
|
||
|
|
if (Enum->HasAnyFlags(RF_NeedLoad))
|
||
|
|
{
|
||
|
|
UnderlyingArchive.Preload(Enum);
|
||
|
|
}
|
||
|
|
|
||
|
|
// There's no guarantee EnumValueName is still present in Enum, in which case Value will be set to the enum's max value.
|
||
|
|
// On save, it will then be serialized as NAME_None.
|
||
|
|
const int32 EnumIndex = Enum->GetIndexByName(EnumValueName, EGetByNameFlags::ErrorIfNotFound);
|
||
|
|
if (EnumIndex == INDEX_NONE)
|
||
|
|
{
|
||
|
|
NewEnumValue = Enum->GetMaxEnumValue();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
NewEnumValue = Enum->GetValueByIndex(EnumIndex);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
UnderlyingProp->SetIntPropertyValue(Value, NewEnumValue);
|
||
|
|
}
|
||
|
|
// Saving
|
||
|
|
else if (UnderlyingArchive.IsSaving())
|
||
|
|
{
|
||
|
|
FName EnumValueName;
|
||
|
|
if (Enum)
|
||
|
|
{
|
||
|
|
const int64 IntValue = UnderlyingProp->GetSignedIntPropertyValue(Value);
|
||
|
|
|
||
|
|
if (Enum->IsValidEnumValue(IntValue))
|
||
|
|
{
|
||
|
|
EnumValueName = Enum->GetNameByValue(IntValue);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Slot << EnumValueName;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
UnderlyingProp->SerializeItem(Slot, Value, Defaults);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool FEnumProperty::NetSerializeItem(FArchive& Ar, UPackageMap* Map, void* Data, TArray<uint8>* MetaData) const
|
||
|
|
{
|
||
|
|
if (Ar.EngineNetVer() < HISTORY_FIX_ENUM_SERIALIZATION)
|
||
|
|
{
|
||
|
|
Ar.SerializeBits(Data, FMath::CeilLogTwo64(Enum->GetMaxEnumValue()));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Ar.SerializeBits(Data, GetMaxNetSerializeBits());
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void FEnumProperty::Serialize(FArchive& Ar)
|
||
|
|
{
|
||
|
|
Super::Serialize(Ar);
|
||
|
|
Ar << Enum;
|
||
|
|
if (Enum != nullptr)
|
||
|
|
{
|
||
|
|
Ar.Preload(Enum);
|
||
|
|
}
|
||
|
|
SerializeSingleField(Ar, UnderlyingProp, this);
|
||
|
|
}
|
||
|
|
|
||
|
|
void FEnumProperty::AddReferencedObjects(FReferenceCollector& Collector)
|
||
|
|
{
|
||
|
|
Collector.AddReferencedObject(Enum);
|
||
|
|
Super::AddReferencedObjects(Collector);
|
||
|
|
}
|
||
|
|
|
||
|
|
FString FEnumProperty::GetCPPType(FString* ExtendedTypeText, uint32 CPPExportFlags) const
|
||
|
|
{
|
||
|
|
check(Enum);
|
||
|
|
check(UnderlyingProp);
|
||
|
|
|
||
|
|
const bool bNonNativeEnum = Enum->GetClass() != UEnum::StaticClass(); // cannot use RF_Native flag, because in UHT the flag is not set
|
||
|
|
|
||
|
|
if (!Enum->CppType.IsEmpty())
|
||
|
|
{
|
||
|
|
return Enum->CppType;
|
||
|
|
}
|
||
|
|
|
||
|
|
FString EnumName = Enum->GetName();
|
||
|
|
|
||
|
|
// This would give the wrong result if it's a namespaced type and the CppType hasn't
|
||
|
|
// been set, but we do this here in case existing code relies on it... somehow.
|
||
|
|
if ((CPPExportFlags & CPPF_BlueprintCppBackend) && bNonNativeEnum)
|
||
|
|
{
|
||
|
|
ensure(Enum->CppType.IsEmpty());
|
||
|
|
FString Result = ::UnicodeToCPPIdentifier(EnumName, false, TEXT("E__"));
|
||
|
|
return Result;
|
||
|
|
}
|
||
|
|
|
||
|
|
return EnumName;
|
||
|
|
}
|
||
|
|
|
||
|
|
void FEnumProperty::ExportTextItem(FString& ValueStr, const void* PropertyValue, const void* DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope) const
|
||
|
|
{
|
||
|
|
if (Enum == nullptr)
|
||
|
|
{
|
||
|
|
UE_LOG(
|
||
|
|
LogClass,
|
||
|
|
Warning,
|
||
|
|
TEXT("Member 'Enum' of %s is nullptr, export operation would fail. This can occur when the enum class has been moved or deleted."),
|
||
|
|
*GetFullName());
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
check(UnderlyingProp);
|
||
|
|
|
||
|
|
FNumericProperty* LocalUnderlyingProp = UnderlyingProp;
|
||
|
|
|
||
|
|
if (PortFlags & PPF_ExportCpp)
|
||
|
|
{
|
||
|
|
const int64 ActualValue = LocalUnderlyingProp->GetSignedIntPropertyValue(PropertyValue);
|
||
|
|
const int64 MaxValue = Enum->GetMaxEnumValue();
|
||
|
|
const int64 GoodValue = Enum->IsValidEnumValue(ActualValue) ? ActualValue : MaxValue;
|
||
|
|
const bool bNonNativeEnum = Enum->GetClass() != UEnum::StaticClass();
|
||
|
|
ensure(!bNonNativeEnum || Enum->CppType.IsEmpty());
|
||
|
|
const FString FullyQualifiedEnumName = bNonNativeEnum ? ::UnicodeToCPPIdentifier(Enum->GetName(), false, TEXT("E__")) : (Enum->CppType.IsEmpty() ? Enum->GetName() : Enum->CppType);
|
||
|
|
if (GoodValue == MaxValue)
|
||
|
|
{
|
||
|
|
// not all native enums have Max value declared
|
||
|
|
ValueStr += FString::Printf(TEXT("(%s)(%ull)"), *FullyQualifiedEnumName, ActualValue);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ValueStr += FString::Printf(TEXT("%s::%s"), *FullyQualifiedEnumName,
|
||
|
|
*Enum->GetNameStringByValue(GoodValue));
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (PortFlags & PPF_ConsoleVariable)
|
||
|
|
{
|
||
|
|
UnderlyingProp->ExportTextItem(ValueStr, PropertyValue, DefaultValue, Parent, PortFlags, ExportRootScope);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
int64 Value = LocalUnderlyingProp->GetSignedIntPropertyValue(PropertyValue);
|
||
|
|
|
||
|
|
// if the value is the max value (the autogenerated *_MAX value), export as "INVALID", unless we're exporting text for copy/paste (for copy/paste,
|
||
|
|
// the property text value must actually match an entry in the enum's names array)
|
||
|
|
if (!Enum->IsValidEnumValue(Value) || (!(PortFlags & PPF_Copy) && Value == Enum->GetMaxEnumValue()))
|
||
|
|
{
|
||
|
|
ValueStr += TEXT("(INVALID)");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// We do not want to export the enum text for non-display uses, localization text is very dynamic and would cause issues on import
|
||
|
|
if (PortFlags & PPF_PropertyWindow)
|
||
|
|
{
|
||
|
|
ValueStr += Enum->GetDisplayNameTextByValue(Value).ToString();
|
||
|
|
}
|
||
|
|
else if (PortFlags & PPF_ExternalEditor)
|
||
|
|
{
|
||
|
|
ValueStr += Enum->GetAuthoredNameStringByValue(Value);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ValueStr += Enum->GetNameStringByValue(Value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const TCHAR* FEnumProperty::ImportText_Internal(const TCHAR* InBuffer, void* Data, int32 PortFlags, UObject* Parent, FOutputDevice* ErrorText) const
|
||
|
|
{
|
||
|
|
check(Enum);
|
||
|
|
check(UnderlyingProp);
|
||
|
|
|
||
|
|
if (!(PortFlags & PPF_ConsoleVariable))
|
||
|
|
{
|
||
|
|
FString Temp;
|
||
|
|
if (const TCHAR* Buffer = FPropertyHelpers::ReadToken(InBuffer, Temp, true))
|
||
|
|
{
|
||
|
|
int32 EnumIndex = Enum->GetIndexByName(*Temp, EGetByNameFlags::CheckAuthoredName);
|
||
|
|
if (EnumIndex == INDEX_NONE && (Temp.IsNumeric() && !Algo::Find(Temp, TEXT('.'))))
|
||
|
|
{
|
||
|
|
int64 EnumValue = INDEX_NONE;
|
||
|
|
LexFromString(EnumValue, *Temp);
|
||
|
|
EnumIndex = Enum->GetIndexByValue(EnumValue);
|
||
|
|
}
|
||
|
|
if (EnumIndex != INDEX_NONE)
|
||
|
|
{
|
||
|
|
UnderlyingProp->SetIntPropertyValue(Data, Enum->GetValueByIndex(EnumIndex));
|
||
|
|
return Buffer;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Enum could not be created from value. This indicates a bad value so
|
||
|
|
// return null so that the caller of ImportText can generate a more meaningful
|
||
|
|
// warning/error
|
||
|
|
UObject* SerializedObject = nullptr;
|
||
|
|
if (FLinkerLoad* Linker = GetLinker())
|
||
|
|
{
|
||
|
|
if (FUObjectSerializeContext* LoadContext = Linker->GetSerializeContext())
|
||
|
|
{
|
||
|
|
SerializedObject = LoadContext->SerializedObject;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
UE_LOG(LogClass, Warning, TEXT("In asset '%s', there is an enum property of type '%s' with an invalid value of '%s'"), *GetPathNameSafe(SerializedObject ? SerializedObject : FUObjectThreadContext::Get().ConstructedObject), *Enum->GetName(), *Temp);
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const TCHAR* Result = UnderlyingProp->ImportText(InBuffer, Data, PortFlags, Parent, ErrorText);
|
||
|
|
return Result;
|
||
|
|
}
|
||
|
|
|
||
|
|
FString FEnumProperty::GetCPPMacroType(FString& ExtendedTypeText) const
|
||
|
|
{
|
||
|
|
ExtendedTypeText = Enum->GetName();
|
||
|
|
return TEXT("ENUM");
|
||
|
|
}
|
||
|
|
|
||
|
|
FString FEnumProperty::GetCPPTypeForwardDeclaration() const
|
||
|
|
{
|
||
|
|
check(Enum);
|
||
|
|
check(Enum->GetCppForm() == UEnum::ECppForm::EnumClass);
|
||
|
|
|
||
|
|
return FString::Printf(TEXT("enum class %s : %s;"), *Enum->GetName(), *UnderlyingProp->GetCPPType());
|
||
|
|
}
|
||
|
|
|
||
|
|
void FEnumProperty::GetPreloadDependencies(TArray<UObject*>& OutDeps)
|
||
|
|
{
|
||
|
|
Super::GetPreloadDependencies(OutDeps);
|
||
|
|
// OutDeps.Add(UnderlyingProp);
|
||
|
|
OutDeps.Add(Enum);
|
||
|
|
}
|
||
|
|
|
||
|
|
void FEnumProperty::LinkInternal(FArchive& Ar)
|
||
|
|
{
|
||
|
|
check(UnderlyingProp);
|
||
|
|
|
||
|
|
UnderlyingProp->Link(Ar);
|
||
|
|
|
||
|
|
this->ElementSize = UnderlyingProp->ElementSize;
|
||
|
|
this->PropertyFlags |= CPF_IsPlainOldData | CPF_NoDestructor | CPF_ZeroConstructor;
|
||
|
|
|
||
|
|
PropertyFlags |= (UnderlyingProp->PropertyFlags & CPF_HasGetValueTypeHash);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool FEnumProperty::Identical(const void* A, const void* B, uint32 PortFlags) const
|
||
|
|
{
|
||
|
|
return UnderlyingProp->Identical(A, B, PortFlags);
|
||
|
|
}
|
||
|
|
|
||
|
|
int32 FEnumProperty::GetMinAlignment() const
|
||
|
|
{
|
||
|
|
return UnderlyingProp->GetMinAlignment();
|
||
|
|
}
|
||
|
|
|
||
|
|
bool FEnumProperty::SameType(const FProperty* Other) const
|
||
|
|
{
|
||
|
|
return Super::SameType(Other) && static_cast<const FEnumProperty*>(Other)->Enum == Enum;
|
||
|
|
}
|
||
|
|
|
||
|
|
EConvertFromTypeResult FEnumProperty::ConvertFromType(const FPropertyTag& Tag, FStructuredArchive::FSlot Slot, uint8* Data, UStruct* DefaultsStruct)
|
||
|
|
{
|
||
|
|
if ((Enum == nullptr) || (UnderlyingProp == nullptr))
|
||
|
|
{
|
||
|
|
return EConvertFromTypeResult::UseSerializeItem;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Tag.Type == NAME_ByteProperty)
|
||
|
|
{
|
||
|
|
uint8 PreviousValue = 0;
|
||
|
|
if (Tag.EnumName == NAME_None)
|
||
|
|
{
|
||
|
|
// If we're a nested property the EnumName tag got lost. Handle this case for backward compatibility reasons
|
||
|
|
FProperty* const PropertyOwner = GetOwner<FProperty>();
|
||
|
|
|
||
|
|
if (PropertyOwner)
|
||
|
|
{
|
||
|
|
FPropertyTag InnerPropertyTag;
|
||
|
|
InnerPropertyTag.Type = Tag.Type;
|
||
|
|
InnerPropertyTag.EnumName = Enum->GetFName();
|
||
|
|
InnerPropertyTag.ArrayIndex = 0;
|
||
|
|
|
||
|
|
PreviousValue = (uint8)FNumericProperty::ReadEnumAsInt64(Slot, DefaultsStruct, InnerPropertyTag);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// a byte property gained an enum
|
||
|
|
Slot << PreviousValue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
PreviousValue = (uint8)FNumericProperty::ReadEnumAsInt64(Slot, DefaultsStruct, Tag);
|
||
|
|
}
|
||
|
|
|
||
|
|
// now copy the value into the object's address space
|
||
|
|
UnderlyingProp->SetIntPropertyValue(ContainerPtrToValuePtr<void>(Data, Tag.ArrayIndex), (uint64)PreviousValue);
|
||
|
|
}
|
||
|
|
else if (Tag.Type == NAME_Int8Property)
|
||
|
|
{
|
||
|
|
UE4EnumProperty_Private::ConvertIntToEnumProperty<int8>(Slot, this, UnderlyingProp, Enum, ContainerPtrToValuePtr<void>(Data, Tag.ArrayIndex));
|
||
|
|
}
|
||
|
|
else if (Tag.Type == NAME_Int16Property)
|
||
|
|
{
|
||
|
|
UE4EnumProperty_Private::ConvertIntToEnumProperty<int16>(Slot, this, UnderlyingProp, Enum, ContainerPtrToValuePtr<void>(Data, Tag.ArrayIndex));
|
||
|
|
}
|
||
|
|
else if (Tag.Type == NAME_IntProperty)
|
||
|
|
{
|
||
|
|
UE4EnumProperty_Private::ConvertIntToEnumProperty<int32>(Slot, this, UnderlyingProp, Enum, ContainerPtrToValuePtr<void>(Data, Tag.ArrayIndex));
|
||
|
|
}
|
||
|
|
else if (Tag.Type == NAME_Int64Property)
|
||
|
|
{
|
||
|
|
UE4EnumProperty_Private::ConvertIntToEnumProperty<int64>(Slot, this, UnderlyingProp, Enum, ContainerPtrToValuePtr<void>(Data, Tag.ArrayIndex));
|
||
|
|
}
|
||
|
|
else if (Tag.Type == NAME_UInt16Property)
|
||
|
|
{
|
||
|
|
UE4EnumProperty_Private::ConvertIntToEnumProperty<uint16>(Slot, this, UnderlyingProp, Enum, ContainerPtrToValuePtr<void>(Data, Tag.ArrayIndex));
|
||
|
|
}
|
||
|
|
else if (Tag.Type == NAME_UInt32Property)
|
||
|
|
{
|
||
|
|
UE4EnumProperty_Private::ConvertIntToEnumProperty<uint32>(Slot, this, UnderlyingProp, Enum, ContainerPtrToValuePtr<void>(Data, Tag.ArrayIndex));
|
||
|
|
}
|
||
|
|
else if (Tag.Type == NAME_UInt64Property)
|
||
|
|
{
|
||
|
|
UE4EnumProperty_Private::ConvertIntToEnumProperty<uint64>(Slot, this, UnderlyingProp, Enum, ContainerPtrToValuePtr<void>(Data, Tag.ArrayIndex));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return EConvertFromTypeResult::UseSerializeItem;
|
||
|
|
}
|
||
|
|
|
||
|
|
return EConvertFromTypeResult::Converted;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint32 FEnumProperty::GetValueTypeHashInternal(const void* Src) const
|
||
|
|
{
|
||
|
|
check(UnderlyingProp);
|
||
|
|
return UnderlyingProp->GetValueTypeHash(Src);
|
||
|
|
}
|
||
|
|
|
||
|
|
FField* FEnumProperty::GetInnerFieldByName(const FName& InName)
|
||
|
|
{
|
||
|
|
if (UnderlyingProp && UnderlyingProp->GetFName() == InName)
|
||
|
|
{
|
||
|
|
return UnderlyingProp;
|
||
|
|
}
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
void FEnumProperty::GetInnerFields(TArray<FField*>& OutFields)
|
||
|
|
{
|
||
|
|
if (UnderlyingProp)
|
||
|
|
{
|
||
|
|
OutFields.Add(UnderlyingProp);
|
||
|
|
UnderlyingProp->GetInnerFields(OutFields);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
uint64 FEnumProperty::GetMaxNetSerializeBits() const
|
||
|
|
{
|
||
|
|
const uint64 MaxBits = ElementSize * 8;
|
||
|
|
const uint64 DesiredBits = FMath::CeilLogTwo64(Enum->GetMaxEnumValue() + 1);
|
||
|
|
|
||
|
|
return FMath::Min(DesiredBits, MaxBits);
|
||
|
|
}
|
||
|
|
|
||
|
|
#include "UObject/DefineUPropertyMacros.h"
|