/*-----------------------------------------------------------------------------
UByteProperty.
-----------------------------------------------------------------------------*/
void UByteProperty::SerializeItem( FArchive& Ar, void* Value, void const* Defaults ) const
{
if(Enum && Ar.UseToResolveEnumerators())
{
const int32 ResolvedIndex = Enum->ResolveEnumerator(Ar, *(uint8*)Value);
*(uint8*)Value = static_cast<uint8>(ResolvedIndex);
return;
}
// Serialize enum values by name unless we're not saving or loading OR for backwards compatibility
const bool bUseBinarySerialization = (Enum == NULL) || (!Ar.IsLoading() && !Ar.IsSaving());
if( bUseBinarySerialization )
{
Super::SerializeItem(Ar, Value, Defaults);
}
// Loading
else if (Ar.IsLoading())
{
FName EnumValueName;
Ar << EnumValueName;
// Make sure enum is properly populated
if( Enum->HasAnyFlags(RF_NeedLoad) )
{
Ar.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.
int32 EnumIndex = Enum->FindEnumIndex(EnumValueName);
if (EnumIndex == INDEX_NONE)
{
*(uint8*)Value = Enum->GetMaxEnumValue();
}
else
{
*(uint8*)Value = Enum->GetValueByIndex(EnumIndex);
}
}
// Saving
else
{
FName EnumValueName;
uint8 ByteValue = *(uint8*)Value;
// subtract 1 because the last entry in the enum's Names array
// is the _MAX entry
if ( Enum->IsValidEnumValue(ByteValue) )
{
EnumValueName = Enum->GetNameByValue(ByteValue);
}
else
{
EnumValueName = NAME_None;
}
Ar << EnumValueName;
}
}
int32 FEnumEditorUtils::ResolveEnumerator(const UEnum* Enum, FArchive& Ar, int32 EnumeratorIndex)
{
check(Ar.UseToResolveEnumerators());
const FArchiveEnumeratorResolver* EnumeratorResolver = (FArchiveEnumeratorResolver*)(&Ar);
if(Enum == EnumeratorResolver->Enum)
{
const auto& OldNames = EnumeratorResolver->OldNames;
if(EnumeratorIndex < OldNames.Num())
{
const FName EnumeratorName = OldNames[EnumeratorIndex].Key;
const int32 NewEnumIndex = Enum->FindEnumIndex(EnumeratorName);
if(INDEX_NONE != NewEnumIndex)
{
return NewEnumIndex;
}
}
return (Enum->NumEnums() - 1);
}
return EnumeratorIndex;
}
int32 FEnumEditorUtils::ResolveEnumerator(const UEnum* Enum, FArchive& Ar, int32 EnumeratorValue)
{
check(Ar.UseToResolveEnumerators());
const FArchiveEnumeratorResolver* EnumeratorResolver = (FArchiveEnumeratorResolver*)(&Ar);
if(Enum == EnumeratorResolver->Enum)
{
for (TPair<FName, uint8> OldName : EnumeratorResolver->OldNames)
{
if (OldName.Value == EnumeratorValue)
{
const FName EnumeratorName = OldName.Key;
const int32 NewEnumValue = Enum->GetValueByName(EnumeratorName);
if(INDEX_NONE != NewEnumValue)
{
return NewEnumValue;
}
}
}
return Enum->GetMaxEnumValue();
}
return EnumeratorValue;
}
