[UE5] Editor Utility Widget Basics: Change Selected Props' Rotation and Scale from a Button

The trees and rocks you placed all face the same way at the same size. You want a bit of variation, but you keep selecting one, changing its rotation, selecting the next, changing its scale.

Editor Utility Widget lets you gather that work behind an editor button. Using the same Blueprint thinking that drives your game, you build small tools for your own production work.

This article builds a tool that changes the rotation and scale of selected props together. We start with a button that only displays the selection count, then add the change logic and Undo.

What You'll Learn

• The difference between an editor tool and in-game UI
• Placing a button and fetching the currently selected Actors
• Structuring per-Actor rotation and scale changes
• Making a bulk change reversible with one Undo

An Editor Utility Widget is a tool for production

A Widget is a screen element combining buttons and text. An Editor Utility Widget uses that mechanism to build a tab in the UE editor . How you assemble the screen is much like UMG for in-game HP bars and pause menus (see UMG Basics).

Here we edit things placed in a level with Play stopped. It is not a menu the player uses mid-game. Placements changed from the tool become part of the game's level once saved.

Approach	Where you operate	What it suits
Editor Utility Widget	Buttons and fields in your own tab	Repeated work while adjusting values
Scripted Actions	The right-click menu on assets and Actors	Running fixed logic on what you selected

Scripted Actions is one way to build with an Editor Utility Blueprint. Use the parent class matching the purpose, such as AssetActionUtility for assets and ActorActionUtility for Actors. This article focuses on Editor Utility Widget, which builds an operation screen.

Which are you selecting, assets or Actors?

Even for the same tree, the mesh in the Content Browser and one instance placed in the level are different targets.

• Asset : the material storing the tree's shape. Selected from the Content Browser.
• Actor : something placed in the level using that material. Selected from the viewport or Outliner.

Ten Actors can share one tree asset while each Actor's rotation and scale change independently. We are editing placed props here, so we fetch the Actor side.

Node	What it fetches	Provider
Get Selected Assets	Assets selected in the Content Browser	Editor Utility Library
Get Selected Level Actors	Actors selected in the level editor	Editor Actor Subsystem

A Subsystem is a UE feature that takes on a specific job. Editor Actor Subsystem handles selecting and editing Actors in the editor. You fetch that entry point and then ask it "tell me what is currently selected".

What comes back is an array , a list of several Actors in order. Later we use For Each Loop to apply logic to each Actor in that list.

Start with a button that shows the selection count

Before changing many props, confirm the button can fetch the selection.

1. Build the tab's contents

1. Create a Content/EditorTools folder in the Content Browser.
2. Right-click and choose "Editor Utilities → Editor Utility Widget", naming it EUW_ScatterTool .
3. Double-click to open it and place a Vertical Box at the Designer's root. A Vertical Box stacks children vertically. If another root already exists, place it inside that.
4. Put a Button inside the Vertical Box named BtnScatter . Add a Text Block as its child with the label "Check selection count".
5. Below the Button, as another child of the same Vertical Box, place another Text Block named TxtStatus . Set its initial text to "Not run yet" and turn on "Is Variable".

Buttons have no text of their own, so the child Text Block provides the label. "Is Variable" lets the Graph address that element and rewrite its text.

2. Show the count from the button

Select BtnScatter in the Designer and press the "+" on Details' "Events → On Clicked". The Graph gains an event called when the button is pressed.

1. Search the Graph for Editor Actor Subsystem and place the fetch node Get Editor Actor Subsystem . Naming and spacing vary by version; pick the one whose Return Value is an Editor Actor Subsystem.
2. Drag from that Return Value to create Get Selected Level Actors and connect it to Target.
3. Connect On Clicked 's white exec pin to Get Selected Level Actors 's exec input. Do not wire white exec to the Subsystem fetch node.
4. Create Length from the returned Actor array. Length returns how many items the array holds.
5. Enter Selected: {Count} into Format Text and connect Length's value to the Count pin that appears.
6. Place a Get of TxtStatus in the Graph and create Set Text (Text) from it. Target is TxtStatus and In Text is Format Text's Result.
7. Connect Get Selected Level Actors' exec output to Set Text's exec input, then compile and save.

White wires carry the order work proceeds in ; data wires carry which Actors and values to use . Separating fetching the Subsystem from asking it to do work keeps the wiring readable.

Including the execution order, the whole flow looks like this.

3. Open it and run it small

Right-click EUW_ScatterTool in the Content Browser and choose "Run Editor Utility Widget". The tab that opens can be docked alongside other Level Editor tabs.

With Play stopped, select three prop Actors in the Outliner and press the button. "Selected: 3" means fetching and display are connected. Select one and press again for 1; deselect and press for 0. The display updates at the moment you press the button.

Hands-On: change selected props' rotation and scale

Now we add the change logic. First place just 3 to 5 Static Mesh Actors of trees or rocks with visible orientation in a practice level. A Static Mesh Actor places a non-deforming mesh in a level. Cubes work if you have no assets, but check rotation with the numbers in Details.

Standardize on these conditions.

• Do not attach the Actors to each other; place them independently.
• Initial rotation 0 and scale (1, 1, 1) . No physics simulation.
• Target plain Static Mesh Actors, excluding Blueprint Actors and foliage painted with the Foliage tool.

Decide what to change

Yaw is rotation around the vertical Z axis, turning left and right. We pick Yaw randomly from 0 to 360 degrees and keep Pitch and Roll at 0. A random value is chosen from a specified range.

Scale is a size multiplier. 1 is the original size, 0.9 is 90 percent, 1.1 is 10 percent larger. Passing the same value to X, Y, and Z preserves proportions.

This tool does not keep multiplying current values; it replaces rotation and scale with new values . Pressing repeatedly will not grow things without limit. Positions are left alone.

1. Prepare the Undo record

The Transact Object we are about to use records the state of something you are about to change, for Undo . An Actor's location, rotation, and scale live on its base component, the Root Component . So this change records the Root Component as well as the Actor.

Further, wrap the bulk change between these two.

Node	Role
Begin Transaction	Starts a group of operations undone in one step
End Transaction	Closes that group

A Transaction here is "one unit of editing undone together". Change five props and one Undo restores the result of one button press.

2. Create a function that changes one Actor

Create ScatterOne from the "+" on EUW_ScatterTool's "My Blueprint → Functions". A function names a block of logic. Here we gather "change one prop's rotation and scale".

Add an input TargetMesh typed as a Static Mesh Actor Object Reference . It is the input naming which placed object to change. Distinguish it from a Class Reference.

Also create a Float (decimal) local variable NewScale inside the function. A local variable is a place for values used during that function.

Wire white exec from the function's entry in this order.

1. Transact Object with TargetMesh into Object.
2. Another Transact Object with the Return Value of Get Root Component , fetched from TargetMesh, into Object.
3. Set Actor Rotation with Target TargetMesh and New Rotation from Make Rotator 's Return Value. Connect Random Float in Range (Min 0, Max 360) to Make Rotator's Yaw only, with Roll and Pitch at 0.
4. Set NewScale with a separate Random Float in Range (Min 0.9, Max 1.1) as its value.
5. Set Actor Scale 3D with Target TargetMesh. Pass Get NewScale to Make Vector 's X, Y, and Z and its Return Value to New Scale 3D.

Storing the scale random value in NewScale once makes it obvious the same value goes to all three axes. Since the function runs per Actor, each prop picks a new value.

The first half is "keep the pre-change state and change the rotation". The scale change that follows shares one value across three axes, as shown below. The 1.05 in the diagram is one example of a chosen random value.

Make Vector combines three numbers into one value. Pass its result to New Scale 3D. That is a different input from Target, which names what to change.

3. Change the selected props in order from the button

Keep the count display you built first and add logic after it. The Branch used here splits execution into True when a condition holds and False when it does not.

1. Create a variable SelectedActors on the Widget, typed as an Actor Object Reference with the container set to array.
2. Insert Set SelectedActors right after Get Selected Level Actors, storing the returned array. Use that array for the count display's Length too.
3. Place a Branch after Set Text with Length > 0 into Condition. The False side simply ends.
4. From True, call Begin Transaction . Context is EUW_ScatterTool , Description is Change prop rotation and scale , and Primary Object can be left unspecified.
5. Check with a Branch whether Begin Transaction's Return Value is 0 or greater . From the success True, call For Each Loop with SelectedActors into Array.
6. From Loop Body, call Cast To StaticMeshActor with Array Element into Object. From the success side, call ScatterOne with As Static Mesh Actor into TargetMesh. ScatterOne's own Target is the tool's Self.
7. Call End Transaction from For Each Loop's Completed . Do not close it inside the loop.

The Cast checks whether the fetched Actor can be treated as a Static Mesh Actor. Selecting lights alongside props leaves anything failing that check unchanged. The Cast Failed side can stay unconnected. For Each Loop processes the remaining elements and finally reaches Completed.

On the False side when Begin Transaction fails, do not proceed to changes; display "Could not start the change" in TxtStatus. Normal button use should succeed, but splitting it keeps you from changing things without an open transaction.

Finally change the button's Text Block to "Change rotation and scale", then compile and save. The count display shows the number of all selected Actors . That differs from the number changed, so select only the target props in practice.

Confirm the behavior and Undo

Save the practice level, select only the target props, and press the button. Watch that positions stay and rotation and scale change.

1. Without any other edits in between, run "Edit → Undo" once in the Level Editor. Confirm the menu entry says "Change prop rotation and scale" and that all changed targets revert.
2. Press the button again and see it produce a new combination.
3. Select one prop and check Yaw and scale in Details. Angles may be normalized to equivalent negative values.
4. Confirm scale X, Y, and Z match and fall within 0.9 to 1.1. If the result is good, save with Save All.

Editor tool changes do not revert automatically when you stop Play. That is why we build and verify Undo. If it does not revert, fix the wiring on a practice copy before using it. Do not run large batches assuming "closing without saving always restores everything".

Symptom	Where to check
The selection is 0	Whether Play is stopped, and whether you selected level Actors rather than the Content Browser
The count shows but nothing changes	Whether the targets are Static Mesh Actors, and whether the Cast success side reaches ScatterOne
Rotation differences are hard to see	Whether the shapes are spheres or symmetrical. Compare Rotation in Details too
Only one prop changes	Whether you target Array Element and change from Loop Body
Props get squashed or stretched	Whether NewScale is stored once and that same value goes to X, Y, and Z
Undo does not revert	Whether Begin and End wrap the whole thing, and whether Actors and Root Components were recorded before the change

As a small experiment, widen the scale range to 0.5 to 2.0 and the size differences become obvious. Undo afterwards, set the values back to 0.9 to 1.1, and compile and save. Changing the tool's values is separate from reverting changes already applied to placements.

Bonus: grow it to fit your own workflow

For large amounts of foliage, use the built-in feature too

To paint foliage onto terrain, Foliage has its own features for varying rotation and scale. Our tool is an example of editing props already placed as ordinary Actors. It does not scatter positions, so things placed in a row stay in a row (see Landscape and Foliage).

If you want to preserve original tilt and size

We reset Pitch and Roll to 0 and set scale as an absolute value. Using it directly on rocks you already tilted or props you already resized overwrites those adjustments. Fetching the original values and changing only the axes you need, or keeping the initial values separately, is the next step for such uses.

Make the targets and results visible before running

To grow it for production, adding a list of selected names, the number that will actually change, and a preview of the resulting values makes it easier to use. The fetch-then-process-a-list structure here is the foundation (see Array, Set, and Map basics).

Keep editor logic separate from game logic

Editor Utility Widgets are for the editor. Structure things so game Blueprints do not reference tools or try to run editor-only nodes. The EditorTools folder name is for organization; a name alone does not decide packaging behavior.

Also, level placements and assets your tool edits become data your game uses once saved. The relationship is use tools during production and hand the data they shaped to the game (see Packaging basics).

Summary

Building a button with an Editor Utility Widget and fetching the selected Actors as a list lets you gather everyday editing work. We first displayed the count to confirm the targets, gathered per-item logic into a function, and applied it to the selected props in order.

Once changes and Undo work on a few props, apply it to the work you repeat. Building fetching, changing, and confirming as separate pieces makes it easy to grow the tool gradually.

Further Reading

• Epic: Editor Utility Widgets
• Epic: Scripted Actions
• Epic: Get Selected Level Actors
• Epic: Begin Transaction
• Epic: Transact Object
• Epic: Actors and Root Components