ReferenceInfo

ReferenceInfo

#Overview

name: ReferenceInfo

This variable is created as a Console Variable (cvar).

It is referenced in 26 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of ReferenceInfo is to store and manage information about references between objects in Unreal Engine. This variable is used in various subsystems to track and handle object relationships, particularly in the context of garbage collection, serialization, and networking.

ReferenceInfo is used across several Unreal Engine subsystems and modules, including:

  1. Garbage Collection system
  2. Serialization system
  3. Networking and Replication system
  4. Editor tools (e.g., reference finder)

The value of ReferenceInfo is typically set within the specific contexts where it’s used. For example:

ReferenceInfo often interacts with other variables and structures, such as:

Developers should be aware of the following when using ReferenceInfo:

  1. It’s a crucial part of Unreal Engine’s object management system.
  2. Modifying or misusing ReferenceInfo can lead to issues with garbage collection or object serialization.
  3. It’s used in both runtime and editor contexts.

Best practices when using ReferenceInfo include:

  1. Avoid manually modifying ReferenceInfo unless absolutely necessary.
  2. When implementing custom garbage collection or serialization logic, ensure proper use of ReferenceInfo to maintain object relationships.
  3. Use existing engine systems for reference management when possible, rather than creating custom solutions.
  4. When extending engine functionality that involves object references, consider how ReferenceInfo should be handled to maintain consistency with the engine’s expectations.

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/ReferenceInfoUtils.cpp:50

Scope: file

Source code excerpt:


static FAutoConsoleCommandWithWorldAndArgs ActorReferenceInfoCVar(
	TEXT("ReferenceInfo"),
	TEXT("Outputs reference info for selected actors to a log file. Syntax is: ReferenceInfo [-depth=<depth value>] [-nodefault] [-noscript]"),
	FConsoleCommandWithWorldAndArgsDelegate::CreateStatic(ExecuteReferenceInfo)
	);

namespace ReferenceInfoUtils
{

#Loc: <Workspace>/Engine/Source/Editor/Persona/Private/SSlotNameReferenceWindow.cpp:41

Scope (from outer to inner):

file
function     void SMontageReferenceListRow::Construct

Source code excerpt:

{
	check(InArgs._ReferenceInfo.IsValid());
	ReferenceInfo = InArgs._ReferenceInfo;

	SMultiColumnTableRow<TSharedPtr<FDisplayedMontageReferenceInfo>>::Construct(FSuperRowType::FArguments(), InOwnerTableView);
}

TSharedRef<SWidget> SMontageReferenceListRow::GenerateWidgetForColumn(const FName& ColumnName)
{

#Loc: <Workspace>/Engine/Source/Editor/Persona/Private/SSlotNameReferenceWindow.cpp:54

Scope (from outer to inner):

file
function     TSharedRef<SWidget> SMontageReferenceListRow::GenerateWidgetForColumn

Source code excerpt:

			.VAlign(VAlign_Center)
			[
				SNew(STextBlock).Text(FText::FromString(ReferenceInfo->AssetData.AssetName.ToString()))
			];
	}
	else if(ColumnName == TEXT("Asset"))
	{
		// Buttons to jump to / view asset
		return SNew(SHorizontalBox)

#Loc: <Workspace>/Engine/Source/Editor/Persona/Private/SSlotNameReferenceWindow.cpp:96

Scope (from outer to inner):

file
function     FReply SMontageReferenceListRow::OnViewInContentBrowserClicked

Source code excerpt:

{
	TArray<FAssetData> Objects;
	Objects.Add(ReferenceInfo->AssetData);
	GEditor->SyncBrowserToObjects(Objects);

	return FReply::Handled();
}

FReply SMontageReferenceListRow::OnOpenAssetClicked()
{
	GEditor->GetEditorSubsystem<UAssetEditorSubsystem>()->OpenEditorForAsset(ReferenceInfo->AssetData.GetAsset());

	return FReply::Handled();
}

//------------------------------------------------------------------------------------------

#Loc: <Workspace>/Engine/Source/Editor/Persona/Private/SSlotNameReferenceWindow.cpp:114

Scope (from outer to inner):

file
function     void SBlueprintReferenceListRow::Construct

Source code excerpt:

{
	check(InArgs._ReferenceInfo.IsValid());
	ReferenceInfo = InArgs._ReferenceInfo;

	SMultiColumnTableRow<TSharedPtr<FDisplayedBlueprintReferenceInfo>>::Construct(FSuperRowType::FArguments(), InOwnerTableView);
}

TSharedRef<SWidget> SBlueprintReferenceListRow::GenerateWidgetForColumn(const FName& ColumnName)
{
	if(ColumnName == TEXT("BlueprintName"))
	{
		return SNew(STextBlock).Text(FText::FromString(ReferenceInfo->BlueprintName));
	}
	else if(ColumnName == TEXT("GraphName"))
	{
		return SNew(STextBlock).Text(FText::FromString(ReferenceInfo->GraphName));
	}
	else if(ColumnName == TEXT("NodeName"))
	{
		return SNew(STextBlock).Text(FText::FromString(ReferenceInfo->NodeName));
	}
	else if(ColumnName == TEXT("Asset"))
	{
		// Buttons to jump to / view asset
		return SNew(SHorizontalBox)
			+ SHorizontalBox::Slot()

#Loc: <Workspace>/Engine/Source/Editor/Persona/Private/SSlotNameReferenceWindow.cpp:171

Scope (from outer to inner):

file
function     FReply SBlueprintReferenceListRow::OnViewInContentBrowserClicked

Source code excerpt:

FReply SBlueprintReferenceListRow::OnViewInContentBrowserClicked()
{
	check(ReferenceInfo->AnimBlueprint);
	TArray<UObject*> Objects;
	UObject* BPAsObject = ReferenceInfo->AnimBlueprint;
	Objects.Add(BPAsObject);
	GEditor->SyncBrowserToObjects(Objects);

	return FReply::Handled();
}

FReply SBlueprintReferenceListRow::OnOpenAssetClicked()
{
	GEditor->GetEditorSubsystem<UAssetEditorSubsystem>()->OpenEditorForAsset(ReferenceInfo->AnimBlueprint);
	
	FBlueprintEditor* BPEditor = static_cast<FBlueprintEditor*>(GEditor->GetEditorSubsystem<UAssetEditorSubsystem>()->FindEditorForAsset(ReferenceInfo->AnimBlueprint, true));
	if(BPEditor)
	{
		// Should only ever get an FPersona object back for an animBP.
		TSharedPtr<SGraphEditor> GraphEditor = BPEditor->OpenGraphAndBringToFront(ReferenceInfo->NodeGraph);
		if(GraphEditor.IsValid())
		{
			// Open the right graph and zoom in on the offending node
			GraphEditor->JumpToNode(ReferenceInfo->Node, false);
		}
	}

	return FReply::Handled();
}

#Loc: <Workspace>/Engine/Source/Editor/Persona/Private/SSlotNameReferenceWindow.cpp:393

Scope (from outer to inner):

file
function     TSharedRef<ITableRow> SSlotNameReferenceWindow::HandleGenerateMontageReferenceRow

Source code excerpt:

{
	return SNew(SMontageReferenceListRow, OwnerTable)
			.ReferenceInfo(Item);
}

TSharedRef<ITableRow> SSlotNameReferenceWindow::HandleGenerateBlueprintReferenceRow(TSharedPtr<FDisplayedBlueprintReferenceInfo> Item, const TSharedRef<STableViewBase>& OwnerTable)
{
	return SNew(SBlueprintReferenceListRow, OwnerTable)
			.ReferenceInfo(Item);
}

FReply SSlotNameReferenceWindow::OnRetryClicked()
{
	if(OnRetry.IsBound())
	{

#Loc: <Workspace>/Engine/Source/Editor/Persona/Private/SSlotNameReferenceWindow.h:86

Scope (from outer to inner):

file
class        class SMontageReferenceListRow : public SMultiColumnTableRow < TSharedPtr<FDisplayedMontageReferenceInfo> >

Source code excerpt:

	FReply OnOpenAssetClicked();

	TSharedPtr<FDisplayedMontageReferenceInfo> ReferenceInfo;
};

class SBlueprintReferenceListRow : public SMultiColumnTableRow<TSharedPtr<FDisplayedBlueprintReferenceInfo>>
{
public:
	SLATE_BEGIN_ARGS(SBlueprintReferenceListRow) {}

#Loc: <Workspace>/Engine/Source/Editor/Persona/Private/SSlotNameReferenceWindow.h:107

Scope (from outer to inner):

file
class        class SBlueprintReferenceListRow : public SMultiColumnTableRow<TSharedPtr<FDisplayedBlueprintReferenceInfo>>

Source code excerpt:

	FReply OnOpenAssetClicked();

	TSharedPtr<FDisplayedBlueprintReferenceInfo> ReferenceInfo;
};

// Required information to update a reference window widget, used in conjunction with SSlotNameReferenceWindow::UpdateInfo
// any fields that do not get set by the caller will not be updated and will keep its previous value
struct FReferenceWindowInfo
{

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/AssetPrivatizeModel.cpp:58

Scope (from outer to inner):

file
function     void FPendingPrivateAsset::CheckForIllegalReferences
lambda-function

Source code excerpt:

	ObjectTools::GatherObjectReferencersForDeletion(Object, bIsReferencedInMemoryByNonUndo, bIsReferencedInMemoryByUndo, &IllegalMemoryReferences);

	IllegalMemoryReferences.ExternalReferences.RemoveAll([this](const FReferencerInformation& ReferenceInfo)
		{
			if (ReferenceInfo.Referencer->HasAnyFlags(RF_Transient))
			{
				return true;
			}
			return !IsReferenceIllegal(ReferenceInfo.Referencer->GetPackage()->GetFName());
		});

	IllegalMemoryReferences.InternalReferences.RemoveAll([this](const FReferencerInformation& ReferenceInfo)
		{
			if (ReferenceInfo.Referencer->HasAnyFlags(RF_Transient))
			{
				return true;
			}
			return !IsReferenceIllegal(ReferenceInfo.Referencer->GetPackage()->GetFName());
		});

	if (IllegalMemoryReferences.ExternalReferences.IsEmpty() && IllegalMemoryReferences.InternalReferences.IsEmpty())
	{
		bIsReferencedInMemoryByNonUndo = false;
	}

#Loc: <Workspace>/Engine/Source/Runtime/CoreUObject/Private/UObject/GarbageCollection.cpp:5197

Scope (from outer to inner):

file
namespace    UE::GC
function     static void ClearWeakReferences

Source code excerpt:

	{
		GGCStats.NumWeakReferencesForClearing += Context->WeakReferences.Num();
		for (FWeakReferenceInfo& ReferenceInfo : Context->WeakReferences)
		{
			UObject* ReferencedObject = ReferenceInfo.ReferencedObject;
			if (ReferencedObject && ReferencedObject->IsUnreachable())
			{
				if constexpr (bGatheredWithIncrementalReachability)
				{
					// When running incremental reachability we can't assume the Reference pointer is still valid
					// so instead collect all referencing objects and run AddReferencedObjects on them again with
					// a special collector that will null out references to unrachable objects
					ObjectsThatNeedWeakReferenceClearing.Add(ReferenceInfo.ReferenceOwner);
				}
				else
				{
					*ReferenceInfo.Reference = nullptr;
				}
			}
		}
		Context->WeakReferences.Reset();
	}
	if constexpr (bGatheredWithIncrementalReachability)

#Loc: <Workspace>/Engine/Source/Runtime/CoreUObject/Private/UObject/ReferenceChainSearch.cpp:720

Scope (from outer to inner):

file
namespace    UE::ReferenceChainSearch
function     void PerformInitialGatherFromGCHistory

Source code excerpt:

				int64 StartOffset = TempGraph.Buffer.Num();
				FVertex FromVertex = Policy.ObjectToVertex(Pair.Key.AsGCObjectInfo());
				for (FGCDirectReference& ReferenceInfo : *Pair.Value)
				{
					if (ReferenceInfo.Reference.IsGCObjectInfo())
					{
						FVertex ToVertex = Policy.ObjectToVertex(ReferenceInfo.Reference.AsGCObjectInfo());
						check(TempGraph.EdgeLists.IsValidIndex(ToVertex));
						TempGraph.Buffer.Add(ToVertex);
					}
				}
				TempGraph.EdgeLists[FromVertex] =
					TConstArrayView<int32>(TempGraph.Buffer.GetData() + StartOffset, static_cast<int32>(TempGraph.Buffer.Num() - StartOffset));

#Loc: <Workspace>/Engine/Source/Runtime/CoreUObject/Private/UObject/ReferenceChainSearch.cpp:1391

Scope (from outer to inner):

file
function     void FReferenceChainSearch::DumpChain

Source code excerpt:

		bool bPostCallbackContinue = true;
		const int32 RootIndex = Chain->Num() - 1;
		const FNodeReferenceInfo* ReferenceInfo = Chain->GetReferenceInfo(RootIndex);
		FGCObjectInfo* ReferencerObject = Chain->GetNode(RootIndex)->ObjectInfo;
		{
			FCallbackParams Params;
			Params.Referencer = nullptr;
			Params.Object = ReferencerObject;
			Params.ReferenceInfo = nullptr;
			Params.Indent = FMath::Min<int32>(TCStringSpcHelper<TCHAR>::MAX_SPACES, Chain->Num() - RootIndex);
			Params.Out = &Out;

			Out.Logf(ELogVerbosity::Log, TEXT("%s%s %s"),
				FCString::Spc(Params.Indent),
				*GetObjectFlags(*ReferencerObject),

#Loc: <Workspace>/Engine/Source/Runtime/CoreUObject/Private/UObject/ReferenceChainSearch.cpp:1417

Scope (from outer to inner):

file
function     void FReferenceChainSearch::DumpChain

Source code excerpt:

			Params.Referencer = ReferencerObject;
			Params.Object = Object;
			Params.ReferenceInfo = ReferenceInfo;
			Params.Indent = FMath::Min<int32>(TCStringSpcHelper<TCHAR>::MAX_SPACES, Chain->Num() - NodeIndex - 1);
			Params.Out = &Out;

			if (ReferenceInfo && ReferenceInfo->Type == EReferenceType::Property)
			{
				FString ReferencingPropertyName;
				UClass* ReferencerClass = Cast<UClass>(ReferencerObject->GetClass()->TryResolveObject());
				TArray<FProperty*> ReferencingProperties;

				if (ReferencerClass && UE::GC::FPropertyStack::ConvertPathToProperties(ReferencerClass, ReferenceInfo->ReferencerName, ReferencingProperties))
				{
					FProperty* InnermostProperty = ReferencingProperties.Last();
					FProperty* OutermostProperty = ReferencingProperties[0];

					ReferencingPropertyName = FString::Printf(TEXT("%s %s%s::%s"),
						*InnermostProperty->GetCPPType(),
						OutermostProperty->GetOwnerClass()->GetPrefixCPP(),
						*OutermostProperty->GetOwnerClass()->GetName(),
						*ReferenceInfo->ReferencerName.ToString());
				}
				else
				{
					// Handle base UObject referencer info (it's only exposed to the GC token stream and not to the reflection system)
					static const FName ClassPropertyName(TEXT("Class"));
					static const FName OuterPropertyName(TEXT("Outer"));

					FString ClassName;
					if (ReferenceInfo->ReferencerName == ClassPropertyName || ReferenceInfo->ReferencerName == OuterPropertyName)
					{
						ClassName = TEXT("UObject");
					}
					else if (ReferencerClass)
					{
						// Use the native class name when possible

#Loc: <Workspace>/Engine/Source/Runtime/CoreUObject/Private/UObject/ReferenceChainSearch.cpp:1460

Scope (from outer to inner):

file
function     void FReferenceChainSearch::DumpChain

Source code excerpt:

						ClassName = ReferencerObject->GetClassName();
					}
					ReferencingPropertyName = FString::Printf(TEXT("UObject* %s::%s"), *ClassName, *ReferenceInfo->ReferencerName.ToString());
				}

				Out.Logf(ELogVerbosity::Log, TEXT("%s-> %s = %s %s"),
					FCString::Spc(Params.Indent),
					*ReferencingPropertyName,
					*GetObjectFlags(*Object),
					*Object->GetFullName());
			}
			else if (ReferenceInfo && ReferenceInfo->Type == EReferenceType::AddReferencedObjects)
			{
				FString UObjectOrGCObjectName;
				if (ReferenceInfo->ReferencerName.IsNone())
				{
					UClass* ReferencerClass = Cast<UClass>(ReferencerObject->GetClass()->TryResolveObject());
					if (ReferencerClass)
					{
						UObjectOrGCObjectName = ReferencerClass->GetPrefixCPP();
						UObjectOrGCObjectName += ReferencerClass->GetName();

#Loc: <Workspace>/Engine/Source/Runtime/CoreUObject/Private/UObject/ReferenceChainSearch.cpp:1487

Scope (from outer to inner):

file
function     void FReferenceChainSearch::DumpChain

Source code excerpt:

				else
				{
					UObjectOrGCObjectName = ReferenceInfo->ReferencerName.ToString();
				}

				Out.Logf(ELogVerbosity::Log, TEXT("%s-> %s::AddReferencedObjects(%s %s)"),
					FCString::Spc(Params.Indent),
					*UObjectOrGCObjectName,
					*GetObjectFlags(*Object),
					*Object->GetFullName());

				if (ReferenceInfo->StackFrames.Num())
				{
					ConvertStackFramesToCallstack(ReferenceInfo->StackFrames.GetData(),
						ReferenceInfo->StackFrames.Num(),
						Params.Indent,
						Out,
						CallstackCache);
				}
			}
			else if (ReferenceInfo && ReferenceInfo->Type == EReferenceType::OuterChain)
			{
				Out.Logf(ELogVerbosity::Log, TEXT("%s-> %s = %s %s"),
					FCString::Spc(Params.Indent),
					TEXT("Outer Chain"),
					*GetObjectFlags(*Object),
					*Object->GetFullName());

#Loc: <Workspace>/Engine/Source/Runtime/CoreUObject/Private/UObject/ReferenceChainSearch.cpp:1525

Scope (from outer to inner):

file
function     void FReferenceChainSearch::DumpChain

Source code excerpt:


			ReferencerObject = Object;
			ReferenceInfo = Chain->GetReferenceInfo(NodeIndex);
		}
		Out.Logf(ELogVerbosity::Log, TEXT("  "));
	}
}

bool FReferenceChainSearch::FReferenceChain::IsExternal() const

#Loc: <Workspace>/Engine/Source/Runtime/CoreUObject/Public/UObject/ReferenceChainSearch.h:278

Scope (from outer to inner):

file
class        class FReferenceChainSearch

Source code excerpt:

		FGCObjectInfo* Referencer = nullptr;
		/** Information about the type of reference (Referencer -> Object) */
		const FNodeReferenceInfo* ReferenceInfo = nullptr;
		/** For use when outputting custom information: current indent */
		int32 Indent = 0;
		/** Output device used for printing */
		FOutputDevice* Out = nullptr;
	};

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/GameFramework/CharacterNetworkSerializationPackedBitsNetSerializer.cpp:324

Scope (from outer to inner):

file
namespace    UE::Net
function     void FCharacterNetworkSerializationPackedBitsNetSerializer::CollectNetReferences

Source code excerpt:

	FNetReferenceCollector& Collector = *reinterpret_cast<UE::Net::FNetReferenceCollector*>(Args.Collector);

	const FNetReferenceInfo ReferenceInfo(FNetReferenceInfo::EResolveType::ResolveOnClient);	
	for (const FNetObjectReference& Ref : MakeArrayView(Value.ObjectReferenceStorage.GetData(), Value.ObjectReferenceStorage.Num()))
	{
		Collector.Add(ReferenceInfo, Ref, Args.ChangeMaskInfo);
	}
}

static const FName PropertyNetSerializerRegistry_NAME_CharacterMoveResponsePackedBits("CharacterMoveResponsePackedBits");
static const FName PropertyNetSerializerRegistry_NAME_CharacterServerMovePackedBitsPackedBits("CharacterServerMovePackedBits");
static const FName PropertyNetSerializerRegistry_NAME_CharacterNetworkSerializationPackedBits("CharacterNetworkSerializationPackedBits");

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Iris/Core/Private/Iris/ReplicationSystem/ReplicationReader.cpp:1389

Scope (from outer to inner):

file
namespace    UE::Net::Private
function     void FReplicationReader::ResolveAndDispatchUnresolvedReferencesForObject

Source code excerpt:

		if (NewResolvedRefHandles.Num())
		{
			for (const FNetReferenceCollector::FReferenceInfo& ReferenceInfo : Collector.GetResolvedReferences())
			{
				const FNetRefHandle& MatchRefHandle = ReferenceInfo.Reference.GetRefHandle();
				if (NewResolvedRefHandles.ContainsByPredicate([&MatchRefHandle](const FNetRefHandle& RefHandle) { return RefHandle == MatchRefHandle;} ))
				{
					const FNetSerializerChangeMaskParam& ChangeMaskInfo = ReferenceInfo.ChangeMaskInfo;
					if (ChangeMaskInfo.BitCount)
					{
						ResolvedChangeMask.SetBit(ChangeMaskInfo.BitOffset);
					}
					else
					{

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Iris/Core/Private/Iris/ReplicationSystem/ReplicationReader.cpp:1649

Scope (from outer to inner):

file
namespace    UE::Net::Private
function     void FReplicationReader::DispatchStateData

Source code excerpt:

					if (NewResolvedRefHandles.Num())
					{
						for (const FNetReferenceCollector::FReferenceInfo& ReferenceInfo : Collector.GetResolvedReferences())
						{
							const FNetRefHandle& MatchRefHandle = ReferenceInfo.Reference.GetRefHandle();
							if (NewResolvedRefHandles.ContainsByPredicate([&MatchRefHandle](const FNetRefHandle& RefHandle) { return RefHandle == MatchRefHandle;} ))
							{
								ChangeMask.SetBit(ReferenceInfo.ChangeMaskInfo.BitOffset);
							}
						}
					}
				}
			}

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Iris/Core/Private/Iris/Serialization/LastResortPropertyNetSerializer.cpp:381

Scope (from outer to inner):

file
namespace    UE::Net
function     void FLastResortPropertyNetSerializer::CollectNetReferences

Source code excerpt:

	FNetReferenceCollector& Collector = *reinterpret_cast<UE::Net::FNetReferenceCollector*>(Args.Collector);

	const FNetReferenceInfo ReferenceInfo(FNetReferenceInfo::EResolveType::ResolveOnClient);	
	for (const FNetObjectReference& Ref : MakeArrayView(Value.ObjectReferenceStorage.GetData(), Value.ObjectReferenceStorage.Num()))
	{
		Collector.Add(ReferenceInfo, Ref, Args.ChangeMaskInfo);
	}
}


}

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Iris/Core/Private/Iris/Serialization/SoftObjectNetSerializers.cpp:334

Scope (from outer to inner):

file
namespace    UE::Net
function     void FSoftObjectNetSerializer::CollectNetReferences

Source code excerpt:

		FNetReferenceCollector& Collector = *reinterpret_cast<FNetReferenceCollector*>(Args.Collector);

		const FNetReferenceInfo ReferenceInfo(FNetReferenceInfo::EResolveType::ResolveOnClient);
		Collector.Add(ReferenceInfo, Value.ObjectReference, Args.ChangeMaskInfo);
	}
}

// FSoftObjectPathNetSerializer
void FSoftObjectPathNetSerializer::Quantize(FNetSerializationContext& Context, const FNetQuantizeArgs& Args)
{

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Iris/Core/Public/Iris/Serialization/NetReferenceCollector.h:35

Scope (from outer to inner):

file
namespace    UE::Net
class        class FNetReferenceCollector

Source code excerpt:

	explicit FNetReferenceCollector(ENetReferenceCollectorTraits InTraits) : Traits(InTraits) {}
	
	inline void Add(const FNetReferenceInfo& ReferenceInfo, const FNetObjectReference& Reference, const FNetSerializerChangeMaskParam& ChangeMaskInfo);

	const FReferenceInfoArray& GetCollectedReferences() const { return ReferenceInfos; }

	void Reset() { ReferenceInfos.Reset(); }

private:

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Iris/Core/Public/Iris/Serialization/NetReferenceCollector.h:46

Scope (from outer to inner):

file
namespace    UE::Net
function     void FNetReferenceCollector::Add

Source code excerpt:

};

void FNetReferenceCollector::Add(const FNetReferenceInfo& ReferenceInfo, const FNetObjectReference& Reference, const FNetSerializerChangeMaskParam& ChangeMaskInfo)
{
	if (!Reference.IsValid() && !EnumHasAnyFlags(Traits, ENetReferenceCollectorTraits::IncludeInvalidReferences))
	{
		return;
	}

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Iris/Core/Public/Iris/Serialization/NetReferenceCollector.h:59

Scope (from outer to inner):

file
namespace    UE::Net
function     void FNetReferenceCollector::Add

Source code excerpt:


	FReferenceInfo RefInfo;
	RefInfo.Info = ReferenceInfo;
	RefInfo.Reference = Reference;
	RefInfo.ChangeMaskInfo = ChangeMaskInfo;

	ReferenceInfos.Add(MoveTemp(RefInfo));
}