How to Dress Your MetaHuman in UEFN (Without the Wardrobe Malfunction)

So, you've got a MetaHuman standing in your island looking like a naked mannequin. It's functional, sure, but it's also giving off serious "abandoned shopping mall" vibes. You want them to wear something? A hoodie? A tactical vest? A sweater made of pure chaos?

In Fortnite Creative, we don't just "put clothes on" characters like we do in a dressing room mirror. We have to build the clothes, simulate how they move, and then import them into the game so they react to gravity, wind, and your player's frantic sprinting. This tutorial covers the high-level workflow for creating custom clothing assets using Unreal Engine and bringing them into UEFN.

What You'll Learn

• The difference between a static mesh (a statue) and a cloth asset (something that flaps in the wind).
• How to use Chaos Cloth, UE's physics system for fabric, to make your gear look alive.
• The "Migrate" trick to get your custom assets from Unreal Engine into your UEFN project.
• What doesn't work yet (so you don't waste hours trying to make your character slide around on ice because of their pants).

How It Works

Think of a normal 3D model (like a tree or a crate) as a Statue. It's hard. It doesn't move unless you push it. In game dev terms, that's a Static Mesh.

Clothing, however, is Jelly. When your MetaHuman runs, their jacket doesn't stay perfectly still; it flaps, drags, and bounces. To make this happen, we use a system called Chaos Cloth Simulation.

The Workflow: From Sketch to Island

You can't just draw a shirt in UEFN. You need to go through a three-step pipeline:

1. The DCC Package (The Workshop): "DCC" stands for Digital Content Creation. This is where you actually model the clothes using software like Marvelous Designer, Blender, or Maya. You create the shape of the sweater.
2. Unreal Engine (The Physics Lab): You bring that sweater mesh into Unreal Engine. Here, you don't just make it look good; you teach it how to move. You attach Chaos Cloth data to the mesh. This tells the engine: "This part is stiff (shoulders), but this part is floppy (hem)." You configure parameters like gravity, collision, and stiffness.
3. UEFN (The Playground): Once the asset is ready in UE, you use the Migrate Tool. This is basically a magical teleporter that copies your asset and all its dependencies into your UEFN project folder.

The Scene Graph Connection

In the context of the Scene Graph (the hierarchy of objects in your game world), your clothing is a Component attached to a Character Entity.

• The Entity: The MetaHuman itself (the skeleton, the logic, the hitbox).
• The Component: The Clothing Asset (the visual mesh + the physics data).

When you migrate the asset, you are essentially creating a new "type" of component that your MetaHuman can wear.

Let's Build It

Since we can't write Verse code to generate a 3D mesh from scratch (Verse handles logic, not high-poly modeling), we will walk through the Asset Creation & Migration process. This is the critical technical step that most beginners miss.

Step 1: Create the Asset in Unreal Engine

1. Open Unreal Editor for Fortnite (UEFN).
2. Go to the Content Browser.
3. Right-click in an empty space > Miscellaneous > Clothing Asset.
   • Note: If you don't see this, ensure you are in a project that supports MetaHumans.
4. Name it MyCoolSweater.
5. Double-click MyCoolSweater to open the Clothing Asset editor.
6. In the Details Panel, look for Cloth Asset. You'll need to import your mesh (from your DCC software like Blender) into the project first, then assign it here.
7. Configure the Chaos Cloth settings:
   • Gravity: How hard does the fabric fall?
   • Stiffness: Does it hang like silk or stand up like cardboard?
   • Collision: Does it collide with the body? (Crucial, otherwise your character looks like they're wearing a ghost sheet).

Step 2: Migrate to UEFN

This is the magic step. You don't drag-and-drop files into UEFN manually. You use the Migrate Tool.

1. In the Unreal Engine Content Browser, right-click your MyCoolSweater asset.
2. Select Asset Actions > Migrate....
3. A window pops up showing all the files that will be copied (the mesh, the material, the cloth data). Click OK.
4. A folder browser opens. Navigate to your UEFN project's Common folder.
   • Why Common? Because this folder is synced across your project and accessible to all players/assets.
5. Click Select Folder.
6. Wait for the migration to finish.

Step 3: Use It in UEFN

Now that the asset is in UEFN:

1. Open your UEFN project.
2. Place a MetaHuman prop or character in your island.
3. In the Details Panel for that MetaHuman, look for the Clothing or Appearance section.
4. You should now see MyCoolSweater in the dropdown list. Select it.
5. Playtest. Watch your character run. Does the sweater flap? If it looks like a stiff cardboard box, go back to Unreal Engine and tweak the Chaos Cloth stiffness. If it looks like a melting candle, increase the stiffness or check the collision settings.

Annotated "Verse" Concept: The Data Link

While we aren't writing code to make the clothes, Verse is what applies them dynamically. Imagine you want to give your player a "Stealth Hoodie" only when they pick up a specific item.

Here is how you'd conceptually link the asset in Verse (pseudo-code logic for clarity):

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

# This is a Verse Script attached to an Item Granter or Trigger.
# Note: Verse does not currently expose a direct SetClothing() API for
# MetaHumans. The pattern below uses an item_granter_device to trigger
# a cosmetic swap — the closest real runtime hook available in UEFN.
stealth_hoodie_granter := class(creative_device):

    # 1. Wire this item_granter_device in the UEFN editor to the device
    #    that holds your migrated MyCoolSweater skeletal mesh swap logic.
    @editable
    HoodieGranter : item_granter_device = item_granter_device{}

    # 2. Wire a trigger_device in the editor; this fires when the
    #    player interacts with your pick-up prop.
    @editable
    PickupTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        # Subscribe to the trigger so we react every time it fires.
        PickupTrigger.TriggeredEvent.Subscribe(OnPlayerPickedUp)

    # 3. The Event: Trigger activates (player "picks up" the item).
    OnPlayerPickedUp(Agent : ?agent) : void =
        # 4. Grant the hoodie item to the agent.
        #    item_granter_device.GrantItem() is the real UEFN API for
        #    delivering an inventory item (or cosmetic-swap item) to a player.
        if (A := Agent?):
            HoodieGranter.GrantItem(A)
        # note: To swap the visible skeletal mesh to MyCoolSweater at
        # runtime you must set up a Conditional Button + Outfit Changer
        # device chain in the editor; Verse cannot directly assign a
        # clothing asset to a MetaHuman component at this time.```

*   **item_granter_device:** The real UEFN device that delivers items to players at runtime. Wire it in the editor Details Panel to control *which* item or cosmetic is granted.
*   **TriggeredEvent.Subscribe:** The correct Verse pattern for reacting to a `trigger_device` firing — pass a callback function and it will be called every time the trigger activates.

## Try It Yourself

**Challenge:** Create a "Wind-Swept Scarf" for a MetaHuman.

1.  Model a simple scarf in Blender or Marvelous Designer (keep it low-poly!).
2.  Import it into Unreal Engine and create a **Clothing Asset**.
3.  Set the **Stiffness** very low and **Gravity** high so it drags behind them.
4.  Migrate the asset to your UEFN project.
5.  Equip it on a MetaHuman and run around.

**Hint:** If the scarf clips through the MetaHuman's head, check the **Collision** settings in the Clothing Asset editor. You need to enable "Self-Collision" or adjust the **Offset** values so the fabric sits *on* the skin, not *inside* it.

## Recap

*   **Clothing is Physics:** Unlike static props, clothing uses **Chaos Cloth** to simulate fabric movement.
*   **The Pipeline:** Model in DCC (Blender/Marvelous) -> Configure Physics in Unreal Engine -> Migrate to UEFN.
*   **Migrate is Key:** Always use the **Migrate Tool** to move assets from UE to UEFN. Don't copy-paste folders manually.
*   **Test and Tweak:** The first pass will never look perfect. Adjust stiffness and collision in Unreal Engine until the fabric behaves like the real thing.

Now go make your MetaHumans look like they stepped out of a high-end fashion show, not a survival bunker.

## References

- https://dev.epicgames.com/documentation/en-us/uefn/realistic-assets-characters-and-environments-in-unreal-editor-for-fortnite
- https://dev.epicgames.com/documentation/en-us/fortnite/realistic-assets-characters-and-environments-in-unreal-editor-for-fortnite
- https://dev.epicgames.com/documentation/en-us/uefn/creating-clothing-assets-for-unreal-editor-for-fortnite-using-unreal-engine
- https://dev.epicgames.com/documentation/en-us/fortnite/creating-clothing-assets-for-unreal-editor-for-fortnite-using-unreal-engine
- https://dev.epicgames.com/documentation/en-us/uefn/metahuman-overview-in-unreal-editor-for-fortnite