VersionInfo

VersionInfo

#Overview

name: VersionInfo

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 50 C++ source files. Also referenced in 4 C# build files meaning it may affect the build system logic.

#Summary

#Usage in the C++ source code

The purpose of VersionInfo is to store and manage version information related to different aspects of the Unreal Engine and its components. This variable is used across various subsystems and modules to keep track of version details, compatibility, and build information. Here’s a breakdown of its usage and importance:

  1. The VersionInfo variable is used in multiple Unreal Engine subsystems, plugins, and modules, including:

    • RigLogic animation system
    • Concert multi-user collaboration system
    • Blueprint search and indexing
    • Platform-specific functionality (iOS, Windows, Linux)
    • Network file operations
    • HTTP and cURL implementations

  2. The value of this variable is typically set during initialization or creation of specific objects or systems. For example, in the iOS runtime settings, it’s set to a default value of “1.0.0” and can be customized by developers.

  3. VersionInfo often interacts with other variables related to versioning, such as major, minor, and patch version numbers, as well as build identifiers.

  4. Developers must be aware that VersionInfo is crucial for maintaining compatibility between different components of the engine and ensuring proper functionality across various versions of the software.

  5. Best practices when using this variable include:

    • Keeping it up-to-date with the current version of the component or system it represents
    • Using it for version checks to ensure compatibility between different parts of the engine
    • Properly serializing and deserializing it when saving or loading data
    • Considering it when implementing backwards compatibility features

  6. VersionInfo is particularly important in areas such as:

    • Plugin and module compatibility checks
    • Network communication protocols
    • File format versioning
    • API versioning and compatibility

  7. In some cases, VersionInfo is used to determine the appropriate data format or processing method based on the version of the component or data being handled.

  8. For platform-specific implementations (e.g., Windows, Linux, iOS), VersionInfo may be used to determine feature availability or to adjust behavior based on the operating system version.

  9. In the context of the Concert multi-user collaboration system, VersionInfo is crucial for ensuring that all participants in a session are using compatible versions of the software.

  10. For Blueprint searching and indexing, VersionInfo helps manage the versioning of search data and ensures that outdated search indices are properly updated.

By understanding and properly utilizing VersionInfo, developers can ensure better compatibility, easier maintenance, and smoother upgrades across different versions of Unreal Engine components and related software.

#Usage in the C# source code and build system

The purpose of VersionInfo is to specify the short version string for iOS and tvOS applications built with Unreal Engine 5. This setting is crucial for versioning the application in the App Store and on users’ devices.

This setting variable is primarily relied upon by the iOS and tvOS deployment systems within Unreal Engine. Specifically, it’s used in the following modules:

  1. UEDeployIOS: Handles deployment for iOS devices
  2. UEDeployTVOS: Manages deployment for tvOS devices
  3. XcodeProject: Generates Xcode project files for iOS and tvOS targets

The value of this variable is set in the IOSRuntimeSettings section of the project’s configuration files. It can be modified through the project settings in the Unreal Editor or by directly editing the relevant configuration files.

VersionInfo interacts with other iOS and tvOS specific settings, such as:

  1. bSupportsMetal: Determines if the Metal graphics API is supported
  2. bEnableGoogleSupport: Enables Google services integration
  3. bEnableSimulatorSupport: Allows building for iOS simulator

Developers must be aware that:

  1. This version string should follow semantic versioning guidelines (e.g., “1.0.0”).
  2. It needs to be updated for each new release of the application to the App Store.
  3. The version string affects how updates are handled on user devices and in the App Store.

Best practices when using this variable include:

  1. Consistently increment the version for each new release.
  2. Ensure the version string in VersionInfo matches the version number used in other parts of the project (e.g., marketing materials, internal documentation).
  3. Use a systematic versioning scheme that clearly communicates the nature of updates to users and the App Store.
  4. Coordinate changes to this variable with your team to maintain consistency across the project.

There is no directly associated variable mentioned in the provided information. However, it’s worth noting that VersionInfo works in conjunction with other iOS and tvOS specific settings to define the characteristics and capabilities of the deployed application.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Config/BaseEngine.ini:3002, section: [/Script/IOSRuntimeSettings.IOSRuntimeSettings]

#References in C++ code

#Callsites

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

#Loc: <Workspace>/Engine/Plugins/Animation/RigLogic/Source/RigLogicLib/Public/riglogic/version/VersionInfo.h:7

Scope (from outer to inner):

file
namespace    rl4
function     struct RLAPI VersionInfo { static int getMajorVersion

Source code excerpt:

namespace rl4 {

struct RLAPI VersionInfo {
    static int getMajorVersion();
    static int getMinorVersion();
    static int getPatchVersion();
    static StringView getVersionString();
};

#Loc: <Workspace>/Engine/Plugins/Developer/Concert/ConcertApp/MultiUserClient/Source/MultiUserClient/Private/Widgets/Disconnected/SConcertClientSessionBrowser.cpp:625

Scope (from outer to inner):

file
function     void SConcertClientSessionBrowser::PopulateSessionInfoGrid

Source code excerpt:

	if (SessionInfo.VersionInfos.Num() > 0)
	{
		const FConcertSessionVersionInfo& VersionInfo = SessionInfo.VersionInfos.Last();
		AddDetailRow(Grid, Row++, LOCTEXT("EngineVersion", "Engine Version:"), VersionInfo.AsText());
	}
	AddDetailRow(Grid, Row++, LOCTEXT("ServerEndPointId", "Server Endpoint ID:"), FText::FromString(SessionInfo.ServerEndpointId.ToString()));
}

TSharedRef<ITableRow> SConcertClientSessionBrowser::OnGenerateClientRowWidget(TSharedPtr<FConcertSessionClientInfo> Item, const TSharedRef<STableViewBase>& OwnerTable)
{

#Loc: <Workspace>/Engine/Plugins/Developer/Concert/ConcertApp/MultiUserServer/Source/MultiUserServer/Private/Widgets/Browser/ConcertServerSessionBrowserController.cpp:118

Scope (from outer to inner):

file
namespace    UE::MultiUserServer
function     void FConcertServerSessionBrowserController::CreateSession

Source code excerpt:

			SessionInfo.Settings.ProjectName = ProjectName;
		}
		FConcertSessionVersionInfo VersionInfo;
		VersionInfo.Initialize(false /* bSupportMixedBuildTypes */ );
		SessionInfo.VersionInfos.Emplace(VersionInfo);

		FAsyncTaskNotification Notification(
			MakeAsyncNotification(FText::Format(LOCTEXT("CreateSessionFmt.InProgress", "Created Session '{0}'"), FText::FromString(SessionName)))
			);
		FText FailureReason = FText::GetEmpty();
		const bool bSuccess = ServerInstance->GetConcertServer()->CreateSession(SessionInfo, FailureReason) != nullptr;

#Loc: <Workspace>/Engine/Plugins/Developer/Concert/ConcertMain/Source/Concert/Private/ConcertMessageData.cpp:140

Scope (from outer to inner):

file
function     FText FConcertSessionInfo::ToDisplayString

Source code excerpt:

	if (VersionInfos.Num() > 0)
	{
		const FConcertSessionVersionInfo& VersionInfo = VersionInfos.Last();
		TextBuilder.AppendLineFormat(
			NSLOCTEXT("ConcertSessionInfo", "EngineVersion", "Session Engine Version: {0}.{1}.{2}-{3}"), 
			FText::AsNumber(VersionInfo.EngineVersion.Major, &FNumberFormattingOptions::DefaultNoGrouping()),
			FText::AsNumber(VersionInfo.EngineVersion.Minor, &FNumberFormattingOptions::DefaultNoGrouping()),
			FText::AsNumber(VersionInfo.EngineVersion.Patch, &FNumberFormattingOptions::DefaultNoGrouping()),
			FText::AsNumber(VersionInfo.EngineVersion.Changelist, &FNumberFormattingOptions::DefaultNoGrouping())
			);
	}
	TextBuilder.AppendLineFormat(NSLOCTEXT("ConcertSessionInfo", "ServerEndpointId", "Server Endpoint ID: {0}"), FText::FromString(ServerEndpointId.ToString()));
	return TextBuilder.ToText();
}

#Loc: <Workspace>/Engine/Plugins/Developer/Concert/ConcertMain/Source/Concert/Public/ConcertMessages.h:271

Scope: file

Source code excerpt:


	UPROPERTY(VisibleAnywhere, Category="Concert Message")
	FConcertSessionVersionInfo VersionInfo;
};

USTRUCT()
struct FConcertAdmin_FindSessionRequest : public FConcertRequestData
{
	GENERATED_BODY()

#Loc: <Workspace>/Engine/Plugins/Developer/Concert/ConcertMain/Source/Concert/Public/ConcertMessages.h:289

Scope: file

Source code excerpt:


	UPROPERTY(VisibleAnywhere, Category="Concert Message")
	FConcertSessionVersionInfo VersionInfo;
};

/** Used to copy a live session or restore an archived one. */
USTRUCT()
struct FConcertAdmin_CopySessionRequest : public FConcertRequestData
{

#Loc: <Workspace>/Engine/Plugins/Developer/Concert/ConcertMain/Source/Concert/Public/ConcertMessages.h:316

Scope: file

Source code excerpt:

	/** Version information of the client requesting the copy. */
	UPROPERTY(VisibleAnywhere, Category="Concert Message")
	FConcertSessionVersionInfo VersionInfo;

	/** The filter controlling which activities from the session should be copied over. */
	UPROPERTY(VisibleAnywhere, Category="Concert Message")
	FConcertSessionFilter SessionFilter;

	/** True to constrain the session to copy to be an archive (implying a restore operation). */

#Loc: <Workspace>/Engine/Plugins/Developer/Concert/ConcertMain/Source/ConcertClient/Private/ConcertClient.cpp:1198

Scope (from outer to inner):

file
function     TFuture<EConcertResponseCode> FConcertClient::InternalCreateSession

Source code excerpt:

		CreateSessionRequest.SessionName = CreateSessionArgs.SessionName;
		CreateSessionRequest.OwnerClientInfo = ClientInfo;
		CreateSessionRequest.VersionInfo.Initialize(GetConfiguration()->ClientSettings.bSupportMixedBuildTypes);
	
		// Session settings
		CreateSessionRequest.SessionSettings.Initialize();
		CreateSessionRequest.SessionSettings.ArchiveNameOverride = CreateSessionArgs.ArchiveNameOverride;

		ConnectionTasks.Emplace(MakeUnique<FConcertClientCreateSessionTask>(this, MoveTemp(CreateSessionRequest), ServerAdminEndpointId));

#Loc: <Workspace>/Engine/Plugins/Developer/Concert/ConcertMain/Source/ConcertClient/Private/ConcertClient.cpp:1244

Scope (from outer to inner):

file
function     TFuture<EConcertResponseCode> FConcertClient::InternalJoinSession

Source code excerpt:

		FindSessionRequest.SessionId = SessionId;
		FindSessionRequest.OwnerClientInfo = ClientInfo;
		FindSessionRequest.VersionInfo.Initialize(GetConfiguration()->ClientSettings.bSupportMixedBuildTypes);

		// Session settings
		FindSessionRequest.SessionSettings.Initialize();

		ConnectionTasks.Emplace(MakeUnique<FConcertClientJoinSessionTask>(this, MoveTemp(FindSessionRequest), ServerAdminEndpointId, ResolvedSessionName));
	}

#Loc: <Workspace>/Engine/Plugins/Developer/Concert/ConcertMain/Source/ConcertClient/Private/ConcertClient.cpp:1273

Scope (from outer to inner):

file
function     TFuture<EConcertResponseCode> FConcertClient::InternalCopySession

Source code excerpt:

	CopySessionRequest.bRestoreOnly = bRestoreOnlyConstraint;
	CopySessionRequest.OwnerClientInfo = ClientInfo;
	CopySessionRequest.VersionInfo.Initialize(GetConfiguration()->ClientSettings.bSupportMixedBuildTypes);

	// Session settings
	CopySessionRequest.SessionSettings.Initialize();
	CopySessionRequest.SessionSettings.ArchiveNameOverride = CopySessionArgs.ArchiveNameOverride;

	TUniquePtr<FAsyncTaskNotification> Notification = MoveTemp(OngoingNotification);

#Loc: <Workspace>/Engine/Plugins/Developer/Concert/ConcertMain/Source/ConcertServer/Private/ConcertServer.cpp:1102

Scope (from outer to inner):

file
function     TFuture<FConcertAdmin_SessionInfoResponse> FConcertServer::HandleCreateSessionRequest

Source code excerpt:

		SessionInfo.SessionName = Message->SessionName;
		SessionInfo.Settings = Message->SessionSettings;
		SessionInfo.VersionInfos.Add(Message->VersionInfo);
		NewServerSession = CreateSession(SessionInfo, CreateFailureReason);
	}

	// We have a valid session if it succeeded
	FConcertAdmin_SessionInfoResponse ResponseData;
	if (NewServerSession)

#Loc: <Workspace>/Engine/Plugins/Developer/Concert/ConcertMain/Source/ConcertServer/Private/ConcertServer.cpp:1132

Scope (from outer to inner):

file
function     TFuture<FConcertAdmin_SessionInfoResponse> FConcertServer::HandleFindSessionRequest

Source code excerpt:

	TSharedPtr<IConcertServerSession> ServerSession = GetLiveSession(Message->SessionId);
	const TCHAR* ServerSessionNamePtr = ServerSession ? *ServerSession->GetName() : TEXT("<unknown>");
	if (CanJoinSession(ServerSession, Message->SessionSettings, Message->VersionInfo, Message->ConcertEndpointId, Message->OwnerClientInfo, &ResponseData.Reason))
	{
		ResponseData.ResponseCode = EConcertResponseCode::Success;
		ResponseData.SessionInfo = ServerSession->GetSessionInfo();
		UE_LOG(LogConcert, Display, TEXT("Allowing user %s to join session %s (Id: %s, Owner: %s)"), *Message->OwnerClientInfo.UserName, ServerSessionNamePtr, *Message->SessionId.ToString(), *ServerSession->GetSessionInfo().OwnerUserName);
	}
	else

#Loc: <Workspace>/Engine/Plugins/Developer/Concert/ConcertMain/Source/ConcertServer/Private/ConcertServer.cpp:1161

Scope (from outer to inner):

file
function     TFuture<FConcertAdmin_SessionInfoResponse> FConcertServer::HandleCopySessionRequest

Source code excerpt:

		SessionInfo.SessionName = Message->SessionName;
		SessionInfo.Settings = Message->SessionSettings;
		SessionInfo.VersionInfos.Add(Message->VersionInfo);
		NewServerSession = Message->bRestoreOnly ?
			RestoreSession(Message->SessionId, SessionInfo, Message->SessionFilter, FailureReason) :
			CopySession(Message->SessionId, SessionInfo, Message->SessionFilter, FailureReason);
	}

	// We have a valid session if it succeeded

#Loc: <Workspace>/Engine/Plugins/Developer/Concert/ConcertSync/ConcertSyncClient/Source/ConcertSyncClient/Private/ConcertClientTransactionManager.cpp:591

Scope (from outer to inner):

file
function     void FConcertClientTransactionManager::ProcessTransactionFinalizedEvent

Source code excerpt:

void FConcertClientTransactionManager::ProcessTransactionFinalizedEvent(const FPendingTransactionToProcessContext& InContext, const FConcertTransactionFinalizedEvent& InEvent)
{
	const FConcertSessionVersionInfo* VersionInfo = LiveSession->GetSession().GetSessionInfo().VersionInfos.IsValidIndex(InEvent.VersionIndex) ? &LiveSession->GetSession().GetSessionInfo().VersionInfos[InEvent.VersionIndex] : nullptr;
	FConcertLocalIdentifierTable LocalIdentifierTable(InEvent.LocalIdentifierState);
	TransactionBridge->OnApplyTransaction().Broadcast(ETransactionNotification::Begin, /*bIsSnapshot*/ false);
	CheckEventForSendConflicts(InEvent);
	TransactionBridge->ApplyRemoteTransaction(InEvent, VersionInfo, InContext.PackagesToProcess, &LocalIdentifierTable, /*bIsSnapshot*/false);

	TransactionBridge->OnApplyTransaction().Broadcast(ETransactionNotification::End, /*bIsSnapshot*/ false);
}

void FConcertClientTransactionManager::ProcessTransactionSnapshotEvent(const FPendingTransactionToProcessContext& InContext, const FConcertTransactionSnapshotEvent& InEvent)
{
	const FConcertSessionVersionInfo* VersionInfo = LiveSession->GetSession().GetSessionInfo().VersionInfos.IsValidIndex(InEvent.VersionIndex) ? &LiveSession->GetSession().GetSessionInfo().VersionInfos[InEvent.VersionIndex] : nullptr;
	TransactionBridge->OnApplyTransaction().Broadcast(ETransactionNotification::Begin, /*bIsSnapshot*/ true);
	TransactionBridge->ApplyRemoteTransaction(InEvent, VersionInfo, InContext.PackagesToProcess, nullptr, /*bIsSnapshot*/true);
	TransactionBridge->OnApplyTransaction().Broadcast(ETransactionNotification::End, /*bIsSnapshot*/ true);
}

FConcertClientTransactionManager::FPendingTransactionToSend&
FConcertClientTransactionManager::HandleLocalTransactionCommon(
	const FConcertClientLocalTransactionCommonData& InCommonData,

#Loc: <Workspace>/Engine/Plugins/Developer/Concert/ConcertSync/ConcertSyncCore/Source/ConcertSyncCore/Private/ConcertSyncSessionDatabase.cpp:369

Scope (from outer to inner):

file
namespace    PackageDataUtil
function     int64 EstimatePackageBlobMetaDataSize

Source code excerpt:

int64 EstimatePackageBlobMetaDataSize()
{
	// Roughly: VersionInfo + PackageDataOffset + Footer.
	return sizeof(uint32) + sizeof(int64) + sizeof(FGuid);
}

bool WillUseMemoryWriter(int64 DataSize)
{
	using namespace UE::Concert::Compression;

#Loc: <Workspace>/Engine/Plugins/Developer/Concert/ConcertUI/ConcertSharedSlate/Source/ConcertSharedSlate/Private/Session/Browser/SConcertSessionBrowser.cpp:176

Scope (from outer to inner):

file
namespace    UE::SessionBrowser::Private
function     static FConcertSessionTreeItem GenerateSessionItem

Source code excerpt:

	if (Session.SessionInfo.VersionInfos.Num()>0)
	{
		const FConcertSessionVersionInfo& VersionInfo = Session.SessionInfo.VersionInfos.Last();
		Version = VersionInfo.AsText();
	}
	return FConcertSessionTreeItem(
		GetEType<SessionType>(),
		Session.ServerInfo.AdminEndpointId,
		Session.SessionInfo.SessionId,
		Session.SessionInfo.SessionName,

#Loc: <Workspace>/Engine/Plugins/Experimental/MetaHuman/MetaHumanProjectUtilities/Source/MetaHumanProjectUtilities/Private/MetaHumanImport.cpp:143

Scope (from outer to inner):

file
namespace    UE::MetaHumanImport::Private
function     TMap<FString, FMetaHumanAssetVersion> ParseVersionInfo

Source code excerpt:

		FString VersionInfoString;
		FFileHelper::LoadFileToString(VersionInfoString, *AssetVersionFilePath);
		TMap<FString, FMetaHumanAssetVersion> VersionInfo;
		TSharedPtr<FJsonObject> AssetsVersionInfoObject;
		FJsonSerializer::Deserialize(TJsonReaderFactory<>::Create(VersionInfoString), AssetsVersionInfoObject);
		TArray<TSharedPtr<FJsonValue>> AssetsVersionInfoArray = AssetsVersionInfoObject->GetArrayField(TEXT("assets"));

		for (const TSharedPtr<FJsonValue>& AssetVersionInfoObject : AssetsVersionInfoArray)
		{
			FString AssetPath = AssetVersionInfoObject->AsObject()->GetStringField(TEXT("path"));
			FMetaHumanAssetVersion AssetVersion = FMetaHumanAssetVersion::FromString(AssetVersionInfoObject->AsObject()->GetStringField(TEXT("version")));
			VersionInfo.Add(AssetPath, AssetVersion);
		}

		return VersionInfo;
	}

	void CopyFiles(const FAssetOperationPaths& AssetOperations, const FImportPaths& ImportPaths)
	{
		TArray<UPackage*> PackagesToReload;
		TArray<UPackage*> BPsToReload;

#Loc: <Workspace>/Engine/Plugins/VirtualProduction/LevelSnapshots/Source/LevelSnapshots/Public/Data/SnapshotVersion.h:70

Scope (from outer to inner):

file
function     FArchive& operator<<

Source code excerpt:

	void Initialize(const FCustomVersion& InVersion);

	friend FArchive& operator<<(FArchive& Archive, FSnapshotCustomVersionInfo& VersionInfo)
	{
		Archive << VersionInfo.FriendlyName;
		return Archive;
	}
	
	/** Friendly name of the version */
	UPROPERTY()
	FName FriendlyName;

#Loc: <Workspace>/Engine/Source/Developer/CrashDebugHelper/Private/Windows/WindowsPlatformStackWalkExt.cpp:167

Scope (from outer to inner):

file
function     void FWindowsPlatformStackWalkExt::GetExeFileVersionAndModuleList

Source code excerpt:

	if( ExecutableIndex > -1 )
	{
		VS_FIXEDFILEINFO VersionInfo = {0};
		Symbol->GetModuleVersionInformationWide( ExecutableIndex, 0, TEXT( "\\" ), &VersionInfo, sizeof( VS_FIXEDFILEINFO ), NULL );

		out_ExeFileVersion.Major = HIWORD( VersionInfo.dwProductVersionMS );
		out_ExeFileVersion.Minor = LOWORD( VersionInfo.dwProductVersionMS );
		out_ExeFileVersion.Patch = HIWORD( VersionInfo.dwProductVersionLS );
	}
	else
	{
		UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Unable to locate the executable" ) );
	}
}

#Loc: <Workspace>/Engine/Source/Developer/CrashDebugHelper/Private/Windows/WindowsPlatformStackWalkExt.cpp:343

Scope (from outer to inner):

file
function     void FWindowsPlatformStackWalkExt::GetModuleInfoDetailed

Source code excerpt:

		CrashModule->SizeOfImage = ModuleParameters.Size;

		VS_FIXEDFILEINFO VersionInfo = { 0 };
		Symbol->GetModuleVersionInformationWide( ModuleIndex, ModuleBase, TEXT( "\\" ), &VersionInfo, sizeof( VS_FIXEDFILEINFO ), NULL );

		CrashModule->Major = HIWORD( VersionInfo.dwProductVersionMS );
		CrashModule->Minor = LOWORD( VersionInfo.dwProductVersionMS );
		CrashModule->Patch = HIWORD( VersionInfo.dwProductVersionLS );
		CrashModule->Revision = LOWORD( VersionInfo.dwProductVersionLS );

		// NOTE: The function below was commented because in some occasions (unknown reason), it triggered a search for modules on the user disk,
		//       scanning all projects assets for each module, taking an unacceptable long time in very large projects. This could be observed with
		//       SysInternal ProcessMonitor. The original intent for calling ReloadWide() is unknown, but normally, this function is meant
		//       to control when the modules are reloaded, for example if the .pdb were about to be deleted, we would want to reload and cache the
		//       symbols before losing them. Since we configured the debug engine with SYMOPT_DEFERRED_LOADS to only load symbols if needed,

#Loc: <Workspace>/Engine/Source/Developer/DesktopPlatform/Private/Windows/DesktopPlatformWindows.cpp:587

Scope (from outer to inner):

file
function     int32 FDesktopPlatformWindows::GetShellIntegrationVersion

Source code excerpt:

	if (VersionInfoSize != 0)
	{
		TArray<uint8> VersionInfo;
		VersionInfo.AddUninitialized(VersionInfoSize);
		if (GetFileVersionInfo(*FileName, NULL, VersionInfoSize, VersionInfo.GetData()))
		{
			TCHAR *ShellVersion;
			::UINT ShellVersionLen;
			if (VerQueryValue(VersionInfo.GetData(), TEXT("\\StringFileInfo\\040904b0\\ShellIntegrationVersion"), (LPVOID*)&ShellVersion, &ShellVersionLen))
			{
				TCHAR *ShellVersionEnd;
				int32 Version = FCString::Strtoi(ShellVersion, &ShellVersionEnd, 10);
				if(*ShellVersionEnd == 0)
				{
					return Version;

#Loc: <Workspace>/Engine/Source/Developer/IOS/IOSPlatformEditor/Private/IOSTargetSettingsCustomization.cpp:799

Scope: file

Source code excerpt:

	SETUP_PLIST_PROP(BundleName, BundleCategory);
	SETUP_STATUS_PROP(BundleIdentifier, BundleCategory);
	SETUP_PLIST_PROP(VersionInfo, BundleCategory);
	SETUP_PLIST_PROP(bSupportsPortraitOrientation, OrientationCategory);
	SETUP_PLIST_PROP(bSupportsUpsideDownOrientation, OrientationCategory);
	SETUP_PLIST_PROP(bSupportsLandscapeLeftOrientation, OrientationCategory);
	SETUP_PLIST_PROP(bSupportsLandscapeRightOrientation, OrientationCategory);
	SETUP_PLIST_PROP(PreferredLandscapeOrientation, OrientationCategory);

#Loc: <Workspace>/Engine/Source/Editor/Kismet/Private/FindInBlueprintManager.cpp:173

Scope (from outer to inner):

file
function     uint32 FStreamSearch::Run

Source code excerpt:

		{
			// If the Blueprint is below the version, add it to a list. The search will still proceed on this Blueprint
			if (QueryResult.VersionInfo.FiBDataVersion < SearchOptions.MinimiumVersionRequirement)
			{
				++BlueprintCountBelowVersion;
			}

			TSharedPtr< FFiBSearchInstance > SearchInstance(new FFiBSearchInstance);
			FSearchResult SearchResult;

#Loc: <Workspace>/Engine/Source/Editor/Kismet/Private/FindInBlueprintManager.cpp:1767

Scope: file

Source code excerpt:

								{
									using namespace BlueprintSearchMetaDataHelpers;
									SearchData.Value = GatherBlueprintSearchMetadata<FFindInBlueprintJsonWriter>(Blueprint, SearchData.VersionInfo.FiBDataVersion);

									if (SearchData.Value.Len() > 0)
									{
										bEnqueueForAsyncIndexing = ShouldFullyIndexAssets();
									}
									else

#Loc: <Workspace>/Engine/Source/Editor/Kismet/Private/FindInBlueprintManager.cpp:1825

Scope (from outer to inner):

file
function     void Tick

Source code excerpt:

						{
							using namespace BlueprintSearchMetaDataHelpers;
							SearchData.Value = GatherBlueprintSearchMetadata<FFindInBlueprintJsonWriter>(Blueprint, SearchData.VersionInfo.FiBDataVersion);
						}
					}

					// Signal that this deferred asset has now been indexed.
					SearchData.StateFlags |= ESearchDataStateFlags::IsIndexed;

#Loc: <Workspace>/Engine/Source/Editor/Kismet/Private/FindInBlueprintManager.cpp:2261

Scope (from outer to inner):

file
function     bool FFindInBlueprintSearchManager::ProcessEncodedValueForUnloadedBlueprint

Source code excerpt:


	const FString& EncodedString = !TempEncodedString.IsEmpty() ? TempEncodedString : SearchData.Value;
	if (FiBSerializationHelpers::ValidateSearchDataVersionInfo(AssetPath, EncodedString, SearchData.VersionInfo))
	{
		// Parse the data into json and then clear the memory
		SearchData.ImaginaryBlueprint = MakeShareable(new FImaginaryBlueprint(FPaths::GetBaseFilename(AssetPath), AssetPath, SearchData.ParentClass, SearchData.Interfaces, EncodedString, SearchData.VersionInfo));
		SearchData.ClearEncodedValue();

		return true;
	}

	return false;

#Loc: <Workspace>/Engine/Source/Editor/Kismet/Private/FindInBlueprintManager.cpp:2348

Scope (from outer to inner):

file
function     void FFindInBlueprintSearchManager::ExtractUnloadedFiBData

Source code excerpt:


	// This will be set to 'None' if the data is versioned. Deserialization of the actual version from the tag value is deferred until later.
	NewSearchData.VersionInfo.FiBDataVersion = InFiBDataVersion;

	// In these modes, or if there is no tag data, no additional indexing work is deferred for unloaded assets.
	if (!bDisableDeferredIndexing && !bDisableThreadedIndexing && NewSearchData.HasEncodedValue())
	{
		// Add it to the list of assets that require a full index rebuild from the metadata. This work will not block the main thread and is decoupled from the search thread.
		PendingAssets.Add(NewSearchData.AssetPath);

#Loc: <Workspace>/Engine/Source/Editor/Kismet/Private/FindInBlueprintManager.cpp:2646

Scope (from outer to inner):

file
function     void FFindInBlueprintSearchManager::AddOrUpdateBlueprintSearchMetadata

Source code excerpt:


		// Update version info stored in database. This indicates which format to use when regenerating the tag value.
		SearchData.VersionInfo = FSearchDataVersionInfo::Current;
		if (InVersion != EFiBVersion::FIB_VER_NONE)
		{
			SearchData.VersionInfo.FiBDataVersion = InVersion;
		}

		// During unindexed/out-of-date caching we will arrive here as a result of loading the asset, so don't remove the IsUnindexedCacheInProgress() check!
		if (bForceRecache || bClearCachedValue || IsUnindexedCacheInProgress() || bDisableDeferredIndexing)
		{
			// Cannot successfully gather most searchable data if there is no SkeletonGeneratedClass, so don't try, leave it as whatever it was last set to

#Loc: <Workspace>/Engine/Source/Editor/Kismet/Private/FindInBlueprintManager.cpp:2661

Scope (from outer to inner):

file
function     void FFindInBlueprintSearchManager::AddOrUpdateBlueprintSearchMetadata

Source code excerpt:


				// Update search metadata string content
				SearchData.Value = GatherBlueprintSearchMetadata<FFindInBlueprintJsonWriter>(InBlueprint, SearchData.VersionInfo.FiBDataVersion);
			}

			// Mark it as having been indexed in the following cases:
			// a) Deferred or multithreaded indexing is disabled. In these cases, indexing will be handled by the search thread.
			// b) There is no generated metadata. In this case, there's nothing to search, so there's no need to index the asset.
			if (bDisableDeferredIndexing || bDisableThreadedIndexing || SearchData.Value.Len() == 0)

#Loc: <Workspace>/Engine/Source/Editor/Kismet/Private/FindInBlueprintManager.cpp:3301

Scope (from outer to inner):

file
function     void FFindInBlueprintSearchManager::CacheAllAssets

Source code excerpt:

			for (FSearchData SearchData : SearchArray)
			{
				if ((SearchData.Value.Len() != 0 || SearchData.ImaginaryBlueprint.IsValid()) && SearchData.VersionInfo.FiBDataVersion < InOptions.MinimiumVersionRequirement)
				{
					BlueprintsToUpdate.Add(SearchData.AssetPath);
				}
			}

			FText DialogTitle = LOCTEXT("ConfirmIndexAll_Title", "Indexing All");

#Loc: <Workspace>/Engine/Source/Editor/Kismet/Private/FindInBlueprintManager.cpp:3387

Scope (from outer to inner):

file
function     void FFindInBlueprintSearchManager::ExportOutdatedAssetList

Source code excerpt:

		for (FSearchData SearchData : SearchArray)
		{
			if ((SearchData.Value.Len() != 0 || SearchData.ImaginaryBlueprint.IsValid()) && SearchData.VersionInfo.FiBDataVersion < EFiBVersion::FIB_VER_LATEST)
			{
				const FString OutdatedEntry = FString::Printf(TEXT("%s\n"), *SearchData.AssetPath.ToString());
				Ar->Serialize(TCHAR_TO_ANSI(*OutdatedEntry), OutdatedEntry.Len());
			}
		}

#Loc: <Workspace>/Engine/Source/Editor/Kismet/Private/FindInBlueprints.cpp:1245

Scope (from outer to inner):

file
function     void SFindInBlueprints::MakeSearchQuery

Source code excerpt:

			if (bHasValidSearchData)
			{
				FImaginaryFiBDataSharedPtr ImaginaryBlueprint(new FImaginaryBlueprint(Blueprint->GetName(), Blueprint->GetPathName(), ParentClass, Interfaces, SearchData.Value, SearchData.VersionInfo));
				TSharedPtr< FFiBSearchInstance > SearchInstance(new FFiBSearchInstance);
				FSearchResult SearchResult = RootSearchResult = SearchInstance->StartSearchQuery(SearchValue, ImaginaryBlueprint);

				if (SearchResult.IsValid())
				{
					ItemsFound = SearchResult->Children;

#Loc: <Workspace>/Engine/Source/Editor/Kismet/Public/FindInBlueprintManager.h:211

Scope: file

Source code excerpt:


	/** Data versioning */
	FSearchDataVersionInfo VersionInfo;

	/** State flags (see enum) */
	ESearchDataStateFlags StateFlags;

	FSearchData()
		: Blueprint(nullptr)

#Loc: <Workspace>/Engine/Source/Runtime/ApplicationCore/Private/Linux/LinuxPlatformSplash.cpp:769

Scope (from outer to inner):

file
function     void FLinuxPlatformSplash::Show

Source code excerpt:

			const FText Version = FText::FromString( FEngineVersion::Current().ToString( FEngineBuildSettings::IsPerforceBuild() ? EVersionComponent::Branch : EVersionComponent::Patch ) );

			FText VersionInfo = FText::Format( NSLOCTEXT( "UnrealEd", "UnrealEdTitleWithVersionNoGameName_F", "Unreal Editor {0}" ), Version );
			AppName = NSLOCTEXT( "UnrealEd", "UnrealEdTitleNoGameName_F", "Unreal Editor" );

			GSplashState->SetSplashText( SplashTextType::VersionInfo1, VersionInfo );
		}

		// Display copyright information in editor splash screen
		{
			const FText CopyrightInfo = NSLOCTEXT( "UnrealEd", "SplashScreen_CopyrightInfo", "Copyright \x00a9   Epic Games, Inc.   All rights reserved." );
			GSplashState->SetSplashText( SplashTextType::CopyrightInfo, CopyrightInfo );

#Loc: <Workspace>/Engine/Source/Runtime/ApplicationCore/Private/Mac/MacPlatformSplash.cpp:212

Scope (from outer to inner):

file
lambda-function

Source code excerpt:

					const FText Version = FText::FromString( FEngineVersion::Current().ToString( FEngineBuildSettings::IsPerforceBuild() ? EVersionComponent::Branch : EVersionComponent::Patch ) );

					FText VersionInfo;
					FText AppName;
					if( GameName.IsEmpty() )
					{
						VersionInfo = FText::Format( NSLOCTEXT( "UnrealEd", "UnrealEdTitleWithVersionNoGameName_F", "Unreal Editor {0}" ), Version );
						AppName = NSLOCTEXT( "UnrealEd", "UnrealEdTitleNoGameName_F", "Unreal Editor" );
						StartSetSplashText( SplashTextType::GameName, AppName);
					}
					else
					{
						VersionInfo = FText::Format( NSLOCTEXT( "UnrealEd", "UnrealEdTitleWithVersionWithGameName_F", "Unreal Editor {0}  -  {1}" ), Version, GameName );
						AppName = FText::Format( NSLOCTEXT( "UnrealEd", "UnrealEdTitle_F", "Unreal Editor - {0}" ), GameName );
					}

					StartSetSplashText( SplashTextType::VersionInfo1, VersionInfo );

					// Change the window text (which will be displayed in the taskbar)
					GSplashScreenAppName = AppName;
				}

				// Display copyright information in editor splash screen

#Loc: <Workspace>/Engine/Source/Runtime/ApplicationCore/Private/Windows/WindowsApplication.cpp:884

Scope (from outer to inner):

file
function     EWindowTitleAlignment::Type FWindowsApplication::GetWindowTitleAlignment

Source code excerpt:

EWindowTitleAlignment::Type FWindowsApplication::GetWindowTitleAlignment() const
{
	OSVERSIONINFOEX VersionInfo;
	FMemory::Memzero(VersionInfo);
	VersionInfo.dwMajorVersion = 6;
	VersionInfo.dwMinorVersion = 2;
	VersionInfo.dwOSVersionInfoSize = sizeof(VersionInfo);

	DWORDLONG LongConditionMask = 0;
	BYTE ConditionMask = VER_GREATER_EQUAL;
	VER_SET_CONDITION(LongConditionMask, VER_MAJORVERSION, ConditionMask);
	VER_SET_CONDITION(LongConditionMask, VER_MINORVERSION, ConditionMask);

	if (::VerifyVersionInfo(&VersionInfo, VER_MAJORVERSION | VER_MINORVERSION, LongConditionMask) != 0)
	{
		return EWindowTitleAlignment::Center;
	}		

	return EWindowTitleAlignment::Left;
}

#Loc: <Workspace>/Engine/Source/Runtime/ApplicationCore/Private/Windows/WindowsPlatformSplash.cpp:667

Scope (from outer to inner):

file
function     void FWindowsPlatformSplash::Show

Source code excerpt:


					FText AppName;
					FText VersionInfo = FText::Format(NSLOCTEXT("UnrealEd", "UnrealEdTitleWithVersion_F", "Unreal Editor {0}"), Version);
					if( GameName.IsEmpty() )
					{
						AppName = NSLOCTEXT( "UnrealEd", "UnrealEdTitleNoGameName_F", "Unreal Editor" );
					}
					else
					{

#Loc: <Workspace>/Engine/Source/Runtime/ApplicationCore/Private/Windows/WindowsPlatformSplash.cpp:678

Scope (from outer to inner):

file
function     void FWindowsPlatformSplash::Show

Source code excerpt:


					StartSetSplashText(SplashTextType::GameName, *AppName.ToString());
					StartSetSplashText(SplashTextType::VersionInfo1, *VersionInfo.ToString());

					// Change the window text (which will be displayed in the taskbar)
					GSplashScreenAppName = AppName;
				}

				// Display copyright information in editor splash screen

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Windows/WindowsPlatformMisc.cpp:4110

Scope (from outer to inner):

file
function     uint64 FWindowsPlatformMisc::GetFileVersion

Source code excerpt:

	if (VersionInfoSize != 0)
	{
		TArray<uint8> VersionInfo;
		VersionInfo.AddUninitialized(VersionInfoSize);
		if (GetFileVersionInfo(*FileName, NULL, VersionInfoSize, VersionInfo.GetData()))
		{
			VS_FIXEDFILEINFO *FileInfo;
			::UINT FileInfoLen;
			if (VerQueryValue(VersionInfo.GetData(), TEXT("\\"), (LPVOID*)&FileInfo, &FileInfoLen))
			{
				return (uint64(FileInfo->dwFileVersionMS) << 32) | uint64(FileInfo->dwFileVersionLS);
			}
		}
	}
	return 0;

#Loc: <Workspace>/Engine/Source/Runtime/CoreUObject/Private/UObject/UObjectBase.cpp:643

Scope (from outer to inner):

file
function     void RegisterCompiledInInfo

Source code excerpt:

	{
		const FClassRegisterCompiledInInfo& Info = ClassInfo[Index];
		RegisterCompiledInInfo(Info.OuterRegister, Info.InnerRegister, PackageName, Info.Name, *Info.Info, Info.VersionInfo);
	}

	for (size_t Index = 0; Index < NumStructInfo; ++Index)
	{
		const FStructRegisterCompiledInInfo& Info = StructInfo[Index];
		RegisterCompiledInInfo(Info.OuterRegister, PackageName, Info.Name, *Info.Info, Info.VersionInfo);
		if (Info.CreateCppStructOps != nullptr)
		{
			UScriptStruct::DeferCppStructOps(FTopLevelAssetPath(FName(PackageName), FName(Info.Name)), (UScriptStruct::ICppStructOps*)Info.CreateCppStructOps());
		}
	}

#Loc: <Workspace>/Engine/Source/Runtime/CoreUObject/Private/UObject/UObjectBase.cpp:659

Scope (from outer to inner):

file
function     void RegisterCompiledInInfo

Source code excerpt:

	{
		const FEnumRegisterCompiledInInfo& Info = EnumInfo[Index];
		RegisterCompiledInInfo(Info.OuterRegister, PackageName, Info.Name, *Info.Info, Info.VersionInfo);
	}
}

/** Register all loaded classes */
void UClassRegisterAllCompiledInClasses()
{

#Loc: <Workspace>/Engine/Source/Runtime/CoreUObject/Public/UObject/ObjectMacros.h:1753

Scope: file

Source code excerpt:


#if WITH_RELOAD
#define CONSTRUCT_RELOAD_VERSION_INFO(VersionInfo, ...) VersionInfo { __VA_ARGS__ }
#else
#define CONSTRUCT_RELOAD_VERSION_INFO(VersionInfo, ...) VersionInfo()
#endif

/*-----------------------------------------------------------------------------
	Class declaration macros.
-----------------------------------------------------------------------------*/

#Loc: <Workspace>/Engine/Source/Runtime/CoreUObject/Public/UObject/UObjectBase.h:355

Scope: file

Source code excerpt:

	const TCHAR* Name;
	FClassRegistrationInfo* Info;
	FClassReloadVersionInfo VersionInfo;
};

/**
 * Adds a class registration and version information. The InInfo parameter must be static.
 */
COREUOBJECT_API void RegisterCompiledInInfo(class UClass* (*InOuterRegister)(), class UClass* (*InInnerRegister)(), const TCHAR* InPackageName, const TCHAR* InName, FClassRegistrationInfo& InInfo, const FClassReloadVersionInfo& InVersionInfo);

#Loc: <Workspace>/Engine/Source/Runtime/CoreUObject/Public/UObject/UObjectBase.h:388

Scope: file

Source code excerpt:

	const TCHAR* Name;
	FStructRegistrationInfo* Info;
	FStructReloadVersionInfo VersionInfo;
};

/**
 * Adds a struct registration and version information. The InInfo parameter must be static.
 */
COREUOBJECT_API void RegisterCompiledInInfo(class UScriptStruct* (*InOuterRegister)(), const TCHAR* InPackageName, const TCHAR* InName, FStructRegistrationInfo& InInfo, const FStructReloadVersionInfo& InVersionInfo);

#Loc: <Workspace>/Engine/Source/Runtime/CoreUObject/Public/UObject/UObjectBase.h:424

Scope: file

Source code excerpt:

	const TCHAR* Name;
	FEnumRegistrationInfo* Info;
	FEnumReloadVersionInfo VersionInfo;
};

/**
 * Adds a static enum registration and version information. The InInfo parameter must be static.
 */
COREUOBJECT_API void RegisterCompiledInInfo(class UEnum* (*InOuterRegister)(), const TCHAR* InPackageName, const TCHAR* InName, FEnumRegistrationInfo& InInfo, const FEnumReloadVersionInfo& InVersionInfo);

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/AudioWaveFormatParser.h:60

Scope: file

Source code excerpt:

	
	// Version information of the format
	uint32 VersionInfo;
	
	// Subformat-specific setting information
	uint8 ConfigData[4];
	
	// Reserved, 0
	uint32 Reserved;

#Loc: <Workspace>/Engine/Source/Runtime/IOS/IOSRuntimeSettings/Classes/IOSRuntimeSettings.h:404

Scope (from outer to inner):

file
class        class UIOSRuntimeSettings : public UObject

Source code excerpt:

	// Specifies the version for the application.
	UPROPERTY(GlobalConfig, EditAnywhere, Category = BundleInformation)
	FString VersionInfo;

	/**
	 * Choose whether to use a custom LaunchScreen.Storyboard as a Launchscreen. To use this option, create a storyboard in Xcode and 
	 * copy it named LaunchScreen.storyboard in Build/IOS/Resources/Interface under your Project folder. This will be compiled and 
	 * copied to the bundle app and the Launch screen image above will not be included in the app.
	 * When using assets in your custom LaunchScreen.storyboard, add them in Build/IOS/Resources/Interface/Assets and they will be included.

#Loc: <Workspace>/Engine/Source/Runtime/IOS/IOSRuntimeSettings/Private/IOSRuntimeSettings.cpp:34

Scope (from outer to inner):

file
function     UIOSRuntimeSettings::UIOSRuntimeSettings

Source code excerpt:

	BundleName = TEXT("MyUnrealGame");
	BundleIdentifier = TEXT("com.YourCompany.GameNameNoSpaces");
	VersionInfo = TEXT("1.0.0");
    FrameRateLock = EPowerUsageFrameRateLock::PUFRL_30;
	bEnableDynamicMaxFPS = false;
	bSupportsIPad = true;
	bSupportsIPhone = true;
	bEnableSplitView = false;
	bEnableSimulatorSupport = false;

#Loc: <Workspace>/Engine/Source/Runtime/NetworkFile/Private/NetworkPlatformFile.cpp:842

Scope (from outer to inner):

file
function     void FNetworkPlatformFile::FillGetFileList

Source code excerpt:

	Payload << ConnectionFlags;

	FString VersionInfo = GetVersionInfo();
	Payload << VersionInfo;

	bool bBindAllDummy;
	TSharedRef<FInternetAddr> HostAddr = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->GetLocalHostAddr(*GLog, bBindAllDummy);
	FString HostAddress = HostAddr->ToString(false);
	Payload << HostAddress;

#Loc: <Workspace>/Engine/Source/Runtime/Online/HTTP/Private/Curl/CurlHttpManager.cpp:145

Scope (from outer to inner):

file
function     void FCurlHttpManager::InitCurl

Source code excerpt:

	if (InitResult == 0)
	{
		curl_version_info_data * VersionInfo = curl_version_info(CURLVERSION_NOW);
		if (VersionInfo)
		{
			UE_LOG(LogInit, Log, TEXT("Using libcurl %s"), ANSI_TO_TCHAR(VersionInfo->version));
			UE_LOG(LogInit, Log, TEXT(" - built for %s"), ANSI_TO_TCHAR(VersionInfo->host));

			if (VersionInfo->features & CURL_VERSION_SSL)
			{
				UE_LOG(LogInit, Log, TEXT(" - supports SSL with %s"), ANSI_TO_TCHAR(VersionInfo->ssl_version));
			}
			else
			{
				// No SSL
				UE_LOG(LogInit, Log, TEXT(" - NO SSL SUPPORT!"));
			}

			if (VersionInfo->features & CURL_VERSION_LIBZ)
			{
				UE_LOG(LogInit, Log, TEXT(" - supports HTTP deflate (compression) using libz %s"), ANSI_TO_TCHAR(VersionInfo->libz_version));
			}

			UE_LOG(LogInit, Log, TEXT(" - other features:"));

#define PrintCurlFeature(Feature)	\
			if (VersionInfo->features & Feature) \

#References in C# build files

This variable is referenced in the following C# build files:

Location: <Workspace>/Engine/Source/Programs/UnrealBuildTool/Platform/IOS/UEDeployIOS.cs:627

			// short version string
			string BundleShortVersion;
			Ini.GetString("/Script/IOSRuntimeSettings.IOSRuntimeSettings", "VersionInfo", out BundleShortVersion);

			// required capabilities (arm64 always required)
			string RequiredCaps = "\t\t<string>arm64</string>\n";

			Ini.GetBool("/Script/IOSRuntimeSettings.IOSRuntimeSettings", "bSupportsMetal", out bSupported);
			RequiredCaps += bSupported ? "\t\t<string>metal</string>\n" : "";

Location: <Workspace>/Engine/Source/Programs/UnrealBuildTool/Platform/IOS/UEDeployIOS.cs:282

			// short version string
			string BundleShortVersion;
			Ini.GetString("/Script/IOSRuntimeSettings.IOSRuntimeSettings", "VersionInfo", out BundleShortVersion);

			// Get Google Support details
			bool bEnableGoogleSupport = true;
			Ini.GetBool("/Script/IOSRuntimeSettings.IOSRuntimeSettings", "bEnableGoogleSupport", out bEnableGoogleSupport);

			// Write the Google iOS URL Scheme if we need it.

Location: <Workspace>/Engine/Source/Programs/UnrealBuildTool/Platform/TVOS/UEDeployTVOS.cs:63

			// short version string
			string BundleShortVersion;
			Ini.GetString("/Script/IOSRuntimeSettings.IOSRuntimeSettings", "VersionInfo", out BundleShortVersion);

			// required capabilities
			string RequiredCaps = "\t\t<string>arm64</string>\n";

			// minimum iOS version
			string MinVersionSetting = "";

Location: <Workspace>/Engine/Source/Programs/UnrealBuildTool/ProjectFiles/Xcode/XcodeProject.cs:1800


				// short version string
				PlatformIni.GetString($"/Script/IOSRuntimeSettings.IOSRuntimeSettings", "VersionInfo", out MarketingVersion);

				if (Platform == UnrealTargetPlatform.IOS)
				{
					bool bEnableSimulatorSupport = false;
					PlatformIni.GetBool("/Script/IOSRuntimeSettings.IOSRuntimeSettings", "bEnableSimulatorSupport", out bEnableSimulatorSupport);