graphic settings wip

UnrealProject/Lost_Edge/Config/DefaultGameUserSettings.ini

@@ -3,6 +3,11 @@ bUseMotionBlur=False
 bShowFps=False
 bMouseInverted=False
 fMouseSensetivity=1.000000
+fMasterVolume=0.500000
+fMusicVolume=1.000000
+fEffectsVolume=1.000000
+fVoicesVolume=1.000000
+fMenuVolume=1.000000
 bUseVSync=False
 bUseDynamicResolution=False
 ResolutionSizeX=1920

UnrealProject/Lost_Edge/Source/Lost_Edge/Lost_Edge.Build.cs

@@ -2,14 +2,16 @@
 
 using UnrealBuildTool;
 
-public class Lost_Edge : ModuleRules {
+public class Lost_Edge : ModuleRules
-    public Lost_Edge(ReadOnlyTargetRules Target) : base(Target) {
+{
+    public Lost_Edge(ReadOnlyTargetRules Target) : base(Target)
+    {
         PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
 
         PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "OpenCV" });
 
         PrivateDependencyModuleNames.AddRange(new string[] { "EnhancedInput", "UMG", "RHI", "RenderCore", "Lost_EdgeShaders", "PakFile", //"TextureCompressor",
-            "LevelSequence", "MovieScene", "HTTP", "Json" }); // "Slate", "SlateCore"
+            "LevelSequence", "MovieScene", "HTTP", "Json", "ApplicationCore" }); // "Slate", "SlateCore"
 
         // UE_LOG(LogTemp, Log, TEXT("capture: %s"), (capture ? TEXT("true") : TEXT("false")));
         // GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Yellow, TEXT("1"));

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/CommonFunctions.cpp

@@ -29,6 +29,16 @@ FText UCommonFunctions::GetKeyDisplayName(FKey key)
     return key.GetDisplayName(false);
 }
 
+int32 UCommonFunctions::StringIndexInTextArray(const TArray<FText>& array, const FString& value)
+{
+    FString v = value.ToLower();
+    for(int32 i = 0; i < array.Num(); ++i)
+        if(FTextInspector::GetSourceString(array[i])->ToLower().Equals(v))
+            return i;
+
+    return -1;
+}
+
 void UCommonFunctions::DestroyActorRecursively(AActor* actor)
 {
     TArray<AActor*> childs;

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/CommonFunctions.h

@@ -25,6 +25,9 @@ public:
     UFUNCTION(BlueprintPure)
     static FText GetKeyDisplayName(struct FKey key);
 
+    UFUNCTION(BlueprintPure)
+    static int32 StringIndexInTextArray(const TArray<FText>& array, const FString& value);
+
     /** Recursively destroy actor and all its childs (the default Destroy doesn't have consistent behavior) */
     UFUNCTION(BlueprintCallable, Category = Actor)
     static void DestroyActorRecursively(class AActor* actor);

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/CustomGameInstance.cpp

@@ -6,10 +6,17 @@
 #include "Kismet/KismetSystemLibrary.h"
 
 #include "ContentLoader.h"
+#include "CustomGameSettings.h"
 #include "Levels/LevelBase.h"
 #include "PlayerBase.h"
 #include "SaveData.h"
 
+namespace
+{
+    constexpr auto saveName = TEXT("Save");
+    constexpr int32 saveIndex = 0;
+}
+
 UCustomGameInstance* UCustomGameInstance::instance = nullptr;
 
 void UCustomGameInstance::Init()
@@ -17,8 +24,28 @@ void UCustomGameInstance::Init()
     UGameInstance::Init();
 
     instance = this;
+
     contentLoader = NewObject<UContentLoader>(this);
-    saveData = Cast<USaveData>(UGameplayStatics::CreateSaveGameObject(USaveData::StaticClass()));
+    for(auto& _class : globalInstancesClasses)
+    {
+        UObject* gi = NewObject<UObject>(_class);
+        gi->AddToRoot();
+        globalInstances.Add(_class.Get(), gi);
+    }
+    globalInstancesClasses.Empty();
+
+    if(auto save = UGameplayStatics::LoadGameFromSlot(saveName, saveIndex))
+        saveData = Cast<USaveData>(save);
+    else
+        saveData = Cast<USaveData>(UGameplayStatics::CreateSaveGameObject(USaveData::StaticClass()));
+}
+
+void UCustomGameInstance::Shutdown()
+{
+    if(auto settings = UCustomGameSettings::Get())
+        settings->SaveSettings();
+
+    Super::Shutdown();
 }
 
 UCustomGameInstance* UCustomGameInstance::Get()
@@ -34,6 +61,22 @@ UContentLoader* UCustomGameInstance::GetContentLoader()
     return nullptr;
 }
 
+UObject* UCustomGameInstance::GetGlobalInstance(UClass* _class)
+{
+    if(auto GI = Get())
+        return *(GI->globalInstances.Find(_class));
+
+    return nullptr;
+}
+
+bool UCustomGameInstance::IsGameSaved()
+{
+    if(auto GI = Get())
+        return GI->saveData != nullptr;
+
+    return false;
+}
+
 void UCustomGameInstance::SaveGame(FName checkpointName)
 {
     auto levelScript = ALevelBase::Get();
@@ -56,12 +99,12 @@ void UCustomGameInstance::SaveGame(FName checkpointName)
     else
         saveData->playerRightPocketItem = FName(TEXT(""));
 
-    UGameplayStatics::SaveGameToSlot(saveData, TEXT("Save"), 0);
+    UGameplayStatics::SaveGameToSlot(saveData, saveName, saveIndex);
 }
 
 void UCustomGameInstance::LoadGame()
 {
-    saveData = Cast<USaveData>(UGameplayStatics::LoadGameFromSlot(TEXT("Save"), 0));
+    saveData = Cast<USaveData>(UGameplayStatics::LoadGameFromSlot(saveName, saveIndex));
     if(!saveData)
         return;
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/CustomGameInstance.h

@@ -20,17 +20,24 @@ class UCustomGameInstance : public UGameInstance
 public:
     /** Instantiates content loader, dummy save data and applies settings */
     virtual void Init() override;
+    /** Saves settings */
+    virtual void Shutdown() override;
 
     UFUNCTION(BlueprintPure, meta = (DisplayName = "Get Custom Game Instance"))
     static UCustomGameInstance* Get();
-
     UFUNCTION(BlueprintPure)
     static class UContentLoader* GetContentLoader();
+    UFUNCTION(BlueprintPure)
+    static UObject* GetGlobalInstance(UClass* _class);
 
+    /** Return true is save data are present and valid */
+    UFUNCTION(BlueprintPure)
+    static bool IsGameSaved();
     UFUNCTION(BlueprintCallable, Category = Save)
     void SaveGame(FName checkpointName);
     UFUNCTION(BlueprintCallable, Category = Save)
     void LoadGame();
+
     UFUNCTION(BlueprintCallable)
     void ExitGame();
 
@@ -46,4 +53,7 @@ protected:
     UPROPERTY()
     class UContentLoader* contentLoader;
 
+    UPROPERTY(EditDefaultsOnly)
+    TSet<TSubclassOf<UObject>> globalInstancesClasses;
+    TMap<UClass*, UObject*> globalInstances;
 };

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/CustomGameSettings.cpp

@@ -4,12 +4,35 @@
 
 #include "Kismet/GameplayStatics.h"
 
+namespace
+{
+    /** Game */
+    constexpr float fDefaultMouseSensetivity = 0.5f;
+    constexpr bool bDefaultMouseInverted = false;
+
+    /** Audio */
+    constexpr float fDefaultMasterVolume = 0.4f;
+    constexpr float fDefaultMusicVolume = 1.0f;
+    constexpr float fDefaultEffectsVolume = 1.0f;
+    constexpr float fDefaultVoicesVolume = 1.0f;
+    constexpr float fDefaultMenuVolume = 1.0f;
+}
+
 UCustomGameSettings::UCustomGameSettings(const FObjectInitializer& ObjectInitializer) :Super(ObjectInitializer)
 {
     bUseMotionBlur = false;
     bShowFps = false;
-    bMouseInverted = false;
+
-    fMouseSensetivity = 1.0f;
+    /** Game */
+    fMouseSensetivity = GetDefaultMouseSensetivity();
+    bMouseInverted = GetDefaultMouseInverted();
+
+    /** Audio */
+    fMasterVolume = GetDefaultMasterVolume();
+    fMusicVolume = GetDefaultMusicVolume();
+    fEffectsVolume = GetDefaultEffectsVolume();
+    fVoicesVolume = GetDefaultVoicesVolume();
+    fMenuVolume = GetDefaultMenuVolume();
 }
 
 UCustomGameSettings* UCustomGameSettings::Get()
@@ -17,12 +40,89 @@ UCustomGameSettings* UCustomGameSettings::Get()
     return Cast<UCustomGameSettings>(UGameUserSettings::GetGameUserSettings());
 }
 
+
+
+/** Game */
+float UCustomGameSettings::GetDefaultMouseSensetivity() const
+{
+    return fDefaultMouseSensetivity;
+}
+float UCustomGameSettings::GetMouseSensetivity() const
+{
+    return fMouseSensetivity;
+}
 void UCustomGameSettings::SetMouseSensetivity(float value)
 {
     fMouseSensetivity = FMath::Clamp(value, 0.1f, 2.0f);
 }
 
-float UCustomGameSettings::GetMouseSensetivity() const
+bool UCustomGameSettings::GetDefaultMouseInverted() const
 {
-    return fMouseSensetivity;
+    return bDefaultMouseInverted;
-}
+}
+
+
+
+/** Audio */
+float UCustomGameSettings::GetDefaultMasterVolume() const
+{
+    return fDefaultMasterVolume;
+}
+float UCustomGameSettings::GetDefaultMusicVolume() const
+{
+    return fDefaultMusicVolume;
+}
+float UCustomGameSettings::GetDefaultEffectsVolume() const
+{
+    return fDefaultEffectsVolume;
+}
+float UCustomGameSettings::GetDefaultVoicesVolume() const
+{
+    return fDefaultVoicesVolume;
+}
+float UCustomGameSettings::GetDefaultMenuVolume() const
+{
+    return fDefaultMenuVolume;
+}
+
+float UCustomGameSettings::GetMasterVolume() const
+{
+    return fMasterVolume;
+}
+float UCustomGameSettings::GetMusicVolume() const
+{
+    return fMusicVolume;
+}
+float UCustomGameSettings::GetEffectsVolume() const
+{
+    return fEffectsVolume;
+}
+float UCustomGameSettings::GetVoicesVolume() const
+{
+    return fVoicesVolume;
+}
+float UCustomGameSettings::GetMenuVolume() const
+{
+    return fMenuVolume;
+}
+
+void UCustomGameSettings::SetMasterVolume(float value)
+{
+    fMasterVolume = FMath::Clamp(value, 0.0f, 1.0f);
+}
+void UCustomGameSettings::SetMusicVolume(float value)
+{
+    fMusicVolume = FMath::Clamp(value, 0.0f, 1.0f);
+}
+void UCustomGameSettings::SetEffectsVolume(float value)
+{
+    fEffectsVolume = FMath::Clamp(value, 0.0f, 1.0f);
+}
+void UCustomGameSettings::SetVoicesVolume(float value)
+{
+    fVoicesVolume = FMath::Clamp(value, 0.0f, 1.0f);
+}
+void UCustomGameSettings::SetMenuVolume(float value)
+{
+    fMenuVolume = FMath::Clamp(value, 0.0f, 1.0f);
+}

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/CustomGameSettings.h

@@ -10,28 +10,19 @@
  * Manages custom game settings.
  * Mouse sensetivity and inversion, motion blur usage, fps show.
  */
-UCLASS(Config = Game, defaultconfig)
+UCLASS(defaultconfig)
 class UCustomGameSettings : public UGameUserSettings
 {
-    GENERATED_UCLASS_BODY()
+    GENERATED_BODY()
 
 public:
     // Is auto defined by UE but implementation is in cpp
-    //UCustomGameSettings(const FObjectInitializer& ObjectInitializer);
+    UCustomGameSettings(const FObjectInitializer& ObjectInitializer);
 
     UFUNCTION(BlueprintPure, Category = Settings, meta = (DisplayName = "Get Custom Game Settings"))
     static UCustomGameSettings* Get();
 
-    /**
-     * Sets mouse sensetivity multiplier
-     * @param value [0.1 - 2.0]
-     */
-    UFUNCTION(BlueprintCallable, Category = Settings)
-    void SetMouseSensetivity(float value);
 
-    /** Returns mouse sensetivity multiplier in [0.1 - 2.0] */
-    UFUNCTION(BlueprintCallable, Category = Settings)
-    float GetMouseSensetivity() const;
 
     UPROPERTY(Config, BlueprintReadWrite)
     bool bUseMotionBlur;
@@ -39,11 +30,79 @@ public:
     UPROPERTY(Config, BlueprintReadWrite)
     bool bShowFps;
 
+
+
+    /** Game */
+    UFUNCTION(BlueprintPure, Category = Settings)
+    float GetDefaultMouseSensetivity() const;
+    /** Returns mouse sensetivity multiplier in [0.1 - 2.0] */
+    UFUNCTION(BlueprintPure, Category = Settings)
+    float GetMouseSensetivity() const;
+    /**
+     * Sets mouse sensetivity multiplier
+     * @param value [0.1 - 2.0]
+     */
+    UFUNCTION(BlueprintCallable, Category = Settings)
+    void SetMouseSensetivity(float value);
+
+    UFUNCTION(BlueprintPure, Category = Settings)
+    bool GetDefaultMouseInverted() const;
     UPROPERTY(Config, BlueprintReadWrite)
     bool bMouseInverted;
 
+
+
+    /**
+     * Audio
+     * All values are clamped in [0.0 - 1.0]
+     */
+    UFUNCTION(BlueprintPure, Category = Settings)
+    float GetDefaultMasterVolume() const; // UFUNCTION doesn't support constexpr functions
+    UFUNCTION(BlueprintPure, Category = Settings)
+    float GetDefaultMusicVolume() const; // UFUNCTION doesn't support constexpr functions
+    UFUNCTION(BlueprintPure, Category = Settings)
+    float GetDefaultEffectsVolume() const; // UFUNCTION doesn't support constexpr functions
+    UFUNCTION(BlueprintPure, Category = Settings)
+    float GetDefaultVoicesVolume() const; // UFUNCTION doesn't support constexpr functions
+    UFUNCTION(BlueprintPure, Category = Settings)
+    float GetDefaultMenuVolume() const; // UFUNCTION doesn't support constexpr functions
+
+    UFUNCTION(BlueprintPure, Category = Settings)
+    float GetMasterVolume() const;
+    UFUNCTION(BlueprintPure, Category = Settings)
+    float GetMusicVolume() const;
+    UFUNCTION(BlueprintPure, Category = Settings)
+    float GetEffectsVolume() const;
+    UFUNCTION(BlueprintPure, Category = Settings)
+    float GetVoicesVolume() const;
+    UFUNCTION(BlueprintPure, Category = Settings)
+    float GetMenuVolume() const;
+
+    UFUNCTION(BlueprintCallable, Category = Settings)
+    void SetMasterVolume(float value);
+    UFUNCTION(BlueprintCallable, Category = Settings)
+    void SetMusicVolume(float value);
+    UFUNCTION(BlueprintCallable, Category = Settings)
+    void SetEffectsVolume(float value);
+    UFUNCTION(BlueprintCallable, Category = Settings)
+    void SetVoicesVolume(float value);
+    UFUNCTION(BlueprintCallable, Category = Settings)
+    void SetMenuVolume(float value);
+
 protected:
     UPROPERTY(Config)
     float fMouseSensetivity;
 
+    /** Audio */
+    UPROPERTY(Config)
+    float fMasterVolume;
+    UPROPERTY(Config)
+    float fMusicVolume;
+    UPROPERTY(Config)
+    float fEffectsVolume;
+    UPROPERTY(Config)
+    float fVoicesVolume;
+    UPROPERTY(Config)
+    float fMenuVolume;
+
 };

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/CustomPlayerController.cpp

@@ -33,6 +33,13 @@ void ACustomPlayerController::AppendInputContext(TSoftObjectPtr<class UInputMapp
         subsystem->AddMappingContext(context.LoadSynchronous(), 0);
 }
 
+void ACustomPlayerController::ApplyMouseSettings()
+{
+    if(auto settings = UCustomGameSettings::Get())
+        for(auto& context : contexts)
+            ApplyMouseSettings(context, settings);
+}
+
 void ACustomPlayerController::BeginPlay()
 {
     Super::BeginPlay();
@@ -71,15 +78,19 @@ void ACustomPlayerController::EndPlay(const EEndPlayReason::Type EndPlayReason)
     Super::EndPlay(EndPlayReason);
 }
 
-void ACustomPlayerController::ApplyMouseSettings(TSoftObjectPtr<class UInputMappingContext>& context)
+void ACustomPlayerController::ApplyMouseSettings(TSoftObjectPtr<class UInputMappingContext>& context, UCustomGameSettings* settings)
 {
-    auto gameSettings = UCustomGameSettings::Get();
+    if(!settings)
-    if(!gameSettings)
+    {
-        return;
+        settings = UCustomGameSettings::Get();
+        if(!settings)
+            return;
+    }
 
     if(!context.LoadSynchronous())
         return;
 
+    bool contextChanged = false;
     for(auto& mapping : context.LoadSynchronous()->GetMappings())
     {
         if(mapping.Key != EKeys::Mouse2D)
@@ -87,20 +98,27 @@ void ACustomPlayerController::ApplyMouseSettings(TSoftObjectPtr<class UInputMapp
 
         for(auto& modifier : mapping.Modifiers)
         {
-            if(gameSettings->bMouseInverted)
+            if(auto negate_modifier = Cast<UInputModifierNegate>(modifier))
             {
-                if(auto negate_modifier = Cast<UInputModifierNegate>(modifier))
+                negate_modifier->bY = !settings->bMouseInverted;
-                {
+                contextChanged = true;
-                    negate_modifier->bY = !negate_modifier->bY;
+            }
-                    continue;
+            else if(auto scalar_modifier = Cast<UInputModifierScalar>(modifier))
-                }
+            {
+                scalar_modifier->Scalar = FVector{ settings->GetMouseSensetivity() };
+                contextChanged = true;
             }
-            if(auto scalar_modifier = Cast<UInputModifierScalar>(modifier))
-                scalar_modifier->Scalar = FVector{ gameSettings->GetMouseSensetivity() * 0.5 };
         }
     }
 
-    UEnhancedInputLibrary::RequestRebuildControlMappingsUsingContext(context.LoadSynchronous());
+    if(contextChanged)
+    {
+        if(subsystem)
+        {
+            FModifyContextOptions options;
+            subsystem->RequestRebuildControlMappings(options, EInputMappingRebuildType::RebuildWithFlush);
+        }
+    }
 }
 
 void ACustomPlayerController::OnAnyKeyPressed(FKey key)

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/CustomPlayerController.h

@@ -30,6 +30,10 @@ public:
     UFUNCTION(BlueprintCallable)
     static void AppendInputContext(TSoftObjectPtr<class UInputMappingContext> context);
 
+    /** Applies mouse settings to all loaded contexts */
+    UFUNCTION(BlueprintCallable)
+    static void ApplyMouseSettings();
+
     FPlayerAnyKeyPressedDelegate onAnyKeyPressed;
     FPlayerAnyKeyReleasedDelegate onAnyKeyReleased;
 
@@ -38,7 +42,8 @@ protected:
     virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
 private:
-    static void ApplyMouseSettings(TSoftObjectPtr<class UInputMappingContext>& context);
+    /** Applies mouse settings to the specific context */
+    static void ApplyMouseSettings(TSoftObjectPtr<class UInputMappingContext>& context, class UCustomGameSettings* settings = nullptr);
 
     void OnAnyKeyPressed(FKey key);
     void OnAnyKeyReleased(FKey key);

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/GraphicsSettingsHelper.cpp

@@ -0,0 +1,37 @@
+// Oleg Petruny proprietary.
+
+#include "GraphicsSettingsHelper.h"
+
+#include "GenericPlatform/GenericApplication.h"
+
+int32 UGraphicsSettingsHelper::GetPrimaryMonitorId()
+{
+    FDisplayMetrics FDM;
+    FDisplayMetrics::GetMonitorsInfo(FDM);
+    TArray<FMonitorInfo> buffer;
+    for(const FMonitorInfo& i : FDM.MonitorInfo)
+    {
+        buffer.Add(FMonitorInfo(i.Name, i.ID, i.NativeWidth, i.NativeHeight,
+            FPlatformRectangle(i.DisplayRect.Left, i.DisplayRect.Top, i.DisplayRect.Right, i.DisplayRect.Bottom),
+            FPlatformRectangle(i.WorkArea.Left, i.WorkArea.Top, i.WorkArea.Right, i.WorkArea.Bottom),
+            i.bIsPrimary, i.DPI));
+    }
+    monitors = buffer;
+    TArray<FMonitorInfo> monitors = GetAvailableMonitors();
+    for(int i = 0; i < monitors.Num(); i++)
+        if(monitors[i].bIsPrimary)
+            return i;
+}
+
+int32 UGraphicsSettingsHelper::GetCurrentMonitorId()
+{
+    return int32();
+}
+
+//TArray<FMonitorInfo> UGraphicsSettingsHelper::GetAvailableMonitors()
+//{
+//    return TArray<FMonitorInfo>();
+//}
+
+void UGraphicsSettingsHelper::SetMonitor(int32 id)
+{}

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/GraphicsSettingsHelper.h

@@ -0,0 +1,23 @@
+// Oleg Petruny proprietary.
+
+#pragma once
+
+#include "Kismet/BlueprintFunctionLibrary.h"
+
+#include "GraphicsSettingsHelper.generated.h"
+
+UCLASS()
+class UGraphicsSettingsHelper : public UBlueprintFunctionLibrary
+{
+    GENERATED_BODY()
+
+public:
+    UFUNCTION(BlueprintPure, Category = GraphicsSettingsHelper)
+    static int32 GetPrimaryMonitorId();
+    UFUNCTION(BlueprintPure, Category = GraphicsSettingsHelper)
+    static int32 GetCurrentMonitorId();
+    //UFUNCTION(BlueprintPure, Category = GraphicsSettingsHelper)
+    //static TArray<FMonitorInfo> GetAvailableMonitors();
+    UFUNCTION(BlueprintCallable, Category = GraphicsSettingsHelper)
+    static void SetMonitor(int32 id);
+};

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/PlayerBase.cpp

@@ -371,16 +371,22 @@ void APlayerBase::ShowMenu()
         if(GetWorld()->IsPaused())
         {
             WM->HideMainMenu();
-            playerController->SetShowMouseCursor(false);
+            if(auto PC = ACustomPlayerController::Get())
-            playerController->SetInputMode(FInputModeGameOnly{});
+            {
+                PC->SetShowMouseCursor(false);
+                PC->SetInputMode(FInputModeGameOnly{});
+            }
             UnlockPlayer(FPlayerLock::All());
             UGameplayStatics::SetGamePaused(GetWorld(), false);
         }
         else
         {
             WM->ShowMainMenu();
-            playerController->SetShowMouseCursor(true);
+            if(auto PC = ACustomPlayerController::Get())
-            playerController->SetInputMode(FInputModeGameAndUI{});
+            {
+                PC->SetShowMouseCursor(true);
+                PC->SetInputMode(FInputModeGameAndUI{});
+            }
             LockPlayer(FPlayerLock::All());
             UGameplayStatics::SetGamePaused(GetWorld(), true);
         }

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/PlayerBase.h

@@ -113,7 +113,6 @@ protected:
     UFUNCTION(BlueprintCallable, Category = Character)
     void ShowMenu();
 
-    class APlayerController* playerController;
     UPROPERTY(EditAnywhere)
     float moveSpeed = 200;
     UPROPERTY(EditAnywhere)

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/AutohideWidget.h

@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include "ResolutionResponsiveUserWidget.h"
+#include "ResolutionResponsiveWidget.h"
 
 #include "AutohideWidget.generated.h"
 
@@ -10,7 +10,7 @@
  * Automatically hides itself after some period
  */
 UCLASS()
-class UAutohideWidget : public UResolutionResponsiveUserWidget
+class UAutohideWidget : public UResolutionResponsiveWidget
 {
     GENERATED_BODY()
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/ComboBoxText.cpp

@@ -0,0 +1,20 @@
+// Oleg Petruny proprietary.
+
+#include "ComboBoxText.h"
+
+void UComboBoxText::PostInitProperties()
+{
+    Super::PostInitProperties();
+
+    SetOptions(_DefaultOptions);
+    _DefaultOptions.Empty();
+}
+
+void UComboBoxText::SetOptions(const TArray<FText>& options)
+{
+    ClearSelection();
+    Options.Empty();
+    for(auto& o : options)
+        Options.Add(MakeShareable(new FString(o.ToString())));
+    RefreshOptions();
+}

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/ComboBoxText.h

@@ -0,0 +1,23 @@
+// Oleg Petruny proprietary.
+
+#pragma once
+
+#include "Components/ComboBoxString.h"
+
+#include "ComboBoxText.generated.h"
+
+UCLASS(Blueprintable, meta = (DisplayName = "ComboBox (Text)"), MinimalAPI)
+class UComboBoxText : public UComboBoxString
+{
+    GENERATED_BODY()
+
+public:
+    virtual void PostInitProperties() override;
+
+    UFUNCTION(BlueprintCallable)
+    void SetOptions(const TArray<FText>& options);
+
+protected:
+    UPROPERTY(EditAnywhere, Category = ComboBoxTextDefault)
+    TArray<FText> _DefaultOptions;
+};

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/CutsceneSkipWidget.h

@@ -3,14 +3,14 @@
 #pragma once
 
 #include "InputAnimatedWidgetInterface.h"
-#include "ResolutionResponsiveUserWidget.h"
+#include "ResolutionResponsiveWidget.h"
 
 #include "CutsceneSkipWidget.generated.h"
 
 DECLARE_DYNAMIC_DELEGATE(FSkipCutsceneDelegate);
 
 UCLASS(Blueprintable, Abstract)
-class UCutsceneSkipWidget : public UResolutionResponsiveUserWidget, public IInputAnimatedWidgetInterface
+class UCutsceneSkipWidget : public UResolutionResponsiveWidget, public IInputAnimatedWidgetInterface
 {
     GENERATED_BODY()
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/DialogueRowWidget.h

@@ -2,14 +2,14 @@
 
 #pragma once
 
-#include "ResolutionResponsiveUserWidget.h"
+#include "ResolutionResponsiveWidget.h"
 
 #include "DialogueRowWidget.generated.h"
 
 enum class EDialogueWaveType : uint8;
 
 UCLASS(Blueprintable, Abstract)
-class UDialogueRowWidget : public UResolutionResponsiveUserWidget
+class UDialogueRowWidget : public UResolutionResponsiveWidget
 {
     GENERATED_BODY()
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/DialogueSkipWidget.h

@@ -3,14 +3,14 @@
 #pragma once
 
 #include "InputAnimatedWidgetInterface.h"
-#include "ResolutionResponsiveUserWidget.h"
+#include "ResolutionResponsiveWidget.h"
 
 #include "DialogueSkipWidget.generated.h"
 
 DECLARE_DYNAMIC_DELEGATE(FDialogueSkipDelegate);
 
 UCLASS(Blueprintable, Abstract)
-class UDialogueSkipWidget : public UResolutionResponsiveUserWidget, public IInputAnimatedWidgetInterface
+class UDialogueSkipWidget : public UResolutionResponsiveWidget, public IInputAnimatedWidgetInterface
 {
     GENERATED_BODY()
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/InteractableHintWidget.h

@@ -3,12 +3,12 @@
 #pragma once
 
 #include "InputAnimatedWidgetInterface.h"
-#include "ResolutionResponsiveUserWidget.h"
+#include "ResolutionResponsiveWidget.h"
 
 #include "InteractableHintWidget.generated.h"
 
 UCLASS(Blueprintable, Abstract)
-class UInteractableHintWidget : public UResolutionResponsiveUserWidget, public IInputAnimatedWidgetInterface
+class UInteractableHintWidget : public UResolutionResponsiveWidget, public IInputAnimatedWidgetInterface
 {
     GENERATED_BODY()
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/JournalWidget.h

@@ -3,7 +3,7 @@
 #pragma once
 
 #include "AutohideWidget.h"
-#include "ResolutionResponsiveUserWidget.h"
+#include "ResolutionResponsiveWidget.h"
 
 #include "JournalWidget.generated.h"
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/MainMenu/MainMenuWidget.cpp

@@ -11,16 +11,6 @@
 
 bool UMainMenuWidget::Initialize()
 {
-    if(ButtonLoadLastSave)
-    {
-        auto GI = UCustomGameInstance::Get();
-        if(GI && GI->saveData)
-        {
-            ButtonLoadLastSave->SetIsEnabled(true);
-            ButtonLoadLastSave->SetRenderOpacity(1.0f);
-        }
-    }
-
     //FWidgetAnimationDynamicEvent closeFinished;
     //closeFinished.BindDynamic(this, &UMainMenuWidget::Closed);
     //BindToAnimationFinished(closeAnimation, closeFinished);

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/MainMenu/MainMenuWidget.h

@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include "Widgets/ResolutionResponsiveUserWidget.h"
+#include "Widgets/ResolutionResponsiveWidget.h"
 
 #include "MainMenuWidget.generated.h"
 
@@ -30,24 +30,9 @@ public:
     UPROPERTY(BlueprintAssignable)
     FMainMenuClosedDelegate OnMainMenuClosedDelegate;
 
-    UPROPERTY(meta = (BindWidget))
+    UPROPERTY(BlueprintReadOnly, Transient, meta = (BindWidgetAnim))
-    class UMainMenuButtonWidget* ButtonContinue;
+    class UWidgetAnimation* extendAnimation;
-    UPROPERTY(meta = (BindWidget))
+    UPROPERTY(BlueprintReadOnly, Transient, meta = (BindWidgetAnim))
-    class UMainMenuButtonWidget* ButtonLoadLastSave;
-    UPROPERTY(meta = (BindWidget))
-    class UMainMenuButtonWidget* ButtonNewGame;
-    UPROPERTY(meta = (BindWidget))
-    class UMainMenuButtonWidget* ButtonOptions;
-    UPROPERTY(meta = (BindWidget))
-    class UMainMenuButtonWidget* ButtonCredits;
-    UPROPERTY(meta = (BindWidget))
-    class UMainMenuButtonWidget* ButtonExit;
-
-    UPROPERTY(Transient, meta = (BindWidgetAnim))
-    class UWidgetAnimation* showFullAnimation;
-    UPROPERTY(Transient, meta = (BindWidgetAnim))
-    class UWidgetAnimation* showFastAnimation;
-    UPROPERTY(Transient, meta = (BindWidgetAnim))
     class UWidgetAnimation* closeAnimation;
 
 protected:

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/QuickTimeEventWidget.h

@@ -3,14 +3,14 @@
 #pragma once
 
 #include "QuickTimeEvent.h" // forward declaration of EQuickTimeEventResult is somehow insufficient on some machines
-#include "Widgets/ResolutionResponsiveUserWidget.h"
+#include "Widgets/ResolutionResponsiveWidget.h"
 
 #include "QuickTimeEventWidget.generated.h"
 
 enum class EQuickTimeEventResult : uint8;
 
 UCLASS(Blueprintable, Abstract)
-class UQuickTimeEventWidget : public UResolutionResponsiveUserWidget
+class UQuickTimeEventWidget : public UResolutionResponsiveWidget
 {
     GENERATED_BODY()
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/QuickTimeEventWidgetManager.h

@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include "Widgets/WorldDilationResponsiveUserWidget.h"
+#include "Widgets/WorldDilationResponsiveWidget.h"
 
 #include "QuickTimeEventWidgetManager.generated.h"
 
@@ -12,7 +12,7 @@ enum class EQuickTimeEventResult : uint8;
 class UQuickTimeEventWidget;
 
 UCLASS(Blueprintable, Abstract)
-class UQuickTimeEventWidgetManager : public UWorldDilationResponsiveUserWidget
+class UQuickTimeEventWidgetManager : public UWorldDilationResponsiveWidget
 {
     GENERATED_BODY()
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/ResolutionResponsiveWidget.cpp

@@ -1,18 +1,18 @@
 // Oleg Petruny proprietary.
 
-#include "ResolutionResponsiveUserWidget.h"
+#include "ResolutionResponsiveWidget.h"
 
 #include "Components/PanelSlot.h"
 #include "UnrealClient.h"
 
-bool UResolutionResponsiveUserWidget::Initialize()
+bool UResolutionResponsiveWidget::Initialize()
 {
-    _viewportResizedEventHandle = FViewport::ViewportResizedEvent.AddUObject(this, &UResolutionResponsiveUserWidget::Rescale);
+    _viewportResizedEventHandle = FViewport::ViewportResizedEvent.AddUObject(this, &UResolutionResponsiveWidget::Rescale);
 
     return UUserWidget::Initialize();
 }
 
-void UResolutionResponsiveUserWidget::BeginDestroy()
+void UResolutionResponsiveWidget::BeginDestroy()
 {
     if(_viewportResizedEventHandle.IsValid())
     {
@@ -22,18 +22,18 @@ void UResolutionResponsiveUserWidget::BeginDestroy()
     UUserWidget::BeginDestroy();
 }
 
-void UResolutionResponsiveUserWidget::Rescale(FViewport* ViewPort, uint32 val)
+void UResolutionResponsiveWidget::Rescale(FViewport* ViewPort, uint32 val)
 {
     _scale = (float)defaultResolution / ViewPort->GetSizeXY().GetMin();
     Rescale();
 }
 
-void UResolutionResponsiveUserWidget::Rescale_Implementation()
+void UResolutionResponsiveWidget::Rescale_Implementation()
 {
     SetRenderScale(FVector2D{ _scale });
 }
 
-float UResolutionResponsiveUserWidget::GetScale() const
+float UResolutionResponsiveWidget::GetScale() const
 {
     return _scale;
 }

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/ResolutionResponsiveWidget.h

@@ -4,13 +4,13 @@
 
 #include "Blueprint/UserWidget.h"
 
-#include "ResolutionResponsiveUserWidget.generated.h"
+#include "ResolutionResponsiveWidget.generated.h"
 
 /**
  * Automatically scale itself for current resolution to keep UI sizes universal.
  */
 UCLASS()
-class UResolutionResponsiveUserWidget : public UUserWidget
+class UResolutionResponsiveWidget : public UUserWidget
 {
     GENERATED_BODY()
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/WorldDilationResponsiveWidget.cpp

@@ -1,6 +1,6 @@
 // Oleg Petruny proprietary.
 
-#include "WorldDilationResponsiveUserWidget.h"
+#include "WorldDilationResponsiveWidget.h"
 
 #include "Animation/UMGSequencePlayer.h"
 #include "Animation/WidgetAnimation.h"
@@ -8,21 +8,21 @@
 
 #include "CommonFunctions.h"
 
-bool UWorldDilationResponsiveUserWidget::Initialize()
+bool UWorldDilationResponsiveWidget::Initialize()
 {
-    UCommonFunctions::GetWorldDilationChangedDelegate().AddDynamic(this, &UWorldDilationResponsiveUserWidget::UpdateAnimations);
+    UCommonFunctions::GetWorldDilationChangedDelegate().AddDynamic(this, &UWorldDilationResponsiveWidget::UpdateAnimations);
 
     return UUserWidget::Initialize();
 }
 
-void UWorldDilationResponsiveUserWidget::BeginDestroy()
+void UWorldDilationResponsiveWidget::BeginDestroy()
 {
-    UCommonFunctions::GetWorldDilationChangedDelegate().RemoveDynamic(this, &UWorldDilationResponsiveUserWidget::UpdateAnimations);
+    UCommonFunctions::GetWorldDilationChangedDelegate().RemoveDynamic(this, &UWorldDilationResponsiveWidget::UpdateAnimations);
 
     UUserWidget::BeginDestroy();
 }
 
-void UWorldDilationResponsiveUserWidget::UpdateAnimations(float newSpeed)
+void UWorldDilationResponsiveWidget::UpdateAnimations(float newSpeed)
 {
     UpdateAnimation(GetRootWidget(), newSpeed);
 
@@ -70,7 +70,7 @@ void UWorldDilationResponsiveUserWidget::UpdateAnimations(float newSpeed)
     }
 }
 
-void UWorldDilationResponsiveUserWidget::UpdateAnimation(UWidget* widget, float newSpeed)
+void UWorldDilationResponsiveWidget::UpdateAnimation(UWidget* widget, float newSpeed)
 {
     if(auto userWidget = Cast<UUserWidget>(widget))
     {

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/WorldDilationResponsiveWidget.h

@@ -4,13 +4,13 @@
 
 #include "Blueprint/UserWidget.h"
 
-#include "WorldDilationResponsiveUserWidget.generated.h"
+#include "WorldDilationResponsiveWidget.generated.h"
 
 /**
  * Automatically update animations speed to sync with world time dilation
  */
 UCLASS()
-class UWorldDilationResponsiveUserWidget : public UUserWidget
+class UWorldDilationResponsiveWidget : public UUserWidget
 {
     GENERATED_BODY()