How to Add Player Skin (Mutable Plugin / MetaHuman)

This guide explains how to create a Mutable-based player skin using the built‑in pipeline. The example uses a MetaHuman, but the same approach works for any character as long as you have compatible body and head meshes.

---

1. Prerequisites and Entry Point

Before you start:

• Follow the steps from “How to Add a Non‑MetaHuman Player Skin” to:
  • Create a new player skin DataAsset.
  • Register it in the systems that use skins.

In that workflow, when you create the skin:

• Set UseMutablePlugin = true instead of false.

This flag tells the system to generate a default Customizable Object for this skin.

---

2. Generated Customizable Object Overview

After you create the skin with UseMutablePlugin = true:

• A Customizable Object asset is generated automatically for this skin.

  • Its name will follow the pattern:
    CO_<SkinName>
    Example: CO_Player_MH_John.

• Find this Customizable Object in the Content Browser and open it.

Inside the graph you will see that some basic structure is already generated for you:

• There are two Skeletal Mesh nodes:
  • The upper Skeletal Mesh node – for the body.
  • The lower Skeletal Mesh node – for the head.

These nodes are already connected to a base setup with BaseObject, Skeletal Mesh Component nodes for Body and a ChildObject for the head.

---

3. Step 1 – Assign Body and Head Meshes

In the Customizable Object graph:

1. Body Skeletal Mesh node (upper node):

   • In its Details → Customizable Object section:
     • Set SkeletalMesh to the player body Skeletal Mesh for this skin (MetaHuman body or your own body mesh).

2. Head Skeletal Mesh node (lower node):

   • Set SkeletalMesh to the head Skeletal Mesh for this skin (MetaHuman head or your own head mesh).

Make sure that:

• Both meshes use the correct skeleton(s) expected by your animation setup.
• If you use MetaHuman, use the standard MetaHuman body/head meshes for that character.

---

4. Step 2 – Expose Parameters for the Body

For each body Skeletal Mesh node:

1. After setting the Skeletal Mesh, you will see several LOD outputs on the body Skeletal Mesh node (one per LOD).

2. For each LOD output:

   • Add a Mesh Section node.
   • Connect the corresponding LOD output to that Mesh Section.

3. In each Mesh Section node:

   • Open Details → Pins.
   • Enable the material parameter(s) you want to control from UI.
   • In this example, we only expose:
     • UnderwearsColor
   • Tick/enable the UnderwearsColor pin for each Mesh Section (for all LODs).

4. Create a new Color parameter in the Customizable Object:

   • Name example: Body_UnderwearsColor.
   • Connect this Color parameter to the UnderwearsColor input pin on each Mesh Section.
   • Use a consistent naming scheme (e.g. Body_...) so it is easy to identify.

5. There is already a Skeletal Mesh Component node for the Body:

   • Its Name is typically Body.
   • Connect the output of each Mesh Section node (for all body LODs) into the appropriate inputs of the Body Skeletal Mesh Component node (same LOD indices).

At this point:

• The Body component uses your body Skeletal Mesh.
• The UnderwearsColor parameter controls the underwear color across all LODs.

---

5. Step 3 – Expose Parameters for the Head

Repeat a similar process for the head:

1. For the head Skeletal Mesh node:

   • After assigning the head mesh, you will see LOD outputs.

2. For each head LOD:

   • Add a Mesh Section node.
   • Connect the LOD output from the head Skeletal Mesh node into that Mesh Section.

3. In each Mesh Section:

   • Open Details → Pins.
   • Enable the material parameters you want to drive for the head (if any).
   • For a minimal example, you might not expose anything yet; the head is just driven by default material settings.

4. In the generated graph, there is a ChildObject node for the head:

   • Its Name is usually set to Head.
   • Connect the outputs of the head Mesh Section nodes into this Head ChildObject (through the appropriate Skeletal Mesh/Skeletal Mesh Component inputs that are already prepared in the template).

The idea:

• The Body is controlled by a main Skeletal Mesh Component called Body.
• The Head is handled through a separate ChildObject called Head.

---

6. Step 4 – Register Runtime Parameters (Body)

Every parameter you create must be registered so the runtime system can change it.

For Body parameters:

1. Select the BaseObject node of the skin’s Customizable Object.

2. In the Details panel, find:

   • CustomizableObject → States

3. Locate the state responsible for the body:

   • Name: BODY

4. Inside the BODY state:

   • Find RuntimeParameters array.
   • Add new elements to this array for each body parameter you created.
   • Use the exact parameter names (for example, Body_UnderwearsColor).

This tells the Mutable Object that Body_UnderwearsColor is a runtime parameter that can be changed while the game is running.

---

7. Step 5 – Register Runtime Parameters (Head)

Repeat the same for Head parameters (if you have any for the head):

1. With the BaseObject node still selected:

2. In CustomizableObject → States, locate the state:

   • Name: HEAD

3. Inside the HEAD state:

   • Find the RuntimeParameters array.
   • Add new elements with the names of the parameters that apply to the head.
   • For example: Head_SkinTone, Head_MakeupVariant, etc. (if you created them).

If your first version only exposes UnderwearsColor for the body and nothing for the head, you may leave the head’s RuntimeParameters empty for now. You can always add head parameters later.

---

8. Step 6 – Connect to the Skin DataAsset

If you followed How to Add a Non‑MetaHuman Player Skin:

• Your player skin DataAsset is already created and points to:
  • The correct body/head meshes.
  • The generated Customizable Object CO_<SkinName>.

Double‑check in the skin DataAsset:

• UseMutablePlugin is set to true.
• The Customizable Object field references your CO_<SkinName>.
• The Skeleton and mesh references match the ones you used in the Customizable Object.

Once this is wired:

• When the game uses this skin:
  • The character is built from the Mutable Object.
  • Runtime code can manipulate the parameters you registered (for example, Body_UnderwearsColor) through the customization UI or initialization logic.

---

After this, you have a working Mutable‑based player skin (MetaHuman or any other character) that can be extended with additional parameters over time.