Your menu’s foundation is now in place — inputs are working and your navigation feels responsive. Now it’s time to structure your UI like a real game menu.

This system gives you a flexible Tab Menu Constructor, a centralized master menu configuration, and a built-in widget pooling system to optimize performance. Let’s go step by step.

Tab Menu Constructor

Tabbed menus let you organize complex panels (like Settings, Save/Load, etc.) in a way that’s clean and scalable. The constructor handles the button-panel relationship automatically.

Here’s how to set up a tabbed menu:

1. In your widget (e.g. WB_MainMenuPanel), add the WB_TabMenuConstructor widget
2. Under the exposed variables, assign:
   
   • Buttons (array of tab buttons)
   • Panels (array of content widgets)
3. Make sure the index of each button matches the index of the panel it should display

Example: Button[0] shows Panel[0], Button[1] shows Panel[1], etc.

Once set up, the constructor will automatically switch panels and focus based on input.

Working with Tab Navigation

To connect tab navigation:

1. Implement Get Tab Constructor Reference
   
   • Just return a reference to your WB_TabMenuConstructor
2. When GetNavigables is called, pass it from the active tab’s panel — not the parent panel
3. This way, input always focuses on the correct active content

Master Menu Configuration (WB_MenuMaster)

This is your control center for how the UI behaves across the board.

Here’s what you can configure:

• Animation behavior (fade speeds, transition delays)
• Aspect ratio enforcement
• Initial panel or camera position
• Input delay values
• Tilt UI toggle for gamepad movement effects
• Keybinding overrides (Pause, Return, etc.)

To access:

1. Open WB_MenuMaster
2. In the Designer tab, select the root widget
3. You’ll see all exposed variables under the Details Panel

These settings apply globally — meaning you don’t need to hardcode delays or animation logic in each panel.

Widget Pooling System

One of the most performance-critical parts of UMG is how widgets are created. Spawning a complex widget at runtime can cause noticeable lag — especially on lower-end hardware.

This system solves that with widget pooling.

Here’s how it works:

1. On game start, UMS pre-creates a list of widgets
2. These widgets are stored in a pool and reused throughout the session
3. If a widget is missing, it’s created once and then added to the pool for future use

To configure the pool:

1. Open WB_MenuMaster
2. Find the Widget Pool Array
3. Add any widgets you want preloaded (e.g. WB_SettingsPanel, WB_PauseMenu, etc.)

Tip: You can still create panels at runtime — the system will just cache them after the first load. But adding them ahead of time gives a smoother experience.

Customizing Transitions

Want to change how panels slide in/out?

1. Use Load Content From Class for animated transitions
2. You can select animation types, or force an override
3. Panels can load instantly or wait for animation logic to finish — your choice

What’s Next?

Now your UI is clean, optimized, and modular — with tabbed panels, reusable widgets, and global control from a single menu blueprint.

In the next page, we’ll explore how to create your own custom panels and make them fully compatible with Ultimate Menu System using interfaces and panel events.