void FAssetTypeActions_GameplayTagAssetBase::GetActions(const TArray<UObject*>& InObjects, FMenuBuilder& MenuBuilder)
{
TArray<UObject*> ContainerObjectOwners;
TArray<FGameplayTagContainer*> Containers;
for (int32 ObjIdx = 0; ObjIdx < InObjects.Num(); ++ObjIdx)
{
UObject* CurObj = InObjects[ObjIdx];
if (CurObj)
{
UStructProperty* StructProp = FindField<UStructProperty>(CurObj->GetClass(), OwnedGameplayTagPropertyName);
if(StructProp != NULL)
{
ContainerObjectOwners.Add(CurObj);
Containers.Add(StructProp->ContainerPtrToValuePtr<FGameplayTagContainer>(CurObj));
}
}
}
ensure(Containers.Num() == ContainerObjectOwners.Num());
if (Containers.Num() > 0 && (Containers.Num() == ContainerObjectOwners.Num()))
{
MenuBuilder.AddMenuEntry(
LOCTEXT("GameplayTags_Edit", "Edit Gameplay Tags..."),
LOCTEXT("GameplayTags_EditToolTip", "Opens the Gameplay Tag Editor."),
FSlateIcon(),
FUIAction(FExecuteAction::CreateSP(this, &FAssetTypeActions_GameplayTagAssetBase::OpenGameplayTagEditor, ContainerObjectOwners, Containers), FCanExecuteAction()));
}
}
FText FSimpleAssetEditor::GetToolkitName() const
{
const TArray<UObject*>& EditingObjs = GetEditingObjects();
check( EditingObjs.Num() > 0 );
FFormatNamedArguments Args;
Args.Add( TEXT("ToolkitName"), GetBaseToolkitName() );
if( EditingObjs.Num() == 1 )
{
const UObject* EditingObject = EditingObjs[ 0 ];
const bool bDirtyState = EditingObject->GetOutermost()->IsDirty();
Args.Add( TEXT("ObjectName"), FText::FromString( EditingObject->GetName() ) );
Args.Add( TEXT("DirtyState"), bDirtyState ? FText::FromString( TEXT( "*" ) ) : FText::GetEmpty() );
return FText::Format( LOCTEXT("ToolkitTitle", "{ObjectName}{DirtyState} - {ToolkitName}"), Args );
}
else
{
bool bDirtyState = false;
UClass* SharedBaseClass = nullptr;
for( int32 x = 0; x < EditingObjs.Num(); ++x )
{
UObject* Obj = EditingObjs[ x ];
check( Obj );
UClass* ObjClass = Cast<UClass>(Obj);
if (ObjClass == nullptr)
{
ObjClass = Obj->GetClass();
}
check( ObjClass );
// Initialize with the class of the first object we encounter.
if( SharedBaseClass == nullptr )
{
SharedBaseClass = ObjClass;
}
// If we've encountered an object that's not a subclass of the current best baseclass,
// climb up a step in the class hierarchy.
while( !ObjClass->IsChildOf( SharedBaseClass ) )
{
SharedBaseClass = SharedBaseClass->GetSuperClass();
}
// If any of the objects are dirty, flag the label
bDirtyState |= Obj->GetOutermost()->IsDirty();
}
check(SharedBaseClass);
Args.Add( TEXT("NumberOfObjects"), EditingObjs.Num() );
Args.Add( TEXT("ClassName"), FText::FromString( SharedBaseClass->GetName() ) );
Args.Add( TEXT("DirtyState"), bDirtyState ? FText::FromString( TEXT( "*" ) ) : FText::GetEmpty() );
return FText::Format( LOCTEXT("ToolkitTitle_EditingMultiple", "{NumberOfObjects} {ClassName}{DirtyState} - {ToolkitName}"), Args );
}
}
UEnum* GetEnumForByteTrack(TSharedPtr<ISequencer> Sequencer, const FGuid& OwnerObjectHandle, FName PropertyName, UMovieSceneByteTrack* ByteTrack)
{
UObject* RuntimeObject = Sequencer->GetFocusedMovieSceneSequence()->FindObject(OwnerObjectHandle);
TSet<UEnum*> PropertyEnums;
if (RuntimeObject != nullptr)
{
UProperty* Property = RuntimeObject->GetClass()->FindPropertyByName(PropertyName);
if (Property != nullptr)
{
UByteProperty* ByteProperty = Cast<UByteProperty>(Property);
if (ByteProperty != nullptr && ByteProperty->Enum != nullptr)
{
PropertyEnums.Add(ByteProperty->Enum);
}
}
}
UEnum* TrackEnum;
if (PropertyEnums.Num() == 1)
{
TrackEnum = PropertyEnums.Array()[0];
}
else
{
TrackEnum = nullptr;
}
return TrackEnum;
}
void FBlueprintCompileReinstancer::VerifyReplacement()
{
TArray<UObject*> SourceObjects;
// Find all instances of the old class
for( TObjectIterator<UObject> it; it; ++it )
{
UObject* CurrentObj = *it;
if( (CurrentObj->GetClass() == DuplicatedClass) )
{
SourceObjects.Add(CurrentObj);
}
}
// For each instance, track down references
if( SourceObjects.Num() > 0 )
{
TFindObjectReferencers<UObject> Referencers(SourceObjects, NULL, false);
for (TFindObjectReferencers<UObject>::TIterator It(Referencers); It; ++It)
{
UObject* CurrentObject = It.Key();
UObject* ReferencedObj = It.Value();
FPlatformMisc::LowLevelOutputDebugStringf(TEXT("- Object %s is referencing %s ---"), *CurrentObject->GetName(), *ReferencedObj->GetName());
}
}
}
UClass* FClassData::GetClass()
{
UClass* RetClass = Class.Get();
if (RetClass == NULL && GeneratedClassPackage.Len())
{
GWarn->BeginSlowTask(LOCTEXT("LoadPackage", "Loading Package..."), true);
UPackage* Package = LoadPackage(NULL, *GeneratedClassPackage, LOAD_NoRedirects);
if (Package)
{
Package->FullyLoad();
UObject* Object = FindObject<UObject>(Package, *AssetName);
GWarn->EndSlowTask();
UBlueprint* BlueprintOb = Cast<UBlueprint>(Object);
RetClass = BlueprintOb ? *BlueprintOb->GeneratedClass : Object->GetClass();
Class = RetClass;
}
else
{
GWarn->EndSlowTask();
FMessageLog EditorErrors("EditorErrors");
EditorErrors.Error(LOCTEXT("PackageLoadFail", "Package Load Failed"));
EditorErrors.Info(FText::FromString(GeneratedClassPackage));
EditorErrors.Notify(LOCTEXT("PackageLoadFail", "Package Load Failed"));
}
}
return RetClass;
}
// Looks at the Objects array and returns the best base class. Called by
// Finalize(); that is, when the list of selected objects is being finalized.
void FObjectPropertyNode::SetBestBaseClass()
{
BaseClass = NULL;
for( int32 x = 0 ; x < Objects.Num() ; ++x )
{
UObject* Obj = Objects[x].Get();
if( Obj )
{
UClass* ObjClass = Cast<UClass>(Obj);
if (ObjClass == NULL)
{
ObjClass = Obj->GetClass();
}
check( ObjClass );
// Initialize with the class of the first object we encounter.
if( BaseClass == NULL )
{
BaseClass = ObjClass;
}
// If we've encountered an object that's not a subclass of the current best baseclass,
// climb up a step in the class hierarchy.
while( !ObjClass->IsChildOf( BaseClass.Get() ) )
{
BaseClass = BaseClass->GetSuperClass();
}
}
}
}
/**
* Internal version of GetPathName() that eliminates unnecessary copies.
*/
void UObjectBaseUtility::GetPathName( const UObject* StopOuter, FString& ResultString ) const
{
if( this != StopOuter && this != NULL )
{
UObject* ObjOuter = GetOuter();
if (ObjOuter && ObjOuter != StopOuter )
{
ObjOuter->GetPathName( StopOuter, ResultString );
// SUBOBJECT_DELIMITER is used to indicate that this object's outer is not a UPackage
if (ObjOuter->GetClass() != UPackage::StaticClass()
&& ObjOuter->GetOuter()->GetClass() == UPackage::StaticClass())
{
ResultString += SUBOBJECT_DELIMITER;
}
else
{
ResultString += TEXT(".");
}
}
AppendName(ResultString);
}
else
{
ResultString += TEXT("None");
}
}
TSharedPtr<FGraphNodeClassNode> FGraphNodeClassHelper::CreateClassDataNode(const class FAssetData& AssetData)
{
TSharedPtr<FGraphNodeClassNode> Node;
const FString* GeneratedClassname = AssetData.TagsAndValues.Find("GeneratedClass");
const FString* ParentClassname = AssetData.TagsAndValues.Find("ParentClass");
if (GeneratedClassname && ParentClassname)
{
FString AssetClassName = *GeneratedClassname;
UObject* Outer1(NULL);
ResolveName(Outer1, AssetClassName, false, false);
FString AssetParentClassName = *ParentClassname;
UObject* Outer2(NULL);
ResolveName(Outer2, AssetParentClassName, false, false);
Node = MakeShareable(new FGraphNodeClassNode);
Node->ParentClassName = AssetParentClassName;
UObject* AssetOb = AssetData.IsAssetLoaded() ? AssetData.GetAsset() : NULL;
UBlueprint* AssetBP = Cast<UBlueprint>(AssetOb);
UClass* AssetClass = AssetBP ? *AssetBP->GeneratedClass : AssetOb ? AssetOb->GetClass() : NULL;
FGraphNodeClassData NewData(AssetData.AssetName.ToString(), AssetData.PackageName.ToString(), AssetClassName, AssetClass);
Node->Data = NewData;
}
return Node;
}
// Finds the class for the given stack state.
UStruct* FindClass( const FReadState& State )
{
UStruct* Class = nullptr;
if (State.Property != nullptr)
{
UProperty* ParentProperty = State.Property;
UArrayProperty* ArrayProperty = Cast<UArrayProperty>(ParentProperty);
if (ArrayProperty != nullptr)
{
ParentProperty = ArrayProperty->Inner;
}
UStructProperty* StructProperty = Cast<UStructProperty>(ParentProperty);
UObjectPropertyBase* ObjectProperty = Cast<UObjectPropertyBase>(ParentProperty);
if (StructProperty != nullptr)
{
Class = StructProperty->Struct;
}
else if (ObjectProperty != nullptr)
{
Class = ObjectProperty->PropertyClass;
}
}
else
{
UObject* RootObject = static_cast<UObject*>(State.Data);
Class = RootObject->GetClass();
}
return Class;
}
void UObjectPropertyBase::CheckValidObject(void* Value) const
{
UObject *Object = GetObjectPropertyValue(Value);
if (Object)
{
//
// here we want to make sure the the object value still matches the
// object type expected by the property...
UClass* ObjectClass = Object->GetClass();
// we could be in the middle of replacing references to the
// PropertyClass itself (in the middle of an FArchiveReplaceObjectRef
// pass)... if this is the case, then we might have already replaced
// the object's class, but not the PropertyClass yet (or vise-versa)...
// so we use this to ensure, in that situation, that we don't clear the
// object value (if CLASS_NewerVersionExists is set, then we are likely
// in the middle of an FArchiveReplaceObjectRef pass)
bool bIsReplacingClassRefs = PropertyClass && PropertyClass->HasAnyClassFlags(CLASS_NewerVersionExists) != ObjectClass->HasAnyClassFlags(CLASS_NewerVersionExists);
#if USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
FLinkerLoad* PropertyLinker = GetLinker();
bool const bIsDeferringValueLoad = ((PropertyLinker == nullptr) || (PropertyLinker->LoadFlags & LOAD_DeferDependencyLoads)) &&
(Object->IsA<ULinkerPlaceholderExportObject>() || Object->IsA<ULinkerPlaceholderClass>());
#if USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
check( bIsDeferringValueLoad || (!Object->IsA<ULinkerPlaceholderExportObject>() && !Object->IsA<ULinkerPlaceholderClass>()) );
#endif // USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
#else // USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
bool const bIsDeferringValueLoad = false;
#endif // USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
if ((PropertyClass != nullptr) && !ObjectClass->IsChildOf(PropertyClass) && !bIsReplacingClassRefs && !bIsDeferringValueLoad)
{
UE_LOG(LogProperty, Warning,
TEXT("Serialized %s for a property of %s. Reference will be NULLed.\n Property = %s\n Item = %s"),
*Object->GetClass()->GetFullName(),
*PropertyClass->GetFullName(),
*GetFullName(),
*Object->GetFullName()
);
SetObjectPropertyValue(Value, NULL);
}
}
}
void USelection::DeselectAll( UClass* InClass )
{
// Fast path for deselecting all UObjects with any flags
if ( InClass == UObject::StaticClass() )
{
InClass = nullptr;
}
bool bSelectionChanged = false;
TSet<FSelectedClassInfo> RemovedClasses;
// Remove from the end to minimize memmoves.
for ( int32 i = SelectedObjects.Num()-1 ; i >= 0 ; --i )
{
UObject* Object = GetSelectedObject(i);
if ( !Object )
{
// Remove NULLs from SelectedObjects array.
SelectedObjects.RemoveAt( i );
}
else if( !InClass || Object->IsA( InClass ) )
{
// if the object is of type InClass then all objects of that same type will be removed
RemovedClasses.Add(FSelectedClassInfo(Object->GetClass()));
GSelectedAnnotation.Clear(Object);
SelectedObjects.RemoveAt( i );
// Call this after the item has been removed from the selection set.
USelection::SelectObjectEvent.Broadcast( Object );
bSelectionChanged = true;
}
}
if( InClass == nullptr )
{
SelectedClasses.Empty();
}
else
{
// Remove the passed in class and all child classes that were removed
// from the list of currently selected classes
RemovedClasses.Add(InClass);
SelectedClasses = SelectedClasses.Difference(RemovedClasses);
}
if ( bSelectionChanged )
{
MarkBatchDirty();
if ( !IsBatchSelecting() )
{
USelection::SelectionChangedEvent.Broadcast(this);
}
}
}
const FSlateBrush* SPropertyEditorEditInline::GetDisplayValueIcon() const
{
UObject* CurrentValue = nullptr;
FPropertyAccess::Result Result = PropertyEditor->GetPropertyHandle()->GetValue( CurrentValue );
if( Result == FPropertyAccess::Success && CurrentValue != nullptr )
{
return FClassIconFinder::FindIconForClass(CurrentValue->GetClass());
}
return nullptr;
}
bool UObjectPropertyBase::Identical( const void* A, const void* B, uint32 PortFlags ) const
{
UObject* ObjectA = A ? GetObjectPropertyValue(A) : NULL;
UObject* ObjectB = B ? GetObjectPropertyValue(B) : NULL;
if (!ObjectA && !ObjectB)
{
return true;
}
if (!ObjectA || !ObjectB)
{
return false;
}
// Compare actual pointers. We don't do this during PIE because we want to be sure to serialize everything. An example is the LevelScriptActor being serialized against its CDO,
// which contains actor references. We want to serialize those references so they are fixed up.
const bool bDuplicatingForPIE = (PortFlags&PPF_DuplicateForPIE) != 0;
bool bResult = !bDuplicatingForPIE ? (ObjectA == ObjectB) : false;
// always serialize the cross level references, because they could be NULL
// @todo: okay, this is pretty hacky overall - we should have a PortFlag or something
// that is set during SavePackage. Other times, we don't want to immediately return false
// (instead of just this ExportDefProps case)
// instance testing
if (!bResult && ObjectA->GetClass() == ObjectB->GetClass())
{
bool bPerformDeepComparison = (PortFlags&PPF_DeepComparison) != 0;
if ((PortFlags&PPF_DeepCompareInstances) && !bPerformDeepComparison)
{
bPerformDeepComparison = ObjectA->IsTemplate() != ObjectB->IsTemplate();
}
if (!bResult && bPerformDeepComparison)
{
// In order for deep comparison to be match they both need to have the same name and that name needs to be included in the instancing table for the class
if (ObjectA->GetFName() == ObjectB->GetFName() && ObjectA->GetClass()->GetDefaultSubobjectByName(ObjectA->GetFName()))
{
checkSlow(ObjectA->IsDefaultSubobject() && ObjectB->IsDefaultSubobject() && ObjectA->GetClass()->GetDefaultSubobjectByName(ObjectA->GetFName()) == ObjectB->GetClass()->GetDefaultSubobjectByName(ObjectB->GetFName())); // equivalent
bResult = AreInstancedObjectsIdentical(ObjectA,ObjectB,PortFlags);
}
}
}
return bResult;
}
UObject* UFactory::CreateOrOverwriteAsset(UClass* InClass, UObject* InParent, FName InName, EObjectFlags InFlags, UObject* InTemplate) const
{
// Creates an asset if it doesn't exist.
UObject* ExistingAsset = StaticFindObject(NULL, InParent, *InName.ToString());
if ( !ExistingAsset )
{
return NewObject<UObject>(InParent, InClass, InName, InFlags, InTemplate);
}
// If it does exist then it overwrites it if possible.
if ( ExistingAsset->GetClass()->IsChildOf(InClass) )
{
return NewObject<UObject>(InParent, InClass, InName, InFlags, InTemplate);
}
// If it can not overwrite then it will delete and replace.
if ( ObjectTools::DeleteSingleObject( ExistingAsset ) )
{
// Keep InPackage alive through the GC, in case ExistingAsset was the only reason it was around.
const bool bRootedPackage = InParent->IsRooted();
if ( !bRootedPackage )
{
InParent->AddToRoot();
}
// Force GC so we can cleanly create a new asset (and not do an 'in place' replacement)
CollectGarbage( GARBAGE_COLLECTION_KEEPFLAGS );
if ( !bRootedPackage )
{
InParent->RemoveFromRoot();
}
// Try to find the existing asset again now that the GC has occurred
ExistingAsset = StaticFindObject(NULL, InParent, *InName.ToString());
if ( ExistingAsset )
{
// Even after the delete and GC, the object is still around. Fail this operation.
return NULL;
}
else
{
// We can now create the asset in the package
return NewObject<UObject>(InParent, InClass, InName, InFlags, InTemplate);
}
}
else
{
// The delete did not succeed. There are still references to the old content.
return NULL;
}
}
FText SPropertyEditorEditInline::GetDisplayValueAsString() const
{
UObject* CurrentValue = NULL;
FPropertyAccess::Result Result = PropertyEditor->GetPropertyHandle()->GetValue( CurrentValue );
if( Result == FPropertyAccess::Success && CurrentValue != NULL )
{
return CurrentValue->GetClass()->GetDisplayNameText();
}
else
{
return PropertyEditor->GetValueAsText();
}
}
UObject* UObject::GetArchetypeFromRequiredInfo(UClass* Class, UObject* Outer, FName Name, EObjectFlags ObjectFlags)
{
UObject* Result = NULL;
const bool bIsCDO = !!(ObjectFlags&RF_ClassDefaultObject);
if (bIsCDO)
{
static UClass* UObjectStaticClass(UObject::StaticClass());
if (Class != UObjectStaticClass)
{
Result = Class->GetSuperClass()->GetDefaultObject(); // the archetype of any CDO (other than the UObject CDO) is the CDO of the super class
}
// else the archetype of the UObject CDO is NULL
}
else
{
if (Outer
&& Outer->GetClass() != UPackage::StaticClass()) // packages cannot have subobjects
{
UObject* ArchetypeToSearch = Outer->GetArchetype();
UObject* MyArchetype = static_cast<UObject*>(FindObjectWithOuter(ArchetypeToSearch, Class, Name));
if (MyArchetype)
{
Result = MyArchetype; // found that my outers archetype had a matching component, that must be my archetype
}
else if (!!(ObjectFlags&RF_InheritableComponentTemplate) && Outer->IsA<UClass>())
{
for (auto SuperClassArchetype = static_cast<UClass*>(Outer)->GetSuperClass();
SuperClassArchetype && SuperClassArchetype->HasAllClassFlags(CLASS_CompiledFromBlueprint);
SuperClassArchetype = SuperClassArchetype->GetSuperClass())
{
Result = static_cast<UObject*>(FindObjectWithOuter(SuperClassArchetype, Class, Name));
if (Result)
{
break;
}
}
}
else
{
Result = ArchetypeToSearch->GetClass()->FindArchetype(Class, Name);
}
}
if (!Result)
{
// nothing found, I am not a CDO, so this is just the class CDO
Result = Class->GetDefaultObject();
}
}
return Result;
}
USceneComponent* FComponentEditorUtils::GetSceneComponent( UObject* Object, UObject* SubObject /*= NULL*/ )
{
if( Object )
{
AActor* Actor = Cast<AActor>( Object );
if( Actor )
{
if( SubObject )
{
if( SubObject->HasAnyFlags( RF_DefaultSubObject ) )
{
UObject* ClassDefaultObject = SubObject->GetOuter();
if( ClassDefaultObject )
{
for( TFieldIterator<UObjectProperty> ObjPropIt( ClassDefaultObject->GetClass() ); ObjPropIt; ++ObjPropIt )
{
UObjectProperty* ObjectProperty = *ObjPropIt;
if( SubObject == ObjectProperty->GetObjectPropertyValue_InContainer( ClassDefaultObject ) )
{
return CastChecked<USceneComponent>( ObjectProperty->GetObjectPropertyValue_InContainer( Actor ) );
}
}
}
}
else if( UBlueprint* Blueprint = Cast<UBlueprint>( SubObject->GetOuter() ) )
{
if( Blueprint->SimpleConstructionScript )
{
TArray<USCS_Node*> SCSNodes = Blueprint->SimpleConstructionScript->GetAllNodes();
for( int32 SCSNodeIndex = 0; SCSNodeIndex < SCSNodes.Num(); ++SCSNodeIndex )
{
USCS_Node* SCS_Node = SCSNodes[ SCSNodeIndex ];
if( SCS_Node && SCS_Node->ComponentTemplate == SubObject )
{
return SCS_Node->GetParentComponentTemplate( Blueprint );
}
}
}
}
}
return Actor->GetRootComponent();
}
else if( Object->IsA<USceneComponent>() )
{
return CastChecked<USceneComponent>( Object );
}
}
return NULL;
}
FText FSimpleAssetEditor::GetToolkitToolTipText() const
{
const TArray<UObject*>& EditingObjs = GetEditingObjects();
check( EditingObjs.Num() > 0 );
FFormatNamedArguments Args;
Args.Add( TEXT("ToolkitName"), GetBaseToolkitName() );
if( EditingObjs.Num() == 1 )
{
const UObject* EditingObject = EditingObjs[ 0 ];
return FAssetEditorToolkit::GetToolTipTextForObject(EditingObject);
}
else
{
UClass* SharedBaseClass = NULL;
for( int32 x = 0; x < EditingObjs.Num(); ++x )
{
UObject* Obj = EditingObjs[ x ];
check( Obj );
UClass* ObjClass = Cast<UClass>(Obj);
if (ObjClass == nullptr)
{
ObjClass = Obj->GetClass();
}
check( ObjClass );
// Initialize with the class of the first object we encounter.
if( SharedBaseClass == nullptr )
{
SharedBaseClass = ObjClass;
}
// If we've encountered an object that's not a subclass of the current best baseclass,
// climb up a step in the class hierarchy.
while( !ObjClass->IsChildOf( SharedBaseClass ) )
{
SharedBaseClass = SharedBaseClass->GetSuperClass();
}
}
check(SharedBaseClass);
Args.Add( TEXT("NumberOfObjects"), EditingObjs.Num() );
Args.Add( TEXT("ClassName"), FText::FromString( SharedBaseClass->GetName() ) );
return FText::Format( LOCTEXT("ToolkitTitle_EditingMultipleToolTip", "{NumberOfObjects} {ClassName} - {ToolkitName}"), Args );
}
}
UClass* FClassBrowseHelper::FindAssetClass(const FString& GeneratedClassPackage, const FString& AssetName)
{
UPackage* Package = FindPackage(NULL, *GeneratedClassPackage );
if (Package)
{
UObject* Object = FindObject<UObject>(Package, *AssetName);
if (Object)
{
UBlueprint* BlueprintOb = Cast<UBlueprint>(Object);
return BlueprintOb ? *BlueprintOb->GeneratedClass : Object->GetClass();
}
}
return NULL;
}
//------------------------------------------------------------------------------
int32 FLinkerPlaceholderBase::ResolvePlaceholderPropertyValues(UObject* NewObjectValue)
{
int32 ResolvedTotal = 0;
UObject* ThisAsUObject = GetPlaceholderAsUObject();
for (auto& ReferencingPair : ReferencingContainers)
{
TWeakObjectPtr<UObject> ContainerPtr = ReferencingPair.Key;
if (!ContainerPtr.IsValid())
{
continue;
}
UObject* Container = ContainerPtr.Get();
for (const UObjectProperty* Property : ReferencingPair.Value)
{
#if USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
check(Property->GetOwnerClass() == Container->GetClass());
#endif // USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
TArray<const UProperty*> PropertyChain;
LinkerPlaceholderObjectImpl::BuildPropertyChain(Property, PropertyChain);
const UProperty* OutermostProperty = PropertyChain.Last();
uint8* OutermostAddress = OutermostProperty->ContainerPtrToValuePtr<uint8>((uint8*)Container, /*ArrayIndex =*/0);
int32 ResolvedCount = LinkerPlaceholderObjectImpl::ResolvePlaceholderValues(PropertyChain, PropertyChain.Num() - 1, OutermostAddress, ThisAsUObject, NewObjectValue);
ResolvedTotal += ResolvedCount;
#if USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
// we expect that (because we have had ReferencingProperties added)
// there should be at least one reference that is resolved... if
// there were none, then a property could have changed its value
// after it was set to this
//
// NOTE: this may seem it can be resolved by properties removing
// themselves from ReferencingProperties, but certain
// properties may be the inner of a UArrayProperty (meaning
// there could be multiple references per property)... we'd
// have to inc/decrement a property ref-count to resolve that
// scenario
check(ResolvedCount > 0);
#endif // USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
}
}
return ResolvedTotal;
}
void UInterfaceProperty::ExportTextItem( FString& ValueStr, const void* PropertyValue, const void* DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope ) const
{
FScriptInterface* InterfaceValue = (FScriptInterface*)PropertyValue;
UObject* Temp = InterfaceValue->GetObject();
if (0 != (PortFlags & PPF_ExportCpp))
{
const FString GetObjectStr = Temp
? FString::Printf(TEXT("LoadObject<UObject>(nullptr, TEXT(\"%s\"))"), *Temp->GetPathName().ReplaceCharWithEscapedChar())
: TEXT("");
ValueStr += FString::Printf(TEXT("TScriptInterface<I%s>(%s)")
, (InterfaceClass ? *InterfaceClass->GetName() : TEXT("Interface"))
, *GetObjectStr);
return;
}
if( Temp != NULL )
{
bool bExportFullyQualified = true;
// When exporting from one package or graph to another package or graph, we don't want to fully qualify the name, as it may refer
// to a level or graph that doesn't exist or cause a linkage to a node in a different graph
UObject* StopOuter = NULL;
if (PortFlags & PPF_ExportsNotFullyQualified)
{
StopOuter = (ExportRootScope || (Parent == NULL)) ? ExportRootScope : Parent->GetOutermost();
bExportFullyQualified = !Temp->IsIn(StopOuter);
}
// if we want a full qualified object reference, use the pathname, otherwise, use just the object name
if (bExportFullyQualified)
{
StopOuter = NULL;
if ( (PortFlags&PPF_SimpleObjectText) != 0 && Parent != NULL )
{
StopOuter = Parent->GetOutermost();
}
}
ValueStr += FString::Printf( TEXT("%s'%s'"), *Temp->GetClass()->GetName(), *Temp->GetPathName(StopOuter) );
}
else
{
ValueStr += TEXT("None");
}
}
int32 FReferenceChainSearch::FFindReferencerCollector::FindReferencedObjectIndex(const UObject& ReferencedBy, const UObject& ReferencedObject)
{
int32 Result = INDEX_NONE;
auto & TokenMap = ReferencedBy.GetClass()->DebugTokenMap;
for (int32 Index = 0, End = TokenMap.GetTokenMapSize(); Index < End; ++Index)
{
auto TokenName = TokenMap.GetTokenInfo(Index).Name;
if (ReferencedObject.GetFName() == TokenName)
{
Result = Index;
break;
}
}
return Result;
}
void FSequencerObjectBindingNode::HandlePropertyMenuItemExecute(TArray<UProperty*> PropertyPath)
{
FSequencer& Sequencer = GetSequencer();
UObject* BoundObject = GetSequencer().FindSpawnedObjectOrTemplate(ObjectBinding);
TArray<UObject*> KeyableBoundObjects;
if (BoundObject != nullptr)
{
if (Sequencer.CanKeyProperty(FCanKeyPropertyParams(BoundObject->GetClass(), PropertyPath)))
{
KeyableBoundObjects.Add(BoundObject);
}
}
FKeyPropertyParams KeyPropertyParams(KeyableBoundObjects, PropertyPath, ESequencerKeyMode::ManualKeyForced);
Sequencer.KeyProperty(KeyPropertyParams);
}
unreal::UIntPtr unreal::helpers::ClassMap_obj::wrap(unreal::UIntPtr inUObject) {
if (inUObject == 0) return 0;
UObject *obj = (UObject *) inUObject;
UClass *cls = obj->GetClass();
auto& map = getClassMap();
while (cls != nullptr) {
if (cls->HasAllClassFlags(CLASS_Native)) {
auto it = map.find(cls);
if (it != map.end()) {
return (it->second)(inUObject);
}
}
cls = cls->GetSuperClass();
}
UE_LOG(LogTemp,Fatal,TEXT("No haxe wrapper was found for the uobject from class %s nor from any of its superclasses"), *obj->GetClass()->GetName());
// won't get here
return 0;
}
void SDetailsView::ReplaceObjects( const TMap<UObject*, UObject*>& OldToNewObjectMap )
{
TArray< TWeakObjectPtr< UObject > > NewObjectList;
bool bObjectsReplaced = false;
TArray< FObjectPropertyNode* > ObjectNodes;
for(TSharedPtr<FComplexPropertyNode>& RootNode : RootPropertyNodes)
{
PropertyEditorHelpers::CollectObjectNodes(RootNode, ObjectNodes );
}
for( int32 ObjectNodeIndex = 0; ObjectNodeIndex < ObjectNodes.Num(); ++ObjectNodeIndex )
{
FObjectPropertyNode* CurrentNode = ObjectNodes[ObjectNodeIndex];
// Scan all objects and look for objects which need to be replaced
for ( TPropObjectIterator Itor( CurrentNode->ObjectIterator() ); Itor; ++Itor )
{
UObject* Replacement = OldToNewObjectMap.FindRef( Itor->Get() );
if( Replacement && Replacement->GetClass() == Itor->Get()->GetClass() )
{
bObjectsReplaced = true;
if( CurrentNode->IsRootNode() )
{
// Note: only root objects count for the new object list. Sub-Objects (i.e components count as needing to be replaced but they don't belong in the top level object list
NewObjectList.Add( Replacement );
}
}
else if( CurrentNode->IsRootNode() )
{
// Note: only root objects count for the new object list. Sub-Objects (i.e components count as needing to be replaced but they don't belong in the top level object list
NewObjectList.Add( Itor->Get() );
}
}
}
if( bObjectsReplaced )
{
SetObjectArrayPrivate( NewObjectList );
}
}
//------------------------------------------------------------------------------
bool FLinkerPlaceholderBase::AddReferencingPropertyValue(const UObjectProperty* ReferencingProperty, void* DataPtr)
{
TArray<UObject*>& PossibleReferencers = FPlaceholderContainerTracker::Get().PerspectiveReferencerStack;
UObject* FoundReferencer = nullptr;
// iterate backwards because this is meant to act as a stack, where the last
// entry is most likely the one we're looking for
for (int32 CandidateIndex = PossibleReferencers.Num() - 1; CandidateIndex >= 0; --CandidateIndex)
{
UObject* ReferencerCandidate = PossibleReferencers[CandidateIndex];
UClass* CandidateClass = ReferencerCandidate->GetClass();
UClass* PropOwnerClass = ReferencingProperty->GetOwnerClass();
if (CandidateClass->IsChildOf(PropOwnerClass))
{
FoundReferencer = ReferencerCandidate;
break;
}
}
#if USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
check(ReferencingProperty->GetObjectPropertyValue(DataPtr) == GetPlaceholderAsUObject());
check(FoundReferencer != nullptr);
#endif // USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
if (FoundReferencer != nullptr)
{
#if USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
// @TODO: verify that DataPtr belongs to FoundReferencer
// uint8* ContainerStart = (uint8*)FoundReferencer;
// uint8* ContainerEnd = ContainerStart + FoundReferencer->GetClass()->GetStructureSize();
// // check that we picked the right container object, and that DataPtr exists within it
// check(DataPtr >= ContainerStart && DataPtr <= ContainerEnd);
#endif // USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
ReferencingContainers.FindOrAdd(FoundReferencer).Add(ReferencingProperty);
}
return (FoundReferencer != nullptr);
}
virtual void HandleObjectReference(UObject*& InObject, const UObject* InReferencingObject, const UProperty* InReferencingProperty) override
{
UObject* Object = InObject;
if (!Object || Object->IsA<UBlueprint>())
{
return;
}
UClass* ActualClass = Cast<UClass>(Dependencies.GetActualStruct());
UStruct* CurrentlyConvertedStruct = ActualClass ? Dependencies.FindOriginalClass(ActualClass) : Dependencies.GetActualStruct();
ensure(CurrentlyConvertedStruct);
if (Object == CurrentlyConvertedStruct)
{
return;
}
if (Object->HasAnyFlags(RF_ClassDefaultObject))
{
// Static functions from libraries are called on CDO. (The functions is stored as a name not an object).
UClass* OwnerClass = Object->GetClass();
if (OwnerClass && (OwnerClass != CurrentlyConvertedStruct))
{
UBlueprintGeneratedClass* OwnerAsBPGC = Cast<UBlueprintGeneratedClass>(OwnerClass);
if (OwnerAsBPGC && !Dependencies.ConvertedClasses.Contains(OwnerAsBPGC) && Dependencies.WillClassBeConverted(OwnerAsBPGC))
{
Dependencies.ConvertedClasses.Add(OwnerAsBPGC);
}
}
}
const bool bUseZConstructorInGeneratedCode = false;
//TODO: What About Delegates?
auto ObjAsBPGC = Cast<UBlueprintGeneratedClass>(Object);
const bool bWillBeConvetedAsBPGC = ObjAsBPGC && Dependencies.WillClassBeConverted(ObjAsBPGC);
if (bWillBeConvetedAsBPGC)
{
if (ObjAsBPGC != CurrentlyConvertedStruct)
{
Dependencies.ConvertedClasses.Add(ObjAsBPGC);
if(!bUseZConstructorInGeneratedCode)
{
IncludeTheHeaderInBody(ObjAsBPGC);
}
}
}
else if (UUserDefinedStruct* UDS = Cast<UUserDefinedStruct>(Object))
{
if (!UDS->HasAnyFlags(RF_ClassDefaultObject))
{
Dependencies.ConvertedStructs.Add(UDS);
if(!bUseZConstructorInGeneratedCode)
{
IncludeTheHeaderInBody(UDS);
}
}
}
else if (UUserDefinedEnum* UDE = Cast<UUserDefinedEnum>(Object))
{
if (!UDE->HasAnyFlags(RF_ClassDefaultObject))
{
Dependencies.ConvertedEnum.Add(UDE);
}
}
else if ((Object->IsAsset() || ObjAsBPGC) && !Object->IsIn(CurrentlyConvertedStruct))
{
// include all not converted super classes
for (auto SuperBPGC = ObjAsBPGC ? Cast<UBlueprintGeneratedClass>(ObjAsBPGC->GetSuperClass()) : nullptr;
SuperBPGC && !Dependencies.WillClassBeConverted(SuperBPGC);
SuperBPGC = Cast<UBlueprintGeneratedClass>(SuperBPGC->GetSuperClass()))
{
Dependencies.Assets.AddUnique(SuperBPGC);
}
Dependencies.Assets.AddUnique(Object);
return;
}
else if (auto ObjAsClass = Cast<UClass>(Object))
{
if (ObjAsClass->HasAnyClassFlags(CLASS_Native))
{
return;
}
}
else if (Object->IsA<UScriptStruct>())
{
return;
}
FindReferencesForNewObject(Object);
}
void FGatherConvertedClassDependencies::DependenciesForHeader()
{
TArray<UObject*> ObjectsToCheck;
GetObjectsWithOuter(OriginalStruct, ObjectsToCheck, true);
TArray<UObject*> NeededObjects;
FReferenceFinder HeaderReferenceFinder(NeededObjects, nullptr, false, false, true, false);
auto ShouldIncludeHeaderFor = [&](UObject* InObj)->bool
{
if (InObj
&& (InObj->IsA<UClass>() || InObj->IsA<UEnum>() || InObj->IsA<UScriptStruct>())
&& !InObj->HasAnyFlags(RF_ClassDefaultObject))
{
auto ObjAsBPGC = Cast<UBlueprintGeneratedClass>(InObj);
const bool bWillBeConvetedAsBPGC = ObjAsBPGC && WillClassBeConverted(ObjAsBPGC);
const bool bRemainAsUnconvertedBPGC = ObjAsBPGC && !bWillBeConvetedAsBPGC;
if (!bRemainAsUnconvertedBPGC && (InObj->GetOutermost() != OriginalStruct->GetOutermost()))
{
return true;
}
}
return false;
};
for (auto Obj : ObjectsToCheck)
{
const UProperty* Property = Cast<const UProperty>(Obj);
if (const UArrayProperty* ArrayProperty = Cast<UArrayProperty>(Property))
{
Property = ArrayProperty->Inner;
}
const UProperty* OwnerProperty = IsValid(Property) ? Property->GetOwnerProperty() : nullptr;
const bool bIsParam = OwnerProperty && (0 != (OwnerProperty->PropertyFlags & CPF_Parm)) && OwnerProperty->IsIn(OriginalStruct);
const bool bIsMemberVariable = OwnerProperty && (OwnerProperty->GetOuter() == OriginalStruct);
if (bIsParam || bIsMemberVariable)
{
if (auto ObjectProperty = Cast<const UObjectPropertyBase>(Property))
{
DeclareInHeader.Add(GetFirstNativeOrConvertedClass(ObjectProperty->PropertyClass));
}
else if (auto InterfaceProperty = Cast<const UInterfaceProperty>(Property))
{
IncludeInHeader.Add(InterfaceProperty->InterfaceClass);
}
else if (auto DelegateProperty = Cast<const UDelegateProperty>(Property))
{
IncludeInHeader.Add(DelegateProperty->SignatureFunction ? DelegateProperty->SignatureFunction->GetOwnerStruct() : nullptr);
}
/* MC Delegate signatures are recreated in local scope anyway.
else if (auto MulticastDelegateProperty = Cast<const UMulticastDelegateProperty>(Property))
{
IncludeInHeader.Add(MulticastDelegateProperty->SignatureFunction ? MulticastDelegateProperty->SignatureFunction->GetOwnerClass() : nullptr);
}
*/
else if (const UByteProperty* ByteProperty = Cast<const UByteProperty>(Property))
{
// HeaderReferenceFinder.FindReferences(Obj); cannot find this enum..
IncludeInHeader.Add(ByteProperty->Enum);
}
else
{
HeaderReferenceFinder.FindReferences(Obj);
}
}
}
if (auto SuperStruct = OriginalStruct->GetSuperStruct())
{
IncludeInHeader.Add(SuperStruct);
}
if (auto SourceClass = Cast<UClass>(OriginalStruct))
{
for (auto& ImplementedInterface : SourceClass->Interfaces)
{
IncludeInHeader.Add(ImplementedInterface.Class);
}
}
for (auto Obj : NeededObjects)
{
if (ShouldIncludeHeaderFor(Obj))
{
IncludeInHeader.Add(CastChecked<UField>(Obj));
}
}
// DEFAULT VALUES FROM UDS:
UUserDefinedStruct* UDS = Cast<UUserDefinedStruct>(OriginalStruct);
if (UDS)
{
FStructOnScope StructOnScope(UDS);
UDS->InitializeDefaultValue(StructOnScope.GetStructMemory());
for (TFieldIterator<UObjectPropertyBase> PropertyIt(UDS); PropertyIt; ++PropertyIt)
{
UObject* DefaultValueObject = ((UObjectPropertyBase*)*PropertyIt)->GetObjectPropertyValue_InContainer(StructOnScope.GetStructMemory());
UField* ObjAsField = Cast<UField>(DefaultValueObject);
UField* FieldForHeader = ObjAsField ? ObjAsField : (DefaultValueObject ? DefaultValueObject->GetClass() : nullptr);
IncludeInHeader.Add(FieldForHeader);
}
}
// REMOVE UNNECESSARY HEADERS
UClass* AsBPGC = Cast<UBlueprintGeneratedClass>(OriginalStruct);
UClass* OriginalClassFromOriginalPackage = AsBPGC ? FindOriginalClass(AsBPGC) : nullptr;
const UPackage* OriginalStructPackage = OriginalStruct ? OriginalStruct->GetOutermost() : nullptr;
for (auto Iter = IncludeInHeader.CreateIterator(); Iter; ++Iter)
{
UField* CurrentField = *Iter;
if (CurrentField)
{
if (CurrentField->GetOutermost() == OriginalStructPackage)
{
Iter.RemoveCurrent();
}
else if (CurrentField == OriginalStruct)
{
Iter.RemoveCurrent();
}
else if (OriginalClassFromOriginalPackage && (CurrentField == OriginalClassFromOriginalPackage))
{
Iter.RemoveCurrent();
}
}
}
}
virtual void HandleObjectReference(UObject*& InObject, const UObject* InReferencingObject, const UProperty* InReferencingProperty) override
{
UObject* Object = InObject;
if (!Object || Object->IsA<UBlueprint>())
{
return;
}
UClass* ActualClass = Cast<UClass>(Dependencies.GetActualStruct());
UStruct* CurrentlyConvertedStruct = ActualClass ? Dependencies.FindOriginalClass(ActualClass) : Dependencies.GetActualStruct();
ensure(CurrentlyConvertedStruct);
if (Object == CurrentlyConvertedStruct)
{
return;
}
{
auto ObjAsField = Cast<UField>(Object);
if (!ObjAsField)
{
const bool bTransientObject = (Object->HasAnyFlags(RF_Transient) && !Object->IsIn(CurrentlyConvertedStruct)) || Object->IsIn(GetTransientPackage());
if (bTransientObject)
{
return;
}
ObjAsField = Object->GetClass();
}
if (ObjAsField && !ObjAsField->HasAnyFlags(RF_ClassDefaultObject))
{
if (ObjAsField->IsA<UProperty>())
{
ObjAsField = ObjAsField->GetOwnerStruct();
}
if (ObjAsField->IsA<UFunction>())
{
ObjAsField = ObjAsField->GetOwnerClass();
}
IncludeTheHeaderInBody(ObjAsField);
}
}
if ((Object->IsAsset() || Object->IsA<UBlueprintGeneratedClass>()) && !Object->IsIn(CurrentlyConvertedStruct))
{
return;
}
auto OwnedByAnythingInHierarchy = [&]()->bool
{
for (UStruct* IterStruct = CurrentlyConvertedStruct; IterStruct; IterStruct = IterStruct->GetSuperStruct())
{
if (Object->IsIn(IterStruct))
{
return true;
}
UClass* IterClass = Cast<UClass>(IterStruct);
UObject* CDO = IterClass ? IterClass->GetDefaultObject(false) : nullptr;
if (CDO && Object->IsIn(CDO))
{
return true;
}
}
return false;
};
if (!Object->IsA<UField>() && !Object->HasAnyFlags(RF_ClassDefaultObject) && !OwnedByAnythingInHierarchy())
{
Object = Object->GetClass();
}
FindReferencesForNewObject(Object);
}
void FHotReloadClassReinstancer::UpdateDefaultProperties()
{
struct FPropertyToUpdate
{
UProperty* Property;
FName SubobjectName;
uint8* OldSerializedValuePtr;
uint8* NewValuePtr;
int64 OldSerializedSize;
};
/** Memory writer archive that supports UObject values the same way as FCDOWriter. */
class FPropertyValueMemoryWriter : public FMemoryWriter
{
public:
FPropertyValueMemoryWriter(TArray<uint8>& OutData)
: FMemoryWriter(OutData)
{}
virtual FArchive& operator<<(class UObject*& InObj) override
{
FArchive& Ar = *this;
if (InObj)
{
FName ClassName = InObj->GetClass()->GetFName();
FName ObjectName = InObj->GetFName();
Ar << ClassName;
Ar << ObjectName;
}
else
{
FName UnusedName = NAME_None;
Ar << UnusedName;
Ar << UnusedName;
}
return *this;
}
virtual FArchive& operator<<(FName& InName) override
{
FArchive& Ar = *this;
NAME_INDEX ComparisonIndex = InName.GetComparisonIndex();
NAME_INDEX DisplayIndex = InName.GetDisplayIndex();
int32 Number = InName.GetNumber();
Ar << ComparisonIndex;
Ar << DisplayIndex;
Ar << Number;
return Ar;
}
virtual FArchive& operator<<(FLazyObjectPtr& LazyObjectPtr) override
{
FArchive& Ar = *this;
auto UniqueID = LazyObjectPtr.GetUniqueID();
Ar << UniqueID;
return *this;
}
virtual FArchive& operator<<(FAssetPtr& AssetPtr) override
{
FArchive& Ar = *this;
auto UniqueID = AssetPtr.GetUniqueID();
Ar << UniqueID;
return Ar;
}
virtual FArchive& operator<<(FStringAssetReference& Value) override
{
FArchive& Ar = *this;
Ar << Value.AssetLongPathname;
return Ar;
}
};
// Collect default subobjects to update their properties too
const int32 DefaultSubobjectArrayCapacity = 16;
TArray<UObject*> DefaultSubobjectArray;
DefaultSubobjectArray.Empty(DefaultSubobjectArrayCapacity);
NewClass->GetDefaultObject()->CollectDefaultSubobjects(DefaultSubobjectArray);
TArray<FPropertyToUpdate> PropertiesToUpdate;
// Collect all properties that have actually changed
for (auto& Pair : ReconstructedCDOProperties.Properties)
{
auto OldPropertyInfo = OriginalCDOProperties.Properties.Find(Pair.Key);
if (OldPropertyInfo)
{
auto& NewPropertyInfo = Pair.Value;
uint8* OldSerializedValuePtr = OriginalCDOProperties.Bytes.GetData() + OldPropertyInfo->SerializedValueOffset;
uint8* NewSerializedValuePtr = ReconstructedCDOProperties.Bytes.GetData() + NewPropertyInfo.SerializedValueOffset;
if (OldPropertyInfo->SerializedValueSize != NewPropertyInfo.SerializedValueSize ||
FMemory::Memcmp(OldSerializedValuePtr, NewSerializedValuePtr, OldPropertyInfo->SerializedValueSize) != 0)
{
// Property value has changed so add it to the list of properties that need updating on instances
FPropertyToUpdate PropertyToUpdate;
PropertyToUpdate.Property = NewPropertyInfo.Property;
PropertyToUpdate.NewValuePtr = nullptr;
PropertyToUpdate.SubobjectName = NewPropertyInfo.SubobjectName;
if (NewPropertyInfo.Property->GetOuter() == NewClass)
{
PropertyToUpdate.NewValuePtr = PropertyToUpdate.Property->ContainerPtrToValuePtr<uint8>(NewClass->GetDefaultObject());
}
else if (NewPropertyInfo.SubobjectName != NAME_None)
{
UObject* DefaultSubobjectPtr = FindDefaultSubobject(DefaultSubobjectArray, NewPropertyInfo.SubobjectName);
if (DefaultSubobjectPtr && NewPropertyInfo.Property->GetOuter() == DefaultSubobjectPtr->GetClass())
{
PropertyToUpdate.NewValuePtr = PropertyToUpdate.Property->ContainerPtrToValuePtr<uint8>(DefaultSubobjectPtr);
}
}
if (PropertyToUpdate.NewValuePtr)
{
PropertyToUpdate.OldSerializedValuePtr = OldSerializedValuePtr;
PropertyToUpdate.OldSerializedSize = OldPropertyInfo->SerializedValueSize;
PropertiesToUpdate.Add(PropertyToUpdate);
}
}
}
}
if (PropertiesToUpdate.Num())
{
TArray<uint8> CurrentValueSerializedData;
// Update properties on all existing instances of the class
for (FObjectIterator It(NewClass); It; ++It)
{
UObject* ObjectPtr = *It;
DefaultSubobjectArray.Empty(DefaultSubobjectArrayCapacity);
ObjectPtr->CollectDefaultSubobjects(DefaultSubobjectArray);
for (auto& PropertyToUpdate : PropertiesToUpdate)
{
uint8* InstanceValuePtr = nullptr;
if (PropertyToUpdate.SubobjectName == NAME_None)
{
InstanceValuePtr = PropertyToUpdate.Property->ContainerPtrToValuePtr<uint8>(ObjectPtr);
}
else
{
UObject* DefaultSubobjectPtr = FindDefaultSubobject(DefaultSubobjectArray, PropertyToUpdate.SubobjectName);
if (DefaultSubobjectPtr && PropertyToUpdate.Property->GetOuter() == DefaultSubobjectPtr->GetClass())
{
InstanceValuePtr = PropertyToUpdate.Property->ContainerPtrToValuePtr<uint8>(DefaultSubobjectPtr);
}
}
if (InstanceValuePtr)
{
// Serialize current value to a byte array as we don't have the previous CDO to compare against, we only have its serialized property data
CurrentValueSerializedData.Empty(CurrentValueSerializedData.Num() + CurrentValueSerializedData.GetSlack());
FPropertyValueMemoryWriter CurrentValueWriter(CurrentValueSerializedData);
PropertyToUpdate.Property->SerializeItem(CurrentValueWriter, InstanceValuePtr);
// Update only when the current value on the instance is identical to the original CDO
if (CurrentValueSerializedData.Num() == PropertyToUpdate.OldSerializedSize &&
FMemory::Memcmp(CurrentValueSerializedData.GetData(), PropertyToUpdate.OldSerializedValuePtr, CurrentValueSerializedData.Num()) == 0)
{
// Update with the new value
PropertyToUpdate.Property->CopyCompleteValue(InstanceValuePtr, PropertyToUpdate.NewValuePtr);
}
}
}
}
}
}
