OutputKeys

OutputKeys

#Overview

name: OutputKeys

The value of this variable can be defined or overridden in .ini config files. 7 .ini config files referencing this setting variable.

It is referenced in 31 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of OutputKeys is to provide a mechanism for accessing and manipulating output data in the Procedural Content Generation (PCG) system of Unreal Engine 5. It is primarily used for managing attribute data and metadata in various PCG operations.

OutputKeys is relied upon by several Unreal Engine subsystems and modules, particularly:

  1. PCG Plugin: This is the main system that utilizes OutputKeys, as evident from the numerous references in PCG-related files.
  2. Metadata System: OutputKeys is used in various metadata operations within the PCG system.
  3. Localization System: It’s used in the localization configuration and text gathering processes.
  4. MovieScene System: It’s utilized in the movie scene property component handler.

The value of OutputKeys is typically set within the PCG system, often using helper functions like PCGAttributeAccessorHelpers::CreateKeys(). It’s usually populated based on the output target or settings of a particular PCG operation.

OutputKeys often interacts with other variables such as:

Developers should be aware that:

  1. OutputKeys is often used in pairs with OutputAccessors.
  2. It’s crucial for managing the flow of data in PCG operations.
  3. Its validity should be checked before use (e.g., OutputKeys.IsValid()).
  4. It’s used in both reading and writing operations within the PCG system.

Best practices when using OutputKeys include:

  1. Always validate OutputKeys before use.
  2. Ensure proper memory management, as it’s often used with smart pointers (TUniquePtr).
  3. Use it in conjunction with the appropriate accessors and other PCG-related variables.
  4. Be mindful of its usage in performance-critical sections, as it’s involved in data access operations.

By following these guidelines, developers can effectively utilize OutputKeys in their PCG workflows within Unreal Engine 5.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Config/Localization/Category.ini:39, section: [GatherTextStep0]

Location: <Workspace>/Engine/Config/Localization/Editor.ini:80, section: [GatherTextStep2]

Location: <Workspace>/Engine/Config/Localization/Editor.ini:83, section: [GatherTextStep2]

Location: <Workspace>/Engine/Config/Localization/Keywords.ini:34, section: [GatherTextStep0]

Location: <Workspace>/Engine/Config/Localization/PropertyNames.ini:39, section: [GatherTextStep0]

Location: <Workspace>/Engine/Config/Localization/ToolTips.ini:39, section: [GatherTextStep0]

Location: <Workspace>/Engine/Config/Localization/ToolTips.ini:42, section: [GatherTextStep0]

#References in C++ code

#Callsites

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

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Elements/Metadata/PCGMetadataOpElementBase.cpp:576

Scope (from outer to inner):

file
function     bool FPCGMetadataElementBase::PrepareDataInternal
lambda-function

Source code excerpt:

		// So first forward outputs and create the attribute
		OperationData.OutputAccessors.SetNum(Settings->GetResultNum());
		OperationData.OutputKeys.SetNum(Settings->GetResultNum());

		const FPCGAttributePropertyOutputSelector OutputTarget = Settings->OutputTarget.CopyAndFixSource(&OperationData.InputSources[PrimaryPinIndex]);

		// Use implicit capture, since we capture a lot
		auto CreateAttribute = [&]<typename AttributeType>(uint32 OutputIndex, AttributeType DummyOutValue) -> bool
		{

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Elements/Metadata/PCGMetadataOpElementBase.cpp:649

Scope (from outer to inner):

file
function     bool FPCGMetadataElementBase::PrepareDataInternal
lambda-function
lambda-function

Source code excerpt:

			}

			OperationData.OutputKeys[OutputIndex] = PCGAttributeAccessorHelpers::CreateKeys(const_cast<UPCGData*>(OutputData.Data.Get()), OutputTarget);

			return OperationData.OutputKeys[OutputIndex].IsValid();
		};

		auto CreateAllSameAttributes = [NumberOfResults, &CreateAttribute](auto DummyOutValue) -> bool
		{
			for (uint32 i = 0; i < NumberOfResults; ++i)
			{

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Elements/PCGAttributeNoise.cpp:323

Scope (from outer to inner):

file
function     bool FPCGAttributeNoiseElement::ExecuteInternal

Source code excerpt:

			}

			Context->OutputKeys = PCGAttributeAccessorHelpers::CreateKeys(OutputData, Context->OutputTarget);

			if (!Context->OutputAccessor || !Context->OutputKeys)
			{
				PCGE_LOG(Error, GraphAndLog, FText::Format(LOCTEXT("OutputTargetInvalid", "Failed to find/create Attribute/Property '{0}'."), Context->OutputTarget.GetDisplayText()));
				Outputs.RemoveAt(Outputs.Num() - 1);
				Context->CurrentInput++;
				continue;
			}

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Elements/PCGAttributeNoise.cpp:385

Scope (from outer to inner):

file
lambda-function
lambda-function

Source code excerpt:

					}

					Context->OutputAccessor->SetRange<AttributeType>(Values, StartWriteIndex, *Context->OutputKeys, EPCGAttributeAccessorFlags::AllowBroadcast | EPCGAttributeAccessorFlags::AllowConstructible);
				}

				return Count;
			}, MoveDataRange, Finished, /*bEnableTimeSlicing=*/true, ChunkSize);
		});

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Elements/PCGAttributeTransferElement.cpp:285

Scope (from outer to inner):

file
function     bool FPCGAttributeTransferElement::ExecuteInternal

Source code excerpt:


	TUniquePtr<IPCGAttributeAccessor> OutputAccessor = PCGAttributeAccessorHelpers::CreateAccessor(OutputData, TargetAttributeProperty);
	TUniquePtr<IPCGAttributeAccessorKeys> OutputKeys = PCGAttributeAccessorHelpers::CreateKeys(OutputData, TargetAttributeProperty);

	if (!OutputAccessor.IsValid() || !OutputKeys.IsValid())
	{
		PCGE_LOG(Error, GraphAndLog, LOCTEXT("FailedToCreateOutputAccessor", "Failed to create output accessor or iterator"));
		return true;
	}

	if (OutputAccessor->IsReadOnly())

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Elements/PCGAttributeTransferElement.cpp:300

Scope (from outer to inner):

file
function     bool FPCGAttributeTransferElement::ExecuteInternal
lambda-function

Source code excerpt:


	// At this point, we are ready.
	auto Operation = [&InputAccessor, &InputKeys, &OutputAccessor, &OutputKeys, Context](auto Dummy)
	{
		using OutputType = decltype(Dummy);
		OutputType Value{};

		EPCGAttributeAccessorFlags Flags = EPCGAttributeAccessorFlags::AllowBroadcast | EPCGAttributeAccessorFlags::AllowConstructible;

		const int32 NumberOfElements = OutputKeys->GetNum();
		constexpr int32 ChunkSize = 256;

		TArray<OutputType, TInlineAllocator<ChunkSize>> TempValues;
		TempValues.SetNum(ChunkSize);

		const int32 NumberOfIterations = (NumberOfElements + ChunkSize - 1) / ChunkSize;

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Elements/PCGAttributeTransferElement.cpp:322

Scope (from outer to inner):

file
function     bool FPCGAttributeTransferElement::ExecuteInternal
lambda-function

Source code excerpt:


			if (!InputAccessor->GetRange<OutputType>(View, StartIndex, *InputKeys, Flags)
				|| !OutputAccessor->SetRange<OutputType>(View, StartIndex, *OutputKeys, Flags))
			{
				PCGE_LOG_C(Error, GraphAndLog, Context, LOCTEXT("ConversionFailed", "Source attribute/property cannot be converted to target attribute/property"));
				return false;
			}
		}

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Helpers/PCGMetadataHelpers.cpp:224

Scope (from outer to inner):

file
namespace    PCGMetadataHelpers
function     bool CopyAttributes

Source code excerpt:


				TUniquePtr<IPCGAttributeAccessor> OutputAccessor = PCGAttributeAccessorHelpers::CreateAccessor(TargetData, OutputTarget);
				TUniquePtr<IPCGAttributeAccessorKeys> OutputKeys = PCGAttributeAccessorHelpers::CreateKeys(TargetData, OutputTarget);

				if (!OutputAccessor.IsValid() || !OutputKeys.IsValid())
				{
					PCGLog::LogWarningOnGraph(LOCTEXT("FailedToCreateOutputAccessor", "Failed to create output accessor or iterator"), OptionalContext);
					continue;
				}

				if (OutputAccessor->IsReadOnly())

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Helpers/PCGMetadataHelpers.cpp:249

Scope (from outer to inner):

file
namespace    PCGMetadataHelpers
function     bool CopyAttributes

Source code excerpt:

				Params.InKeys = InputKeys.Get();
				Params.InAccessor = InputAccessor.Get();
				Params.OutKeys = OutputKeys.Get();
				Params.OutAccessor = OutputAccessor.Get();
				Params.IterationCount = PCGMetadataElementCommon::FCopyFromAccessorToAccessorParams::Out;
				Params.Flags = EPCGAttributeAccessorFlags::AllowBroadcast | EPCGAttributeAccessorFlags::AllowConstructible;

				if (!PCGMetadataElementCommon::CopyFromAccessorToAccessor(Params))
				{

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Tests/Elements/Metadata/PCGMetadataBreakTransformTest.cpp:141

Scope (from outer to inner):

file
function     bool FPCGMetadataBreakTransformTest::RunTest
lambda-function
lambda-function

Source code excerpt:


			TUniquePtr<const IPCGAttributeAccessor> OutputAccessor = PCGAttributeAccessorHelpers::CreateConstAccessor(Output.Data, OutSelector);
			TUniquePtr<const IPCGAttributeAccessorKeys> OutputKeys = PCGAttributeAccessorHelpers::CreateConstKeys(Output.Data, OutSelector);

			if (!TestTrue("OutputTarget was found", OutputAccessor.IsValid() && OutputKeys.IsValid()))
			{
				bTestPassed = false;
				return;
			}

			if (!TestEqual("Output has a valid type", OutputAccessor->GetUnderlyingType(), PCG::Private::MetadataTypes<OutType>::Id))

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Tests/Elements/Metadata/PCGMetadataBreakTransformTest.cpp:155

Scope (from outer to inner):

file
function     bool FPCGMetadataBreakTransformTest::RunTest
lambda-function
lambda-function

Source code excerpt:

			}

			if (!TestEqual("Identical EntryKeys count", InputKeys->GetNum(), OutputKeys->GetNum()))
			{
				bTestPassed = false;
				return;
			}

			for (int32 i = 0; i < OutputKeys->GetNum(); ++i)
			{
				FTransform SourceValue{};
				if (!InputAccessor->Get<FTransform>(SourceValue, i, *InputKeys))
				{
					bTestPassed = false;
					return;

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Tests/Elements/Metadata/PCGMetadataBreakTransformTest.cpp:171

Scope (from outer to inner):

file
function     bool FPCGMetadataBreakTransformTest::RunTest
lambda-function
lambda-function

Source code excerpt:


				OutType OutValue{};
				if (!OutputAccessor->Get<OutType>(OutValue, i, *OutputKeys))
				{
					bTestPassed = false;
					return;
				}

				if constexpr (std::is_same_v<FVector, OutType>)

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Tests/Elements/Metadata/PCGMetadataBreakVectorTest.cpp:157

Scope (from outer to inner):

file
function     bool FPCGMetadataBreakVectorTest::RunTest
lambda-function
lambda-function

Source code excerpt:


			TUniquePtr<const IPCGAttributeAccessor> OutputAccessor = PCGAttributeAccessorHelpers::CreateConstAccessor(Output.Data, OutSelector);
			TUniquePtr<const IPCGAttributeAccessorKeys> OutputKeys = PCGAttributeAccessorHelpers::CreateConstKeys(Output.Data, OutSelector);

			if (!TestTrue("OutputTarget was found", OutputAccessor.IsValid() && OutputKeys.IsValid()))
			{
				bTestPassed = false;
				return;
			}

			if (!TestEqual("Output has a valid type (double)", OutputAccessor->GetUnderlyingType(), PCG::Private::MetadataTypes<double>::Id))

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Tests/Elements/Metadata/PCGMetadataBreakVectorTest.cpp:171

Scope (from outer to inner):

file
function     bool FPCGMetadataBreakVectorTest::RunTest
lambda-function
lambda-function

Source code excerpt:

			}

			if (!TestEqual("Identical EntryKeys count", InputKeys->GetNum(), OutputKeys->GetNum()))
			{
				bTestPassed = false;
				return;
			}

			for (int32 i = 0; i < OutputKeys->GetNum(); ++i)
			{
				FVector4 SourceValue{};
				if (InputAccessor->GetUnderlyingType() == PCG::Private::MetadataTypes<FVector>::Id)
				{
					FVector TempValue{};
					if (!InputAccessor->Get<FVector>(TempValue, i, *InputKeys))

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Tests/Elements/Metadata/PCGMetadataBreakVectorTest.cpp:225

Scope (from outer to inner):

file
function     bool FPCGMetadataBreakVectorTest::RunTest
lambda-function
lambda-function

Source code excerpt:


				double OutValue{};
				if (!OutputAccessor->Get<double>(OutValue, i, *OutputKeys))
				{
					bTestPassed = false;
					return;
				}

				if (ComponentToCheck == PCGBreakVectorTest::EPCGComponentToCheck::X)

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Tests/Elements/Metadata/PCGMetadataMakeTransformTest.cpp:159

Scope (from outer to inner):

file
function     bool FPCGMetadataMakeTransformTest::RunTest
lambda-function

Source code excerpt:


		TUniquePtr<const IPCGAttributeAccessor> OutputAccessor = PCGAttributeAccessorHelpers::CreateConstAccessor(Output.Data, Settings->OutputTarget);
		TUniquePtr<const IPCGAttributeAccessorKeys> OutputKeys = PCGAttributeAccessorHelpers::CreateConstKeys(Output.Data, Settings->OutputTarget);

		if (!TestTrue("OutputTarget was found", OutputAccessor.IsValid() && OutputKeys.IsValid()))
		{
			return false;
		}

		if (!TestEqual("Output has a valid type (Transform)", OutputAccessor->GetUnderlyingType(), PCG::Private::MetadataTypes<FTransform>::Id))
		{

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Tests/Elements/Metadata/PCGMetadataMakeTransformTest.cpp:171

Scope (from outer to inner):

file
function     bool FPCGMetadataMakeTransformTest::RunTest
lambda-function

Source code excerpt:

		}

		if (!TestEqual("Identical EntryKeys count", InputKeys1->GetNum(), OutputKeys->GetNum()))
		{
			return false;
		}

		for (int32 i = 0; i < OutputKeys->GetNum(); ++i)
		{
			FVector TranslationValue{};
			FQuat QuatValue{};
			FVector ScaleValue{};
			FTransform OutValue{};

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Tests/Elements/Metadata/PCGMetadataMakeTransformTest.cpp:186

Scope (from outer to inner):

file
function     bool FPCGMetadataMakeTransformTest::RunTest
lambda-function

Source code excerpt:

				|| !InputAccessor2->Get<FQuat>(QuatValue, i, *InputKeys2)
				|| !InputAccessor3->Get<FVector>(ScaleValue, i, *InputKeys3)
				|| !OutputAccessor->Get<FTransform>(OutValue, i, *OutputKeys))
			{
				return false;
			}
			
			if (!TestEqual("Mismatch between input and output for translation", OutValue.GetTranslation(), TranslationValue))
			{

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Public/Elements/Metadata/PCGMetadataOpElementBase.h:177

Scope (from outer to inner):

file
namespace    PCGMetadataOps

Source code excerpt:


		TArray<TUniquePtr<const IPCGAttributeAccessorKeys>> InputKeys;
		TArray<TUniquePtr<IPCGAttributeAccessorKeys>> OutputKeys;

		TArray<TUniquePtr<const IPCGAttributeAccessor>> InputAccessors;
		TArray<TUniquePtr<IPCGAttributeAccessor>> OutputAccessors;

		template <int32 NbInputs, int32 NbOutputs>
		void Validate();

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Public/Elements/Metadata/PCGMetadataOpElementBase.h:303

Scope (from outer to inner):

file
namespace    Private
namespace    NAryOperation
function     bool Apply

Source code excerpt:

			else
			{
				bSuccess = InOperationData.OutputAccessors[OutputIndex]->SetRange(OutValuesView, StartIndex, *InOperationData.OutputKeys[OutputIndex], InOptions.SetFlags);
			}

			if (!bSuccess)
			{
				return false;
			}

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Public/Elements/Metadata/PCGMetadataOpElementBase.h:389

Scope (from outer to inner):

file
function     void PCGMetadataOps::FOperationData::Validate

Source code excerpt:

void PCGMetadataOps::FOperationData::Validate()
{
	check(OutputKeys.Num() == NbOutputs);

	for (int32 i = 0; i < NbInputs; ++i)
	{
		check(InputAccessors[i].IsValid());
		check(InputKeys[i].IsValid());
	}

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Public/Elements/Metadata/PCGMetadataOpElementBase.h:400

Scope (from outer to inner):

file
function     void PCGMetadataOps::FOperationData::Validate

Source code excerpt:

	{
		check(OutputAccessors[j].IsValid());
		check(OutputKeys[j].IsValid());
	}
}

template <typename... InputTypes, typename... Callbacks>
inline bool FPCGMetadataElementBase::DoNAryOp(PCGMetadataOps::FOperationData& InOperationData, TTuple<Callbacks...>&& InCallbacks) const
{

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Public/Elements/PCGAttributeNoise.h:119

Scope: file

Source code excerpt:

	TUniquePtr<IPCGAttributeAccessor> OutputAccessor;
	TUniquePtr<const IPCGAttributeAccessorKeys> InputKeys;
	TUniquePtr<IPCGAttributeAccessorKeys> OutputKeys;
};

class FPCGAttributeNoiseElement : public IPCGElement
{
protected:
	virtual FPCGContext* CreateContext() override;

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Public/Metadata/PCGObjectPropertyOverride.h:76

Scope: file

Source code excerpt:

	TUniquePtr<IPCGAttributeAccessor> ObjectOverrideOutputAccessor;

	// InputKeyIndex, OutputKeys
	using ApplyOverrideFunction = bool(FPCGObjectSingleOverride::*)(int32, IPCGAttributeAccessorKeys&);
	ApplyOverrideFunction ObjectOverrideFunction = nullptr;

	template <typename Type>
	bool ApplyImpl(int32 InputKeyIndex, IPCGAttributeAccessorKeys& OutputKey)
	{

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:430

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateGatherTextConfigFile

Source code excerpt:

				ConfigSection.Add( TEXT("InputKeys"), Specification.MetaDataKey.Name );
				ConfigSection.Add( TEXT("OutputNamespaces"), Specification.TextNamespace );
				ConfigSection.Add( TEXT("OutputKeys"), Specification.TextKeyPattern.Pattern );
			}

			// Field Type Filters
			for (const FString& FieldTypeToInclude : Target->Settings.GatherFromMetaData.FieldTypesToInclude)
			{
				ConfigSection.Add(TEXT("FieldTypesToInclude"), FieldTypeToInclude);

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Classes/Commandlets/GatherTextFromMetadataCommandlet.h:28

Scope (from outer to inner):

file
class        class UGatherTextFromMetaDataCommandlet : public UGatherTextCommandletBase

Source code excerpt:

		TArray<FString> InputKeys;
		TArray<FString> OutputNamespaces;
		TArray<FString> OutputKeys;
	};

private:
	void GatherTextFromUObjects(const TArray<FString>& IncludePaths, const TArray<FString>& ExcludePaths, const FGatherParameters& Arguments);

	void GatherTextFromField(UField* Field, const FGatherParameters& Arguments, const FName InPlatformName);

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GatherTextFromMetadataCommandlet.cpp:264

Scope (from outer to inner):

file
function     int32 UGatherTextFromMetaDataCommandlet::Main

Source code excerpt:

	GetStringArrayFromConfig(*SectionName, TEXT("InputKeys"), Arguments.InputKeys, GatherTextConfigPath);
	GetStringArrayFromConfig(*SectionName, TEXT("OutputNamespaces"), Arguments.OutputNamespaces, GatherTextConfigPath);
	GetStringArrayFromConfig(*SectionName, TEXT("OutputKeys"), Arguments.OutputKeys, GatherTextConfigPath);

	// Execute gather.
	GatherTextFromUObjects(IncludePathFilters, ExcludePathFilters, Arguments);

	// Add any manifest dependencies if they were provided
	TArray<FString> ManifestDependenciesList;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GatherTextFromMetadataCommandlet.cpp:365

Scope: file

Source code excerpt:

							FLocItem LocItem(MetaDataValue);
							FManifestContext Context;
							Context.Key = FString::Format(*Arguments.OutputKeys[j], PatternArguments);
							Context.SourceLocation = FString::Printf(TEXT("Meta-data for key %s of enum value %s of enum %s in %s"), *Arguments.InputKeys[j], *Enum->GetNameStringByIndex(i), *Enum->GetName(), *Enum->GetFullGroupName(true));
							Context.PlatformName = InPlatformName;
							GatherManifestHelper->AddSourceText(Namespace, LocItem, Context);
						}
					}
				}

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GatherTextFromMetadataCommandlet.cpp:454

Scope (from outer to inner):

file
function     void UGatherTextFromMetaDataCommandlet::GatherTextFromFieldImpl

Source code excerpt:

				FLocItem LocItem(MetaDataValue);
				FManifestContext Context;
				Context.Key = FString::Format(*Arguments.OutputKeys[i], PatternArguments);
				Context.SourceLocation = FString::Printf(TEXT("Meta-data for key %s of member %s in %s (type: %s, owner: %s)"), *Arguments.InputKeys[i], *Field->GetName(), *Field->GetFullGroupName(true), *Field->GetClass()->GetName(), FieldOwnerType ? *FieldOwnerType->GetName() : TEXT("<null>"));
				Context.PlatformName = InPlatformName;
				GatherManifestHelper->AddSourceText(Namespace, LocItem, Context);
			}
		}
	}

#Loc: <Workspace>/Engine/Source/Runtime/MovieScene/Public/EntitySystem/MovieScenePropertyComponentHandler.h:224

Scope (from outer to inner):

file
namespace    UE
namespace    MovieScene
function     void VisitInterrogationAllocation

Source code excerpt:


		TComponentWriter<StorageType>       InitialValues = Allocation->WriteComponents(PropertyDefinition->InitialValueType.ReinterpretCast<StorageType>(), WriteContext);
		TComponentReader<FInterrogationKey> OutputKeys    = Allocation->ReadComponents(BuiltInComponents->Interrogation.OutputKey);

		TTuple< TComponentReader<MetaDataTypes>... > MetaData(
			Allocation->ReadComponents(PropertyDefinition->GetMetaDataComponent<MetaDataTypes>(MetaDataIndices))...
		);

		const FSparseInterrogationChannelInfo& SparseChannelInfo = Interrogation->GetSparseChannelInfo();

#Loc: <Workspace>/Engine/Source/Runtime/MovieScene/Public/EntitySystem/MovieScenePropertyComponentHandler.h:234

Scope (from outer to inner):

file
namespace    UE
namespace    MovieScene
function     void VisitInterrogationAllocation

Source code excerpt:

		for (int32 Index = 0; Index < Num; ++Index)
		{
			FInterrogationChannel Channel = OutputKeys[Index].Channel;

			// Did we already cache this value?
			if (const StorageType* CachedValue = ValuesByChannel.Find(Channel))
			{
				InitialValues[Index] = *CachedValue;
				continue;