BuildTarget

BuildTarget

#Overview

name: BuildTarget

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

It is referenced in 67 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of BuildTarget is to specify the target to be built during the packaging or building process of an Unreal Engine project. It is primarily used in the project packaging and building systems.

BuildTarget is relied upon by several Unreal Engine subsystems and modules, including:

  1. Project Packaging System
  2. Launcher Services
  3. Turnkey Support
  4. Demo Net Driver
  5. Replay System
  6. Tool Target Manager in the Interactive Tools Framework

The value of this variable is typically set in the project’s packaging settings (UProjectPackagingSettings class) or through the Unreal Editor interface. It can also be set programmatically in certain contexts.

BuildTarget often interacts with other variables such as:

Developers should be aware of the following when using this variable:

  1. It should be set to a valid target name for the project.
  2. For content-only projects, it may not need to be explicitly set.
  3. It can affect how the project is built and packaged for different platforms.
  4. Changing this value may require rebuilding the project.

Best practices when using BuildTarget include:

  1. Ensure it’s set correctly for your project type (code vs. content-only).
  2. Verify it’s compatible with your intended build configuration and platform.
  3. Use the appropriate UI or API to modify it rather than changing it directly in configuration files.
  4. Be consistent with its usage across different build and packaging processes for your project.
  5. Consider how it might affect continuous integration and deployment pipelines.

#Setting Variables

#References In INI files

Location: <Workspace>/Projects/Lyra/Config/DefaultGame.ini:85, section: [/Script/UnrealEd.ProjectPackagingSettings]

#References in C++ code

#Callsites

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

#Loc: <Workspace>/Engine/Plugins/Editor/UVEditor/Source/UVEditor/Private/UVEditorSubsystem.cpp:196

Scope (from outer to inner):

file
function     void UUVEditorSubsystem::BuildTargets

Source code excerpt:

	for (UObject* Object : ObjectsIn)
	{
		UToolTarget* Target = ToolTargetManager->BuildTarget(Object, TargetRequirements);
		if (Target)
		{
			TargetsOut.Add(Target);
		}
	}
}

#Loc: <Workspace>/Engine/Plugins/Editor/UVEditor/Source/UVEditor/Private/UVEditorSubsystem.cpp:242

Scope (from outer to inner):

file
function     void UUVEditorSubsystem::StartUVEditor

Source code excerpt:

	for (UObject* Object : ObjectsToEdit)
	{
		UToolTarget* Target = ToolTargetManager->BuildTarget(Object, UUVEditorMode::GetToolTargetRequirements());
		Targets.Add(Target);


		// There are two options here: A) all targets are components (selected from the viewport) or B) all targets aren't components (selected from the content browser). 
		// TODO: Check if it's possible to have a mixture?
		// Depending on which scenario we're in, we'll either use the component transforms relative to each other, or build some transforms ourselves.

#Loc: <Workspace>/Engine/Plugins/Experimental/CharacterFXEditor/ExampleCharacterFXEditor/Source/ExampleCharacterFXEditor/Private/ExampleCharacterFXEditorSubsystem.cpp:47

Scope (from outer to inner):

file
function     void UExampleCharacterFXEditorSubsystem::BuildTargets

Source code excerpt:

	for (UObject* Object : ObjectsIn)
	{
		UToolTarget* Target = ToolTargetManager->BuildTarget(Object, TargetRequirements);
		if (Target)
		{
			TargetsOut.Add(Target);
		}
	}
}

#Loc: <Workspace>/Engine/Plugins/Experimental/Dataflow/Source/DataflowEditor/Private/Dataflow/DataflowComponentToolTarget.cpp:241

Scope (from outer to inner):

file
function     UToolTarget* UDataflowComponentReadOnlyToolTargetFactory::BuildTarget

Source code excerpt:

}

UToolTarget* UDataflowComponentReadOnlyToolTargetFactory::BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& Requirements)
{
	UDataflowComponentReadOnlyToolTarget* Target = NewObject<UDataflowComponentReadOnlyToolTarget>();
	Target->InitializeComponent(Cast<UDataflowComponent>(SourceObject));
	checkSlow(Target->Component.IsValid() && Requirements.AreSatisfiedBy(Target));

	return Target;

#Loc: <Workspace>/Engine/Plugins/Experimental/Dataflow/Source/DataflowEditor/Private/Dataflow/DataflowComponentToolTarget.cpp:265

Scope (from outer to inner):

file
function     UToolTarget* UDataflowComponentToolTargetFactory::BuildTarget

Source code excerpt:

}

UToolTarget* UDataflowComponentToolTargetFactory::BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& Requirements)
{
	UDataflowComponentToolTarget* Target = NewObject<UDataflowComponentToolTarget>();
	Target->InitializeComponent(Cast<UDataflowComponent>(SourceObject));
	checkSlow(Target->Component.IsValid() && Requirements.AreSatisfiedBy(Target));

	return Target;

#Loc: <Workspace>/Engine/Plugins/Experimental/Dataflow/Source/DataflowEditor/Private/Dataflow/DataflowEditorMode.cpp:324

Scope (from outer to inner):

file
function     void UDataflowEditorMode::CreateToolTargets

Source code excerpt:

	if (TObjectPtr<UDataflowBaseContent> EditorContent = PreviewScene->GetDataflowContent())
	{
		if (UToolTarget* Target = GetInteractiveToolsContext()->TargetManager->BuildTarget(EditorContent, GetToolTargetRequirements()))
		{
			ToolTargets.Add(Target);
		}
	}
}

#Loc: <Workspace>/Engine/Plugins/Experimental/Dataflow/Source/DataflowEditor/Private/Dataflow/DataflowToolTarget.cpp:174

Scope (from outer to inner):

file
function     UToolTarget* UDataflowReadOnlyToolTargetFactory::BuildTarget

Source code excerpt:

}

UToolTarget* UDataflowReadOnlyToolTargetFactory::BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& Requirements)
{
	const TObjectPtr<UDataflowBaseContent> BaseContent = CastChecked<UDataflowBaseContent>(SourceObject);

	if(BaseContent)
	{
		UDataflowReadOnlyToolTarget* Target = NewObject<UDataflowReadOnlyToolTarget>();

#Loc: <Workspace>/Engine/Plugins/Experimental/Dataflow/Source/DataflowEditor/Private/Dataflow/DataflowToolTarget.cpp:216

Scope (from outer to inner):

file
function     UToolTarget* UDataflowToolTargetFactory::BuildTarget

Source code excerpt:

}

UToolTarget* UDataflowToolTargetFactory::BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& Requirements)
{
	const TObjectPtr<UDataflowBaseContent> BaseContent = CastChecked<UDataflowBaseContent>(SourceObject);

	if(BaseContent)
	{
		UDataflowToolTarget* Target = NewObject<UDataflowToolTarget>();

#Loc: <Workspace>/Engine/Plugins/Experimental/Dataflow/Source/DataflowEditor/Public/Dataflow/DataflowComponentToolTarget.h:91

Scope (from outer to inner):

file
class        class UDataflowComponentReadOnlyToolTargetFactory : public UToolTargetFactory

Source code excerpt:

	// UToolTargetFactory implementation
	virtual bool CanBuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) const override;
	virtual UToolTarget* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) override;
};


/** Factory for UDataflowComponentToolTarget to be used by the target manager. */
UCLASS(Transient)
class DATAFLOWEDITOR_API UDataflowComponentToolTargetFactory : public UToolTargetFactory

#Loc: <Workspace>/Engine/Plugins/Experimental/Dataflow/Source/DataflowEditor/Public/Dataflow/DataflowComponentToolTarget.h:105

Scope (from outer to inner):

file
class        class UDataflowComponentToolTargetFactory : public UToolTargetFactory

Source code excerpt:

	// UToolTargetFactory implementation
	virtual bool CanBuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) const override;
	virtual UToolTarget* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) override;
};

#Loc: <Workspace>/Engine/Plugins/Experimental/Dataflow/Source/DataflowEditor/Public/Dataflow/DataflowToolTarget.h:104

Scope (from outer to inner):

file
class        class UDataflowReadOnlyToolTargetFactory : public UToolTargetFactory

Source code excerpt:

	// UToolTargetFactory implementation
	virtual bool CanBuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) const override;
	virtual UToolTarget* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) override;
};


/** Factory for UDataflowToolTarget to be used by the target manager. */
UCLASS(Transient)
class DATAFLOWEDITOR_API UDataflowToolTargetFactory : public UToolTargetFactory

#Loc: <Workspace>/Engine/Plugins/Experimental/Dataflow/Source/DataflowEditor/Public/Dataflow/DataflowToolTarget.h:118

Scope (from outer to inner):

file
class        class UDataflowToolTargetFactory : public UToolTargetFactory

Source code excerpt:

	// UToolTargetFactory implementation
	virtual bool CanBuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) const override;
	virtual UToolTarget* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) override;
};

#Loc: <Workspace>/Engine/Plugins/Experimental/MeshModelingToolsetExp/Source/MeshModelingToolsEditorOnlyExp/Private/HarvestInstancesTool.cpp:61

Scope (from outer to inner):

file
function     void UHarvestInstancesToolBuilder::InitializeNewTool
lambda-function

Source code excerpt:

		if (Cast<UStaticMeshComponent>(Component))
		{
			Targets.Add(SceneState.TargetManager->BuildTarget(Component, GetTargetRequirements()));
		}
	});

	NewTool->SetTargets(Targets);
	NewTool->SetWorld(SceneState.World);
}

#Loc: <Workspace>/Engine/Plugins/Experimental/MeshModelingToolsetExp/Source/MeshModelingToolsExp/Private/PatternTool.cpp:83

Scope (from outer to inner):

file
function     void UPatternToolBuilder::InitializeNewTool
lambda-function

Source code excerpt:

		if (Cast<UStaticMeshComponent>(Component) || Cast<UDynamicMeshComponent>(Component))
		{
			Targets.Add(SceneState.TargetManager->BuildTarget(Component, GetTargetRequirements()));
		}
	});

	NewTool->SetTargets(Targets);
	NewTool->SetWorld(SceneState.World);
}

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponentsEditorOnly/Private/ToolTargets/DynamicMeshComponentToolTarget.cpp:234

Scope (from outer to inner):

file
function     UToolTarget* UDynamicMeshComponentToolTargetFactory::BuildTarget

Source code excerpt:

}

UToolTarget* UDynamicMeshComponentToolTargetFactory::BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& Requirements)
{
	UDynamicMeshComponentToolTarget* Target = NewObject<UDynamicMeshComponentToolTarget>();// TODO: Should we set an outer here?
	Target->InitializeComponent(Cast<UDynamicMeshComponent>(SourceObject));
	checkSlow(Target->Component.IsValid() && Requirements.AreSatisfiedBy(Target));

	return Target;

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponentsEditorOnly/Private/ToolTargets/SkeletalMeshComponentToolTarget.cpp:215

Scope (from outer to inner):

file
function     UToolTarget* USkeletalMeshComponentReadOnlyToolTargetFactory::BuildTarget

Source code excerpt:

}

UToolTarget* USkeletalMeshComponentReadOnlyToolTargetFactory::BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& Requirements)
{
	USkeletalMeshComponentReadOnlyToolTarget* Target = NewObject<USkeletalMeshComponentReadOnlyToolTarget>();
	Target->InitializeComponent(Cast<USkeletalMeshComponent>(SourceObject));
	checkSlow(Target->Component.IsValid() && Requirements.AreSatisfiedBy(Target));

	return Target;

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponentsEditorOnly/Private/ToolTargets/SkeletalMeshComponentToolTarget.cpp:239

Scope (from outer to inner):

file
function     UToolTarget* USkeletalMeshComponentToolTargetFactory::BuildTarget

Source code excerpt:

}

UToolTarget* USkeletalMeshComponentToolTargetFactory::BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& Requirements)
{
	USkeletalMeshComponentToolTarget* Target = NewObject<USkeletalMeshComponentToolTarget>();
	Target->InitializeComponent(Cast<USkeletalMeshComponent>(SourceObject));
	checkSlow(Target->Component.IsValid() && Requirements.AreSatisfiedBy(Target));

	return Target;

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponentsEditorOnly/Private/ToolTargets/SkeletalMeshToolTarget.cpp:304

Scope (from outer to inner):

file
function     UToolTarget* USkeletalMeshReadOnlyToolTargetFactory::BuildTarget

Source code excerpt:

}

UToolTarget* USkeletalMeshReadOnlyToolTargetFactory::BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& Requirements)
{
	USkeletalMeshReadOnlyToolTarget* Target = NewObject<USkeletalMeshReadOnlyToolTarget>();
	Target->SkeletalMesh = Cast<USkeletalMesh>(SourceObject);
	checkSlow(Target->SkeletalMesh.IsValid() && Requirements.AreSatisfiedBy(Target));

	return Target;

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponentsEditorOnly/Private/ToolTargets/SkeletalMeshToolTarget.cpp:329

Scope (from outer to inner):

file
function     UToolTarget* USkeletalMeshToolTargetFactory::BuildTarget

Source code excerpt:

}

UToolTarget* USkeletalMeshToolTargetFactory::BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& Requirements)
{
	USkeletalMeshToolTarget* Target = NewObject<USkeletalMeshToolTarget>();
	Target->SkeletalMesh = Cast<USkeletalMesh>(SourceObject);
	checkSlow(Target->SkeletalMesh.IsValid() && Requirements.AreSatisfiedBy(Target));

	return Target;

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponentsEditorOnly/Private/ToolTargets/StaticMeshComponentToolTarget.cpp:297

Scope (from outer to inner):

file
function     UToolTarget* UStaticMeshComponentToolTargetFactory::BuildTarget

Source code excerpt:

}

UToolTarget* UStaticMeshComponentToolTargetFactory::BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& Requirements)
{
	UStaticMeshComponentToolTarget* Target = NewObject<UStaticMeshComponentToolTarget>();// TODO: Should we set an outer here?
	Target->InitializeComponent(Cast<UStaticMeshComponent>(SourceObject));
	Target->SetEditingLOD(EditingLOD);
	checkSlow(Target->Component.Get() && Requirements.AreSatisfiedBy(Target));

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponentsEditorOnly/Private/ToolTargets/StaticMeshToolTarget.cpp:487

Scope (from outer to inner):

file
function     UToolTarget* UStaticMeshToolTargetFactory::BuildTarget

Source code excerpt:

}

UToolTarget* UStaticMeshToolTargetFactory::BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& Requirements)
{
	UStaticMeshToolTarget* Target = NewObject<UStaticMeshToolTarget>();// TODO: Should we set an outer here?
	Target->StaticMesh = Cast<UStaticMesh>(SourceObject);
	Target->SetEditingLOD(EditingLOD);
	checkSlow(Target->StaticMesh.IsValid() && Requirements.AreSatisfiedBy(Target));

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponentsEditorOnly/Private/ToolTargets/VolumeComponentToolTarget.cpp:184

Scope (from outer to inner):

file
function     UToolTarget* UVolumeComponentToolTargetFactory::BuildTarget

Source code excerpt:

}

UToolTarget* UVolumeComponentToolTargetFactory::BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& Requirements)
{
	UVolumeComponentToolTarget* Target = NewObject<UVolumeComponentToolTarget>();
	Target->InitializeComponent(Cast<UBrushComponent>(SourceObject));

	checkSlow(Target->Component.IsValid() && Requirements.AreSatisfiedBy(Target)
		&& Cast<AVolume>(Cast<UBrushComponent>(SourceObject)->GetOwner()));

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponentsEditorOnly/Public/ToolTargets/DynamicMeshComponentToolTarget.h:90

Scope (from outer to inner):

file
class        class UDynamicMeshComponentToolTargetFactory : public UToolTargetFactory

Source code excerpt:

	virtual bool CanBuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) const override;

	virtual UToolTarget* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) override;
};

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponentsEditorOnly/Public/ToolTargets/SkeletalMeshComponentToolTarget.h:104

Scope (from outer to inner):

file
class        class USkeletalMeshComponentReadOnlyToolTargetFactory : public UToolTargetFactory

Source code excerpt:

	virtual bool CanBuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) const override;

	virtual UToolTarget* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) override;
};


/** Factory for USkeletalMeshComponentToolTarget to be used by the target manager. */
UCLASS(Transient)
class MODELINGCOMPONENTSEDITORONLY_API USkeletalMeshComponentToolTargetFactory : public UToolTargetFactory

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponentsEditorOnly/Public/ToolTargets/SkeletalMeshComponentToolTarget.h:118

Scope (from outer to inner):

file
class        class USkeletalMeshComponentToolTargetFactory : public UToolTargetFactory

Source code excerpt:

	virtual bool CanBuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) const override;

	virtual UToolTarget* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) override;
};

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponentsEditorOnly/Public/ToolTargets/SkeletalMeshToolTarget.h:120

Scope (from outer to inner):

file
class        class USkeletalMeshReadOnlyToolTargetFactory : public UToolTargetFactory

Source code excerpt:

	virtual bool CanBuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) const override;

	virtual UToolTarget* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) override;
};


/** Factory for USkeletalMeshToolTarget to be used by the target manager. */
UCLASS(Transient)
class MODELINGCOMPONENTSEDITORONLY_API USkeletalMeshToolTargetFactory : public UToolTargetFactory

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponentsEditorOnly/Public/ToolTargets/SkeletalMeshToolTarget.h:134

Scope (from outer to inner):

file
class        class USkeletalMeshToolTargetFactory : public UToolTargetFactory

Source code excerpt:

	virtual bool CanBuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) const override;

	virtual UToolTarget* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) override;
};

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponentsEditorOnly/Public/ToolTargets/StaticMeshComponentToolTarget.h:101

Scope (from outer to inner):

file
class        class UStaticMeshComponentToolTargetFactory : public UToolTargetFactory

Source code excerpt:

	virtual bool CanBuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) const override;

	virtual UToolTarget* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) override;

public:
	virtual EMeshLODIdentifier GetActiveEditingLOD() const { return EditingLOD; }
	virtual void SetActiveEditingLOD(EMeshLODIdentifier NewEditingLOD);

protected:

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponentsEditorOnly/Public/ToolTargets/StaticMeshToolTarget.h:135

Scope (from outer to inner):

file
class        class UStaticMeshToolTargetFactory : public UToolTargetFactory

Source code excerpt:

	virtual bool CanBuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) const override;

	virtual UToolTarget* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) override;



public:
	virtual EMeshLODIdentifier GetActiveEditingLOD() const { return EditingLOD; }
	virtual void SetActiveEditingLOD(EMeshLODIdentifier NewEditingLOD);

#Loc: <Workspace>/Engine/Plugins/Runtime/MeshModelingToolset/Source/ModelingComponentsEditorOnly/Public/ToolTargets/VolumeComponentToolTarget.h:93

Scope (from outer to inner):

file
class        class UVolumeComponentToolTargetFactory : public UToolTargetFactory

Source code excerpt:

	virtual bool CanBuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) const override;

	virtual UToolTarget* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) override;
};

#Loc: <Workspace>/Engine/Source/Developer/DeveloperToolSettings/Classes/Settings/ProjectPackagingSettings.h:215

Scope (from outer to inner):

file
class        class UProjectPackagingSettings : public UObject

Source code excerpt:

	/** Name of the target to build */
	UPROPERTY(config, EditAnywhere, Category=Project)
	FString BuildTarget;

	/**
	 * If enabled, a full rebuild will be enforced each time the project is being packaged.
	 * If disabled, only modified files will be built, which can improve iteration time.
	 * Unless you iterate on packaging, we recommend full rebuilds when packaging.
	 */

#Loc: <Workspace>/Engine/Source/Developer/DeveloperToolSettings/Private/ProjectPackagingSettings.cpp:250

Scope (from outer to inner):

file
function     const FTargetInfo* UProjectPackagingSettings::GetBuildTargetInfo

Source code excerpt:

const FTargetInfo* UProjectPackagingSettings::GetBuildTargetInfo() const
{
	return FindBestTargetInfo(BuildTarget, false);
}

#undef LOCTEXT_NAMESPACE

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:2929

Scope (from outer to inner):

file
class        class FLauncherProfile final : public ILauncherProfile
function     void ValidateBuildTarget

Source code excerpt:

		bool bBuildTargetIsSelected = false;

		FString BuildTarget = GetBuildTarget();
		TSet<EBuildTargetType> CookTargetTypes = GetCookTargetTypes();
		if (CookTargetTypes.Num() == 0)
		{
			CookTargetTypes.Add(EBuildTargetType::Game); // UAT defaults to 'Game' too
		}

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:2943

Scope (from outer to inner):

file
class        class FLauncherProfile final : public ILauncherProfile
function     void ValidateBuildTarget

Source code excerpt:

			if (CookTargetTypes.Contains(Target.Type))
			{
				if (BuildTarget.IsEmpty())
				{
					// most target types can have a default build target specified in engine ini so no need to enforce this (UAT will give informative error if the ini isn't set up)
					bool bSupportsDefaultBuildTarget = (Target.Type != EBuildTargetType::Program); 

					if (!bSupportsDefaultBuildTarget && BuildTargetNames.Contains(Target.Name))
					{

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfile.h:2956

Scope (from outer to inner):

file
class        class FLauncherProfile final : public ILauncherProfile
function     void ValidateBuildTarget

Source code excerpt:

				else
				{
					if (Target.Name == BuildTarget)
					{
						bBuildTargetIsSelected = true;
						break;
					}
				}
			}
		}

		if (!BuildTarget.IsEmpty() && !bBuildTargetIsSelected)
		{
			ValidationErrors.Add(ELauncherProfileValidationErrors::BuildTargetCookVariantMismatch);
		}

		if (bBuildTargetIsRequired)
		{

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfileManager.cpp:495

Scope (from outer to inner):

file
function     FString FLauncherProfileManager::GetBuildTarget

Source code excerpt:

FString FLauncherProfileManager::GetBuildTarget() const
{
	return BuildTarget;
}

void FLauncherProfileManager::SetBuildTarget( const FString& InBuildTarget )
{
	if (BuildTarget != InBuildTarget)
	{
		BuildTarget = InBuildTarget;
		for (ILauncherProfilePtr Profile : AllProfiles)
		{
			if (Profile.IsValid())
			{
				Profile->FallbackBuildTargetUpdated();
			}

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Private/Profiles/LauncherProfileManager.h:184

Scope (from outer to inner):

file
class        class FLauncherProfileManager : public TSharedFromThis<FLauncherProfileManager> , public ILauncherProfileManager

Source code excerpt:


	// Holds the currently selected build target
	FString BuildTarget;

	// Holds the current explicit build targets
	TArray<FString> ExplicitBuildTargets;
	
	// Holds all registered profile wizards
	TArray<ILauncherProfileWizardPtr> ProfileWizards;

#Loc: <Workspace>/Engine/Source/Developer/LauncherServices/Public/ILauncherProfileManager.h:351

Scope (from outer to inner):

file
class        class ILauncherProfileManager

Source code excerpt:

	/**
	 * Return a list of all build build targets for the current project that need to be specified explicitly via -target=
	 * If a build target isn't in the list, it does not need to be specified (and BuildTarget can be an empty string)
	 */
	virtual const TArray<FString>& GetAllExplicitBuildTargetNames() const = 0;

public:

	/**
	 * Returns a delegate that is invoked when a device group was added.
	 *
	 * @return The delegate.

#Loc: <Workspace>/Engine/Source/Developer/ProjectLauncher/Private/Widgets/Shared/SProjectLauncherBuildTargetSelector.cpp:95

Scope (from outer to inner):

file
function     FText SProjectLauncherBuildTargetSelector::GetBuildTargetText

Source code excerpt:



FText SProjectLauncherBuildTargetSelector::GetBuildTargetText( FString BuildTarget ) const
{
	if (!BuildTarget.IsEmpty())
	{
		return FText::FromString(BuildTarget);
	}

	return LOCTEXT("NoBuildTargetText", "Default");
}

FText SProjectLauncherBuildTargetSelector::HandleBuildTargetComboButtonText() const
{
	FString BuildTarget;

	if (bUseProfile)
	{
		ILauncherProfilePtr Profile = GetProfile();
		if (Profile.IsValid() && Profile->HasBuildTargetSpecified())
		{
			BuildTarget = Profile->GetBuildTarget();
		}
	}
	else
	{
		BuildTarget = Model->GetProfileManager()->GetBuildTarget();
	}

	return GetBuildTargetText(BuildTarget);
}


void SProjectLauncherBuildTargetSelector::HandleBuildTargetSelectionChanged(TSharedPtr<FString> Item, ESelectInfo::Type SelectInfo)
{
	if (Item.IsValid())

#Loc: <Workspace>/Engine/Source/Developer/ProjectLauncher/Private/Widgets/Shared/SProjectLauncherBuildTargetSelector.cpp:163

Scope (from outer to inner):

file
function     void SProjectLauncherBuildTargetSelector::SetBuildTarget

Source code excerpt:



void SProjectLauncherBuildTargetSelector::SetBuildTarget(const FString& BuildTarget)
{
	if (bUseProfile)
	{
		ILauncherProfilePtr Profile = GetProfile();
		if (Profile.IsValid())
		{
			Profile->SetBuildTarget(BuildTarget);
			Profile->SetBuildTargetSpecified(true);
		}
	}
	else
	{
		Model->GetProfileManager()->SetBuildTarget(BuildTarget);
	}
}

void SProjectLauncherBuildTargetSelector::HandleProfileManagerProfileSelected(const ILauncherProfilePtr& SelectedProfile, const ILauncherProfilePtr& PreviousProfile)
{
	if (PreviousProfile.IsValid())

#Loc: <Workspace>/Engine/Source/Developer/ProjectLauncher/Private/Widgets/Shared/SProjectLauncherBuildTargetSelector.cpp:225

Scope (from outer to inner):

file
function     void SProjectLauncherBuildTargetSelector::RefreshBuildTargetList

Source code excerpt:


	BuildTargetList.Reset();
	for ( const FString& BuildTarget : ExplicitBuildTargetNames)
	{
		BuildTargetList.Add(MakeShared<FString>(BuildTarget));
	}

	// add a blank entry to allow resetting back to 'default'
	BuildTargetList.Add(MakeShared<FString>());

	// refresh UI

#Loc: <Workspace>/Engine/Source/Developer/ProjectLauncher/Private/Widgets/Shared/SProjectLauncherBuildTargetSelector.h:50

Scope (from outer to inner):

file
class        class SProjectLauncherBuildTargetSelector : public SCompoundWidget

Source code excerpt:

	EVisibility IsBuildTargetVisible() const;
	FText HandleBuildTargetComboButtonText() const;
	FText GetBuildTargetText( FString BuildTarget ) const;
	void HandleBuildTargetSelectionChanged(TSharedPtr<FString> Item, ESelectInfo::Type SelectInfo);
	TSharedRef<SWidget> HandleBuildTargetGenerateWidget(TSharedPtr<FString> Item);
	void HandleProfileManagerProfileSelected(const ILauncherProfilePtr& SelectedProfile, const ILauncherProfilePtr& PreviousProfile);
	void HandleProfileProjectChanged();
	void HandleProfileBuildTargetOptionsChanged();

	void SetBuildTarget(const FString& BuildTarget);

	ILauncherProfilePtr GetProfile() const;


private:

#Loc: <Workspace>/Engine/Source/Developer/TraceInsights/Private/Insights/Widgets/SStartPageWindow.cpp:200

Scope (from outer to inner):

file
class        class STraceListRow : public SMultiColumnTableRow<TSharedPtr<FTraceViewModel>>, public ILazyToolTipCreator
function     virtual TSharedRef<SWidget> GenerateWidgetForColumn

Source code excerpt:

				];
		}
		else if (ColumnName == TraceStoreColumns::BuildTarget)
		{
			return SNew(SBox)
				.Padding(FMargin(4.0f, 0.0f))
				[
					SNew(STextBlock)
					.Text(this, &STraceListRow::GetTraceBuildTarget)

#Loc: <Workspace>/Engine/Source/Developer/TraceInsights/Private/Insights/Widgets/SStartPageWindow.cpp:1308

Scope: file

Source code excerpt:

			]

			+ SHeaderRow::Column(TraceStoreColumns::BuildTarget)
			.FillWidth(0.1f)
			.InitialSortMode(EColumnSortMode::Ascending)
			.SortMode(this, &STraceStoreWindow::GetSortModeForColumn, TraceStoreColumns::BuildTarget)
			.OnSort(this, &STraceStoreWindow::OnSortModeChanged)
			.OnGetMenuContent(this, &STraceStoreWindow::MakeBuildTargetColumnHeaderMenu)
			[
				SNew(SBox)
				.VAlign(VAlign_Center)
				.MinDesiredHeight(24.0f)

#Loc: <Workspace>/Engine/Source/Developer/TraceInsights/Private/Insights/Widgets/SStartPageWindow.cpp:4168

Scope (from outer to inner):

file
function     void STraceStoreWindow::UpdateSorting

Source code excerpt:

		}
	}
	else if (SortColumn == TraceStoreColumns::BuildTarget)
	{
		if (SortMode == EColumnSortMode::Ascending)
		{
			FilteredTraceViewModels.Sort([](const TSharedPtr<FTraceViewModel>& A, const TSharedPtr<FTraceViewModel>& B)
				{
					return A->TargetType == B->TargetType ?

#Loc: <Workspace>/Engine/Source/Developer/TraceInsights/Private/Insights/Widgets/SStartPageWindow.h:38

Scope (from outer to inner):

file
namespace    TraceStoreColumns

Source code excerpt:

	static const FName AppName(TEXT("AppName"));
	static const FName BuildConfig(TEXT("BuildConfig"));
	static const FName BuildTarget(TEXT("BuildTarget"));
	static const FName Size(TEXT("Size"));
	static const FName Status(TEXT("Status"));
}

////////////////////////////////////////////////////////////////////////////////////////////////////

#Loc: <Workspace>/Engine/Source/Editor/TurnkeySupport/Private/TurnkeySupportModule.cpp:1323

Scope (from outer to inner):

file
function     static void MakeTurnkeyPlatformMenu

Source code excerpt:

			if (ValidTargets.Num() > 1)
			{
				// Set BuildTarget to default to Game if it hasn't been set (or if it was set, but is no longer valid)
				FString BuildTarget = AllPlatformPackagingSettings->BuildTarget;
				if (BuildTarget.IsEmpty() ||
				   !ValidTargets.ContainsByPredicate([&BuildTarget](const FTargetInfo& Target) { return Target.Name == BuildTarget; } ))
				{
					TArray<FTargetInfo> GameTargets = ValidTargets.FilterByPredicate([](const FTargetInfo& Target)
						{ return Target.Type == EBuildTargetType::Game;	});
					// if there are no Game targets, look for a Client target
					if (GameTargets.Num() == 0)
					{

#Loc: <Workspace>/Engine/Source/Editor/TurnkeySupport/Private/TurnkeySupportModule.cpp:1342

Scope (from outer to inner):

file
function     static void MakeTurnkeyPlatformMenu

Source code excerpt:

					}

					AllPlatformPackagingSettings->BuildTarget = GameTargets[0].Name;
					AllPlatformPackagingSettings->SaveConfig();
				}

				FToolMenuSection& TargetSection = ToolMenu->AddSection("BuildTarget", LOCTEXT("TurnkeySection_BuildTarget", "Build Target"));

				TargetSection.AddMenuEntry(
					NAME_None,
					FText::Format(LOCTEXT("DefaultPackageTarget",  "Use Project Setting ({0})"), FText::FromString(AllPlatformPackagingSettings->BuildTarget)),
					FText::Format(LOCTEXT("DefaultPackageTargetTooltip", "Package the {0} target"), FText::FromString(AllPlatformPackagingSettings->BuildTarget)),
					FSlateIcon(),
					FUIAction(
						FExecuteAction::CreateStatic(&FTurnkeySupportCallbacks::SetPackageBuildTarget, VanillaInfo, FString("")),
						FCanExecuteAction(),
						FIsActionChecked::CreateStatic(&FTurnkeySupportCallbacks::PackageBuildTargetIsChecked, VanillaInfo, FString(""))
						),

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/PlayLevelViaLauncher.cpp:281

Scope (from outer to inner):

file
function     void UEditorEngine::StartPlayUsingLauncherSession

Source code excerpt:

	// content only projects won't have multiple targets to pick from, and pasing -target=UnrealGame will fail if what C++ thinks
	// is a content only project needs a temporary target.cs file in UBT, 
	// only set the BuildTarget in code-based projects
	if (LauncherSessionInfo->bPlayUsingLauncherHasCode)
	{
		const FTargetInfo* TargetInfo = GetDefault<UPlatformsMenuSettings>()->GetLaunchOnTargetInfo();
		if (TargetInfo != nullptr)
		{
			LauncherProfile->SetBuildTarget(TargetInfo->Name);

#Loc: <Workspace>/Engine/Source/Programs/Unsync/Private/UnsyncCore.cpp:1349

Scope (from outer to inner):

file
namespace    unsync
function     FFileSyncResult SyncFile

Source code excerpt:

		BuildParams.ScavengeDatabase = Options.ScavengeDatabase;

		FBuildTargetResult BuildResult = BuildTarget(*TargetFile, SourceFile, BaseDataReader, NeedList, BuildParams);

		Result.SourceBytes = BuildResult.SourceBytes;
		Result.BaseBytes   = BuildResult.BaseBytes;

		if (!BuildResult.bSuccess)
		{

#Loc: <Workspace>/Engine/Source/Programs/Unsync/Private/UnsyncTarget.cpp:160

Scope (from outer to inner):

file
namespace    unsync
function     FBuildTargetResult BuildTarget

Source code excerpt:


FBuildTargetResult
BuildTarget(FIOWriter& Output, FIOReader& Source, FIOReader& Base, const FNeedList& NeedList, const FBuildTargetParams& Params)
{
	UNSYNC_LOG_INDENT;

	FBuildTargetResult BuildResult;

	auto TimeBegin = TimePointNow();

#Loc: <Workspace>/Engine/Source/Programs/Unsync/Private/UnsyncTarget.cpp:710

Scope (from outer to inner):

file
namespace    unsync
function     FBuffer BuildTargetBuffer

Source code excerpt:

	Result.Resize(SizeInfo.TotalBytes);
	FMemReaderWriter ResultWriter(Result.Data(), Result.Size());
	BuildTarget(ResultWriter, SourceProvider, BaseProvider, NeedList, Params);
	return Result;
}

FBuffer
BuildTargetBuffer(const uint8*				SourceData,
				  uint64					SourceSize,

#Loc: <Workspace>/Engine/Source/Programs/Unsync/Private/UnsyncTarget.h:35

Scope (from outer to inner):

file
namespace    unsync

Source code excerpt:

};

FBuildTargetResult BuildTarget(FIOWriter&				 Result,
							   FIOReader&				 Source,
							   FIOReader&				 Base,
							   const FNeedList&			 NeedList,
							   const FBuildTargetParams& Params);

FBuffer BuildTargetBuffer(FIOReader& SourceProvider, FIOReader& BaseProvider, const FNeedList& NeedList, const FBuildTargetParams& Params);

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/DemoNetDriver.cpp:3284

Scope (from outer to inner):

file
function     void UDemoNetDriver::ReplayStreamingReady

Source code excerpt:

					ReplayHelper.PlaybackDemoHeader.MinRecordHz, ReplayHelper.PlaybackDemoHeader.MaxRecordHz,
					ReplayHelper.PlaybackDemoHeader.FrameLimitInMS, ReplayHelper.PlaybackDemoHeader.CheckpointLimitInMS,
					*ReplayHelper.PlaybackDemoHeader.Platform, LexToString(ReplayHelper.PlaybackDemoHeader.BuildConfig), LexToString(ReplayHelper.PlaybackDemoHeader.BuildTarget));
			}

			CSV_METADATA(TEXT("ReplayID"), *ReplayHelper.GetPlaybackGuid().ToString(EGuidFormats::Digits));
		}

		// Notify all listeners that a demo is starting

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/ReplayHelper.cpp:286

Scope (from outer to inner):

file
function     void FReplayHelper::WriteNetworkDemoHeader

Source code excerpt:

		DemoHeader.Platform = FPlatformProperties::PlatformName();
		DemoHeader.BuildConfig = FApp::GetBuildConfiguration();
		DemoHeader.BuildTarget = FApp::GetBuildTargetType();

		if (FNetworkReplayDelegates::GetOverridableVersionDataForHeaderWrite.IsBound())
		{
			FOverridableReplayVersionData OverridaleReplayVersionData(DemoHeader);
			FNetworkReplayDelegates::GetOverridableVersionDataForHeaderWrite.Execute(OverridaleReplayVersionData);
			OverridaleReplayVersionData.ApplyVersionDataToDemoHeader(DemoHeader);

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/ReplayTypes.cpp:30

Scope (from outer to inner):

file
function     FNetworkDemoHeader::FNetworkDemoHeader

Source code excerpt:

	CheckpointLimitInMS(0.0f),
	BuildConfig(EBuildConfiguration::Unknown),
	BuildTarget(EBuildTargetType::Unknown),
	EngineVersion(FEngineVersion::Current()),
	HeaderFlags(EReplayHeaderFlags::None),
	PackageVersionUE(GPackageFileUEVersion),
	PackageVersionLicenseeUE(GPackageFileLicenseeUEVersion)
{
}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/ReplayTypes.cpp:223

Scope (from outer to inner):

file
function     FArchive& operator<<

Source code excerpt:

		Ar << Header.Platform;
		Ar << Header.BuildConfig;
		Ar << Header.BuildTarget;
	}

	return Ar;
}

uint32 FOverridableReplayVersionData::GetCustomVersion(const FGuid& VersionGuid) const

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/ReplayTypes.h:201

Scope: file

Source code excerpt:

	FString Platform;
	EBuildConfiguration BuildConfig;
	EBuildTargetType BuildTarget;

	FEngineVersion EngineVersion;					// Full engine version on which the replay was recorded
	EReplayHeaderFlags HeaderFlags;					// Replay flags
	TArray<FLevelNameAndTime> LevelNamesAndTimes;	// Name and time changes of levels loaded for demo
	TArray<FString> GameSpecificData;				// Area for subclasses to write stuff
	FPackageFileVersion PackageVersionUE;			// Engine package version on which the replay was recorded

#Loc: <Workspace>/Engine/Source/Runtime/InteractiveToolsFramework/Private/ToolTargetManager.cpp:52

Scope (from outer to inner):

file
function     UToolTarget* UToolTargetManager::BuildTarget

Source code excerpt:

}

UToolTarget* UToolTargetManager::BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetType)
{
	for (UToolTargetFactory* Factory : Factories)
	{
		if (Factory->CanBuildTarget(SourceObject, TargetType))
		{
			UToolTarget* Result = Factory->BuildTarget(SourceObject, TargetType);
			if (Result != nullptr)
			{
				return Result;
			}
		}
	}

#Loc: <Workspace>/Engine/Source/Runtime/InteractiveToolsFramework/Private/ToolTargetManager.cpp:103

Scope (from outer to inner):

file
function     UToolTarget* UToolTargetManager::BuildFirstSelectedTargetable

Source code excerpt:

UToolTarget* UToolTargetManager::BuildFirstSelectedTargetable(const FToolBuilderState& SceneState, const FToolTargetTypeRequirements& TargetType)
{
	return BuildTarget(
		ToolBuilderUtil::FindFirstComponent(SceneState, [&](UActorComponent* Object)
		{
			return CanBuildTarget(Object, TargetType);
		}),
		TargetType);
}

#Loc: <Workspace>/Engine/Source/Runtime/InteractiveToolsFramework/Private/ToolTargetManager.cpp:122

Scope (from outer to inner):

file
function     TArray<TObjectPtr<UToolTarget>> UToolTargetManager::BuildAllSelectedTargetable

Source code excerpt:

	for (UActorComponent* Component : Components)
	{
		Targets.Add(BuildTarget(Component, TargetType));
	}
	return Targets;
}

#Loc: <Workspace>/Engine/Source/Runtime/InteractiveToolsFramework/Private/ToolTargets/PrimitiveComponentToolTarget.cpp:99

Scope (from outer to inner):

file
function     UToolTarget* UPrimitiveComponentToolTargetFactory::BuildTarget

Source code excerpt:

}

UToolTarget* UPrimitiveComponentToolTargetFactory::BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& Requirements)
{
	UPrimitiveComponentToolTarget* Target = NewObject<UPrimitiveComponentToolTarget>();
	Target->InitializeComponent(Cast<UPrimitiveComponent>(SourceObject));
	checkSlow(Target->Component.IsValid() && Requirements.AreSatisfiedBy(Target));
	return Target;
}

#Loc: <Workspace>/Engine/Source/Runtime/InteractiveToolsFramework/Public/ToolTargetManager.h:76

Scope (from outer to inner):

file
class        class UToolTargetManager : public UObject

Source code excerpt:

	 * @return Tool target that staisfies given requirements, or nullptr if none could be created.
	 */
	INTERACTIVETOOLSFRAMEWORK_API virtual UToolTarget* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetRequirements);

	/** Much like BuildTarget, but casts the target to the template argument before returning. */
	template<typename CastToType>
	CastToType* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetType)
	{
		UToolTarget* Result = BuildTarget(SourceObject, TargetType);
		return (Result != nullptr) ? Cast<CastToType>(Result) : nullptr;
	}

	/**
	 * Looks through the currently selected components and actors and counts the number of
	 * inputs that could be used to create qualifying tool targets.

#Loc: <Workspace>/Engine/Source/Runtime/InteractiveToolsFramework/Public/ToolTargets/PrimitiveComponentToolTarget.h:54

Scope (from outer to inner):

file
class        class UPrimitiveComponentToolTargetFactory : public UToolTargetFactory

Source code excerpt:

public:
	INTERACTIVETOOLSFRAMEWORK_API virtual bool CanBuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) const override;
	INTERACTIVETOOLSFRAMEWORK_API virtual UToolTarget* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) override;
};

#Loc: <Workspace>/Engine/Source/Runtime/InteractiveToolsFramework/Public/ToolTargets/ToolTarget.h:96

Scope (from outer to inner):

file
class        class UToolTargetFactory : public UObject

Source code excerpt:

	INTERACTIVETOOLSFRAMEWORK_API virtual bool CanBuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) const PURE_VIRTUAL(UToolTargetFactory::CanBuildTarget, return false;);

	INTERACTIVETOOLSFRAMEWORK_API virtual UToolTarget* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetTypeInfo) PURE_VIRTUAL(UToolTargetFactory::BuildTarget, return nullptr;);
};

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/DumpGPU.cpp:2194

Scope (from outer to inner):

file
function     void FRDGResourceDumpContext::Start

Source code excerpt:


		FString BuildConfiguration = LexToString(FApp::GetBuildConfiguration());
		FString BuildTarget = LexToString(FApp::GetBuildTargetType());

		FString OSLabel, OSVersion;
		FPlatformMisc::GetOSVersions(OSLabel, OSVersion);
		if (!OSVersion.IsEmpty())
		{
			OSLabel = FString::Printf(TEXT("%s %s"), *OSLabel, *OSVersion);

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/DumpGPU.cpp:2213

Scope (from outer to inner):

file
function     void FRDGResourceDumpContext::Start

Source code excerpt:

		JsonObject->SetStringField(TEXT("BuildDate"), BuildDate ? BuildDate : TEXT(""));
		JsonObject->SetStringField(TEXT("BuildVersion"), BuildVersion ? BuildVersion : TEXT(""));
		JsonObject->SetStringField(TEXT("BuildTarget"), BuildTarget);
		JsonObject->SetStringField(TEXT("BuildConfiguration"), BuildConfiguration);
		JsonObject->SetNumberField(TEXT("Build64Bits"), (PLATFORM_64BITS ? 1 : 0));
		JsonObject->SetStringField(TEXT("Platform"), FPlatformProperties::IniPlatformName());
		JsonObject->SetStringField(TEXT("OS"), OSLabel);
		JsonObject->SetStringField(TEXT("DeviceName"), FPlatformProcess::ComputerName());
		JsonObject->SetStringField(TEXT("CPUVendor"), FPlatformMisc::GetCPUVendor());