Basic on Georgy's Tech Blog

How to focus a Common UI button (UCommonButtonBase) in Unreal Engine

Tue, 27 Aug 2024 00:00:00 +0000

As of UE 5.4, the Common UI button (UCommonButtonBase) still doesn’t support direct focus settings. This is because UCommonButtonBase is derived from UUserWidget, which supports focusing, but doesn’t direct the focus to the underlying button itself automatically. However, you can still set the focus on the button by performing a “deep” focus on the Slate button. Here’s how you can achieve this:

/**
 * Sets the focus on the button
 * This function performs the "deep" focus on the Common UI button, which means that it will set the focus on the button itself
 * This is useful since UCommonButtonBase is derived from UUserWidget, which doesn't support focus when setting it directly
 */
UFUNCTION(BlueprintCallable, Category = "mod.io|UI|Button", DisplayName = "Set Button Focus (Common UI)")
void SetCommonUIButtonFocus()
{
#if UE_VERSION_OLDER_THAN(5, 3, 0)
	if (bIsFocusable)
#else
	if (IsFocusable())
#endif
	{
		if (TSharedPtr<SButton> SlateButton = GetSlateButton())
		{
			if (SlateButton->SupportsKeyboardFocus())
			{
				FSlateApplication::Get().SetKeyboardFocus(SlateButton, EFocusCause::Mouse);
				UE_LOG(LogTemp, Log, TEXT("Set focus on button '%s' (extended way)"), *GetName());
			}
			else
			{
				UE_LOG(LogTemp, Warning, TEXT("Trying to set focus on button '%s' but the button does not support keyboard focus"), *GetName());
			}
		}
		else
		{
			UE_LOG(LogTemp, Warning, TEXT("Trying to set focus on button '%s' but the slate button could not be found"), *GetName());
		}
	}
	else
	{
		UE_LOG(LogTemp, Warning, TEXT("Trying to set focus on button '%s' but the button is not focusable"), *GetName());
	}
}

/**
 * Gets the Slate button widget
 * The button is highly encapsulated and this function tries to scan the widget tree to find the button
 * @return The Slate button widget if found, nullptr otherwise
 */
TSharedPtr<SButton> GetSlateButton() const
{
	if (WidgetTree && WidgetTree->RootWidget)
	{
		if (UButton* InternalButton = Cast<UButton>(WidgetTree->RootWidget))
		{
			// UCommonButtonInternalBase::RebuildWidget() creates a SBox wrapper for the button
			if (TSharedPtr<SBox> BoxButtonWrapper =	StaticCastSharedPtr<SBox>(TSharedPtr<SWidget>(InternalButton->GetCachedWidget())))
			{
				if (BoxButtonWrapper->GetChildren() && BoxButtonWrapper->GetChildren()->Num() > 0)
				{
					if (TSharedPtr<SButton> InternalButtonSlate = StaticCastSharedPtr<SButton>(TSharedPtr<SWidget>(BoxButtonWrapper->GetChildren()->GetChildAt(0))))
					{
						return InternalButtonSlate;
					}
				}
			}
			// UButton::RebuildWidget() returns the button directly
			else if (TSharedPtr<SButton> InternalButtonSlate = StaticCastSharedPtr<SButton>(InternalButton->GetCachedWidget()))
			{
				return InternalButtonSlate;
			}
			else
			{
				UE_LOG(LogTemp, Error, TEXT("Could not find the Slate button widget for button '%s'"), *GetName());
			}
		}
	}
	return nullptr;
}

How to get the currently focused widget in Unreal Engine

Sat, 23 Mar 2024 00:00:00 +0000

In Unreal Engine, you can determine the currently focused widget in both Slate and UMG UI systems.

Slate

To get the currently focused Slate widget, you can use the following code snippet:

// Instead of 0, you can pass the user index if you have multiple users
TSharedPtr<SWidget> FocusedSlateWidget = FSlateApplication::Get().GetUserFocusedWidget(0);

UMG

Getting the currently focused UMG widget is a bit more involved, since there is no direct function to get it or the place where it is stored. However, you can iterate over all UMG widgets and compare their cached Slate widgets to the focused one. This approach is not recommended for performance-critical code, but it can be useful for debugging or testing purposes. Here is an example function that does this:

How to execute code on scope exit in Unreal Engine

Sat, 02 Mar 2024 00:00:00 +0000

If you want to execute some code when the scope is exited, you can use the following handy ON_SCOPE_EXIT macro, like this:

int32 AnyFunction()
{
    ON_SCOPE_EXIT
    {
        // This code will be executed when the scope is exited (after the return statement)
    };

    // Do smth
    
    // Just return 100 for example
    return 100;
}

How to save and restore any value with RAII approach in Unreal Engine

Sun, 25 Feb 2024 00:00:00 +0000

Imagine you’re in a situation where you need to save and restore a value. For instance, let’s say you have a UMG widget that you want to hide temporarily, do some stuff, and then bring back its previous visibility state, all within a single function. The most straightforward approach might be to store the value in a temporary variable, modify it, and then revert it back, like this:

ESlateVisibility VisibilityState;

const ESlateVisibility PreviousVisibility = VisibilityState;
VisibilityState = ESlateVisibility::Hidden;

// Do smth. VisibilityState is Hidden here

// Restore the previous visibility state
VisibilityState = PreviousVisibility;

This method gets the job done, but it’s not very scalable. What if you need to manage multiple values? What if there are several exit points in your function? What if multiple functions require saving and restoring the same value? Duplicating this rather verbose code everywhere is not ideal. We can do it better.

How to cast Slate widgets in Unreal Engine

Sat, 21 Oct 2023 00:00:00 +0000

This brief article addresses the question of how to cast one Slate widget to another in Unreal Engine. Imagine you have an SWidget widget wrapped in a shared pointer like this:

TSharedPtr<SWidget> MyWidgetPtr;

If you want to cast it, for example, to an SSpacer, your code might look like this:

TSharedPtr<SSpacer> MySpacerPtr = StaticCastSharedPtr<SSpacer>(MyWidgetPtr);

It’s important to keep in mind that you should verify whether the shared pointer is valid before using it.

The same approach works for shared references:

How to set a timer for the next tick in Unreal Engine

Fri, 15 Sep 2023 00:00:00 +0000

In Unreal Engine, it is possible to set a delay for the function to execute after a single tick, which is sometimes useful when working with UMG/Slate side of things where the widget properties are only available after a complete rebuild, such as obtaining the desired size of the widget’s geometry, which is often not accessible right after initializing or constructing the widget. In such cases, you may want to implement a delay, as described in this article , but sometimes even a single tick delay is sufficient and can enhance the overall user experience, preventing visual hitches and abrupt interactions.

How to save UObject that is represented as an asset in Unreal Engine

Sun, 05 Feb 2023 00:00:00 +0000

You can save any UObject that is represented as an asset within a UPackage using this method:

bool SaveToAsset(UObject* ObjectToSave)
{
	UPackage* Package = ObjectToSave->GetPackage();
	const FString PackageName = Package->GetName();
	const FString PackageFileName = FPackageName::LongPackageNameToFilename(PackageName, FPackageName::GetAssetPackageExtension());

	FSavePackageArgs SaveArgs;
	
	// This is specified just for example
	{
		SaveArgs.TopLevelFlags = RF_Public | RF_Standalone;
		SaveArgs.SaveFlags = SAVE_NoError;
	}
	
	const bool bSucceeded = UPackage::SavePackage(Package, nullptr, *PackageFileName, SaveArgs);

	if (!bSucceeded)
	{
		UE_LOG(LogTemp, Error, TEXT("Package '%s' wasn't saved!"), *PackageName)
		return false;
	}

	UE_LOG(LogTemp, Warning, TEXT("Package '%s' was successfully saved"), *PackageName)
	return true;
}

How to use variant in Unreal Engine

Fri, 30 Dec 2022 00:00:00 +0000

There is a std::variant class template in the standard library that is essentially a type-safe union. It is generally used when we are not sure in advance which object should be populated from our list of object types, so we assume that one of the specified objects must be there at a time.

How to use delays in C++ in Unreal Engine

Sun, 03 Jul 2022 00:00:00 +0000

Some developers are wondering about the C++ equivalent of the Delay node in Blueprints.

There are two ways to implement Delay that are very similar. Use the option that is more readable and convenient for you.

Lambas

Using FTimerDelegate

FTimerDelegate TimerDelegate;
TimerDelegate.BindLambda([&]
{
	UE_LOG(LogTemp, Warning, TEXT("This text will appear in the console 3 seconds after execution"));
});

FTimerHandle TimerHandle;
GetWorld()->GetTimerManager().SetTimer(TimerHandle, TimerDelegate, 3, false);

Using FTimerHandle only

FTimerHandle TimerHandle;
GetWorld()->GetTimerManager().SetTimer(TimerHandle, [&]()
{
	UE_LOG(LogTemp, Warning, TEXT("This text will appear in the console 3 seconds after execution"));
}, 3, false);

Separate functions

The second way is to use a delay to execute another function.

How to completely disable Tonemapper in Unreal Engine

Sun, 26 Jun 2022 00:00:00 +0000

In this quick tutorial, I will show you how to completely disable Tonemapper without using PostProcess

To do this, just open the DefaultEngine.ini file (in the [PROJECT_NAME]/Config folder) and add the following lines to [/Script/Engine.RendererSettings] section:

r.TonemapperGamma = 0
r.TonemapperFilm = 0
r.Tonemapper.Quality = 0
r.ToneCurveAmount = 0
r.Mobile.TonemapperFilm = 0
r.MobileTonemapperUpscale = 0
r.EyeAdaptationQuality = 0
r.EyeAdaptation.ExponentialTransitionDistance = 0

You can also write the same to the engine’s command line, but I recommend to directly add these lines to a file since it’s more convenient and will always work.

Intro to Unreal Engine containers (TArray, TSet, TMap)

Sun, 05 Jun 2022 00:00:00 +0000

This article may be helpful for those who are familiar with standard containers and would like to learn Unreal-specific ones, or for those who already have a knowledge of the containers but would like to explore them a little deeper.

Here is information about the following containers: TArray, TSet, TMap, and a basic overview of the TMultiMap and TSortedMap.

TArray

Let’s start with TArray. TArray is a dynamically sized array, similar to std::vector in the standard library.

How to convert Enum to FString in Unreal Engine

Sun, 29 May 2022 00:00:00 +0000

This is a short article on how to convert an enumerator to FString in Unreal Engine.

Blueprints

In Blueprints, it is easy to convert all supported enumerators to FString. Simply drag your enumerator to the required pin, which will automatically add the necessary conversion node.