UserGameSettings.h

이 파일의 문서화 페이지로 가기

// Fill out your copyright notice in the Description page of Project Settings.
 
#pragma once
 
#include "CoreMinimal.h"
#include "CK_UE.h"
#include "Blueprint/UserWidget.h"
#include "Data/Settings/EUserGameSettingHeader.h"
#include "Engine/DeveloperSettings.h"
#include "StructUtils/InstancedStruct.h"
#include "UserGameSettings.generated.h"
 
 
class USettingFieldWidget;
class UGameInstance;
class UUserGameSettings;
struct FGlobalUserSettingsRuntime;
struct FDropdownSettingsOptionBase;
struct FSettingsBase;
 
 
#pragma region SettingProcessor
 
USTRUCT(BlueprintType)
struct FSettingProcessor
{
    GENERATED_BODY()
 
public:
    virtual ~FSettingProcessor() = default;
 
public:
    virtual void ApplySettings(const FSettingsBase& Settings, const UUserGameSettings* RuntimeSettings, UGameInstance* GameInstance) const;
 
protected:
    static FGlobalUserSettingsRuntime GetCurrentGlobalUserSettingsRuntime();
    static void SetGlobalUserSettingsRuntime(const FGlobalUserSettingsRuntime& Runtime);
};
 
USTRUCT(BlueprintType)
struct FResolutionSettingProcessor : public FSettingProcessor
{
    GENERATED_BODY()
 
public:
    virtual void ApplySettings(const FSettingsBase& Settings, const UUserGameSettings* RuntimeSettings, UGameInstance* GameInstance) const override;
};
 
USTRUCT(BlueprintType)
struct FWindowModeSettingProcessor : public FSettingProcessor
{
    GENERATED_BODY()
 
public:
    virtual void ApplySettings(const FSettingsBase& Settings, const UUserGameSettings* RuntimeSettings, UGameInstance* GameInstance) const override;
};
 
USTRUCT(BlueprintType)
struct FVSyncSettingProcessor : public FSettingProcessor
{
    GENERATED_BODY()
 
public:
    virtual void ApplySettings(const FSettingsBase& Settings, const UUserGameSettings* RuntimeSettings, UGameInstance* GameInstance) const override;
};
 
USTRUCT(BlueprintType)
struct FFrameRateLimitSettingProcessor : public FSettingProcessor
{
    GENERATED_BODY()
 
public:
    virtual void ApplySettings(const FSettingsBase& Settings, const UUserGameSettings* RuntimeSettings, UGameInstance* GameInstance) const override;
};
 
USTRUCT(BlueprintType)
struct FAudioVolumeSettingProcessor : public FSettingProcessor
{
    GENERATED_BODY()
 
public:
    virtual void ApplySettings(const FSettingsBase& Settings, const UUserGameSettings* RuntimeSettings, UGameInstance* GameInstance) const override;
};
 
USTRUCT(BlueprintType)
struct FInvertYAxisSettingProcessor : public FSettingProcessor
{
    GENERATED_BODY()
 
public:
    virtual void ApplySettings(const FSettingsBase& Settings, const UUserGameSettings* RuntimeSettings, UGameInstance* GameInstance) const override;
};
 
USTRUCT(BlueprintType)
struct FMouseXSensitivitySettingProcessor : public FSettingProcessor
{
    GENERATED_BODY()
 
public:
    virtual void ApplySettings(const FSettingsBase& Settings, const UUserGameSettings* RuntimeSettings, UGameInstance* GameInstance) const override;
};
 
USTRUCT(BlueprintType)
struct FMouseYSensitivitySettingProcessor : public FSettingProcessor
{
    GENERATED_BODY()
 
public:
    virtual void ApplySettings(const FSettingsBase& Settings, const UUserGameSettings* RuntimeSettings, UGameInstance* GameInstance) const override;
};
 
#pragma endregion
 
 
#pragma region SettingValue
 
USTRUCT(BlueprintType)
struct FSettingValue
{
    GENERATED_BODY()
};
 
USTRUCT(BlueprintType)
struct FSettingValueBool : public FSettingValue
{
    GENERATED_BODY()
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, SaveGame, Category = "Value")
    bool bValue = false;
};
 
USTRUCT(BlueprintType)
struct FSettingValueInt : public FSettingValue
{
    GENERATED_BODY()
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, SaveGame, Category = "Value")
    int32 Value = 0;
};
 
USTRUCT(BlueprintType)
struct FSettingValueFloat : public FSettingValue
{
    GENERATED_BODY()
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, SaveGame, Category = "Value")
    float Value = 0.0f;
};
 
USTRUCT(BlueprintType)
struct FSettingValueString : public FSettingValue
{
    GENERATED_BODY()
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, SaveGame, Category = "Value")
    FString Value = FString();
};
 
#pragma endregion
 
 
#pragma region Settings
 
USTRUCT(BlueprintType)
struct FSettingsBase
{
    GENERATED_BODY()
 
public:
    virtual ~FSettingsBase() = default;
 
public:
    virtual void CopySettings(FSettingsBase* OtherSetting);
    virtual const UScriptStruct* GetSettingsStruct() const;
    virtual FInstancedStruct GetSettingValue() const;
    virtual void SetSettingValue(const FInstancedStruct& SettingValue);
    virtual void ApplySettings(const UUserGameSettings* RuntimeSettings, UGameInstance* GameInstance) const;
 
public:
    template <typename T>
    static T* CastSetting(FSettingsBase* OtherSetting);
 
    template <typename T>
    static const T* CastSetting(const FSettingsBase* OtherSetting);
 
public:
    bool operator==(const FSettingsBase& Other) const;
    bool operator!=(const FSettingsBase& Other) const;
 
protected:
    static void CopyBaseSetting(const FSettingsBase& Source, FSettingsBase& Target);
 
public:
    UPROPERTY(EditAnywhere, Category = "Settings")
    FText Label = FText::GetEmpty();
 
    UPROPERTY(EditAnywhere, Category = "Settings")
    FText Tooltip = FText::GetEmpty();
 
    UPROPERTY(EditAnywhere, Category = "Settings")
    bool bAllowImmediateApply = false;
 
    UPROPERTY(EditAnywhere, Category = "Settings", meta = (BaseStruct = "/Script/CK_UE.SettingProcessor", ExcludeBaseStruct))
    FInstancedStruct SettingProcessor;
 
public:
    static const FSettingsBase None;
};
 
 
USTRUCT(BlueprintType)
struct FMinMaxSliderSettings : public FSettingsBase
{
    GENERATED_BODY()
 
public:
    virtual const UScriptStruct* GetSettingsStruct() const override;
    virtual void CopySettings(FSettingsBase* OtherSetting) override;
    virtual FInstancedStruct GetSettingValue() const override;
    virtual void SetSettingValue(const FInstancedStruct& SettingValue) override;
 
public:
    UPROPERTY(EditAnywhere, Category = "Settings")
    float Min = 0.0f;
 
    UPROPERTY(EditAnywhere, Category = "Settings")
    float Max = 1.0f;
 
    UPROPERTY(EditAnywhere, Category = "Settings")
    float InitialValue = 0.0f;
 
    UPROPERTY()
    float CurrentValue = 0.0f;
};
 
 
USTRUCT(BlueprintType)
struct FToggleSettings : public FSettingsBase
{
    GENERATED_BODY()
 
public:
    virtual const UScriptStruct* GetSettingsStruct() const override;
    virtual void CopySettings(FSettingsBase* OtherSetting) override;
    virtual FInstancedStruct GetSettingValue() const override;
    virtual void SetSettingValue(const FInstancedStruct& SettingValue) override;
 
public:
    UPROPERTY(EditAnywhere, Category = "Settings")
    bool bDefaultValue = false;
 
    UPROPERTY(EditAnywhere, Category = "Settings")
    bool bInitialValue = 0.0f;
 
    UPROPERTY()
    bool bIsToggled = false;
};
 
 
USTRUCT(BlueprintType)
struct FDropdownSettings : public FSettingsBase
{
    GENERATED_BODY()
 
public:
    virtual const UScriptStruct* GetSettingsStruct() const override;
    virtual void CopySettings(FSettingsBase* OtherSetting) override;
    virtual FInstancedStruct GetSettingValue() const override;
    virtual void SetSettingValue(const FInstancedStruct& SettingValue) override;
 
public:
    template <typename TDropdownOption>
    const FName& GetKeyByValue(const TDropdownOption& Value) const;
 
    template <typename TDropdownOption>
    const TDropdownOption& GetOptions() const;
 
    template <typename TDropdownOption>
    const TDropdownOption& GetOptions(const FName& Key) const;
 
    FName GetSelectionKey() const;
    bool HasValidSelection() const;
 
public:
    UPROPERTY(EditAnywhere, Category = "Settings", meta = (BaseStruct = "/Script/CK_UE.DropdownSettingsOptionBase", ExcludeBaseStruct))
    TMap<FName, FInstancedStruct> DropdownOptions;
    
    UPROPERTY(EditAnywhere, Category = "Settings")
    FName InitialKey = NAME_None;
 
    UPROPERTY(Transient)
    FName SelectedKey = NAME_None;
};
 
 
USTRUCT(BlueprintType)
struct FDropdownSettingsOptionBase
{
    GENERATED_BODY()
 
public:
    UPROPERTY(EditAnywhere, Category = "Settings")
    FText Tooltip = FText::GetEmpty();
};
 
 
USTRUCT(BlueprintType)
struct FDropdownSettingIntOption : public FDropdownSettingsOptionBase
{
    GENERATED_BODY()
 
public:
    UPROPERTY(EditAnywhere, Category = "Settings")
    mutable int32 Value = 0.0f;
};
 
 
USTRUCT(BlueprintType, DisplayName="Dropdown Setting IntPair Option")
struct FDropdownSettingIntPairOption : public FDropdownSettingsOptionBase
{
    GENERATED_BODY()
 
public:
    UPROPERTY(EditAnywhere, Category = "Settings")
    mutable FIntPoint Value = FIntPoint();
};
 
 
USTRUCT(BlueprintType)
struct FDropdownSettingFloatOption : public FDropdownSettingsOptionBase
{
    GENERATED_BODY()
 
public:
    UPROPERTY(EditAnywhere, Category = "Settings")
    mutable float Value = 0.0f;
};
 
 
USTRUCT(BlueprintType, DisplayName = "Dropdown Setting UClass Option")
struct FDropdownSettingUClassOption : public FDropdownSettingsOptionBase
{
    GENERATED_BODY()
 
public:
    UPROPERTY(EditAnywhere, Category = "Settings")
    mutable TSubclassOf<UObject> ObjectClass;
};
 
#pragma endregion
 
 
UCLASS(Config=Game, DefaultConfig, Blueprintable, BlueprintType, meta=(DisplayName="User Game Settings"))
class CK_UE_API UUserGameSettings : public UDeveloperSettings
{
    GENERATED_BODY()
 
public:
    const TMap<EUserGameSetting, FInstancedStruct> GetSettings(const EUserGameSettingCategory Category) const;
 
public:
    FORCEINLINE const TMap<EUserGameSetting, FInstancedStruct>& GetSettings() const
    {
        return Settings;
    }
 
    FORCEINLINE TMap<EUserGameSetting, FInstancedStruct>& GetMutableSettings()
    {
        return Settings;
    }
    
    FORCEINLINE virtual FName GetCategoryName() const override
    {
        return TEXT("CK_UE");
    }
 
public:
    template <typename T>
    T GetSettingOption(EUserGameSetting SettingType) const;
 
    template <typename T>
    T* GetMutableSettingOption(EUserGameSetting SettingType);
 
    template <typename TFieldWidget>
    TSubclassOf<TFieldWidget> GetSettingFieldWidgetClass() const;
 
protected:
    UPROPERTY(Config, EditAnywhere, BlueprintReadWrite, Category = "Settings", meta = (BaseStruct = "/Script/CK_UE.SettingsBase", ExcludeBaseStruct))
    TMap<EUserGameSetting, FInstancedStruct> Settings;
 
protected:
    UPROPERTY(Config, EditAnywhere, BlueprintReadOnly, Category = "WidgetClass", meta = (BlueprintBaseOnly))
    TSet<TSubclassOf<USettingFieldWidget>> SettingFieldWidgetClass;
};
 
 
#pragma region Templates
 
template <typename T>
T UUserGameSettings::GetSettingOption(const EUserGameSetting SettingType) const
{
    const FInstancedStruct* SettingStruct = Settings.Find(SettingType);
 
    if (SettingStruct == nullptr)
    {
        return T();
    }
 
    const T* Setting = SettingStruct->GetPtr<T>();
 
    if (Setting == nullptr)
    {
        return T();
    }
 
    return *Setting;
}
 
template <typename T>
T* UUserGameSettings::GetMutableSettingOption(const EUserGameSetting SettingType)
{
    FInstancedStruct* SettingStruct = Settings.Find(SettingType);
 
    if (SettingStruct == nullptr)
    {
        return nullptr;
    }
 
    return SettingStruct->GetMutablePtr<T>();
}
 
template <typename TFieldWidget>
TSubclassOf<TFieldWidget> UUserGameSettings::GetSettingFieldWidgetClass() const
{
    static_assert(TIsDerivedFrom<TFieldWidget, UUserWidget>::IsDerived, "TFieldWidget은 UUserWidget을 상속해야 합니다.");
 
    auto Result = Algo::FindByPredicate(SettingFieldWidgetClass, [](const TSubclassOf<USettingFieldWidget>& WidgetClass)
    {
        return WidgetClass && WidgetClass->IsChildOf(TFieldWidget::StaticClass());
    });
 
    if (Result && *Result)
    {
        return (*Result).Get();
    }
    else
    {
        LOG_ERROR(LogCK, "위젯 클래스가 정상적으로 설정되지 않은 것 같습니다.");
        return nullptr;
    }
}
 
template <typename T>
T* FSettingsBase::CastSetting(FSettingsBase* OtherSetting)
{
    if (OtherSetting == nullptr)
    {
        return nullptr;
    }
 
    if (OtherSetting->GetSettingsStruct() != T::StaticStruct())
    {
        return nullptr;
    }
 
    return static_cast<T*>(OtherSetting);
}
 
template <typename T>
const T* FSettingsBase::CastSetting(const FSettingsBase* OtherSetting)
{
    if (OtherSetting == nullptr)
    {
        return nullptr;
    }
 
    if (OtherSetting->GetSettingsStruct() != T::StaticStruct())
    {
        return nullptr;
    }
 
    return static_cast<const T*>(OtherSetting);
}
 
template <typename TDropdownOption>
const FName& FDropdownSettings::GetKeyByValue(const TDropdownOption& Value) const
{
    for (const TPair<FName, FInstancedStruct>& DropdownOption : DropdownOptions)
    {
        const TDropdownOption* Option = DropdownOption.Value.GetPtr<TDropdownOption>();
 
        if (Option && Option->Value == Value.Value)
        {
            return DropdownOption.Key;
        }
    }
 
    static const FName DefaultKey = NAME_None;
    return DefaultKey;
}
 
template <typename TDropdownOption>
const TDropdownOption& FDropdownSettings::GetOptions() const
{
    for (const TPair<FName, FInstancedStruct>& DropdownOption : DropdownOptions)
    {
        const TDropdownOption* Option = DropdownOption.Value.GetPtr<TDropdownOption>();
 
        if (Option)
        {
            return *Option;
        }
    }
 
    static const TDropdownOption EmptyOption;
    return EmptyOption;
}
 
template <typename TDropdownOption>
const TDropdownOption& FDropdownSettings::GetOptions(const FName& Key) const
{
    const FInstancedStruct* Value = DropdownOptions.Find(Key);
    if (Value == nullptr)
    {
        static const TDropdownOption EmptyOption;
        return EmptyOption;
    }
 
    const TDropdownOption* Option = Value->GetPtr<TDropdownOption>();
    if (Option)
    {
        return *Option;
    }
 
    static const TDropdownOption EmptyOption;
    return EmptyOption;
}
 
#pragma endregion