원래는 ULevel이나 ClientTravel 부분부터 상세히 찾아들어가보려 했는데 그러기에 앞서 Level 정보를 담고 있는 FWorldContext의 데이터나 대략적인 변수 용처를 먼저 알고 들어가는 것이 개념 정리에 좋을 것 같아 FWorldContext를 먼저 공부 해보았다.
/** FWorldContext
* A context for dealing with UWorlds at the engine level. As the engine brings up and destroys world, we need a way to keep straight
* what world belongs to what.
*
* WorldContexts can be thought of as a track. By default we have 1 track that we load and unload levels on. Adding a second context is adding
* a second track; another track of progression for worlds to live on.
*
* For the GameEngine, there will be one WorldContext until we decide to support multiple simultaneous worlds.
* For the EditorEngine, there may be one WorldContext for the EditorWorld and one for the PIE World.
*
* FWorldContext provides both a way to manage 'the current PIE UWorld*' as well as state that goes along with connecting/travelling to
* new worlds.
*
* FWorldContext should remain internal to the UEngine classes. Outside code should not keep pointers or try to manage FWorldContexts directly.
* Outside code can still deal with UWorld*, and pass UWorld*s into Engine level functions. The Engine code can look up the relevant context
* for a given UWorld*.
*
* For convenience, FWorldContext can maintain outside pointers to UWorld*s. For example, PIE can tie UWorld* UEditorEngine::PlayWorld to the PIE
* world context. If the PIE UWorld changes, the UEditorEngine::PlayWorld pointer will be automatically updated. This is done with AddRef() and
* SetCurrentWorld().
*
*/
FWorldContext 구조체 선언 위에 적혀 있는 설명 주석입니다.
대략 번역해보면 다음과 같다.
엔진 단위에서 UWorlds를 관리하기 위한 Context
기본적으로 1개를 소지 하고 있다.
World간의 이동 뿐만 아니라 현재 PIE(Play In Editor, 에디터에서 실행하는 경우)의 UWorld까지 관리하는 방안을 제공
반드시 UEngine 내부에서만 접근되어야 하며 외부에서 직접적으로 관리되어서는 안됨.
외부에서는 UWorld*를 사용할 수 있으며 이를 엔진 단위 함수로 전달할 수 있다. 이때 엔진 코드는 주어진 UWorld*와 연관된 WorldContext를 탐색할 수 있다.
편의를 위해 UWorld*의 외부 포인터를 유지할 수 있다. 예를 들어, PIE는 UEditorEngine::PlayWorld 포인터를 PIE WorldContext에 의존시킬 수 있다. 만약 PIE UWorld가 바뀌면, PlayWorld 포인터는 AddRef()와 SeetCurrentWorld()함수로 인해 자동으로 갱신이 된다.
USTRUCT()
struct FWorldContext
{
GENERATED_USTRUCT_BODY()
/**************************************************************/
TEnumAsByte<EWorldType::Type> WorldType;
FSeamlessTravelHandler SeamlessTravelHandler;
FName ContextHandle;
/** URL to travel to for pending client connect */
FString TravelURL;
/** TravelType for pending client connects */
uint8 TravelType;
/** URL the last time we traveled */
UPROPERTY()
struct FURL LastURL;
/** last server we connected to (for "reconnect" command) */
UPROPERTY()
struct FURL LastRemoteURL;
UPROPERTY()
TObjectPtr<UPendingNetGame> PendingNetGame;
/** A list of tag/array pairs that is used at LoadMap time to fully load packages that may be needed for the map/game with DLC, but we can't use DynamicLoadObject to load from the packages */
UPROPERTY()
TArray<struct FFullyLoadedPackagesInfo> PackagesToFullyLoad;
/**
* Array of package/ level names that need to be loaded for the pending map change. First level in that array is
* going to be made a fake persistent one by using ULevelStreamingPersistent.
*/
TArray<FName> LevelsToLoadForPendingMapChange;
/** Array of already loaded levels. The ordering is arbitrary and depends on what is already loaded and such. */
UPROPERTY()
TArray<TObjectPtr<class ULevel>> LoadedLevelsForPendingMapChange;
/** Human readable error string for any failure during a map change request. Empty if there were no failures. */
FString PendingMapChangeFailureDescription;
/** If true, commit map change the next frame. */
uint32 bShouldCommitPendingMapChange:1;
/** Handles to object references; used by the engine to e.g. the prevent objects from being garbage collected. */
UPROPERTY()
TArray<TObjectPtr<class UObjectReferencer>> ObjectReferencers;
UPROPERTY()
TArray<struct FLevelStreamingStatus> PendingLevelStreamingStatusUpdates;
UPROPERTY()
TObjectPtr<class UGameViewportClient> GameViewport;
UPROPERTY()
TObjectPtr<class UGameInstance> OwningGameInstance;
/** A list of active net drivers */
UPROPERTY(transient)
TArray<FNamedNetDriver> ActiveNetDrivers;
/** The PIE instance of this world, -1 is default */
int32 PIEInstance;
/** The Prefix in front of PIE level names, empty is default */
FString PIEPrefix;
/** The feature level that PIE world should use */
ERHIFeatureLevel::Type PIEWorldFeatureLevel;
/** Is this running as a dedicated server */
bool RunAsDedicated;
/** Is this world context waiting for an online login to complete (for PIE) */
bool bWaitingOnOnlineSubsystem;
/** Handle to this world context's audio device.*/
uint32 AudioDeviceID;
/** Custom description to be display in blueprint debugger UI */
FString CustomDescription;
// If > 0, tick this world at a fixed rate in PIE
float PIEFixedTickSeconds = 0.f;
float PIEAccumulatedTickSeconds = 0.f;
/**************************************************************/
/** Outside pointers to CurrentWorld that should be kept in sync if current world changes */
TArray<UWorld**> ExternalReferences;
/** Adds an external reference */
void AddRef(UWorld*& WorldPtr)
{
WorldPtr = ThisCurrentWorld;
ExternalReferences.AddUnique(&WorldPtr);
}
/** Removes an external reference */
void RemoveRef(UWorld*& WorldPtr)
{
ExternalReferences.Remove(&WorldPtr);
WorldPtr = nullptr;
}
/** Set CurrentWorld and update external reference pointers to reflect this*/
ENGINE_API void SetCurrentWorld(UWorld *World);
/** Collect FWorldContext references for garbage collection */
void AddReferencedObjects(FReferenceCollector& Collector, const UObject* ReferencingObject);
FORCEINLINE UWorld* World() const
{
return ThisCurrentWorld;
}
FWorldContext()
: WorldType(EWorldType::None)
, ContextHandle(NAME_None)
, TravelURL()
, TravelType(0)
, PendingNetGame(nullptr)
, bShouldCommitPendingMapChange(0)
, GameViewport(nullptr)
, OwningGameInstance(nullptr)
, PIEInstance(INDEX_NONE)
, PIEWorldFeatureLevel(ERHIFeatureLevel::Num)
, RunAsDedicated(false)
, bWaitingOnOnlineSubsystem(false)
, AudioDeviceID(INDEX_NONE)
, ThisCurrentWorld(nullptr)
{ }
private:
UWorld* ThisCurrentWorld;
};
WorldType
WorldType은 현재 World가 어떤 케이스인지 지칭한다.
타입인 EWorldType은 다음과 같다.
/** Specifies the goal/source of a UWorld object */
namespace EWorldType
{
enum Type
{
/** An untyped world, in most cases this will be the vestigial worlds of streamed in sub-levels */
None,
/** The game world */
Game,
/** A world being edited in the editor */
Editor,
/** A Play In Editor world */
PIE,
/** A preview world for an editor tool */
EditorPreview,
/** A preview world for a game */
GamePreview,
/** A minimal RPC world for a game */
GameRPC,
/** An editor world that was loaded but not currently being edited in the level editor */
Inactive
};
}
여기서 잘 모르는 것이 몇 있다.
Preview가 붙은 것은 오브젝트나 머테리얼에서 미리보기를 하는 World들을 지칭한다.
TRAVEL_Partial의 의미를 유추할 수 있는 코드 부분은 UEngine::HandleDisconnect이다.
void UEngine::HandleDisconnect( UWorld *InWorld, UNetDriver *NetDriver )
{
// There must be some context for this disconnect
check(InWorld || NetDriver);
// If the NetDriver that failed was a pending netgame driver, cancel the PendingNetGame
CancelPending(NetDriver);
// InWorld might be null. It might also not map to any valid world context (for example, a pending net game disconnect)
// If there is a context for this world, setup client travel.
if (FWorldContext* WorldContext = GetWorldContextFromWorld(InWorld))
{
// Remove ?Listen parameter, if it exists
WorldContext->LastURL.RemoveOption( TEXT("Listen") );
WorldContext->LastURL.RemoveOption( TEXT("LAN") );
// Net driver destruction will occur during LoadMap (prevents GetNetMode from changing output for the remainder of the frame)
SetClientTravel( InWorld, TEXT("?closed"), TRAVEL_Absolute );
}
else if (NetDriver)
{
// Shut down any existing game connections
if (InWorld)
{
// Call this to remove the NetDriver from the world context's ActiveNetDriver list
DestroyNamedNetDriver(InWorld, NetDriver->NetDriverName);
}
else
{
NetDriver->Shutdown();
NetDriver->LowLevelDestroy();
// In this case, the world is null and something went wrong, so we should travel back to the default world so that we
// can get back to a good state.
for (FWorldContext& PotentialWorldContext : WorldList)
{
if (PotentialWorldContext.WorldType == EWorldType::Game)
{
FURL DefaultURL;
DefaultURL.LoadURLConfig(TEXT("DefaultPlayer"), GGameIni);
const UGameMapsSettings* GameMapsSettings = GetDefault<UGameMapsSettings>();
if (GameMapsSettings)
{
PotentialWorldContext.TravelURL = FURL(&DefaultURL, *(GameMapsSettings->GetGameDefaultMap() + GameMapsSettings->LocalMapOptions), TRAVEL_Partial).ToString();
PotentialWorldContext.TravelType = TRAVEL_Partial;
}
}
}
}
}
}
마지막 부분을 보면 주석으로 "무언가 잘못 되었을 때 이전 World로 되돌린다"는 설명이 되어있다.
그리고 이 때 TravelType은 TRAVEL_Partial로 지정되어 있다.
이를 통해 TRAVEL_Partial은 일부 정보만 리셋하는 것으로 예상해볼 수 있다.
실제 도큐먼트에서도 carry name, reset server로 기재가 되어있기도 하구 말이다.
LastURL
가장 마지막에 접근했던 Level의 URL이다.
LastRemoteURL
가장 마지막에 connect 했던 Level의 URL이다.
일반적으로는 사용하지 않지만 reconnect를 할 때에는 이 값을 저장한다.
PendingNetGame
이 변수에 대해서는 이렇다 할 정보를 찾지 못했다.
우선 UPendingNetGame 타입이라 별도 클래스이므로 나중에 추가로 확인해보도록 하겠다.
