UGameInstanceSubsystem

GameInstance의 서브 시스템은 UGameInstanceSubsystem 클래스가 있다.
다른 서브 시스템도 있지만 여기서는 UGameInstanceSubsystem만 알아 본다.

UGameInstanceSubsystem를 다음과 같이 상속 했을때 동작은 다음과 같다.
class UMyGamesSubsystem : public UGameInstanceSubsystem

UGameInstance 생성 이후, UMyGamesSubsystem 라는 인스턴스 역시 생성된다.
UGameInstance 초기화 시, 서브시스템에서 Initialize() 가 호출된다.
UGameInstance 종료 시, 서브시스템에서 Deinitialize() 가 호출된다.
이 시점에서 서브시스템에 대한 참조가 삭제되고 더이상 참조가 없으면 서브시스템은 가비지 컬렉션 된다.

서브시스템을 사용하는 이유

프로그래밍 시간이 절약된다.
엔진 클래스 오버라이드를 피할 수 있다.
이미 바쁜 클래스에 API 추가를 피할 수 있다.
사용자에게 친숙한 유형의 노드를 통해 블루프린트로 액세스할 수 있다.
에디터 스크립팅이나 테스트 코드 작성을 위해 Python 스크립트에 액세스할 수 있다.
코드베이스의 모듈성과 일관성을 제공한다.

이하 자세한 개념 설명 보다는 팁의 예제에 대해서 보여준다.
UGameInstanceSubsystem를 상속만 해도 GameInstance의 서브로 자동으로 등록이 된다.

종속 순서 정하기

UGameInstanceSubsystem을 상속한 여러개의 클래스가 있을때 종속 순서를 정해 보자.
종속 순서는 Collection.InitializeDependency 함수로 정한다.
MySecondInstance -> MyFirstInstance 순서로 생성 되도록 설정하는 코드이다.

MyFirstInstance.h

#pragma once

#include "CoreMinimal.h"
#include "Subsystems/GameInstanceSubsystem.h"
#include "MyFirstInstance.generated.h"

UCLASS()
class UMGLISTVIEWDEMO_API UMyFirstInstance : public UGameInstanceSubsystem
{
    GENERATED_BODY()

public:
    virtual void Initialize(FSubsystemCollectionBase& Collection) override;
    virtual void Deinitialize() override;
};

MyFirstInstance.cpp

#include "MyFirstInstance.h"
#include "MySecondInstance.h"
#include "Subsystems/SubsystemCollection.h"

void UMyFirstInstance::Initialize(FSubsystemCollectionBase& Collection)
{
    Collection.InitializeDependency(UMySecondInstance::StaticClass());
    UE_LOG(LogTemp, Warning, TEXT("%s"), *FString(__FUNCTION__));
}

void UMyFirstInstance::Deinitialize()
{
    UE_LOG(LogTemp, Warning, TEXT("%s"), *FString(__FUNCTION__));
}

MySecondInstance.h

#pragma once

#include "CoreMinimal.h"
#include "Subsystems/GameInstanceSubsystem.h"
#include "MySecondInstance.generated.h"

UCLASS()
class UMGLISTVIEWDEMO_API UMySecondInstance : public UGameInstanceSubsystem
{
    GENERATED_BODY()
public:
    virtual void Initialize(FSubsystemCollectionBase& Collection) override;
    virtual void Deinitialize() override;
};

MySecondInstance.cpp

#include "MySecondInstance.h"

void UMySecondInstance::Initialize(FSubsystemCollectionBase& Collection)
{
UE_LOG(LogTemp, Warning, TEXT("%s"), *FString(__FUNCTION__));
}

void UMySecondInstance::Deinitialize()
{
UE_LOG(LogTemp, Warning, TEXT("%s"), *FString(__FUNCTION__));
}

void AUmgListViewDemoGameModeBase::StartPlay()
{
    if (GetWorld() == nullptr)
        return;
    UMyFirstInstance* FirstInstance = GetWorld()->GetGameInstance()->GetSubsystem<UMyFirstInstance>();
}

AGameModeBase를 상속한 클래스에서 UMyFirstInstance 클래스를 얻어오고 있다.

UGameInstanceSubsystem 상속하여 가상 함수 사용하기

UMySubSystem 클래스를 상속하여 가상 함수로 여러개의 GameInstanceSubsystem을 사용해 보자.
UGameInstanceSubsystem은 C++ 순수 가상 함수를 지원하지 않는다.

추상 클래스로 다음과 같이 지정 한다.
UCLASS(Abstract, Blueprintable, BlueprintType)
class UMGLISTVIEWDEMO_API UMySubSystem : public UGameInstanceSubsystem

PURE_VIRTUAL로 순수 가상 함수 처럼 사용하기

MySubSystem.h의 UMySubSystem 클래스에서 순수 가상함수와 같이 사용하기 위해서 PURE_VIRTUAL를 선언한다.
UFUNCTION(BlueprintCallable, Category = "BaseInstance")
virtual FString GetBaseName() PURE_VIRTUAL(UMySubSystem::GetBaseName, return TEXT(""););

UMySubSystem을 상속한다 클래스는 MyInstanceOne, MyInstanceTwo가 있다.
PURE_VIRTUAL을 상속한 GetBaseName은 virtual, override를 붙이지 않아도 잘 동작한다.

상속 했을때 GetBaseName을 정의 하지 않으면 컴파일 에러가 안뜬다.
GetBaseName을 정의 하지 않으면 런타임에 에러가 발생한다.

그냥 가상 함수로 사용

PURE_VIRTUAL 사용시 게임 실행중 죽는게 싫다면 그냥 가상 함수를 사용해야 한다.

그냥 가상 함수로 사용할때는 가상 함수를 선언 하면 된다.
    UFUNCTION(BlueprintCallable, Category = "BaseInstance")
    virtual FString GetBaseName() { return TEXT(""); }

상속한 자식에서는 다음과 같이 선언 한다.
    virtual FString GetBaseName() override
    {
        return TEXT("UMyInstanceOne");
    }

GetBaseName을 오브라이팅 하지 않아도 죽지 않는다.
여러개의 GameInstanceSubsystem을 얻어 올때는 GetSubsystemArray 함수로 얻어온다.

UMySubSystem.h

#pragma once

#include "CoreMinimal.h"
#include "Subsystems/GameInstanceSubsystem.h"
#include "MySubSystem.generated.h"

//UCLASS(abstract)
UCLASS(Abstract, Blueprintable, BlueprintType)
class UMGLISTVIEWDEMO_API UMySubSystem : public UGameInstanceSubsystem
{
    GENERATED_BODY()

public:
    int GetValue();
    void SetValue(int v);

#if 1
    UFUNCTION(BlueprintCallable, Category = "BaseInstance")
    virtual FString GetBaseName() PURE_VIRTUAL(UMySubSystem::GetBaseName, return TEXT(""););
#else
    //그냥 가상 함수로 사용
    UFUNCTION(BlueprintCallable, Category = "BaseInstance")
    virtual FString GetBaseName() { return TEXT(""); };
#endif

protected:
    int Value = 3;
};

UMySubSystem.cpp

#include "MySubSystem.h"

int UMySubSystem::GetValue()
{
return Value;
}

void UMySubSystem::SetValue(int v)
{
Value = v;
}

MyInstanceOne.h

#pragma once

#include "CoreMinimal.h"
#include "MySubSystem.h"
#include "MyInstanceOne.generated.h"

UCLASS()
class UMGLISTVIEWDEMO_API UMyInstanceOne : public UMySubSystem
{
    GENERATED_BODY()

public:
    virtual void Initialize(FSubsystemCollectionBase& Collection) override;
    virtual void Deinitialize() override;

#if 1
    FString GetBaseName()
    {
        return TEXT("UMyInstanceOne");
    }
#else
    //그냥 가상 함수로 사용
    virtual FString GetBaseName() override
    {
        return TEXT("UMyInstanceOne");
    }
#endif
};

MyInstanceOne.cpp

#include "MyInstanceOne.h"

void UMyInstanceOne::Initialize(FSubsystemCollectionBase& Collection)
{
UE_LOG(LogTemp, Warning, TEXT("%s"), *FString(__FUNCTION__));
}

void UMyInstanceOne::Deinitialize()
{
UE_LOG(LogTemp, Warning, TEXT("%s"), *FString(__FUNCTION__));
}

MyInstanceTwo.h

#pragma once

#include "CoreMinimal.h"
#include "MySubSystem.h"
#include "MyInstanceTwo.generated.h"

UCLASS()
class UMGLISTVIEWDEMO_API UMyInstanceTwo : public UMySubSystem
{
    GENERATED_BODY()

public:
    virtual void Initialize(FSubsystemCollectionBase& Collection) override;
    virtual void Deinitialize() override;

#if 1
    FString GetBaseName()
    {
        return TEXT("UMyInstanceTwo");
    }
#else
    //그냥 가상 함수로 사용
    virtual FString GetBaseName() override
    {
        return TEXT("UMyInstanceTwo");
    }
#endif
};

MyInstanceTwo.cpp

#include "MyInstanceTwo.h"

void UMyInstanceTwo::Initialize(FSubsystemCollectionBase& Collection)
{
UE_LOG(LogTemp, Warning, TEXT("%s"), *FString(__FUNCTION__));
}

void UMyInstanceTwo::Deinitialize()
{
UE_LOG(LogTemp, Warning, TEXT("%s"), *FString(__FUNCTION__));
}

여러개의 인스턴스를 가상함수로 실행

    const TArray<UMySubSystem*>& InstList = GetWorld()->GetGameInstance()->GetSubsystemArray<UMySubSystem>();
    for (UMySubSystem* Item : InstList)
    {
        FString BaseName = Item->GetBaseName();
        UE_LOG(LogTemp, Warning, TEXT("GetBaseName : %s"), *BaseName);
    }

참조)
https://docs.unrealengine.com/4.26/ko/ProgrammingAndScripting/Subsystems/
https://www.brightdevelopers.com/unreal-engine-4-c-polymorphism-overview/
http://compacttutorial.blogspot.com/2015/04/unreal-engine-4-pure-virtual-functions.html
https://www.cnblogs.com/shiroe/p/14819721.html
https://jhtop0419.tistory.com/67?category=944635