Overview

Introduction

Installation

Getting Started

Core Features

Influence Modes

Deformation

Refinement & Smoothing

Material Layer System

Modular Character Support

API Reference

Blueprint API

Editor Guide

Asset Editor Overview

Debug Visualization

Resources & Support

Troubleshooting & FAQ

Changelog

Modular Character Support

FleshRing - Modular Character Support Complete Guide

Purpose: This guide covers everything about using FleshRing with modular character setups. After reading this page, you'll understand the two supported approaches (Leader Pose and Skeletal Merging), how to configure multi-mesh characters, swap body parts and ring effects at runtime, and troubleshoot common modular integration issues.


What is Modular Character Support?

[IMAGE: Modular character breakdown — separate body part meshes (head, torso, legs, arms) assembled into a full character]

A modular character is composed of multiple independent skeletal mesh components rather than a single monolithic mesh. Each body part (head, torso, legs, arms) is a separate USkeletalMeshComponent that shares the same skeleton and animates in sync.

FleshRing fully supports modular characters through two approaches:

Approach How It Works Best For
Leader Pose One FleshRingComponent per body part mesh. Each targets its own mesh independently. Runtime part swapping, independent control per body part
Skeletal Merging Merge all parts into a single combined mesh, then apply rings to the result. Simpler setup, single deformer, lower overhead

Key Insight: Both approaches are production-ready. Choose based on whether you need runtime part swapping (Leader Pose) or simpler configuration (Skeletal Merging).


Approach Comparison

Leader Pose Skeletal Merging
Architecture Multiple FleshRingComponents Single FleshRingComponent on merged mesh
Runtime Part Swap Yes — swap individual body parts Requires full rebuild
Runtime Ring Swap Yes — per-part ring changes Yes — per-part ring changes via rebuild
GPU Cost One deformer per body part One deformer total (larger vertex count)
Setup Complexity Higher — one component per part Lower — one merged mesh
BakedMesh Required Yes (for runtime swap) Yes (for parts with rings)
Animation Sync Via LeaderPoseComponent Native (single mesh)

Approach 1: Leader Pose

Architecture

In the Leader Pose approach, each body part is a separate USkeletalMeshComponent with its own UFleshRingComponent. A master "Leader" mesh drives animation, and all body parts follow via UE5's native Leader Pose system.

Character Actor
|
+-- SK_FullBody (Leader Mesh - drives animation)
|
+-- SK_Torso (Follower)
|   +-- SetLeaderPoseComponent(SK_FullBody)
|   +-- UFleshRingComponent_Torso
|       +-- FleshRingAsset = DA_TorsoGarter
|       +-- TargetSkeletalMeshComponent = SK_Torso
|
+-- SK_Legs (Follower)
|   +-- SetLeaderPoseComponent(SK_FullBody)
|   +-- UFleshRingComponent_Legs
|       +-- FleshRingAsset = DA_StockingTop
|       +-- TargetSkeletalMeshComponent = SK_Legs
|
+-- SK_Arms (Follower - no ring needed)
    +-- SetLeaderPoseComponent(SK_FullBody)

[IMAGE: Blueprint Actor hierarchy — Leader mesh with multiple Follower body parts, each with their own FleshRingComponent]

Key Rules

  1. One FleshRingComponent per body part — A single component can only target one skeletal mesh.
  2. One FleshRingAsset per component — Each asset is configured for a specific target mesh.
  3. Leader Pose is automatically preserved — All swap operations backup and restore the LeaderPoseComponent reference.
  4. BakedMesh is required for runtime — The FleshRingAsset must have a pre-baked mesh for runtime swapping.

Setup Workflow

Step Action Details
1 Set up Leader Mesh Full body skeletal mesh that drives animation
2 Create Follower body part meshes Each calls SetLeaderPoseComponent(LeaderMesh)
3 Create FleshRingAsset per body part Target = that body part's skeletal mesh
4 Bake each asset in the editor Generates the BakedMesh required for runtime
5 Add FleshRingComponent per body part Set FleshRingAsset and TargetSkeletalMeshComponent
6 Test runtime swap Use Blueprint API to swap parts/rings

[GIF: Editor setup — adding FleshRingComponent to a body part, setting target mesh and asset]

Component Properties

Property Type Description
FleshRingAsset UFleshRingAsset* The ring data asset (contains Rings, BakedMesh, layer mappings)
TargetSkeletalMeshComponent FComponentReference Must be explicitly set — points to the body part's skeletal mesh component
bEnableFleshRing bool (default: true) Enable/disable the effect at runtime
bShowRingMesh bool (default: true) Show/hide the ring visual mesh

[IMAGE: FleshRingComponent Details panel — FleshRingAsset and TargetSkeletalMeshComponent properties highlighted]

Important: TargetSkeletalMeshComponent uses a Component Picker UI. You must manually select the target mesh component — there is no auto-detection.


Runtime: Swap Ring Asset

Change the ring effect on a body part without changing the mesh itself.

Blueprint Node: Swap Modular Ring Asset

Input:
  FleshRingComponent  → The component to update
  NewAsset            → New FleshRingAsset (must have BakedMesh)

Output:
  Result              → Success / Error code
  ErrorMessage        → Human-readable error description

[IMAGE: Blueprint graph — SwapModularRingAsset node with inputs and outputs]

What happens internally:

  1. Validates NewAsset has a BakedMesh.
  2. Validates skeleton compatibility.
  3. Backs up the LeaderPoseComponent reference.
  4. Cleans up existing ring meshes and deformer.
  5. Applies the new BakedMesh to the target skeletal mesh component.
  6. Restores LeaderPoseComponent.
  7. Recreates ring visual meshes.

Pass nullptr as NewAsset to remove the ring effect entirely — the original mesh is restored.

Example Use Cases:


Runtime: Swap Body Part Mesh

Change the body part mesh itself (e.g., swap leg mesh for a different character variant).

Blueprint Node: Swap Modular Part Mesh

Input:
  SkeletalMeshComponent  → The body part to swap
  NewMesh                → New skeletal mesh (must share same skeleton)

Output:
  Result                 → Success / Error code
  ErrorMessage           → Human-readable error description

[IMAGE: Blueprint graph — SwapModularPartMesh node]

What happens internally:

  1. Validates skeleton compatibility with the Leader (if present).
  2. Finds all FleshRingComponents targeting this mesh.
  3. Detaches ring effects from the old mesh.
  4. Sets the new mesh on the component.
  5. Preserves LeaderPoseComponent.

Important: After swapping a body part mesh, the ring effect is detached — not automatically reapplied. You must call Swap Modular Ring Asset separately to apply a ring to the new mesh.

Typical Swap Sequence:

1. SwapModularPartMesh(LegsComponent, NewLegMesh)     // Swap mesh
2. SwapModularRingAsset(LegsFleshRing, NewStockingAsset)  // Reapply ring

Approach 2: Skeletal Merging

Architecture

In the Skeletal Merging approach, all body parts are combined into a single skeletal mesh at runtime. Ring effects are applied to the merged result.

Input Parts:                              Merged Output:
+-- SK_Torso (+ DA_TorsoGarter)          +-- SK_MergedCharacter
+-- SK_Legs  (+ DA_StockingTop)     =>       +-- FleshRingComponent (ring visuals only)
+-- SK_Arms  (no ring)                       +-- All vertices in single mesh

[IMAGE: Skeletal Merging diagram — multiple input parts combining into one merged mesh with ring visuals attached]

How It Works

The merge operation uses UE5's native FSkeletalMeshMerge system:

  1. Collect parts — Each part specifies a BaseMesh and an optional RingAsset.
  2. Resolve meshes — For parts with a RingAsset, the BakedMesh is used (pre-deformed). For parts without, the BaseMesh is used as-is.