776 lines
27 KiB
C++
776 lines
27 KiB
C++
|
// Copyright Epic Games, Inc. All Rights Reserved.
|
||
|
|
|
||
|
|
#include "CoreMinimal.h"
|
||
|
|
#include "UObject/ObjectMacros.h"
|
||
|
|
#include "Templates/Casts.h"
|
||
|
|
#include "UObject/PropertyTag.h"
|
||
|
|
#include "UObject/UnrealType.h"
|
||
|
|
#include "UObject/UnrealTypePrivate.h"
|
||
|
|
#include "UObject/LinkerLoad.h"
|
||
|
|
#include "UObject/PropertyHelper.h"
|
||
|
|
|
||
|
|
// WARNING: This should always be the last include in any file that needs it (except .generated.h)
|
||
|
|
#include "UObject/UndefineUPropertyMacros.h"
|
||
|
|
|
||
|
|
/*-----------------------------------------------------------------------------
|
||
|
|
FArrayProperty.
|
||
|
|
-----------------------------------------------------------------------------*/
|
||
|
|
IMPLEMENT_FIELD(FArrayProperty)
|
||
|
|
|
||
|
|
#if WITH_EDITORONLY_DATA
|
||
|
|
FArrayProperty::FArrayProperty(UField* InField)
|
||
|
|
: FArrayProperty_Super(InField), ArrayFlags(EArrayPropertyFlags::None)
|
||
|
|
{
|
||
|
|
UArrayProperty* SourceProperty = CastChecked<UArrayProperty>(InField);
|
||
|
|
Inner = CastField<FProperty>(SourceProperty->Inner->GetAssociatedFField());
|
||
|
|
if (!Inner)
|
||
|
|
{
|
||
|
|
Inner = CastField<FProperty>(CreateFromUField(SourceProperty->Inner));
|
||
|
|
SourceProperty->Inner->SetAssociatedFField(Inner);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif // WITH_EDITORONLY_DATA
|
||
|
|
|
||
|
|
FArrayProperty::~FArrayProperty()
|
||
|
|
{
|
||
|
|
delete Inner;
|
||
|
|
Inner = nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
void FArrayProperty::GetPreloadDependencies(TArray<UObject*>& OutDeps)
|
||
|
|
{
|
||
|
|
Super::GetPreloadDependencies(OutDeps);
|
||
|
|
if (Inner)
|
||
|
|
{
|
||
|
|
Inner->GetPreloadDependencies(OutDeps);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void FArrayProperty::PostDuplicate(const FField& InField)
|
||
|
|
{
|
||
|
|
const FArrayProperty& Source = static_cast<const FArrayProperty&>(InField);
|
||
|
|
Inner = CastFieldChecked<FProperty>(FField::Duplicate(Source.Inner, this));
|
||
|
|
Super::PostDuplicate(InField);
|
||
|
|
}
|
||
|
|
|
||
|
|
void FArrayProperty::LinkInternal(FArchive& Ar)
|
||
|
|
{
|
||
|
|
// FLinkerLoad* MyLinker = GetLinker();
|
||
|
|
// if( MyLinker )
|
||
|
|
//{
|
||
|
|
// MyLinker->Preload(this);
|
||
|
|
// }
|
||
|
|
// Ar.Preload(Inner);
|
||
|
|
Inner->Link(Ar);
|
||
|
|
|
||
|
|
SetElementSize();
|
||
|
|
}
|
||
|
|
bool FArrayProperty::Identical(const void* A, const void* B, uint32 PortFlags) const
|
||
|
|
{
|
||
|
|
checkSlow(Inner);
|
||
|
|
|
||
|
|
FScriptArrayHelper ArrayHelperA(this, A);
|
||
|
|
|
||
|
|
const int32 ArrayNum = ArrayHelperA.Num();
|
||
|
|
if (B == NULL)
|
||
|
|
{
|
||
|
|
return ArrayNum == 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
FScriptArrayHelper ArrayHelperB(this, B);
|
||
|
|
if (ArrayNum != ArrayHelperB.Num())
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int32 ArrayIndex = 0; ArrayIndex < ArrayNum; ArrayIndex++)
|
||
|
|
{
|
||
|
|
if (!Inner->Identical(ArrayHelperA.GetRawPtr(ArrayIndex), ArrayHelperB.GetRawPtr(ArrayIndex), PortFlags))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool CanBulkSerialize(FProperty* Property)
|
||
|
|
{
|
||
|
|
#if PLATFORM_LITTLE_ENDIAN
|
||
|
|
// All numeric properties except TEnumAsByte
|
||
|
|
uint64 CastFlags = Property->GetClass()->GetCastFlags();
|
||
|
|
if (!!(CastFlags & CASTCLASS_FNumericProperty))
|
||
|
|
{
|
||
|
|
bool bEnumAsByte = (CastFlags & CASTCLASS_FByteProperty) != 0 && static_cast<FByteProperty*>(Property)->Enum;
|
||
|
|
return !bEnumAsByte;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
void FArrayProperty::SerializeItem(FStructuredArchive::FSlot Slot, void* Value, void const* Defaults) const
|
||
|
|
{
|
||
|
|
check(Inner);
|
||
|
|
FArchive& UnderlyingArchive = Slot.GetUnderlyingArchive();
|
||
|
|
const bool bIsTextFormat = UnderlyingArchive.IsTextFormat();
|
||
|
|
const bool bUPS = Slot.GetArchiveState().UseUnversionedPropertySerialization();
|
||
|
|
TOptional<FPropertyTag> MaybeInnerTag;
|
||
|
|
|
||
|
|
// Ensure that the Inner itself has been loaded before calling SerializeItem() on it
|
||
|
|
// UnderlyingArchive.Preload(Inner);
|
||
|
|
|
||
|
|
FScriptArrayHelper ArrayHelper(this, Value);
|
||
|
|
int32 n = ArrayHelper.Num();
|
||
|
|
|
||
|
|
// Custom branch for UPS to try and take advantage of bulk serialization
|
||
|
|
if (bUPS)
|
||
|
|
{
|
||
|
|
checkf(!UnderlyingArchive.ArUseCustomPropertyList, TEXT("Custom property lists are not supported with UPS"));
|
||
|
|
checkf(!bIsTextFormat, TEXT("Text-based archives are not supported with UPS"));
|
||
|
|
|
||
|
|
if (CanBulkSerialize(Inner))
|
||
|
|
{
|
||
|
|
// We need to enter the slot as *something* to keep the structured archive system happy,
|
||
|
|
// but which maps down to straight writes to the underlying archive.
|
||
|
|
FStructuredArchiveStream Stream = Slot.EnterStream();
|
||
|
|
|
||
|
|
Stream.EnterElement() << n;
|
||
|
|
|
||
|
|
if (UnderlyingArchive.IsLoading())
|
||
|
|
{
|
||
|
|
ArrayHelper.EmptyAndAddUninitializedValues(n);
|
||
|
|
}
|
||
|
|
|
||
|
|
Stream.EnterElement().Serialize(ArrayHelper.GetRawPtr(), n * Inner->ElementSize);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
FStructuredArchiveArray Array = Slot.EnterArray(n);
|
||
|
|
|
||
|
|
if (UnderlyingArchive.IsLoading())
|
||
|
|
{
|
||
|
|
ArrayHelper.EmptyAndAddValues(n);
|
||
|
|
}
|
||
|
|
|
||
|
|
FSerializedPropertyScope SerializedProperty(UnderlyingArchive, Inner, this);
|
||
|
|
for (int32 i = 0; i < n; ++i)
|
||
|
|
{
|
||
|
|
#if WITH_EDITOR
|
||
|
|
static const FName NAME_UArraySerialize = FName(TEXT("FArrayProperty::Serialize"));
|
||
|
|
FName NAME_UArraySerializeCount = FName(NAME_UArraySerialize);
|
||
|
|
NAME_UArraySerializeCount.SetNumber(i);
|
||
|
|
FArchive::FScopeAddDebugData P(UnderlyingArchive, NAME_UArraySerializeCount);
|
||
|
|
#endif
|
||
|
|
Inner->SerializeItem(Array.EnterElement(), ArrayHelper.GetRawPtr(i));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (bIsTextFormat && Inner->IsA<FStructProperty>())
|
||
|
|
{
|
||
|
|
MaybeInnerTag.Emplace(UnderlyingArchive, Inner, 0, (uint8*)Value, (uint8*)Defaults);
|
||
|
|
Slot << SA_ATTRIBUTE(TEXT("InnerStructName"), MaybeInnerTag.GetValue().StructName);
|
||
|
|
Slot << SA_OPTIONAL_ATTRIBUTE(TEXT("InnerStructGuid"), MaybeInnerTag.GetValue().StructGuid, FGuid());
|
||
|
|
}
|
||
|
|
|
||
|
|
FStructuredArchiveArray Array = Slot.EnterArray(n);
|
||
|
|
|
||
|
|
if (UnderlyingArchive.IsLoading())
|
||
|
|
{
|
||
|
|
// If using a custom property list, don't empty the array on load. Not all indices may have been serialized, so we need to preserve existing values at those slots.
|
||
|
|
if (UnderlyingArchive.ArUseCustomPropertyList)
|
||
|
|
{
|
||
|
|
const int32 OldNum = ArrayHelper.Num();
|
||
|
|
if (n > OldNum)
|
||
|
|
{
|
||
|
|
ArrayHelper.AddValues(n - OldNum);
|
||
|
|
}
|
||
|
|
else if (n < OldNum)
|
||
|
|
{
|
||
|
|
ArrayHelper.RemoveValues(n, OldNum - n);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ArrayHelper.EmptyAndAddValues(n);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ArrayHelper.CountBytes(UnderlyingArchive);
|
||
|
|
|
||
|
|
// Serialize a PropertyTag for the inner property of this array, allows us to validate the inner struct to see if it has changed
|
||
|
|
if (UnderlyingArchive.UE4Ver() >= VER_UE4_INNER_ARRAY_TAG_INFO && Inner->IsA<FStructProperty>())
|
||
|
|
{
|
||
|
|
if (!MaybeInnerTag)
|
||
|
|
{
|
||
|
|
MaybeInnerTag.Emplace(UnderlyingArchive, Inner, 0, (uint8*)Value, (uint8*)Defaults);
|
||
|
|
UnderlyingArchive << MaybeInnerTag.GetValue();
|
||
|
|
}
|
||
|
|
|
||
|
|
FPropertyTag& InnerTag = MaybeInnerTag.GetValue();
|
||
|
|
|
||
|
|
if (UnderlyingArchive.IsLoading())
|
||
|
|
{
|
||
|
|
auto CanSerializeFromStructWithDifferentName = [](const FPropertyTag& PropertyTag, const FStructProperty* StructProperty)
|
||
|
|
{
|
||
|
|
return PropertyTag.StructGuid.IsValid() && StructProperty && StructProperty->Struct && (PropertyTag.StructGuid == StructProperty->Struct->GetCustomGuid());
|
||
|
|
};
|
||
|
|
|
||
|
|
// Check if the Inner property can successfully serialize, the type may have changed
|
||
|
|
FStructProperty* StructProperty = CastFieldChecked<FStructProperty>(Inner);
|
||
|
|
// if check redirector to make sure if the name has changed
|
||
|
|
FName NewName = FLinkerLoad::FindNewNameForStruct(InnerTag.StructName);
|
||
|
|
FName StructName = StructProperty->Struct->GetFName();
|
||
|
|
if (NewName != NAME_None && NewName == StructName)
|
||
|
|
{
|
||
|
|
InnerTag.StructName = NewName;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (InnerTag.StructName != StructProperty->Struct->GetFName() && !CanSerializeFromStructWithDifferentName(InnerTag, StructProperty))
|
||
|
|
{
|
||
|
|
UE_LOG(LogClass, Warning, TEXT("Property %s of %s has a struct type mismatch (tag %s != prop %s) in package: %s. If that struct got renamed, add an entry to ActiveStructRedirects."),
|
||
|
|
*InnerTag.Name.ToString(), *GetName(), *InnerTag.StructName.ToString(), *CastFieldChecked<FStructProperty>(Inner)->Struct->GetName(), *UnderlyingArchive.GetArchiveName());
|
||
|
|
|
||
|
|
#if WITH_EDITOR
|
||
|
|
// Ensure the structure is initialized
|
||
|
|
for (int32 i = 0; i < n; i++)
|
||
|
|
{
|
||
|
|
StructProperty->Struct->InitializeDefaultValue(ArrayHelper.GetRawPtr(i));
|
||
|
|
}
|
||
|
|
#endif // WITH_EDITOR
|
||
|
|
|
||
|
|
if (!bIsTextFormat)
|
||
|
|
{
|
||
|
|
// Skip the property
|
||
|
|
const int64 StartOfProperty = UnderlyingArchive.Tell();
|
||
|
|
const int64 RemainingSize = InnerTag.Size - (UnderlyingArchive.Tell() - StartOfProperty);
|
||
|
|
uint8 B;
|
||
|
|
for (int64 i = 0; i < RemainingSize; i++)
|
||
|
|
{
|
||
|
|
UnderlyingArchive << B;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// need to know how much data this call to SerializeItem consumes, so mark where we are
|
||
|
|
int64 DataOffset = UnderlyingArchive.Tell();
|
||
|
|
|
||
|
|
// If we're using a custom property list, first serialize any explicit indices
|
||
|
|
int32 i = 0;
|
||
|
|
bool bSerializeRemainingItems = true;
|
||
|
|
bool bUsingCustomPropertyList = UnderlyingArchive.ArUseCustomPropertyList;
|
||
|
|
if (bUsingCustomPropertyList && UnderlyingArchive.ArCustomPropertyList != nullptr)
|
||
|
|
{
|
||
|
|
// Initially we only serialize indices that are explicitly specified (in order)
|
||
|
|
bSerializeRemainingItems = false;
|
||
|
|
|
||
|
|
const FCustomPropertyListNode* CustomPropertyList = UnderlyingArchive.ArCustomPropertyList;
|
||
|
|
const FCustomPropertyListNode* PropertyNode = CustomPropertyList;
|
||
|
|
FSerializedPropertyScope SerializedProperty(UnderlyingArchive, Inner, this);
|
||
|
|
while (PropertyNode && i < n && !bSerializeRemainingItems)
|
||
|
|
{
|
||
|
|
if (PropertyNode->Property != Inner)
|
||
|
|
{
|
||
|
|
// A null property value signals that we should serialize the remaining array values in full starting at this index
|
||
|
|
if (PropertyNode->Property == nullptr)
|
||
|
|
{
|
||
|
|
i = PropertyNode->ArrayIndex;
|
||
|
|
}
|
||
|
|
|
||
|
|
bSerializeRemainingItems = true;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Set a temporary node to represent the item
|
||
|
|
FCustomPropertyListNode ItemNode = *PropertyNode;
|
||
|
|
ItemNode.ArrayIndex = 0;
|
||
|
|
ItemNode.PropertyListNext = nullptr;
|
||
|
|
UnderlyingArchive.ArCustomPropertyList = &ItemNode;
|
||
|
|
|
||
|
|
// Serialize the item at this array index
|
||
|
|
i = PropertyNode->ArrayIndex;
|
||
|
|
Inner->SerializeItem(Array.EnterElement(), ArrayHelper.GetRawPtr(i));
|
||
|
|
PropertyNode = PropertyNode->PropertyListNext;
|
||
|
|
|
||
|
|
// Restore the current property list
|
||
|
|
UnderlyingArchive.ArCustomPropertyList = CustomPropertyList;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (bSerializeRemainingItems)
|
||
|
|
{
|
||
|
|
// Temporarily suspend the custom property list (as we need these items to be serialized in full)
|
||
|
|
UnderlyingArchive.ArUseCustomPropertyList = false;
|
||
|
|
|
||
|
|
// Serialize each item until we get to the end of the array
|
||
|
|
FSerializedPropertyScope SerializedProperty(UnderlyingArchive, Inner, this);
|
||
|
|
while (i < n)
|
||
|
|
{
|
||
|
|
#if WITH_EDITOR
|
||
|
|
static const FName NAME_UArraySerialize = FName(TEXT("FArrayProperty::Serialize"));
|
||
|
|
FName NAME_UArraySerializeCount = FName(NAME_UArraySerialize);
|
||
|
|
NAME_UArraySerializeCount.SetNumber(i);
|
||
|
|
FArchive::FScopeAddDebugData P(UnderlyingArchive, NAME_UArraySerializeCount);
|
||
|
|
#endif
|
||
|
|
Inner->SerializeItem(Array.EnterElement(), ArrayHelper.GetRawPtr(i++));
|
||
|
|
}
|
||
|
|
|
||
|
|
// Restore use of the custom property list (if it was previously enabled)
|
||
|
|
UnderlyingArchive.ArUseCustomPropertyList = bUsingCustomPropertyList;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (MaybeInnerTag.IsSet() && UnderlyingArchive.IsSaving() && !bIsTextFormat)
|
||
|
|
{
|
||
|
|
FPropertyTag& InnerTag = MaybeInnerTag.GetValue();
|
||
|
|
|
||
|
|
// set the tag's size
|
||
|
|
InnerTag.Size = UnderlyingArchive.Tell() - DataOffset;
|
||
|
|
|
||
|
|
if (InnerTag.Size > 0)
|
||
|
|
{
|
||
|
|
// mark our current location
|
||
|
|
DataOffset = UnderlyingArchive.Tell();
|
||
|
|
|
||
|
|
// go back and re-serialize the size now that we know it
|
||
|
|
UnderlyingArchive.Seek(InnerTag.SizeOffset);
|
||
|
|
UnderlyingArchive << InnerTag.Size;
|
||
|
|
|
||
|
|
// return to the current location
|
||
|
|
UnderlyingArchive.Seek(DataOffset);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool FArrayProperty::NetSerializeItem(FArchive& Ar, UPackageMap* Map, void* Data, TArray<uint8>* MetaData) const
|
||
|
|
{
|
||
|
|
UE_LOG(LogProperty, Fatal, TEXT("Deprecated code path"));
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
void FArrayProperty::Serialize(FArchive& Ar)
|
||
|
|
{
|
||
|
|
Super::Serialize(Ar);
|
||
|
|
|
||
|
|
SerializeSingleField(Ar, Inner, this);
|
||
|
|
checkSlow(Inner);
|
||
|
|
}
|
||
|
|
void FArrayProperty::AddReferencedObjects(FReferenceCollector& Collector)
|
||
|
|
{
|
||
|
|
Super::AddReferencedObjects(Collector);
|
||
|
|
if (Inner)
|
||
|
|
{
|
||
|
|
Inner->AddReferencedObjects(Collector);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
FString FArrayProperty::GetCPPTypeCustom(FString* ExtendedTypeText, uint32 CPPExportFlags, const FString& InnerTypeText, const FString& InInnerExtendedTypeText) const
|
||
|
|
{
|
||
|
|
if (ExtendedTypeText != NULL)
|
||
|
|
{
|
||
|
|
FString InnerExtendedTypeText = InInnerExtendedTypeText;
|
||
|
|
if (InnerExtendedTypeText.Len() && InnerExtendedTypeText.Right(1) == TEXT(">"))
|
||
|
|
{
|
||
|
|
// if our internal property type is a template class, add a space between the closing brackets b/c VS.NET cannot parse this correctly
|
||
|
|
InnerExtendedTypeText += TEXT(" ");
|
||
|
|
}
|
||
|
|
else if (!InnerExtendedTypeText.Len() && InnerTypeText.Len() && InnerTypeText.Right(1) == TEXT(">"))
|
||
|
|
{
|
||
|
|
// if our internal property type is a template class, add a space between the closing brackets b/c VS.NET cannot parse this correctly
|
||
|
|
InnerExtendedTypeText += TEXT(" ");
|
||
|
|
}
|
||
|
|
*ExtendedTypeText = FString::Printf(TEXT("<%s%s>"), *InnerTypeText, *InnerExtendedTypeText);
|
||
|
|
}
|
||
|
|
return TEXT("TArray");
|
||
|
|
}
|
||
|
|
|
||
|
|
FString FArrayProperty::GetCPPType(FString* ExtendedTypeText /*=NULL*/, uint32 CPPExportFlags /*=0*/) const
|
||
|
|
{
|
||
|
|
checkSlow(Inner);
|
||
|
|
FString InnerExtendedTypeText;
|
||
|
|
FString InnerTypeText;
|
||
|
|
if (ExtendedTypeText != NULL)
|
||
|
|
{
|
||
|
|
InnerTypeText = Inner->GetCPPType(&InnerExtendedTypeText, CPPExportFlags & ~CPPF_ArgumentOrReturnValue); // we won't consider array inners to be "arguments or return values"
|
||
|
|
}
|
||
|
|
return GetCPPTypeCustom(ExtendedTypeText, CPPExportFlags, InnerTypeText, InnerExtendedTypeText);
|
||
|
|
}
|
||
|
|
|
||
|
|
FString FArrayProperty::GetCPPTypeForwardDeclaration() const
|
||
|
|
{
|
||
|
|
checkSlow(Inner);
|
||
|
|
return Inner->GetCPPTypeForwardDeclaration();
|
||
|
|
}
|
||
|
|
FString FArrayProperty::GetCPPMacroType(FString& ExtendedTypeText) const
|
||
|
|
{
|
||
|
|
checkSlow(Inner);
|
||
|
|
ExtendedTypeText = Inner->GetCPPType();
|
||
|
|
return TEXT("TARRAY");
|
||
|
|
}
|
||
|
|
void FArrayProperty::ExportTextItem(FString& ValueStr, const void* PropertyValue, const void* DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope) const
|
||
|
|
{
|
||
|
|
checkSlow(Inner);
|
||
|
|
|
||
|
|
if (0 != (PortFlags & PPF_ExportCpp))
|
||
|
|
{
|
||
|
|
FString ExtendedTypeText;
|
||
|
|
FString TypeText = GetCPPType(&ExtendedTypeText, EPropertyExportCPPFlags::CPPF_BlueprintCppBackend);
|
||
|
|
ValueStr += FString::Printf(TEXT("%s%s()"), *TypeText, *ExtendedTypeText);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
FScriptArrayHelper ArrayHelper(this, PropertyValue);
|
||
|
|
|
||
|
|
int32 DefaultSize = 0;
|
||
|
|
if (DefaultValue)
|
||
|
|
{
|
||
|
|
FScriptArrayHelper DefaultArrayHelper(this, DefaultValue);
|
||
|
|
DefaultSize = DefaultArrayHelper.Num();
|
||
|
|
DefaultValue = DefaultArrayHelper.GetRawPtr(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
ExportTextInnerItem(ValueStr, Inner, ArrayHelper.GetRawPtr(0), ArrayHelper.Num(), DefaultValue, DefaultSize, Parent, PortFlags, ExportRootScope);
|
||
|
|
}
|
||
|
|
|
||
|
|
void FArrayProperty::ExportTextInnerItem(FString& ValueStr, const FProperty* Inner, const void* PropertyValue, int32 PropertySize, const void* DefaultValue, int32 DefaultSize, UObject* Parent, int32 PortFlags, UObject* ExportRootScope)
|
||
|
|
{
|
||
|
|
checkSlow(Inner);
|
||
|
|
|
||
|
|
uint8* StructDefaults = NULL;
|
||
|
|
const FStructProperty* StructProperty = CastField<FStructProperty>(Inner);
|
||
|
|
|
||
|
|
const bool bReadableForm = (0 != (PPF_BlueprintDebugView & PortFlags));
|
||
|
|
const bool bExternalEditor = (0 != (PPF_ExternalEditor & PortFlags));
|
||
|
|
|
||
|
|
// ArrayProperties only export a diff because array entries are cleared and recreated upon import. Static arrays are overwritten when importing,
|
||
|
|
// so we export the entire struct to ensure all data is copied over correctly. Behavior is currently inconsistent when copy/pasting between the two types.
|
||
|
|
// In the future, static arrays could export diffs if the property being imported to is reset to default before the import.
|
||
|
|
// When exporting to an external editor, we want to save defaults so all information is available for editing
|
||
|
|
if (StructProperty != NULL && Inner->ArrayDim == 1 && !bExternalEditor)
|
||
|
|
{
|
||
|
|
checkSlow(StructProperty->Struct);
|
||
|
|
StructDefaults = (uint8*)FMemory::Malloc(StructProperty->Struct->GetStructureSize() * Inner->ArrayDim);
|
||
|
|
StructProperty->InitializeValue(StructDefaults);
|
||
|
|
}
|
||
|
|
|
||
|
|
int32 Count = 0;
|
||
|
|
for (int32 i = 0; i < PropertySize; i++)
|
||
|
|
{
|
||
|
|
++Count;
|
||
|
|
if (!bReadableForm)
|
||
|
|
{
|
||
|
|
if (Count == 1)
|
||
|
|
{
|
||
|
|
ValueStr += TCHAR('(');
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ValueStr += TCHAR(',');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (Count > 1)
|
||
|
|
{
|
||
|
|
ValueStr += TCHAR('\n');
|
||
|
|
}
|
||
|
|
ValueStr += FString::Printf(TEXT("[%i] "), i);
|
||
|
|
}
|
||
|
|
|
||
|
|
uint8* PropData = (uint8*)PropertyValue + i * Inner->ElementSize;
|
||
|
|
|
||
|
|
// Always use struct defaults if the inner is a struct, for symmetry with the import of array inner struct defaults
|
||
|
|
uint8* PropDefault = nullptr;
|
||
|
|
if (bExternalEditor)
|
||
|
|
{
|
||
|
|
PropDefault = PropData;
|
||
|
|
}
|
||
|
|
else if (StructProperty)
|
||
|
|
{
|
||
|
|
PropDefault = StructDefaults;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (DefaultValue && DefaultSize > i)
|
||
|
|
{
|
||
|
|
PropDefault = (uint8*)DefaultValue + i * Inner->ElementSize;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Inner->ExportTextItem(ValueStr, PropData, PropDefault, Parent, PortFlags | PPF_Delimited, ExportRootScope);
|
||
|
|
}
|
||
|
|
|
||
|
|
if ((Count > 0) && !bReadableForm)
|
||
|
|
{
|
||
|
|
ValueStr += TEXT(")");
|
||
|
|
}
|
||
|
|
if (StructDefaults)
|
||
|
|
{
|
||
|
|
StructProperty->DestroyValue(StructDefaults);
|
||
|
|
FMemory::Free(StructDefaults);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const TCHAR* FArrayProperty::ImportText_Internal(const TCHAR* Buffer, void* Data, int32 PortFlags, UObject* OwnerObject, FOutputDevice* ErrorText) const
|
||
|
|
{
|
||
|
|
FScriptArrayHelper ArrayHelper(this, Data);
|
||
|
|
|
||
|
|
return ImportTextInnerItem(Buffer, Inner, Data, PortFlags, OwnerObject, &ArrayHelper, ErrorText);
|
||
|
|
}
|
||
|
|
|
||
|
|
const TCHAR* FArrayProperty::ImportTextInnerItem(const TCHAR* Buffer, const FProperty* Inner, void* Data, int32 PortFlags, UObject* Parent, FScriptArrayHelper* ArrayHelper, FOutputDevice* ErrorText)
|
||
|
|
{
|
||
|
|
checkSlow(Inner);
|
||
|
|
|
||
|
|
// If we export an empty array we export an empty string, so ensure that if we're passed an empty string
|
||
|
|
// we interpret it as an empty array.
|
||
|
|
if (*Buffer == TCHAR('\0') || *Buffer == TCHAR(')') || *Buffer == TCHAR(','))
|
||
|
|
{
|
||
|
|
if (ArrayHelper)
|
||
|
|
{
|
||
|
|
ArrayHelper->EmptyValues();
|
||
|
|
}
|
||
|
|
return Buffer;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (*Buffer++ != TCHAR('('))
|
||
|
|
{
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ArrayHelper)
|
||
|
|
{
|
||
|
|
ArrayHelper->EmptyValues();
|
||
|
|
ArrayHelper->ExpandForIndex(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
SkipWhitespace(Buffer);
|
||
|
|
|
||
|
|
int32 Index = 0;
|
||
|
|
while (*Buffer != TCHAR(')'))
|
||
|
|
{
|
||
|
|
SkipWhitespace(Buffer);
|
||
|
|
|
||
|
|
if (*Buffer != TCHAR(','))
|
||
|
|
{
|
||
|
|
uint8* Address = ArrayHelper ? ArrayHelper->GetRawPtr(Index) : ((uint8*)Data + Inner->ElementSize * Index);
|
||
|
|
// Parse the item
|
||
|
|
Buffer = Inner->ImportText(Buffer, Address, PortFlags | PPF_Delimited, Parent, ErrorText);
|
||
|
|
|
||
|
|
if (!Buffer)
|
||
|
|
{
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
SkipWhitespace(Buffer);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (*Buffer == TCHAR(','))
|
||
|
|
{
|
||
|
|
Buffer++;
|
||
|
|
Index++;
|
||
|
|
if (ArrayHelper)
|
||
|
|
{
|
||
|
|
ArrayHelper->ExpandForIndex(Index);
|
||
|
|
}
|
||
|
|
else if (Index >= Inner->ArrayDim)
|
||
|
|
{
|
||
|
|
UE_LOG(LogProperty, Warning, TEXT("%s is a fixed-sized array of %i values. Additional data after %i has been ignored during import."), *Inner->GetName(), Inner->ArrayDim, Inner->ArrayDim);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Make sure we ended on a )
|
||
|
|
if (*Buffer++ != TCHAR(')'))
|
||
|
|
{
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
return Buffer;
|
||
|
|
}
|
||
|
|
|
||
|
|
void FArrayProperty::AddCppProperty(FProperty* Property)
|
||
|
|
{
|
||
|
|
check(!Inner);
|
||
|
|
check(Property);
|
||
|
|
|
||
|
|
Inner = Property;
|
||
|
|
}
|
||
|
|
|
||
|
|
void FArrayProperty::CopyValuesInternal(void* Dest, void const* Src, int32 Count) const
|
||
|
|
{
|
||
|
|
check(Count == 1); // this was never supported, apparently
|
||
|
|
FScriptArrayHelper SrcArrayHelper(this, Src);
|
||
|
|
FScriptArrayHelper DestArrayHelper(this, Dest);
|
||
|
|
|
||
|
|
int32 Num = SrcArrayHelper.Num();
|
||
|
|
if (!(Inner->PropertyFlags & CPF_IsPlainOldData))
|
||
|
|
{
|
||
|
|
DestArrayHelper.EmptyAndAddValues(Num);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
DestArrayHelper.EmptyAndAddUninitializedValues(Num);
|
||
|
|
}
|
||
|
|
if (Num)
|
||
|
|
{
|
||
|
|
int32 Size = Inner->ElementSize;
|
||
|
|
uint8* SrcData = (uint8*)SrcArrayHelper.GetRawPtr();
|
||
|
|
uint8* DestData = (uint8*)DestArrayHelper.GetRawPtr();
|
||
|
|
if (!(Inner->PropertyFlags & CPF_IsPlainOldData))
|
||
|
|
{
|
||
|
|
for (int32 i = 0; i < Num; i++)
|
||
|
|
{
|
||
|
|
Inner->CopyCompleteValue(DestData + i * Size, SrcData + i * Size);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
FMemory::Memcpy(DestData, SrcData, Num * Size);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
void FArrayProperty::ClearValueInternal(void* Data) const
|
||
|
|
{
|
||
|
|
FScriptArrayHelper ArrayHelper(this, Data);
|
||
|
|
ArrayHelper.EmptyValues();
|
||
|
|
}
|
||
|
|
void FArrayProperty::DestroyValueInternal(void* Dest) const
|
||
|
|
{
|
||
|
|
FScriptArrayHelper ArrayHelper(this, Dest);
|
||
|
|
ArrayHelper.EmptyValues();
|
||
|
|
|
||
|
|
//@todo UE4 potential double destroy later from this...would be ok for a script array, but still
|
||
|
|
ArrayHelper.DestroyContainer_Unsafe();
|
||
|
|
}
|
||
|
|
bool FArrayProperty::PassCPPArgsByRef() const
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates new copies of components
|
||
|
|
*
|
||
|
|
* @param Data pointer to the address of the instanced object referenced by this UComponentProperty
|
||
|
|
* @param DefaultData pointer to the address of the default value of the instanced object referenced by this UComponentProperty
|
||
|
|
* @param Owner the object that contains this property's data
|
||
|
|
* @param InstanceGraph contains the mappings of instanced objects and components to their templates
|
||
|
|
*/
|
||
|
|
void FArrayProperty::InstanceSubobjects(void* Data, void const* DefaultData, UObject* InOwner, FObjectInstancingGraph* InstanceGraph)
|
||
|
|
{
|
||
|
|
if (Data && Inner->ContainsInstancedObjectProperty())
|
||
|
|
{
|
||
|
|
FScriptArrayHelper ArrayHelper(this, Data);
|
||
|
|
FScriptArrayHelper DefaultArrayHelper(this, DefaultData);
|
||
|
|
|
||
|
|
int32 InnerElementSize = Inner->ElementSize;
|
||
|
|
void* TempElement = FMemory_Alloca(InnerElementSize);
|
||
|
|
|
||
|
|
for (int32 ElementIndex = 0; ElementIndex < ArrayHelper.Num(); ElementIndex++)
|
||
|
|
{
|
||
|
|
uint8* DefaultValue = (DefaultData && ElementIndex < DefaultArrayHelper.Num()) ? DefaultArrayHelper.GetRawPtr(ElementIndex) : nullptr;
|
||
|
|
FMemory::Memmove(TempElement, ArrayHelper.GetRawPtr(ElementIndex), InnerElementSize);
|
||
|
|
Inner->InstanceSubobjects(TempElement, DefaultValue, InOwner, InstanceGraph);
|
||
|
|
if (ElementIndex < ArrayHelper.Num())
|
||
|
|
{
|
||
|
|
FMemory::Memmove(ArrayHelper.GetRawPtr(ElementIndex), TempElement, InnerElementSize);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Inner->DestroyValue(TempElement);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool FArrayProperty::SameType(const FProperty* Other) const
|
||
|
|
{
|
||
|
|
return Super::SameType(Other) && Inner && Inner->SameType(((FArrayProperty*)Other)->Inner);
|
||
|
|
}
|
||
|
|
|
||
|
|
EConvertFromTypeResult FArrayProperty::ConvertFromType(const FPropertyTag& Tag, FStructuredArchive::FSlot Slot, uint8* Data, UStruct* DefaultsStruct)
|
||
|
|
{
|
||
|
|
// TODO: The ArrayProperty Tag really doesn't have adequate information for
|
||
|
|
// many types. This should probably all be moved in to ::SerializeItem
|
||
|
|
|
||
|
|
if (Tag.Type == NAME_ArrayProperty && Tag.InnerType != NAME_None && Tag.InnerType != Inner->GetID())
|
||
|
|
{
|
||
|
|
void* ArrayPropertyData = ContainerPtrToValuePtr<void>(Data);
|
||
|
|
|
||
|
|
int32 ElementCount = 0;
|
||
|
|
|
||
|
|
if (Slot.GetUnderlyingArchive().IsTextFormat())
|
||
|
|
{
|
||
|
|
Slot.EnterArray(ElementCount);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Slot.GetUnderlyingArchive() << ElementCount;
|
||
|
|
}
|
||
|
|
|
||
|
|
FScriptArrayHelper ScriptArrayHelper(this, ArrayPropertyData);
|
||
|
|
ScriptArrayHelper.EmptyAndAddValues(ElementCount);
|
||
|
|
|
||
|
|
// Convert properties from old type to new type automatically if types are compatible (array case)
|
||
|
|
if (ElementCount > 0)
|
||
|
|
{
|
||
|
|
FPropertyTag InnerPropertyTag;
|
||
|
|
InnerPropertyTag.Type = Tag.InnerType;
|
||
|
|
InnerPropertyTag.ArrayIndex = 0;
|
||
|
|
|
||
|
|
FStructuredArchive::FStream ValueStream = Slot.EnterStream();
|
||
|
|
|
||
|
|
if (Inner->ConvertFromType(InnerPropertyTag, ValueStream.EnterElement(), ScriptArrayHelper.GetRawPtr(0), DefaultsStruct) == EConvertFromTypeResult::Converted)
|
||
|
|
{
|
||
|
|
for (int32 i = 1; i < ElementCount; ++i)
|
||
|
|
{
|
||
|
|
verify(Inner->ConvertFromType(InnerPropertyTag, ValueStream.EnterElement(), ScriptArrayHelper.GetRawPtr(i), DefaultsStruct) == EConvertFromTypeResult::Converted);
|
||
|
|
}
|
||
|
|
|
||
|
|
return EConvertFromTypeResult::Converted;
|
||
|
|
}
|
||
|
|
// TODO: Implement SerializeFromMismatchedTag handling for arrays of structs
|
||
|
|
else
|
||
|
|
{
|
||
|
|
UE_LOG(LogClass, Warning, TEXT("Array Inner Type mismatch in %s of %s - Previous (%s) Current(%s) for package: %s"), *Tag.Name.ToString(), *GetName(), *Tag.InnerType.ToString(), *Inner->GetID().ToString(), *Slot.GetUnderlyingArchive().GetArchiveName());
|
||
|
|
return EConvertFromTypeResult::CannotConvert;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return EConvertFromTypeResult::Converted;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return EConvertFromTypeResult::UseSerializeItem;
|
||
|
|
}
|
||
|
|
|
||
|
|
FField* FArrayProperty::GetInnerFieldByName(const FName& InName)
|
||
|
|
{
|
||
|
|
if (Inner && Inner->GetFName() == InName)
|
||
|
|
{
|
||
|
|
return Inner;
|
||
|
|
}
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
void FArrayProperty::GetInnerFields(TArray<FField*>& OutFields)
|
||
|
|
{
|
||
|
|
if (Inner)
|
||
|
|
{
|
||
|
|
OutFields.Add(Inner);
|
||
|
|
Inner->GetInnerFields(OutFields);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#include "UObject/DefineUPropertyMacros.h"
|