[{"content":"Game localization has traditionally been a time-consuming and expensive process. Manual translation work often requires weeks of coordination with external services. AI language models now provide developers with powerful tools to streamline this workflow while they maintain quality and reduce costs.\nThis guide demonstrates how to set up automated AI-powered translation for your Unreal Engine project using the AI Localization Automator plugin . The plugin turns hours of manual work into minutes of automated processing.\nYour browser does not support the video tag. Why AI-Powered Localization? Modern AI translation offers several advantages over traditional methods:\nSpeed: Translate hundreds of text entries in minutes rather than days Cost-Effectiveness: Significantly reduce translation costs, especially for indie developers Consistency: Maintain consistent terminology and style across your entire project Iteration-Friendly: Quick turnaround allows for rapid prototyping and testing Multiple Providers: Choose from various AI services based on quality, cost, and privacy needs Prerequisites Before you start automated translation, ensure you have:\nLocalizable text content in your project (using FText in C++ or Text properties in Blueprints) A configured localization target with gathered source text At least one target language added to your localization target Access to an AI translation service The AI Localization Automator plugin installed New to Unreal Engine localization? Click here for setup basics If you’re unfamiliar with making text localizable in UE, the fundamental steps are:\nUse FText for localizable content - Only FText (Text in Blueprints) can be localized Mark text as localizable - Enable the “Localize” checkbox in text properties Create localization targets - Set up targets in the Localization Dashboard Gather source text - Use the “Gather Text” process to discover localizable content Add target languages - Specify which languages you want to translate to For detailed setup instructions, see the Localization Setup Guide .\nSetting Up AI Translation Step 1: Access the AI Translation Manager The AI Localization Automator plugin integrates directly with Unreal Engine’s Localization Dashboard. You’ll find AI translation options in your localization target’s toolbar.\nOpen Tools \u2192 Localization Dashboard Select your localization target Click the “AI Translate” button in the toolbar Step 2: Choose Your AI Provider The plugin supports multiple AI providers, each with different advantages for your project needs:\nLocal AI (Ollama)\nComplete privacy - data never leaves your machine No API costs or usage limits Works offline once models are downloaded Requires local setup and capable hardware Cloud Providers\nOpenAI: Consistently high quality, extensive model selection Anthropic Claude: Excellent for creative and narrative content DeepSeek: Cost-effective option with good quality Google Gemini: Strong multilingual support with competitive pricing Step 3: Configure Your Translation Service Configuration varies by provider but typically includes:\nFor Cloud Services:\nAPI Key for authentication Model selection (newer models generally offer better quality) Temperature settings (0.3 recommended for consistent translations) Request timeout and retry settings For Local AI:\nBase URL (typically http:\/\/localhost:11434 for Ollama) Model name (e.g., “llama3.2”) Local processing parameters For detailed configuration options for each provider, see the Translation Providers Guide .\nStep 4: Process Your Translations With configuration complete, the automated translation process becomes straightforward:\nReview discovered content - The system automatically finds all localizable text Start processing - Click “Start Translation” to initiate batch translation Monitor progress - Watch real-time updates as translations complete Save results - Click “Save Translations” to commit successful translations The entire process typically completes in minutes for projects with hundreds of text entries.\nYour browser does not support the video tag. Completing the Localization Pipeline After AI translation, you need to complete the standard UE localization workflow:\n1. Update Localization System Return to the Localization Dashboard and run “Gather Text” to update the system with your new translations.\nYour browser does not support the video tag. 2. Compile Translations Use “Compile Text” to create the binary files your game will actually use.\nYour browser does not support the video tag. 3. Package Language Support In Project Settings \u2192 Packaging, ensure your target languages are selected for packaging:\nTesting Your Translations Verify your automated translations using UE’s built-in preview features:\nEditor Preview: Set “Preview Game Language” in Editor Preferences \u2192 Region & Language\nUMG Preview: Use the language selector in UMG widget previews\nBest Practices Start Small Begin with a subset of your content to test provider configuration and quality expectations before you process large batches.\nMonitor Quality Review translations, especially for:\nTechnical terminology specific to your game Cultural references that may need adaptation UI text that must fit within space constraints Maintain Consistency Use consistent prompt templates and provider settings across your project to ensure terminology remains uniform.\nVersion Control Integration The AI Localization Automator integrates with UE’s standard localization files, which makes it compatible with your existing version control workflow.\nThe Impact on Game Development Automated AI translation changes localization from a bottleneck into an enabler:\nFaster Iteration: Test your game in multiple languages during development Broader Market Access: Cost-effectively target international markets Enhanced Accessibility: Make your game available to global audiences Resource Allocation: Focus human expertise on polish and cultural adaptation rather than initial translation Key Features of AI Localization Automator The AI Localization Automator plugin provides:\nMultiple AI Providers: Choose from OpenAI, Claude, DeepSeek, Gemini, or run locally with Ollama Seamless Integration: Built-in integration with Unreal Engine’s Localization Dashboard Batch Processing: Translate hundreds of text entries efficiently with configurable concurrency Smart Retry System: Automatic retry logic with configurable failure thresholds Real-time Progress Tracking: Live progress updates with detailed status information Production Ready: Tested extensively with large-scale localization projects For complete documentation, visit docs.georgy.dev\/ai-localization-automator .\nConclusion AI-powered localization represents a significant shift in how developers approach international game distribution. The AI Localization Automator automates the translation process while it maintains integration with Unreal Engine’s robust localization system. Developers can focus on creating great games rather than managing complex translation workflows.\nWhether you’re an indie developer who wants to expand market reach or a studio that manages large-scale localization projects, automated AI translation provides the tools to make multilingual game development both accessible and efficient.\n","permalink":"https:\/\/georgy.dev\/posts\/automate-unreal-engine-localization-workflow-ai\/","summary":"

Game localization has traditionally been a time-consuming and expensive process. Manual translation work often requires weeks of coordination with external services. AI language models now provide developers with powerful tools to streamline this workflow while they maintain quality and reduce costs.<\/p>\n

This guide demonstrates how to set up automated AI-powered translation for your Unreal Engine project using the \n AI Localization Automator plugin\n <\/a>. The plugin turns hours of manual work into minutes of automated processing.<\/p>","title":"How to automate your Unreal Engine localization workflow with AI"},{"content":"Introduction Still, as of UE 5.5, multi-line editable text boxes lack proper keyboard and gamepad navigation support. Let’s fix this without modifying the engine’s source code. I’ll experiment with a simple 2x2 grid of text boxes to demonstrate how we can implement smooth, unified navigation across both keyboard and gamepad input devices, which you can also recreate for testing purposes.\nCurrent Limitations Keyboard Arrow keys only allow navigation within the content of a single text box, and there’s no way to navigate between text boxes themselves.\nGamepad The left stick moves between the text boxes, but neither the right stick nor the D-pad can be used to navigate between the content of a text box or between boxes themselves.\nSolution To fix this, we will create custom widgets extending both UMultiLineEditableTextBox (for UMG) and SMultiLineEditableTextBox (for Slate). The UMG widget will override the RebuildWidget() method to instantiate our custom Slate widget, which will handle both keyboard and gamepad navigation in a unified way.\nHere’s the implementation:\nClick to see the code Header:\nclass RUNTIMETTSDEMO_API SCustomMultiLineEditableTextBox : public SMultiLineEditableTextBox { protected: \/** Whether we should ignore the next OnKeyDown event *\/ bool bIgnoreOnKeyDown = false; public: \/\/~ Begin SWidget Interface virtual bool SupportsKeyboardFocus() const override { return true; } virtual FReply OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent) override; \/\/~ End SWidget Interface virtual FReply HandleNavigation(const FGeometry& MyGeometry, EUINavigation Navigation); }; UCLASS(ClassGroup = "UI", meta = (Category = "Mod.io Common UI")) class RUNTIMETTSDEMO_API UCustomMultiLineEditableTextBox : public UMultiLineEditableTextBox { GENERATED_BODY() protected: virtual TSharedRef<SWidget> RebuildWidget() override; }; Source:\nFReply SCustomMultiLineEditableTextBox::OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent) { if (bIgnoreOnKeyDown) { return FReply::Unhandled(); } const FKey Key = InKeyEvent.GetKey(); if (Key == EKeys::Up || Key == EKeys::Gamepad_RightStick_Up || Key == EKeys::Gamepad_LeftStick_Up || Key == EKeys::Gamepad_DPad_Up) { return HandleNavigation(MyGeometry, EUINavigation::Up); } if (Key == EKeys::Down || Key == EKeys::Gamepad_RightStick_Down || Key == EKeys::Gamepad_LeftStick_Down || Key == EKeys::Gamepad_DPad_Down) { return HandleNavigation(MyGeometry, EUINavigation::Down); } if (Key == EKeys::Left || Key == EKeys::Gamepad_RightStick_Left || Key == EKeys::Gamepad_LeftStick_Left || Key == EKeys::Gamepad_DPad_Left) { return HandleNavigation(MyGeometry, EUINavigation::Left); } if (Key == EKeys::Right || Key == EKeys::Gamepad_RightStick_Right || Key == EKeys::Gamepad_LeftStick_Right || Key == EKeys::Gamepad_DPad_Right) { return HandleNavigation(MyGeometry, EUINavigation::Right); } return FReply::Unhandled(); } FReply SCustomMultiLineEditableTextBox::HandleNavigation(const FGeometry& MyGeometry, EUINavigation Navigation) { TSharedPtr<SWidget> EditableTextWidget = StaticCastSharedPtr<SWidget>(EditableText); if (!EditableTextWidget) { UE_LOG(LogTemp, Error, TEXT("Unable to handle '%s' navigation for the multi line text box: EditableText widget is null"), *UEnum::GetValueAsString(Navigation)); return FReply::Unhandled(); } UE_LOG(LogTemp, Log, TEXT("Sending '%s' navigation to the multiline editable text"), *UEnum::GetValueAsString(Navigation)); FKey NavigationKey = [Navigation]() { switch (Navigation) { case EUINavigation::Previous: case EUINavigation::Left: return EKeys::Left; case EUINavigation::Next: case EUINavigation::Right: return EKeys::Right; case EUINavigation::Up: return EKeys::Up; case EUINavigation::Down: return EKeys::Down; default: { UE_LOG(LogTemp, Error, TEXT("Invalid navigation direction '%s'"), *UEnum::GetValueAsString(Navigation)); return EKeys::Invalid; } } }(); const FTextLocation PriorCursorPosition = EditableText->GetCursorLocation(); FKeyEvent NavigationEvent(NavigationKey, FSlateApplication::Get().GetModifierKeys(), 0, false, 0, 0); bIgnoreOnKeyDown = true; FReply HandledEvent = EditableTextWidget->OnKeyDown(MyGeometry, NavigationEvent); bIgnoreOnKeyDown = false; const FTextLocation NewCursorPosition = EditableText->GetCursorLocation(); \/\/ If the cursor changed position, the editable text handled the event by moving the cursor if (PriorCursorPosition != NewCursorPosition) { return HandledEvent; } \/\/ Otherwise, simulate navigation using the gamepad to go beyond the widget's bounds const float AnalogValue = [Navigation]() { switch (Navigation) { case EUINavigation::Previous: case EUINavigation::Left: return -1.0f; case EUINavigation::Next: case EUINavigation::Right: return 1.0f; case EUINavigation::Up: return 1.0f; case EUINavigation::Down: return -1.0f; default: { UE_LOG(LogTemp, Error, TEXT("Invalid navigation direction '%s'"), *UEnum::GetValueAsString(Navigation)); return 0.0f; } } }(); const FKey GamepadKey = [Navigation]() { switch (Navigation) { case EUINavigation::Previous: case EUINavigation::Left: return EKeys::Gamepad_LeftX; case EUINavigation::Next: case EUINavigation::Right: return EKeys::Gamepad_LeftX; case EUINavigation::Up: return EKeys::Gamepad_LeftY; case EUINavigation::Down: return EKeys::Gamepad_LeftY; default: { UE_LOG(LogTemp, Error, TEXT("Invalid navigation direction '%s'"), *UEnum::GetValueAsString(Navigation)); return EKeys::Invalid; } } }(); FAnalogInputEvent GamepadEvent(GamepadKey, FSlateApplication::Get().GetModifierKeys(), 0, false, 0, 0, AnalogValue); FSlateApplication::Get().ProcessAnalogInputEvent(GamepadEvent); return FReply::Handled(); } TSharedRef<SWidget> UCustomMultiLineEditableTextBox::RebuildWidget() { MyEditableTextBlock = SNew(SCustomMultiLineEditableTextBox) .Style(&WidgetStyle) .AllowContextMenu(AllowContextMenu) .IsReadOnly(bIsReadOnly) .VirtualKeyboardOptions(VirtualKeyboardOptions) .VirtualKeyboardDismissAction(VirtualKeyboardDismissAction) .OnTextChanged(BIND_UOBJECT_DELEGATE(FOnTextChanged, HandleOnTextChanged)) .OnTextCommitted(BIND_UOBJECT_DELEGATE(FOnTextCommitted, HandleOnTextCommitted)); MyEditableTextBlock->SetOnKeyDownHandler(FOnKeyDown::CreateWeakLambda(this, [this](const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent) -> FReply { if (TSharedPtr<SWidget> WidgetToHandle = StaticCastSharedPtr<SWidget>(MyEditableTextBlock)) { return WidgetToHandle->OnKeyDown(MyGeometry, InKeyEvent); } return FReply::Unhandled(); })); return MyEditableTextBlock.ToSharedRef(); } Result The result is smooth, consistent navigation:\nKeyboard: Gamepad: ","permalink":"https:\/\/georgy.dev\/posts\/multi-line-editable-text-box-navigations\/","summary":"

Introduction<\/h3>\n

Still, as of UE 5.5, multi-line editable text boxes lack proper keyboard and gamepad navigation support. Let’s fix this without modifying the engine’s source code. I’ll experiment with a simple 2x2 grid of text boxes to demonstrate how we can implement smooth, unified navigation across both keyboard and gamepad input devices, which you can also recreate for testing purposes.<\/p>\n

Current Limitations<\/h3>\n

Keyboard<\/h4>\n

Arrow keys only allow navigation within the content of a single text box, and there’s no way to navigate between text boxes themselves.<\/p>","title":"Improve multi-line editable text box keyboard and gamepad navigations"},{"content":"Need to use third-party libraries that depend on spdlog in your Unreal project? Here’s how to simulate the spdlog API using Unreal’s native UE_LOG system, to let you avoid adding extra dependencies while keeping your code clean.\nWe’ll create a logging utility class that matches the spdlog interface, handling type conversions to FString and formatting along the way.\nImplementation Here’s the code that bridges spdlog and Unreal’s logging system:\n#pragma once #include "Containers\/UnrealString.h" #include "Internationalization\/Text.h" #include "Templates\/EnableIf.h" #include "Templates\/IsIntegral.h" #include "Templates\/IsFloatingPoint.h" #include "Logging\/LogMacros.h" #include <string> DEFINE_LOG_CATEGORY_STATIC(LogPiperLibrary, Log, All); \/** * Class to simulate the spdlog API in Unreal Engine * spdlog is used in the original piper *\/ class spdlog { private: \/\/ Template function for integral types template <typename T, typename TEnableIf<TIsIntegral<T>::Value, bool>::Type = 0> static FString ToFString(T value) { \/\/ Most integral types won't be larger than signed 64-bit integer \/\/ TODO: Add support for larger integral types supported by UE (uint64) return FString::Printf(TEXT("%lld"), static_cast<int64>(value)); } \/\/ Template function for floating-point types template <typename T, typename TEnableIf<TIsFloatingPoint<T>::Value, bool>::Type = 0> static FString ToFString(T value) { return FString::Printf(TEXT("%f"), static_cast<double>(value)); } \/\/ Specialize for FString static FString ToFString(const FString& Value) { return Value; } \/\/ Specialize for std::string static FString ToFString(const std::string& Value) { return StringCast<TCHAR>(Value.c_str(), Value.size()).Get(); } \/\/ Convert the format string to UTF-16 for Unreal Engine static FText ConvertFormatString(const char* FormatString) { \/\/ Convert the format string to FText return FText::FromString(StringCast<TCHAR>(FormatString).Get()); } \/\/ Convert a single argument to FFormatArgumentValue template <typename T> static FFormatArgumentValue ToFormatArgumentValue(const T& value) { return FFormatArgumentValue(FText::FromString(ToFString(value))); } \/\/ Specialize for FString static FFormatArgumentValue ToFormatArgumentValue(const FString& value) { return FFormatArgumentValue(FText::FromString(value)); } \/\/ Specialize for std::string static FFormatArgumentValue ToFormatArgumentValue(const std::string& value) { return FFormatArgumentValue(FText::FromString(StringCast<TCHAR>(value.c_str(), value.size()).Get())); } \/** * Replace {} placeholders with {0}, {1}, etc * This is necessary because FText::Format does not support {} placeholders * @param FormatString The format string to convert * @return The converted format string *\/ static FString ConvertBracedFormatString(const FString& FormatString) { FString ConvertedFormatString = FormatString; int32 PlaceholderIndex = 0; while (ConvertedFormatString.Contains(TEXT("{}"))) { FStringBuilderBase Builder; Builder = ConvertedFormatString; Builder.ReplaceAt(ConvertedFormatString.Find(TEXT("{}")), 2, FString::Printf(TEXT("{%d}"), PlaceholderIndex++)); ConvertedFormatString = Builder.ToString(); } return ConvertedFormatString; } \/\/ Format log message with provided arguments template <typename... Args> static FString FormatLogMessage(const char* FormatString, Args... args) { \/\/ Convert the format string to FText and replace placeholders FText FormatText = ConvertFormatString(FormatString); FText ConvertedFormatText = FText::FromString(ConvertBracedFormatString(FormatText.ToString())); \/\/ Create an array to hold the arguments for formatting TArray<FFormatArgumentValue> FormatArgs; (FormatArgs.Add(ToFormatArgumentValue(args)), ...); \/\/ Use FText to format the string with arguments FText FormattedText = FText::Format(ConvertedFormatText, FormatArgs); return FormattedText.ToString(); } public: \/\/~ Functions for simulating the spdlog API template <typename... Args> static void error(const char* FormatString, Args... args) { FString LogMessage = FormatLogMessage(FormatString, args...); UE_LOG(LogPiperLibrary, Error, TEXT("%s"), *LogMessage); } template <typename... Args> static void warn(const char* FormatString, Args... args) { FString LogMessage = FormatLogMessage(FormatString, args...); UE_LOG(LogPiperLibrary, Warning, TEXT("%s"), *LogMessage); } template <typename... Args> static void debug(const char* FormatString, Args... args) { FString LogMessage = FormatLogMessage(FormatString, args...); UE_LOG(LogPiperLibrary, Log, TEXT("%s"), *LogMessage); } template <typename... Args> static void info(const char* FormatString, Args... args) { FString LogMessage = FormatLogMessage(FormatString, args...); UE_LOG(LogPiperLibrary, Log, TEXT("%s"), *LogMessage); } \/\/ @formatter:off \/\/ Dummy functionality to simulate the spdlog API struct level { constexpr static bool debug = false; }; static bool should_log(bool) { return true; } \/\/ Add more functions as needed \/\/ @formatter:on }; Usage The class lets you use familiar spdlog calls like spdlog::info, spdlog::debug, spdlog::warn, and spdlog::error in your code. Behind the scenes, it routes everything through Unreal’s logging system, so you can avoid adding the spdlog dependency to your project.\n","permalink":"https:\/\/georgy.dev\/posts\/spdlog-ue\/","summary":"

Need to use third-party libraries that depend on spdlog<\/code> in your Unreal project? Here’s how to simulate the spdlog<\/code> API using Unreal’s native UE_LOG<\/code> system, to let you avoid adding extra dependencies while keeping your code clean.<\/p>\n

We’ll create a logging utility class that matches the spdlog<\/code> interface, handling type conversions to FString<\/code> and formatting along the way.<\/p>\n

Implementation<\/h3>\n

Here’s the code that bridges spdlog<\/code> and Unreal’s logging system:<\/p>\n

#pragma once\n<\/span><\/span><\/span><\/span>\n<\/span><\/span>#include<\/span> "Containers\/UnrealString.h"<\/span>\n<\/span><\/span><\/span>#include<\/span> "Internationalization\/Text.h"<\/span>\n<\/span><\/span><\/span>#include<\/span> "Templates\/EnableIf.h"<\/span>\n<\/span><\/span><\/span>#include<\/span> "Templates\/IsIntegral.h"<\/span>\n<\/span><\/span><\/span>#include<\/span> "Templates\/IsFloatingPoint.h"<\/span>\n<\/span><\/span><\/span>#include<\/span> "Logging\/LogMacros.h"<\/span>\n<\/span><\/span><\/span>#include<\/span> <string><\/span>\n<\/span><\/span><\/span><\/span>\n<\/span><\/span>DEFINE_LOG_CATEGORY_STATIC<\/span>(<\/span>LogPiperLibrary<\/span>,<\/span> Log<\/span>,<\/span> All<\/span>);<\/span>\n<\/span><\/span>\n<\/span><\/span>\/**\n<\/span><\/span><\/span> * Class to simulate the spdlog API in Unreal Engine\n<\/span><\/span><\/span> * spdlog is used in the original piper \n<\/span><\/span><\/span> *\/<\/span>\n<\/span><\/span>class<\/span> spdlog<\/span>\n<\/span><\/span>{<\/span>\n<\/span><\/span>private<\/span>:<\/span>\n<\/span><\/span>\t\/\/ Template function for integral types\n<\/span><\/span><\/span><\/span>\ttemplate<\/span> <<\/span>typename<\/span> T<\/span>,<\/span> typename<\/span> TEnableIf<\/span><<\/span>TIsIntegral<\/span><<\/span>T<\/span>>::<\/span>Value<\/span>,<\/span> bool<\/span>>::<\/span>Type<\/span> =<\/span> 0<\/span>><\/span>\n<\/span><\/span>\tstatic<\/span> FString<\/span> ToFString<\/span>(<\/span>T<\/span> value<\/span>)<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\t\/\/ Most integral types won't be larger than signed 64-bit integer\n<\/span><\/span><\/span><\/span>\t\t\/\/ TODO: Add support for larger integral types supported by UE (uint64)\n<\/span><\/span><\/span><\/span>\t\treturn<\/span> FString<\/span>::<\/span>Printf<\/span>(<\/span>TEXT<\/span>(<\/span>"%lld"<\/span>),<\/span> static_cast<\/span><<\/span>int64<\/span>><\/span>(<\/span>value<\/span>));<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\n<\/span><\/span>\t\/\/ Template function for floating-point types\n<\/span><\/span><\/span><\/span>\ttemplate<\/span> <<\/span>typename<\/span> T<\/span>,<\/span> typename<\/span> TEnableIf<\/span><<\/span>TIsFloatingPoint<\/span><<\/span>T<\/span>>::<\/span>Value<\/span>,<\/span> bool<\/span>>::<\/span>Type<\/span> =<\/span> 0<\/span>><\/span>\n<\/span><\/span>\tstatic<\/span> FString<\/span> ToFString<\/span>(<\/span>T<\/span> value<\/span>)<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\treturn<\/span> FString<\/span>::<\/span>Printf<\/span>(<\/span>TEXT<\/span>(<\/span>"%f"<\/span>),<\/span> static_cast<\/span><<\/span>double<\/span>><\/span>(<\/span>value<\/span>));<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\n<\/span><\/span>\t\/\/ Specialize for FString\n<\/span><\/span><\/span><\/span>\tstatic<\/span> FString<\/span> ToFString<\/span>(<\/span>const<\/span> FString<\/span>&<\/span> Value<\/span>)<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\treturn<\/span> Value<\/span>;<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\n<\/span><\/span>\t\/\/ Specialize for std::string\n<\/span><\/span><\/span><\/span>\tstatic<\/span> FString<\/span> ToFString<\/span>(<\/span>const<\/span> std<\/span>::<\/span>string<\/span>&<\/span> Value<\/span>)<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\treturn<\/span> StringCast<\/span><<\/span>TCHAR<\/span>><\/span>(<\/span>Value<\/span>.<\/span>c_str<\/span>(),<\/span> Value<\/span>.<\/span>size<\/span>()).<\/span>Get<\/span>();<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\n<\/span><\/span>\t\/\/ Convert the format string to UTF-16 for Unreal Engine\n<\/span><\/span><\/span><\/span>\tstatic<\/span> FText<\/span> ConvertFormatString<\/span>(<\/span>const<\/span> char<\/span>*<\/span> FormatString<\/span>)<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\t\/\/ Convert the format string to FText\n<\/span><\/span><\/span><\/span>\t\treturn<\/span> FText<\/span>::<\/span>FromString<\/span>(<\/span>StringCast<\/span><<\/span>TCHAR<\/span>><\/span>(<\/span>FormatString<\/span>).<\/span>Get<\/span>());<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\n<\/span><\/span>\t\/\/ Convert a single argument to FFormatArgumentValue\n<\/span><\/span><\/span><\/span>\ttemplate<\/span> <<\/span>typename<\/span> T<\/span>><\/span>\n<\/span><\/span>\tstatic<\/span> FFormatArgumentValue<\/span> ToFormatArgumentValue<\/span>(<\/span>const<\/span> T<\/span>&<\/span> value<\/span>)<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\treturn<\/span> FFormatArgumentValue<\/span>(<\/span>FText<\/span>::<\/span>FromString<\/span>(<\/span>ToFString<\/span>(<\/span>value<\/span>)));<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\n<\/span><\/span>\t\/\/ Specialize for FString\n<\/span><\/span><\/span><\/span>\tstatic<\/span> FFormatArgumentValue<\/span> ToFormatArgumentValue<\/span>(<\/span>const<\/span> FString<\/span>&<\/span> value<\/span>)<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\treturn<\/span> FFormatArgumentValue<\/span>(<\/span>FText<\/span>::<\/span>FromString<\/span>(<\/span>value<\/span>));<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\n<\/span><\/span>\t\/\/ Specialize for std::string\n<\/span><\/span><\/span><\/span>\tstatic<\/span> FFormatArgumentValue<\/span> ToFormatArgumentValue<\/span>(<\/span>const<\/span> std<\/span>::<\/span>string<\/span>&<\/span> value<\/span>)<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\treturn<\/span> FFormatArgumentValue<\/span>(<\/span>FText<\/span>::<\/span>FromString<\/span>(<\/span>StringCast<\/span><<\/span>TCHAR<\/span>><\/span>(<\/span>value<\/span>.<\/span>c_str<\/span>(),<\/span> value<\/span>.<\/span>size<\/span>()).<\/span>Get<\/span>()));<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\n<\/span><\/span>\t\/**\n<\/span><\/span><\/span>\t * Replace {} placeholders with {0}, {1}, etc\n<\/span><\/span><\/span>\t * This is necessary because FText::Format does not support {} placeholders\n<\/span><\/span><\/span>\t * @param FormatString The format string to convert\n<\/span><\/span><\/span>\t * @return The converted format string\n<\/span><\/span><\/span>\t *\/<\/span>\n<\/span><\/span>\tstatic<\/span> FString<\/span> ConvertBracedFormatString<\/span>(<\/span>const<\/span> FString<\/span>&<\/span> FormatString<\/span>)<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\tFString<\/span> ConvertedFormatString<\/span> =<\/span> FormatString<\/span>;<\/span>\n<\/span><\/span>\t\tint32<\/span> PlaceholderIndex<\/span> =<\/span> 0<\/span>;<\/span>\n<\/span><\/span>\n<\/span><\/span>\t\twhile<\/span> (<\/span>ConvertedFormatString<\/span>.<\/span>Contains<\/span>(<\/span>TEXT<\/span>(<\/span>"{}"<\/span>)))<\/span>\n<\/span><\/span>\t\t{<\/span>\n<\/span><\/span>\t\t\tFStringBuilderBase<\/span> Builder<\/span>;<\/span>\n<\/span><\/span>\t\t\tBuilder<\/span> =<\/span> ConvertedFormatString<\/span>;<\/span>\n<\/span><\/span>\t\t\tBuilder<\/span>.<\/span>ReplaceAt<\/span>(<\/span>ConvertedFormatString<\/span>.<\/span>Find<\/span>(<\/span>TEXT<\/span>(<\/span>"{}"<\/span>)),<\/span> 2<\/span>,<\/span>\n<\/span><\/span>\t\t\t                  FString<\/span>::<\/span>Printf<\/span>(<\/span>TEXT<\/span>(<\/span>"{%d}"<\/span>),<\/span> PlaceholderIndex<\/span>++<\/span>));<\/span>\n<\/span><\/span>\t\t\tConvertedFormatString<\/span> =<\/span> Builder<\/span>.<\/span>ToString<\/span>();<\/span>\n<\/span><\/span>\t\t}<\/span>\n<\/span><\/span>\n<\/span><\/span>\t\treturn<\/span> ConvertedFormatString<\/span>;<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\n<\/span><\/span>\t\/\/ Format log message with provided arguments\n<\/span><\/span><\/span><\/span>\ttemplate<\/span> <<\/span>typename<\/span>...<\/span> Args<\/span>><\/span>\n<\/span><\/span>\tstatic<\/span> FString<\/span> FormatLogMessage<\/span>(<\/span>const<\/span> char<\/span>*<\/span> FormatString<\/span>,<\/span> Args<\/span>...<\/span> args<\/span>)<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\t\/\/ Convert the format string to FText and replace placeholders\n<\/span><\/span><\/span><\/span>\t\tFText<\/span> FormatText<\/span> =<\/span> ConvertFormatString<\/span>(<\/span>FormatString<\/span>);<\/span>\n<\/span><\/span>\t\tFText<\/span> ConvertedFormatText<\/span> =<\/span> FText<\/span>::<\/span>FromString<\/span>(<\/span>ConvertBracedFormatString<\/span>(<\/span>FormatText<\/span>.<\/span>ToString<\/span>()));<\/span>\n<\/span><\/span>\n<\/span><\/span>\t\t\/\/ Create an array to hold the arguments for formatting\n<\/span><\/span><\/span><\/span>\t\tTArray<\/span><<\/span>FFormatArgumentValue<\/span>><\/span> FormatArgs<\/span>;<\/span>\n<\/span><\/span>\t\t(<\/span>FormatArgs<\/span>.<\/span>Add<\/span>(<\/span>ToFormatArgumentValue<\/span>(<\/span>args<\/span>)),<\/span> ...);<\/span>\n<\/span><\/span>\n<\/span><\/span>\t\t\/\/ Use FText to format the string with arguments\n<\/span><\/span><\/span><\/span>\t\tFText<\/span> FormattedText<\/span> =<\/span> FText<\/span>::<\/span>Format<\/span>(<\/span>ConvertedFormatText<\/span>,<\/span> FormatArgs<\/span>);<\/span>\n<\/span><\/span>\t\treturn<\/span> FormattedText<\/span>.<\/span>ToString<\/span>();<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\n<\/span><\/span>public<\/span>:<\/span>\n<\/span><\/span>\t\/\/~ Functions for simulating the spdlog API\n<\/span><\/span><\/span><\/span>\ttemplate<\/span> <<\/span>typename<\/span>...<\/span> Args<\/span>><\/span>\n<\/span><\/span>\tstatic<\/span> void<\/span> error<\/span>(<\/span>const<\/span> char<\/span>*<\/span> FormatString<\/span>,<\/span> Args<\/span>...<\/span> args<\/span>)<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\tFString<\/span> LogMessage<\/span> =<\/span> FormatLogMessage<\/span>(<\/span>FormatString<\/span>,<\/span> args<\/span>...);<\/span>\n<\/span><\/span>\t\tUE_LOG<\/span>(<\/span>LogPiperLibrary<\/span>,<\/span> Error<\/span>,<\/span> TEXT<\/span>(<\/span>"%s"<\/span>),<\/span> *<\/span>LogMessage<\/span>);<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\n<\/span><\/span>\ttemplate<\/span> <<\/span>typename<\/span>...<\/span> Args<\/span>><\/span>\n<\/span><\/span>\tstatic<\/span> void<\/span> warn<\/span>(<\/span>const<\/span> char<\/span>*<\/span> FormatString<\/span>,<\/span> Args<\/span>...<\/span> args<\/span>)<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\tFString<\/span> LogMessage<\/span> =<\/span> FormatLogMessage<\/span>(<\/span>FormatString<\/span>,<\/span> args<\/span>...);<\/span>\n<\/span><\/span>\t\tUE_LOG<\/span>(<\/span>LogPiperLibrary<\/span>,<\/span> Warning<\/span>,<\/span> TEXT<\/span>(<\/span>"%s"<\/span>),<\/span> *<\/span>LogMessage<\/span>);<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\n<\/span><\/span>\ttemplate<\/span> <<\/span>typename<\/span>...<\/span> Args<\/span>><\/span>\n<\/span><\/span>\tstatic<\/span> void<\/span> debug<\/span>(<\/span>const<\/span> char<\/span>*<\/span> FormatString<\/span>,<\/span> Args<\/span>...<\/span> args<\/span>)<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\tFString<\/span> LogMessage<\/span> =<\/span> FormatLogMessage<\/span>(<\/span>FormatString<\/span>,<\/span> args<\/span>...);<\/span>\n<\/span><\/span>\t\tUE_LOG<\/span>(<\/span>LogPiperLibrary<\/span>,<\/span> Log<\/span>,<\/span> TEXT<\/span>(<\/span>"%s"<\/span>),<\/span> *<\/span>LogMessage<\/span>);<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\n<\/span><\/span>\ttemplate<\/span> <<\/span>typename<\/span>...<\/span> Args<\/span>><\/span>\n<\/span><\/span>\tstatic<\/span> void<\/span> info<\/span>(<\/span>const<\/span> char<\/span>*<\/span> FormatString<\/span>,<\/span> Args<\/span>...<\/span> args<\/span>)<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\tFString<\/span> LogMessage<\/span> =<\/span> FormatLogMessage<\/span>(<\/span>FormatString<\/span>,<\/span> args<\/span>...);<\/span>\n<\/span><\/span>\t\tUE_LOG<\/span>(<\/span>LogPiperLibrary<\/span>,<\/span> Log<\/span>,<\/span> TEXT<\/span>(<\/span>"%s"<\/span>),<\/span> *<\/span>LogMessage<\/span>);<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\n<\/span><\/span>\t\/\/ @formatter:off\n<\/span><\/span><\/span><\/span>\n<\/span><\/span>\t\/\/ Dummy functionality to simulate the spdlog API\n<\/span><\/span><\/span><\/span>\tstruct<\/span> level<\/span> {<\/span> constexpr<\/span> static<\/span> bool<\/span> debug<\/span> =<\/span> false<\/span>;<\/span> };<\/span>\n<\/span><\/span>\tstatic<\/span> bool<\/span> should_log<\/span>(<\/span>bool<\/span>)<\/span> {<\/span> return<\/span> true<\/span>;<\/span> }<\/span>\n<\/span><\/span>\t\/\/ Add more functions as needed\n<\/span><\/span><\/span><\/span>\n<\/span><\/span>\t\/\/ @formatter:on\n<\/span><\/span><\/span><\/span>};<\/span>\n<\/span><\/span><\/code><\/pre><\/div>
Usage<\/h3>\n
The class lets you use familiar spdlog<\/code> calls like spdlog::info<\/code>, spdlog::debug<\/code>, spdlog::warn<\/code>, and spdlog::error<\/code> in your code. Behind the scenes, it routes everything through Unreal’s logging system, so you can avoid adding the spdlog<\/code> dependency to your project.<\/p>","title":"Simulating spdlog in Unreal Engine"},{"content":"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:\n\/** * 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 =\tStaticCastSharedPtr<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; } ","permalink":"https:\/\/georgy.dev\/posts\/common-ui-button-focus\/","summary":"
As of UE 5.4, the Common UI button (UCommonButtonBase<\/code>) still doesn’t support direct focus settings. This is because UCommonButtonBase<\/code> is derived from UUserWidget<\/code>, 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:<\/p>\n
\/**\n<\/span><\/span><\/span> * Sets the focus on the button\n<\/span><\/span><\/span> * This function performs the "deep" focus on the Common UI button, which means that it will set the focus on the button itself\n<\/span><\/span><\/span> * This is useful since UCommonButtonBase is derived from UUserWidget, which doesn't support focus when setting it directly\n<\/span><\/span><\/span> *\/<\/span>\n<\/span><\/span>UFUNCTION<\/span>(<\/span>BlueprintCallable<\/span>,<\/span> Category<\/span> =<\/span> "mod.io|UI|Button"<\/span>,<\/span> DisplayName<\/span> =<\/span> "Set Button Focus (Common UI)"<\/span>)<\/span>\n<\/span><\/span>void<\/span> SetCommonUIButtonFocus<\/span>()<\/span>\n<\/span><\/span>{<\/span>\n<\/span><\/span>#if UE_VERSION_OLDER_THAN(5, 3, 0)\n<\/span><\/span><\/span><\/span>\tif<\/span> (<\/span>bIsFocusable<\/span>)<\/span>\n<\/span><\/span>#else\n<\/span><\/span><\/span><\/span>\tif<\/span> (<\/span>IsFocusable<\/span>())<\/span>\n<\/span><\/span>#endif\n<\/span><\/span><\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\tif<\/span> (<\/span>TSharedPtr<\/span><<\/span>SButton<\/span>><\/span> SlateButton<\/span> =<\/span> GetSlateButton<\/span>())<\/span>\n<\/span><\/span>\t\t{<\/span>\n<\/span><\/span>\t\t\tif<\/span> (<\/span>SlateButton<\/span>-><\/span>SupportsKeyboardFocus<\/span>())<\/span>\n<\/span><\/span>\t\t\t{<\/span>\n<\/span><\/span>\t\t\t\tFSlateApplication<\/span>::<\/span>Get<\/span>().<\/span>SetKeyboardFocus<\/span>(<\/span>SlateButton<\/span>,<\/span> EFocusCause<\/span>::<\/span>Mouse<\/span>);<\/span>\n<\/span><\/span>\t\t\t\tUE_LOG<\/span>(<\/span>LogTemp<\/span>,<\/span> Log<\/span>,<\/span> TEXT<\/span>(<\/span>"Set focus on button '%s' (extended way)"<\/span>),<\/span> *<\/span>GetName<\/span>());<\/span>\n<\/span><\/span>\t\t\t}<\/span>\n<\/span><\/span>\t\t\telse<\/span>\n<\/span><\/span>\t\t\t{<\/span>\n<\/span><\/span>\t\t\t\tUE_LOG<\/span>(<\/span>LogTemp<\/span>,<\/span> Warning<\/span>,<\/span> TEXT<\/span>(<\/span>"Trying to set focus on button '%s' but the button does not support keyboard focus"<\/span>),<\/span> *<\/span>GetName<\/span>());<\/span>\n<\/span><\/span>\t\t\t}<\/span>\n<\/span><\/span>\t\t}<\/span>\n<\/span><\/span>\t\telse<\/span>\n<\/span><\/span>\t\t{<\/span>\n<\/span><\/span>\t\t\tUE_LOG<\/span>(<\/span>LogTemp<\/span>,<\/span> Warning<\/span>,<\/span> TEXT<\/span>(<\/span>"Trying to set focus on button '%s' but the slate button could not be found"<\/span>),<\/span> *<\/span>GetName<\/span>());<\/span>\n<\/span><\/span>\t\t}<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\telse<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\tUE_LOG<\/span>(<\/span>LogTemp<\/span>,<\/span> Warning<\/span>,<\/span> TEXT<\/span>(<\/span>"Trying to set focus on button '%s' but the button is not focusable"<\/span>),<\/span> *<\/span>GetName<\/span>());<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>}<\/span>\n<\/span><\/span>\n<\/span><\/span>\/**\n<\/span><\/span><\/span> * Gets the Slate button widget\n<\/span><\/span><\/span> * The button is highly encapsulated and this function tries to scan the widget tree to find the button\n<\/span><\/span><\/span> * @return The Slate button widget if found, nullptr otherwise\n<\/span><\/span><\/span> *\/<\/span>\n<\/span><\/span>TSharedPtr<\/span><<\/span>SButton<\/span>><\/span> GetSlateButton<\/span>()<\/span> const<\/span>\n<\/span><\/span>{<\/span>\n<\/span><\/span>\tif<\/span> (<\/span>WidgetTree<\/span> &&<\/span> WidgetTree<\/span>-><\/span>RootWidget<\/span>)<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\tif<\/span> (<\/span>UButton<\/span>*<\/span> InternalButton<\/span> =<\/span> Cast<\/span><<\/span>UButton<\/span>><\/span>(<\/span>WidgetTree<\/span>-><\/span>RootWidget<\/span>))<\/span>\n<\/span><\/span>\t\t{<\/span>\n<\/span><\/span>\t\t\t\/\/ UCommonButtonInternalBase::RebuildWidget() creates a SBox wrapper for the button\n<\/span><\/span><\/span><\/span>\t\t\tif<\/span> (<\/span>TSharedPtr<\/span><<\/span>SBox<\/span>><\/span> BoxButtonWrapper<\/span> =<\/span>\tStaticCastSharedPtr<\/span><<\/span>SBox<\/span>><\/span>(<\/span>TSharedPtr<\/span><<\/span>SWidget<\/span>><\/span>(<\/span>InternalButton<\/span>-><\/span>GetCachedWidget<\/span>())))<\/span>\n<\/span><\/span>\t\t\t{<\/span>\n<\/span><\/span>\t\t\t\tif<\/span> (<\/span>BoxButtonWrapper<\/span>-><\/span>GetChildren<\/span>()<\/span> &&<\/span> BoxButtonWrapper<\/span>-><\/span>GetChildren<\/span>()<\/span>-><\/span>Num<\/span>()<\/span> ><\/span> 0<\/span>)<\/span>\n<\/span><\/span>\t\t\t\t{<\/span>\n<\/span><\/span>\t\t\t\t\tif<\/span> (<\/span>TSharedPtr<\/span><<\/span>SButton<\/span>><\/span> InternalButtonSlate<\/span> =<\/span> StaticCastSharedPtr<\/span><<\/span>SButton<\/span>><\/span>(<\/span>TSharedPtr<\/span><<\/span>SWidget<\/span>><\/span>(<\/span>BoxButtonWrapper<\/span>-><\/span>GetChildren<\/span>()<\/span>-><\/span>GetChildAt<\/span>(<\/span>0<\/span>))))<\/span>\n<\/span><\/span>\t\t\t\t\t{<\/span>\n<\/span><\/span>\t\t\t\t\t\treturn<\/span> InternalButtonSlate<\/span>;<\/span>\n<\/span><\/span>\t\t\t\t\t}<\/span>\n<\/span><\/span>\t\t\t\t}<\/span>\n<\/span><\/span>\t\t\t}<\/span>\n<\/span><\/span>\t\t\t\/\/ UButton::RebuildWidget() returns the button directly\n<\/span><\/span><\/span><\/span>\t\t\telse<\/span> if<\/span> (<\/span>TSharedPtr<\/span><<\/span>SButton<\/span>><\/span> InternalButtonSlate<\/span> =<\/span> StaticCastSharedPtr<\/span><<\/span>SButton<\/span>><\/span>(<\/span>InternalButton<\/span>-><\/span>GetCachedWidget<\/span>()))<\/span>\n<\/span><\/span>\t\t\t{<\/span>\n<\/span><\/span>\t\t\t\treturn<\/span> InternalButtonSlate<\/span>;<\/span>\n<\/span><\/span>\t\t\t}<\/span>\n<\/span><\/span>\t\t\telse<\/span>\n<\/span><\/span>\t\t\t{<\/span>\n<\/span><\/span>\t\t\t\tUE_LOG<\/span>(<\/span>LogTemp<\/span>,<\/span> Error<\/span>,<\/span> TEXT<\/span>(<\/span>"Could not find the Slate button widget for button '%s'"<\/span>),<\/span> *<\/span>GetName<\/span>());<\/span>\n<\/span><\/span>\t\t\t}<\/span>\n<\/span><\/span>\t\t}<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\treturn<\/span> nullptr<\/span>;<\/span>\n<\/span><\/span>}<\/span>\n<\/span><\/span><\/code><\/pre><\/div>","title":"How to focus a Common UI button (UCommonButtonBase) in Unreal Engine"},{"content":"In Unreal Engine, you can determine the currently focused widget in both Slate and UMG UI systems.\nSlate To get the currently focused Slate widget, you can use the following code snippet:\n\/\/ 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:\nUFUNCTION(BlueprintCallable) static UWidget* GetFocusedUMGWidget() { TSharedPtr<SWidget> FocusedSlateWidget = FSlateApplication::Get().GetUserFocusedWidget(0); if (!FocusedSlateWidget.IsValid()) { UE_LOG(LogTemp, Warning, TEXT("No focused Slate widget found")); return nullptr; } for (TObjectIterator<UWidget> Itr; Itr; ++Itr) { UWidget* CandidateUMGWidget = *Itr; if (CandidateUMGWidget->GetCachedWidget() == FocusedSlateWidget) { UE_LOG(LogTemp, Warning, TEXT("Focused UMG widget found: %s"), *CandidateUMGWidget->GetName()); return CandidateUMGWidget; } } UE_LOG(LogTemp, Warning, TEXT("No focused UMG widget found")); return nullptr; } ","permalink":"https:\/\/georgy.dev\/posts\/get-focused-widget\/","summary":"
In Unreal Engine, you can determine the currently focused widget in both Slate and UMG UI systems.<\/p>\n
Slate<\/h1>\n
To get the currently focused Slate widget, you can use the following code snippet:<\/p>\n
\/\/ Instead of 0, you can pass the user index if you have multiple users\n<\/span><\/span><\/span><\/span>TSharedPtr<\/span><<\/span>SWidget<\/span>><\/span> FocusedSlateWidget<\/span> =<\/span> FSlateApplication<\/span>::<\/span>Get<\/span>().<\/span>GetUserFocusedWidget<\/span>(<\/span>0<\/span>);<\/span>\n<\/span><\/span><\/code><\/pre><\/div>
UMG<\/h1>\n
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:<\/p>","title":"How to get the currently focused widget in Unreal Engine"},{"content":"If you want to execute some code when the scope is exited, you can use the following handy ON_SCOPE_EXIT macro, like this:\nint32 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; } ","permalink":"https:\/\/georgy.dev\/posts\/on-scope-exit\/","summary":"
If you want to execute some code when the scope is exited, you can use the following handy ON_SCOPE_EXIT<\/code> macro, like this:<\/p>\n
int32<\/span> AnyFunction<\/span>()<\/span>\n<\/span><\/span>{<\/span>\n<\/span><\/span>    ON_SCOPE_EXIT<\/span>\n<\/span><\/span>    {<\/span>\n<\/span><\/span>        \/\/ This code will be executed when the scope is exited (after the return statement)\n<\/span><\/span><\/span><\/span>    };<\/span>\n<\/span><\/span>\n<\/span><\/span>    \/\/ Do smth\n<\/span><\/span><\/span><\/span>    \n<\/span><\/span>    \/\/ Just return 100 for example\n<\/span><\/span><\/span><\/span>    return<\/span> 100<\/span>;<\/span>\n<\/span><\/span>}<\/span>\n<\/span><\/span><\/code><\/pre><\/div>","title":"How to execute code on scope exit in Unreal Engine"},{"content":"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:\nESlateVisibility 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.\nWe can use TGuardValue class from Unreal Engine which is a very simple RAII class that saves the value in its constructor and restores it in its destructor. Here’s how you can use it with the previous example:\nESlateVisibility VisibilityState; { TGuardValue<ESlateVisibility> Guard(VisibilityState, ESlateVisibility::Hidden); \/\/ Do smth. VisibilityState is Hidden here } \/\/ Once we exit the scope, Guard will restore the previous value of VisibilityState ","permalink":"https:\/\/georgy.dev\/posts\/guard-value\/","summary":"
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:<\/p>\n
ESlateVisibility<\/span> VisibilityState<\/span>;<\/span>\n<\/span><\/span>\n<\/span><\/span>const<\/span> ESlateVisibility<\/span> PreviousVisibility<\/span> =<\/span> VisibilityState<\/span>;<\/span>\n<\/span><\/span>VisibilityState<\/span> =<\/span> ESlateVisibility<\/span>::<\/span>Hidden<\/span>;<\/span>\n<\/span><\/span>\n<\/span><\/span>\/\/ Do smth. VisibilityState is Hidden here\n<\/span><\/span><\/span><\/span>\n<\/span><\/span>\/\/ Restore the previous visibility state\n<\/span><\/span><\/span><\/span>VisibilityState<\/span> =<\/span> PreviousVisibility<\/span>;<\/span>\n<\/span><\/span><\/code><\/pre><\/div>
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.<\/p>","title":"How to save and restore any value with RAII approach in Unreal Engine"},{"content":"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:\nTSharedPtr<SWidget> MyWidgetPtr; If you want to cast it, for example, to an SSpacer, your code might look like this:\nTSharedPtr<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.\nThe same approach works for shared references:\nTSharedRef<SWidget> MyWidgetRef; TSharedRef<SSpacer> MySpacerRef = StaticCastSharedRef<SSpacer>(MyWidgetRef); Alternatively, you can perform the casts manually, directly using static_cast or dynamic_cast with the widget. However, be aware that this approach may not be as reliable as the one provided above, so use it with caution.\n","permalink":"https:\/\/georgy.dev\/posts\/cast-slate-widget-pointer\/","summary":"
This brief article addresses the question of how to cast one Slate widget to another in Unreal Engine. Imagine you have an SWidget<\/code> widget wrapped in a shared pointer like this:<\/p>\n
TSharedPtr<\/span><<\/span>SWidget<\/span>><\/span> MyWidgetPtr<\/span>;<\/span>\n<\/span><\/span><\/code><\/pre><\/div>
If you want to cast it, for example, to an SSpacer<\/code>, your code might look like this:<\/p>\n
TSharedPtr<\/span><<\/span>SSpacer<\/span>><\/span> MySpacerPtr<\/span> =<\/span> StaticCastSharedPtr<\/span><<\/span>SSpacer<\/span>><\/span>(<\/span>MyWidgetPtr<\/span>);<\/span>\n<\/span><\/span><\/code><\/pre><\/div>
It’s important to keep in mind that you should verify whether the shared pointer is valid before using it.<\/p>\n
The same approach works for shared references:<\/p>","title":"How to cast Slate widgets in Unreal Engine"},{"content":"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.\nC++ Example if (UWorld* World = GetWorld()) { World->GetTimerManager().SetTimerForNextTick(FTimerDelegate::CreateWeakLambda(this, [this]() { UE_LOG(LogTemp, Warning, TEXT("This will be printed in log after 1 tick")); })); } Blueprints Example P.S. As an alternative approach, you can also use a general Delay node but specify “0.0” seconds, which is equivalent to 1 tick.\nAlso, if you don’t have access to the world or want to avoid this dependency, you can implement the delay using FTSTicker, a thread-safe ticker class. This is mainly used when there’s uncertainty regarding the world, and you want a more generic solution.\nFTSTicker::GetCoreTicker().AddTicker(FTickerDelegate::CreateLambda([](float DeltaTime) { UE_LOG(LogTemp, Warning, TEXT("This will be printed in log after 1 tick")); \/\/ Returning false will remove the ticker from the ticker list return false; })); ","permalink":"https:\/\/georgy.dev\/posts\/settimerfornexttick\/","summary":"
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 \n    this article\n  <\/a>, but sometimes even a single tick delay is sufficient and can enhance the overall user experience, preventing visual hitches and abrupt interactions.<\/p>","title":"How to set a timer for the next tick in Unreal Engine"},{"content":"Chunk downloading is a technique used to retrieve large binary data from the server in separate parts, ensuring reliability and compatibility across different platforms. Unreal Engine’s HTTP module has a limitation of 2GB for binary HTTP response content due to internal restrictions (specifically, TArray<uint8> uses the int32 size type, which has a maximum value of 2,147,483,647, approximately 2 GB in our case). To overcome this limitation, we can use the Range HTTP header supported by most servers, without requiring any file preparation or segmentation.\nAs a more generic example, you can take a look at the recent update of my plugin, Runtime Files Downloader . This plugin provides functionality to download files larger than 2GB to both memory and storage, with the only exception being Blueprints that don’t support TArray64<uint8>, and thus, it only has the functionality to save >2GB of data to storage.\nAnother implementation where chunk downloading is used is my recent plugin, Runtime Speech Recognizer , which includes a feature to download language model files larger than 2GB through the Unreal Engine Editor.\nBelow is a simplified code snippet for downloading files by chunks. In this example, the MaxChunkSize is set to 1048576 bytes (1MB), but you can modify it according to your specific requirements.\nSimplified code snippet Header file:\n#include "CoreMinimal.h" #include "Http.h" #include "Templates\/SharedPointer.h" #include "Async\/Future.h" UCLASS(BlueprintType) class YOURMODULE_API UDownloaderExample : public UObject { GENERATED_BODY() public: UFUNCTION(BlueprintCallable) void DownloadFunctionExample_BP(const FString& URL, const FString& SavePath); virtual TFuture<TArray64<uint8>> DownloadFile(const FString& URL); virtual TFuture<TArray64<uint8>> DownloadFileByChunk(const FString& URL, int64 ContentSize, int64 MaxChunkSize, FInt64Vector2 InternalContentRange = FInt64Vector2(), TArray64<uint8>&& InternalResultData = TArray64<uint8>()); protected: TWeakPtr<IHttpRequest, ESPMode::ThreadSafe> HttpRequestPtr; TFuture<int64> GetContentSize(const FString& URL); }; Source file:\nvoid UDownloaderExample::DownloadFunctionExample_BP(const FString& URL, const FString& SavePath) { DownloadFile(URL).Next([this, SavePath](TArray64<uint8>&& ResultData) { UE_LOG(LogTemp, Display, TEXT("Downloaded %lld bytes"), ResultData.Num()); FFileHelper::SaveArrayToFile(ResultData, *SavePath); }); } TFuture<TArray64<uint8>> UDownloaderExample::DownloadFile(const FString& URL) { TSharedRef<TPromise<TArray64<uint8>>> PromisePtr = MakeShared<TPromise<TArray64<uint8>>>(); GetContentSize(URL).Next([WeakThis = MakeWeakObjectPtr(this), PromisePtr, URL](int64 ContentSize) { if (!WeakThis.IsValid()) { UE_LOG(LogTemp, Error, TEXT("Failed to download file: this is no longer valid")); PromisePtr->SetValue(TArray64<uint8>()); return; } if (ContentSize <= 0) { UE_LOG(LogTemp, Error, TEXT("Failed to download file: content size is 0")); PromisePtr->SetValue(TArray64<uint8>()); return; } \/\/ 1048576 bytes = 1 MB. Just an arbitrary number to use as the chunk size WeakThis->DownloadFileByChunk(URL, ContentSize, 1048576).Next([PromisePtr](TArray64<uint8>&& ResultData) { PromisePtr->SetValue(MoveTemp(ResultData)); }); }); return PromisePtr->GetFuture(); } TFuture<TArray64<uint8>> UDownloaderExample::DownloadFileByChunk(const FString& URL, int64 ContentSize, int64 MaxChunkSize, FInt64Vector2 InternalContentRange, TArray64<uint8>&& InternalResultData) { if (MaxChunkSize <= 0) { UE_LOG(LogTemp, Error, TEXT("Failed to download chunk from %s: MaxChunkSize is 0"), *URL); return MakeFulfilledPromise<TArray64<uint8>>(TArray64<uint8>()).GetFuture(); } \/\/ If the InternalResultData was not provided, initialize it to the size of the file if (InternalResultData.Num() <= 0) { InternalResultData.SetNumUninitialized(ContentSize); } \/\/ If the InternalContentRange was not provided, set it to the first chunk of size MaxChunkSize if (InternalContentRange.X == 0 && InternalContentRange.Y == 0) { InternalContentRange.Y = FMath::Min(ContentSize, MaxChunkSize) - 1; } TSharedRef<IHttpRequest, ESPMode::ThreadSafe> HttpRequestRef = FHttpModule::Get().CreateRequest(); HttpRequestRef->SetVerb("GET"); HttpRequestRef->SetURL(URL); const FString RangeHeaderValue = FString::Format(TEXT("bytes={0}-{1}"), {InternalContentRange.X, InternalContentRange.Y}); HttpRequestRef->SetHeader(TEXT("Range"), RangeHeaderValue); TSharedRef<TPromise<TArray64<uint8>>> PromisePtr = MakeShared<TPromise<TArray64<uint8>>>(); HttpRequestRef->OnProcessRequestComplete().BindLambda([WeakThis = MakeWeakObjectPtr(this), PromisePtr, URL, ContentSize, MaxChunkSize, InternalContentRange, InternalResultData = MoveTemp(InternalResultData)](FHttpRequestPtr Request, FHttpResponsePtr Response, bool bSuccess) mutable { if (!WeakThis.IsValid()) { UE_LOG(LogTemp, Error, TEXT("Failed to download chunk from %s: this is no longer valid"), *Request->GetURL()); PromisePtr->SetValue(TArray64<uint8>()); return; } if (!bSuccess || !Response.IsValid()) { UE_LOG(LogTemp, Error, TEXT("Failed to download chunk from %s: request failed"), *Request->GetURL()); PromisePtr->SetValue(TArray64<uint8>()); return; } if (Response->GetContentSize() <= 0) { UE_LOG(LogTemp, Error, TEXT("Failed to download chunk from %s: content size is 0"), *Request->GetURL()); PromisePtr->SetValue(TArray64<uint8>()); return; } const int64 DataOffset = InternalContentRange.X; const TArray<uint8>& ResponseContent = Response->GetContent(); \/\/ Calculate the overall size of the downloaded content in the result buffer const int64 OverallDownloadedSize = DataOffset + ResponseContent.Num(); \/\/ Check if some values are out of range { if (DataOffset < 0 || DataOffset >= InternalResultData.Num()) { UE_LOG(LogTemp, Error, TEXT("Failed to download chunk from %s: data offset is out of range"), *Request->GetURL()); PromisePtr->SetValue(TArray64<uint8>()); return; } if (OverallDownloadedSize > InternalResultData.Num()) { UE_LOG(LogTemp, Error, TEXT("Failed to download chunk from %s: overall downloaded size is out of range"), *Request->GetURL()); PromisePtr->SetValue(TArray64<uint8>()); return; } } FMemory::Memcpy(InternalResultData.GetData() + DataOffset, ResponseContent.GetData(), ResponseContent.Num()); \/\/ Check if there's still more content to download if (OverallDownloadedSize < ContentSize) { \/\/ Calculate how much more data needs to be downloaded in the next chunk const int64 BytesRemaining = ContentSize - OverallDownloadedSize; const int64 BytesToDownload = FMath::Min(BytesRemaining, MaxChunkSize); \/\/ Calculate the range of data to download in the next chunk const FInt64Vector2 NewContentRange = FInt64Vector2(OverallDownloadedSize, OverallDownloadedSize + BytesToDownload - 1); \/\/ Initiate the next download chunk WeakThis->DownloadFileByChunk(URL, ContentSize, MaxChunkSize, NewContentRange, MoveTemp(InternalResultData)).Next([PromisePtr](TArray64<uint8>&& ResultData) { PromisePtr->SetValue(MoveTemp(ResultData)); }); } else { \/\/ If there is no more content to download, then the download is complete PromisePtr->SetValue(MoveTemp(InternalResultData)); } }); HttpRequestRef->ProcessRequest(); HttpRequestPtr = HttpRequestRef; return PromisePtr->GetFuture(); } TFuture<int64> UDownloaderExample::GetContentSize(const FString& URL) { TSharedPtr<TPromise<int64>> PromisePtr = MakeShared<TPromise<int64>>(); TSharedRef<IHttpRequest, ESPMode::ThreadSafe> HttpRequestRef = FHttpModule::Get().CreateRequest(); HttpRequestRef->SetVerb("HEAD"); HttpRequestRef->SetURL(URL); HttpRequestRef->SetTimeout(5.0f); HttpRequestRef->OnProcessRequestComplete().BindLambda([PromisePtr](const FHttpRequestPtr& Request, const FHttpResponsePtr& Response, const bool bSucceeded) { const int64 ContentSize = FCString::Atoi64(Response.IsValid() ? *Response->GetHeader("Content-Length") : TEXT("0")); if (ContentSize <= 0) { UE_LOG(LogTemp, Error, TEXT("Failed to get size: content size is 0")); PromisePtr->SetValue(0); return; } PromisePtr->SetValue(ContentSize); }); if (!HttpRequestRef->ProcessRequest()) { UE_LOG(LogTemp, Error, TEXT("Failed to get size: request failed")); return MakeFulfilledPromise<int64>(0).GetFuture(); } HttpRequestPtr = HttpRequestRef; return PromisePtr->GetFuture(); } ","permalink":"https:\/\/georgy.dev\/posts\/chunk-download\/","summary":"
Chunk downloading is a technique used to retrieve large binary data from the server in separate parts, ensuring reliability and compatibility across different platforms. Unreal Engine’s HTTP module has a limitation of 2GB for binary HTTP response content due to internal restrictions (specifically, TArray<uint8><\/code> uses the int32<\/code> size type, which has a maximum value of 2,147,483,647, approximately 2 GB in our case). To overcome this limitation, we can use the Range HTTP header supported by most servers, without requiring any file preparation or segmentation.<\/p>","title":"Efficient HTTP file download by chunks in Unreal Engine C++"},{"content":"You can save any UObject that is represented as an asset within a UPackage using this method:\nbool 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; } ","permalink":"https:\/\/georgy.dev\/posts\/save-uobject-to-package\/","summary":"
You can save any UObject<\/code> that is represented as an asset within a UPackage<\/code> using this method:<\/p>\n
bool<\/span> SaveToAsset<\/span>(<\/span>UObject<\/span>*<\/span> ObjectToSave<\/span>)<\/span>\n<\/span><\/span>{<\/span>\n<\/span><\/span>\tUPackage<\/span>*<\/span> Package<\/span> =<\/span> ObjectToSave<\/span>-><\/span>GetPackage<\/span>();<\/span>\n<\/span><\/span>\tconst<\/span> FString<\/span> PackageName<\/span> =<\/span> Package<\/span>-><\/span>GetName<\/span>();<\/span>\n<\/span><\/span>\tconst<\/span> FString<\/span> PackageFileName<\/span> =<\/span> FPackageName<\/span>::<\/span>LongPackageNameToFilename<\/span>(<\/span>PackageName<\/span>,<\/span> FPackageName<\/span>::<\/span>GetAssetPackageExtension<\/span>());<\/span>\n<\/span><\/span>\n<\/span><\/span>\tFSavePackageArgs<\/span> SaveArgs<\/span>;<\/span>\n<\/span><\/span>\t\n<\/span><\/span>\t\/\/ This is specified just for example\n<\/span><\/span><\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\tSaveArgs<\/span>.<\/span>TopLevelFlags<\/span> =<\/span> RF_Public<\/span> |<\/span> RF_Standalone<\/span>;<\/span>\n<\/span><\/span>\t\tSaveArgs<\/span>.<\/span>SaveFlags<\/span> =<\/span> SAVE_NoError<\/span>;<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\t\n<\/span><\/span>\tconst<\/span> bool<\/span> bSucceeded<\/span> =<\/span> UPackage<\/span>::<\/span>SavePackage<\/span>(<\/span>Package<\/span>,<\/span> nullptr<\/span>,<\/span> *<\/span>PackageFileName<\/span>,<\/span> SaveArgs<\/span>);<\/span>\n<\/span><\/span>\n<\/span><\/span>\tif<\/span> (<\/span>!<\/span>bSucceeded<\/span>)<\/span>\n<\/span><\/span>\t{<\/span>\n<\/span><\/span>\t\tUE_LOG<\/span>(<\/span>LogTemp<\/span>,<\/span> Error<\/span>,<\/span> TEXT<\/span>(<\/span>"Package '%s' wasn't saved!"<\/span>),<\/span> *<\/span>PackageName<\/span>)<\/span>\n<\/span><\/span>\t\treturn<\/span> false<\/span>;<\/span>\n<\/span><\/span>\t}<\/span>\n<\/span><\/span>\n<\/span><\/span>\tUE_LOG<\/span>(<\/span>LogTemp<\/span>,<\/span> Warning<\/span>,<\/span> TEXT<\/span>(<\/span>"Package '%s' was successfully saved"<\/span>),<\/span> *<\/span>PackageName<\/span>)<\/span>\n<\/span><\/span>\treturn<\/span> true<\/span>;<\/span>\n<\/span><\/span>}<\/span>\n<\/span><\/span><\/code><\/pre><\/div>","title":"How to save UObject that is represented as an asset in Unreal Engine"},{"content":"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.\nUnreal Engine has an alternative implementation called TVariant that works the same, except that all the types in the declaring template parameter pack must be unique.\nCode example This is an example where either FString or int64 may be filled.\nclass AnyClass { TVariant<FString, int64> StringOrInt64Holder; public: void FillString(const FString& NewString) { StringOrInt64Holder.Set<FString>(NewString); } void FillInt64(int64 NewInt) { StringOrInt64Holder.Set<int64>(NewInt); } }; Note that it is not supported by Unreal Engine’s reflection\/property system and hence in Blueprints, garbage collection, save game files, etc.\n","permalink":"https:\/\/georgy.dev\/posts\/variant\/","summary":"
There is a std::variant<\/code> class template in the standard library that is essentially a type-safe