CharacterEditor Documentation
CharacterEditor Documentation
Animation Update
23. May 2021
Unreal Engine 4.24 to 4.26
I. Description
The Character Editor is a ready-to-use character customization system. Different options like anatomy,
muscularity, obesity, aging, and size help you to customize your characters.
The faces come with ~80 Morph Targets - ready for facial animations with ARKit and AllrightRig support.
Multiple Data Assets are used to create unique characters: Besides hairstyles, there are several skeletal mesh
apparel parts stripped down to predefined main groups like: hats, upper body, lower body, shoes, and others.
This product gives you a solid foundation to customize your Characters from different types.
Each asset uses one or another master material, which allow you to tweak their visual appearance in detail.
II. Introduction
In this documentation we will mostly describe Blueprints, widgets, and their functionality. For detailed
information about what events, functions, macros, and variables are used exactly – or which must be adjusted
– please head over to the desired Blueprints and follow the graphs. We commented the most important
functionalities, while the rest should be self-explanatory for an intermediate level of Blueprint experience.
The Character Editor consists of various main pieces as described below as an overview. For technical details
click their respective links or read further into the documentation as the next chapters cover their topics.
• BP_Character
This Character Blueprint shows you how to use the following components of the pack and shows you,
with intermediate Blueprint knowledge, how to implement all relevant logic into your own character.
• BP_CharacterCustomization component
This component contains the core logic of your characters visual appearance and handles different
things. It is built around the Anatomy Profiles data table and the Customization Profile structure.
• BP_CharacterEditor component
In addition to the previous component, this optional component acts as a manager for the
WBP_CharacterEditor widget and enables that in-game character editor.
• WBP_CharacterEditor
The in-game character editor is the visual core part of the product and exposes mostly all functionality
of the BP_CharacterCustomization component as a vast ready-to-use and extensible showcase.
• Customization Profile
The customization profiles hold all the information how your character customizations are set up.
They are stored in an array of profiles and saved to and loaded from a save game file.
• Anatomy Profiles V2
Anatomies define the look of your character’s body. The profiles hold all information about anatomies
that are possibly selectable by the BP_CharacterCustomization component and the in-game editor.
• Collections V2
They are a part of Customization Data Assets and a small concept of their own. They are used to
group CDAs together and make them visually distinguishable in the character editor.
• BP_LightStudio V3
The Light Studio makes it possible to set up different light settings in the editor viewport and apply
them in editor or in-game afterwards to show see how the character looks in these scenarios.
Quick Info
With this documentation we would like to kick start you right into development with your new assets by
providing the character blueprint mentioned above. It is set up with the two Blueprint components
BP_CharacterCustomization and BP_CharacterEditor, they are described in their respective chapters.
Since we develop this project besides our full-time jobs and know the product by heart, it may lack on some
documentation every now and then. Thus, we kindly request any suggestions for assistance to enlarge the
docs and especially the tutorial section for topics that need more tutorship than raw technical explanation.
Of course, if there are any questions, simply drop us a line via mail or chat. ☺
Version Description
Documentation changes:
- Updated the Table of Contents. See markers for additional changes.
- Updated the BP_CharacterCustomization component section, the
Customization Data Assets and Children section and the
Customization Profile section to explain the new CDA logic.
- Tutorial: Add your own CDA animations to explain CDA animation workflow.
- Tutorial: Integrate Third Party Content: Advanced Locomotion System V4
- Tutorial: Persist Current Customization Profile between different levels
Documentation changes:
- Updated the Table of Contents. See markers for additional changes.
Documentation changes:
- Updated the Introduction section by adding a Core Component Overview.
- Updated the Table of Contents greatly.
- Updated the Using the Blueprints section a lot to match the new features.
- Updated the Using the Character Editor section as well.
- Updated the Tutorials section to give you more info for special cases.
- Added a first-draft FAQ – Frequently Asked Questions section.
- Added various more detailed information throughout the documentation.
- Added many blue cross references to quickly navigate the documentation.
- Added colored badges for you, who already know the pack from the initial
release, to quickly find out where additions and updates happened throughout
the documentation.
Table of Contents
I. Description............................................................................................................................................. 2
3. Tutorials ............................................................................................................................................. 42
3.1. Package the Project ........................................................................................................................... 42
3.2. Upgrade Character Editor from Version 1 to Version 2 ..................................................................... 43
3.3. Upgrade Character Editor from Version 2 to Version 4 ................................................................... 44
3.4. Add Character Editor to your custom Character Blueprint ................................................................ 46
3.5. Add your own meshes ....................................................................................................................... 46
3.6. Add your own skeleton ...................................................................................................................... 47
3.7. Add your own Character animations ................................................................................................. 47
3.8. Add your own CDA animations ........................................................................................................ 48
3.9. Add Customization Profiles and spawn Characters with them applied.............................................. 51
3.10. Add Customization Data Asset Class .............................................................................................. 51
3.11. Add Customization Data Asset ....................................................................................................... 52
3.12. Add Light Studio Profiles ................................................................................................................ 53
3.13. Capture Custom Thumbnails .......................................................................................................... 54
1.1. BP_Character
This Character Blueprint shows you how to use the following components of the pack and shows you, with
intermediate Blueprint knowledge, how to implement all relevant logic into your own character.
In Construction Script a debug mode is passed to the BP_CharacterCustomization component that lets you
print various info of the customization to the log. In this BP_Character example the component is initialized
with “Use Current Profile” which evaluates the variable returned by the interface function
GetCustomizationProfile to allow to edit the character in editor viewport. At last, the Construction Script
updates a list of all Saved Profile Data for easier management in the editor details panel.
In Begin Play we initialize the BP_CharacterCustomization component and the (optional) BP_CharacterEditor
component. All initialization behaviors initialize the latter component either to show or not to show the editor
after initialization. Our showcase map sets the initialization behavior to “Use Current Profile”, thus not
showing the editor at Begin Play. Press [C] to show it.
NOTE Initializing the character with an open character editor in Construction Script has no effect, since
widgets can only be created while the game is running.
Load Profile enables you to load the “Profile to Load” from existing
save games. All available profiles are listed in “Saved Profile
Names” right below. The corresponding “Saved Profile Data” is
collapsed at the bottom in the advanced details.
Furthermore, in Event Graph there is some Basic Example Keyboard Movement with hard-coded inputs that
allow you to move around our sample character like a third person template character.
NOTE We chose hard-coded inputs for testing purposes, so that the Character Editor content pack can be
simply added to your projects. If we had chosen proper input events that are stored in the [Link], we had to
deliver a complete project that – rules by Unreal Marketplace – can only be used with “Create project” and not
with “Add to project”.
This component contains the core logic of your characters visual appearance and handles different things. It is
built around the Anatomy Profiles data table and the Customization Profile structure.
The following process shows you how these two data sources are applied to the character and which function
handles what data exactly.
Initialize loads a profile to the character depending on a given Initialization Behavior and initializes
1 everything needed by the character customization. You call this once, e.g., in Construction Script of
your character. It itself calls UpdateAvailableAnatomyProfiles and ApplyCustomizationProfile (if the
Initialization Behavior shall not open a character editor).
o Initialization Behavior
▪ Use Current Profile applies the current customization profile if supplied by the parent
character. (See BP_Character > GetCustomizationProfile).
▪ Use Profile to Load applies the “Profile to Load” given from the second parameter. If
not found, a default profile is applied.
▪ Open Character Editor with Current Profile skips any appliance. Use the same enum
in your character in conjunction with the BP_CharacterEditor component.
(See BP_Character > Begin Play)
▪ Open Character Editor with Save Game Profile skips any appliance. Use the same
enum in your character in conjunction with the BP_CharacterEditor component.
(See BP_Character > Begin Play)
o Profile to Load is the profile name for Initialization Behavior “Use Profile to Load”.
UpdateBasebody updates mesh components and meshes, the Anim Blueprint and the morph targets
4 depending on the Anatomy Profile and Basebody Profile of the CurrentCustomizationProfile.
(See (Customization Profile) Meta Data > Anatomy and Basebody (Profile) for details.)
UpdateSkinMaterials creates material instances on the body and – if a head is used – on the head
5 meshes for material channels “Body” and “Head” and sets parameters depending on the Skin Profile
in CurrentCustomizationProfile. (See Basebody (Profile) > Skin for details and Anatomy Profiles for
the material channel rules.)
Can be called on its own like in SetSkinMaterialIndex to just update the skin.
UpdateEyeMaterials creates material instances on either the head mesh or – if no head is used – on
6 the body mesh for “Eyes” and “Eyelashes” channels. And sets parameters depending on the Eyes
Profile in CurrentCustomizationProfile. (See Basebody (Profile) > Eyes for details and Anatomy
Profiles for the material channel rules.)
b. Apply the Post Process Anim Blueprint (if available) as the Custom Anim Blueprint and
set its Copy Pose Mesh.
NOTE Coming with V4, this is our new animation workflow. Each Skeletal CDA can
have an optional custom animation. (See Add your own CDA animations)
c. Apply a Material Variant as dynamic material instance to the skeletal mesh component
and add it to a global array (each CDA type has its own global array). If Material Variant
Index is -1, then the original material of the mesh is used.
NOTE For Hairstyles the Material Variant Index is always -1. If you desire, look at
Apparel Profile and Update Apparel to copy that functionality over.
e. Apply AdditionalMorphTargets
(e.g., trousers could add a morph target to stretch a pullover apparel outwards).
NOTE In our preset only feet and accessories make use of type-specific properties as
an example. Feet set foot transforms for high heels and glasses set translucency sorting.
Feel free to add more functionality.
In case of Apparel, after each CDA, it calls the apparel update function
UpdateApparelBasebodyMasks and optionally, applies the alternative skin textures.
UpdateApparelBasebodyMasks takes a basebody mask texture from each dressed apparel to pass it
8 to the assigned Skin Material. These textures hide specified parts of the basebody which would stick
through the apparels otherwise. (See BP_CDA_Apparel > Mesh > Basebody Mask for details.)
Can be called on its own like in SetSkinMaterialIndex to just update the skin.
1. Cleanup
a. Add a STATIC mesh component to the specific socket and apply the mesh.
c. Apply a Material Variant as dynamic material instance to the skeletal mesh component
and add it to a global array (each CDA type has its own global array). If Material Variant
Index is -1, then the original material of the mesh is used.
NOTE For Attachments the Material Variant Index is always -1. If you desire, look at
Apparel Profile and Update Apparel to copy that functionality over.
In addition to the previous component, this optional component acts as a manager for the
WBP_CharacterEditor widget and enables that in-game character editor.
Its process is simple and consists only of Initialize. Though there are some helper functions.
Initialize V2 spawns a BP_CameraStudio (rather than V1 searching for it in the level) and
1 initializes it to focus the character and to enable camera controls for the editor. Then
the V2 WBP_Instructions is created to show minimalist in-game controls. After that, the
WBP_CharacterEditor is created and initialized. All the editor logic happens in that widget itself.
OpenEditor show the character editor widget and enables controls and the camera studio.
2
1.4. WBP_CharacterEditor
The in-game character editor is the visual core part of the product and exposes mostly all functionality of the
BP_CharacterCustomization component as a vast ready-to-use and extensible showcase.
This widget displays all the character editor sub widgets. The following process shows you how these widgets
are linked to the BP_CharacterCustomization component (in this chapter in short “CC”).
Initialize – Float Sliders – Skin, Eyes, Hairstyle, Morph Targets, Age, Size
4 Gets all widgets of type WBP_FloatSlider in the viewport and initializes them – depending on their
Tag – from different value sources and their OnValueChanged are bound to different functions of
the CC as well.
Initialize – Profile Manager – IMPORTANT: Execute After All Other Widgets Have Been Initialized
12 As its name says, the Profile Manager gets initialized at the very end, so all other widgets have their
initialization and event dispatcher bindings done. Depending on the Character Customization
Initialization Behavior, the Profile Manager gets initialized with or without a default profile. It is
responsible for saving and loading profiles.
RefreshCharacterEditor is used when loading a profile from save game and simply re-initializes the
13 character editor without binding again to all the event dispatchers.
The customization profile holds all the information how your character customizations are set up. Multiple of
them are stored in an array of profiles and saved to and loaded from a save game file.
It is divided into several sub structures since each of them is handled differently in logic. All properties are
directly connected to the BP_CharacterCustomization component. When we refer to variables other than
the structure, then these are found in the component Blueprint.
• Name identifies a profile in the save game for loading and saving. It
must be unique among all other profiles. Saving with an already
stored name the profile will be overridden.
NOTE Age and Size cannot work without a properly set up Anim Blueprint. Different Animation
Modes like “Use Animation Assets” are not supported for these settings. Look at our Anim Blueprints if
you want to implement Age and Size into your custom Anim Blueprint as well.
• Skin contains information about the body and head skin materials.
o Material Index picks stored materials for body and head meshes depending on the selected
gender from either Female_SkinMaterials or Male_SkinMaterials.
o HDR Vector Parameters can contain information like Skin Tint in our custom HDR format.
o HDR Vector Parameters contains information like Eye Color in our custom HDR format.
• Morph Targets contains information about all the morph targets set on the main character mesh.
• Morph Target Groups contains information like which face morph target index or eyes morph target
index is selected.
• V2 Data Assets array of structures (replaces V1 Data Asset single structure) defines which
hairstyles are selected. This property now holds an array of FCDA_HairstyleProfiles, instead of a single
BP_CDA_Hairstyle. Thus, multiple hairstyles can be selected, which is used by our male beards. This
way you could add e.g., head-hair, beard-hair, or any more fantasy-hair like arm-hair for werewolves
etc. For each valid data asset, a new skeletal mesh component is added to the character. Can be
empty if a bald character is desired.
• V2 Global HDR Vector Parameters (replaces V1 HDR Vector Parameters) contains information
(e.g., Color) and now also works globally across Data Assets like the Global Scalar Parameters.
NOTE The new FCDA_HairstyleProfile structure currently contains only a single BP_CDA_Hairstyle reference
that may seem like unnecessary overhead, but we wanted to introduce it as a structure for you and us to
expand in the future. (See for FCDA_ApparelProfile and FCDA_AttachmentProfile, which make use of this
expansion idea for specific per-data-asset-settings.)
• V2 Data Assets array of structures (is now what V1 Apparel array items were before; in fact, we
moved these properties one layer down within the hierarchy) defines which apparels are added. For
each valid data asset, a new skeletal mesh component is added to the character. Can be empty if a
naked character is desired.
o Material Variant Index defines which material is set to the skeletal mesh. -1 just takes the
material already present on the skeletal mesh.
• V2 Global Scalar Parameters contains information (e.g., Roughness) and works globally across all
apparel CDAs like the Global Scalar Parameters for hairstyles. Apparel’s per-data-asset-settings are
controlled with the Data Assets > Material Variant Index.
• V2 Global HDR Vector Parameters contains information (e.g., Color) and works globally across all
apparel CDAs like the Global Scalar Parameters.
• Data Assets array of structures defines which equipment is added. For each valid data asset, a new
skeletal mesh component is added to the character. Can be.
o Material Variant Index defines which material is set to the skeletal mesh. -1 just takes the
material already present on the skeletal mesh.
o Parent Socket defines to which bone the skeletal mesh is attached. Leave this at “None”, if
the equipment skeletal mesh is already positioned relative to the root of the character.
o Relative Transform will translate the skeletal mesh relative to the Parent Socket.
• Global Scalar Parameters contains information (e.g., Roughness) and works globally across all apparel
CDAs like the Global Scalar Parameters for hairstyles. Apparel’s per-data-asset-settings are controlled
with the Data Assets > Material Variant Index.
• Global HDR Vector Parameters contains information (e.g., Color) and works globally across all apparel
CDAs like the Global Scalar Parameters.
NOTE Opposing the Apparel Profile, it cannot currently be assigned in the in-game editor, but only via the
customization details of the BP_Character or BP_CharacterCustomization component. It is intended to be
another technical approach for you to add skeletal equipment like tools, weapons, or backpacks. See
BP_CDA_Equipment for details.
Currently, there is no widgets in the Character Editor to control attachments, but you can add them in the
Unreal editor viewport. We have delivered one example hammer to play with.
• Data Assets array of structures defines which attachments are added. For each valid data asset, a new
skeletal mesh component is added to the character. Can be empty if a naked character is desired.
o Relative Transform will translate the static mesh relative to the Parent Socket.
• Global Scalar Parameters contains information (e.g., Roughness) and works globally across all apparel
CDAs like the Global Scalar Parameters for hairstyles. Apparel’s per-data-asset-settings are controlled
with the Data Assets > Material Variant Index.
• Global HDR Vector Parameters contains information (e.g., Color) and works globally across all apparel
CDAs like the Global Scalar Parameters.
In short “CDA”, they are content browser assets that can be placed onto the character (hairstyles, apparels,
and attachments). They define various info and optionally some asset-specific logic.
The general concept of CDAs is, that all child classes of BP_CustomizationDataAsset define more detailed
information describing the actual CDA. They may also have CDA-specific logic in the customization process
(like foot transforms for the BP_CDA_Apparel_Feet). Even cooler (why we did not use the alternative “Data
Table”) is that each data asset could have its own functionality – almost like normal Blueprints do, which can
be used for data validation and other things right in the asset itself.
1.6.1. BP_CustomizationDataAsset
This is the base class of all CDAs and defines basic variables:
• General > Thumbnail is used in-game inside of a CDA Picker. Use them for more as you like.
• V2 General > Anatomies contain zero or more anatomy entries. They define for which selected
Anatomy of the CurrentCustomizationProfile this CDA can be chosen. If the Anatomies list is empty,
the CDA can be chosen in combination with any selected Anatomy.
• V2 General > Collections contain zero or more collection entries. They define for which selected
Collection in the WBP_CDA_CollectionPickers this CDA is visible in their corresponding CDA Pickers. If
the Collections list is empty, the CDA will still appear in the “Any Collection”.
• V4 General > Hidden CDA Classes (got moved here from V2 BP_CDA_Apparel) define zero or
more classes type of BP_CustomizationDataAsset that shall be hidden when this CDA is worn. E.g., a
hoody mesh already has a hat – the hood – and thus can add the BP_CDA_Apparel_Hat class, to hide
each worn hat CDA. The same way other apparels like helmets can add the BP_CDA_Hairstyle_Head
to the array to hide the hairstyle.
• Debug > Debug Asset defines if the CDA is for debugging only. If set to TRUE it will not be visible in the
in-game editor and can only be chosen in the Unreal Editor Details Panel and be saved to and loaded
from customization profiles.
NOTE Debug Assets, that are stored in the customization profile that your character is currently
wearing in the viewport, will get undressed if you press Play in Editor, as they do not appear in the
Apparel Pickers. Also see note of WBP_CDA_ApparelPicker for more information on this behavior.
• V4 Mesh > Material Variants (got moved here from V2 BP_CDA_Apparel) is a list of
F_CDA_MaterialVariant entries, where each of them defines a different set of materials that can be
applied to the skeletal mesh. Thus e.g., a pullover can have a red, yellow, or green color or even
different textures like stripes of blue and white without adding another CDAs to the content browser.
1.6.2. BP_CDA_Skeletal V4
This is the abstract base class for skeletal CDAs and inherits from BP_CustomizationDataAsset.
NOTE Coming with V4, this is a new base class for skeletal CDAs like BP_CDA_Hairstyle, BP_CDA_Apparel
and the new BP_CDA_Equipment to unify their update logic. (E.g., see BP_CharacterCustomization
component > UpdateApparel). As we learned about new techniques to animate modular characters in Unreal
Engine, it was a logical consequence to make a skeletal base class and replace the Custom Anim Blueprint
property of our BP_CDA_Hairstyle with the new animation workflow using Post Process Anim Blueprints. (See
Add your own CDA animations)
• Mesh > Skeletal Mesh is the visual appearance of the skeletal CDA.
There are several additional morph targets that are already present on one or the other type of CDA:
o CDA_Hairstyle
▪ hair deforms or enlarges hats.
o CDA_Apparel_Feet
▪ boot_high_equipped squashes trousers into the shoe or lays them over the shoes.
▪ shoe_dressed hides toes in pointed or tight shoes.
o CDA_Apparel_Hat
▪ hat_equipped_benee compresses hair under tight beanie hats.
▪ hat_equipped_berett compresses hair under beret hats with a diagonal lower edge.
▪ hat_equipped_straight compresses hair under straight hats like caps or country hats.
o CDA_Apparel_LowerBody
▪ tight_long_trousers
▪ trousers_long
o CDA_Apparel_UpperBody
▪ waist_cover to remove some width on lower bodies that the upper body covers it.
NOTE We have prepared all these morph targets in a 3d modelling software. They cannot be added
to your custom meshes directly in engine. We only give you a tool for controlling own morph targets.
• BP_CDA_Apparel
• BP_CDA_Equipment
• BP_CDA_Hairstyle
1.6.3. BP_CDA_Static V4
This is the abstract base class for static CDAs and inherits from BP_CustomizationDataAsset.
NOTE Coming with V4 and, this is a new base class for static CDAs like BP_CDA_Attachment and other
potential CDAs to unify their update logic. (E.g., see BP_CharacterCustomization component >
UpdateAttachments)
• BP_CDA_Attachment
1.6.4. BP_CDA_Apparel
This is the abstract base class for apparels and inherits from BP_CDA_Skeletal. It is selectable by the
WBP_CDA_ApparelPicker. It has several child classes of its own and comes with these additional variables:
• Mesh > Basebody Mask is a black and white texture where black hides skin on the basebody body and
head meshes and white shows the skin. This is to avoid large amounts of morph targets to
compensate skin sticking through clothes.
• V3 Mesh > Use Alternative Skin Textures shows an alternative texture set on the currently assigned
skin if its materials (Body and Head) have assigned appropriate textures. As an example, we have
prepared the materials MI_Skin_Male_01_Body and MI_Skin_Female_01_Body. By setting up
alternative textures like ours, you can make the character naked to support apparels like swimming
clothes which might reveal more skin than the painted underwear of the main textures does.
The main reason for having multiple apparel child classes – beside the information and logic described above
– is that each class represents a possible apparel slot on the character. Each WBP_CDA_ApparelPicker in the
editor can display all data assets of a specific CDA class, which lets you group them visually.
If you want to create e.g., custom backpack assets, then you would create a child blueprint class of
BP_CDA_Apparel called BP_CDA_Apparel_Backpack and place another WBP_CDA_ApparelPicker in the editor
for that new class.
• BP_CDA_Apparel_Accessory
• BP_CDA_Apparel_Feet (sets foot transforms in the Anim Blueprint)
• BP_CDA_Apparel_Glasses (set a custom translucency sorting for the glass material)
• BP_CDA_Apparel_Hands
• BP_CDA_Apparel_Hat
• BP_CDA_Apparel_LowerBody
• BP_CDA_Apparel_Socks
• BP_CDA_Apparel_UpperBody
1.6.5. BP_CDA_Equipment V4
This is the abstract base class for equipment and inherits from BP_CDA_Skeletal. Currently, it is not selectable
in the in-game Character Editor. It has one example child class.
NOTE Coming with V4, we have decided to introduce equipment as a completely new sub class to clearly
separate it from apparel and attachments, as potential equipment logic might differ from apparel a lot and
needs skeletal meshes. Two logical differences to apparel on our side are that the equipment does not support
body masks and changing the skin texture set. You are free to add more logic.
The main differences to Attachment Profiles (that are also meant to be for tools etc.) are that equipment uses
a skeletal mesh and the new custom animation workflow instead of a static mesh without animations. Thus, if
you need interactive items for your character, you should prefer equipment over attachments.
• BP_CDA_Equipment_SingleHanded
1.6.6. BP_CDA_Hairstyle
This is the abstract base class for hairstyles and inherits from BP_CDA_Skeletal. It is selectable by the
WBP_CDA_HairstylePicker and since V4 it comes without additional variables as it only acts as a logically
different parent class.
• V4 Mesh > Custom Anim Blueprint got replaced by the new custom animation pipeline.
• BP_CDA_Hairstyle_Beard
• BP_CDA_Hairstyle_Head
1.6.7. BP_CDA_Attachment V2
This is the abstract base class for attachments and inherits from BP_CDA_Static. Currently, it is not selectable
in the in-game Character Editor. It has one example child class.
The main reason for having multiple attachment child classes – beside the information and logic described
above – is that each class represents a possible attachment slot on the character or type of attachment. Like
for hairstyles and apparels you could display all data assets of a specific CDA class in separate attachment
pickers, which lets you group them visually.
If you want to create e.g., custom two-handed assets, then you would create a child blueprint class of
BP_CDA_Attachment called BP_CDA_Attachment_TwoHanded.
• BP_CDA_Attachment_SingleHanded
Anatomies define the look of your character’s body. The profiles hold all information about anatomies that
are possibly selectable by the BP_CharacterCustomization component and the in-game editor.
The anatomies should be as flexible as possible while already restricting to most generic visual differences of
living beings. We have looked at games, books, and other sources where various living beings other than
“humans” are introduces.
We wanted to prepare the Character Editor for you to extend, without the need of any further logic regarding
those visuals, hence we broke those living beings down to “Race”, “Gender” and “Generation”.
Race represents the general visual differences like “human”, “dwarf”, “elf”, “orc” and the like.
Gender is simple as the name says and represents the second level of granularity.
Generation then makes up the last level and supports for adding differences of “aging” and the like.
Of course, the logic behind the Anatomy Profiles does not restrict to always have all possible combinations of
a new race you would implement into the pack. This is rather a guideline you can follow.
EAnatomy
This enum defines which anatomy is selectable in the Customization Profile. Its name
can be written with spaces.
DT_AnatomyProfiles
This data table stores all the information for the anatomies.
Each table row must be named like the corresponding enum
value, but without spaces, as this is how data tables work.
a) Use the Body Mesh and the Head Mesh separately. They should have the skin material channels
“Body” and “Head” assigned, respectively. Look at HumanFemaleAdult or HumanMaleAdult and
their meshes to see how it is done there.
b) Use only the Body Mesh, where the head is combined with the body. Then the skin material
channels “Body” and “Head” should be present on the combined mesh.
In both a) and b) you have read the little word “should”, as there is a second approach for adding skin
materials. Depending on your desired material setup, you can also only use the material channel
“Body” for the skin. Thus “Body” is the must have – “Head” is optional.
The same goes for the material channels “Eyes” and “Eyelashes”. If you have a separate head mesh
these material channels must be on the head mesh. If you have only one body mesh, then they must
be there.
(Take a look at the Skin Material Sets variables further down. Also see BP_CharacterCustomization
component -> (5) UpdateSkinMaterials and -> (6) UpdateEyeMaterials that make use of this concept.)
• Anim Instance Class contains the Anim Blueprint that is applied to the “Mesh” component / Body
Mesh of the character Blueprint. It is the second must have to make the profile valid.
• Skin Material Sets contains all possible material sets consisting of a Body and Head Material. If you
add custom body meshes, then take a look back at Body and Head Meshes further up to see if you
want to use both materials or just the body material.
All these material sets will be available in the in-game Character Editor and chooseable by
the Basebody (Profile) -> Skin -> Material Index property in the Customization Profile.
• Default Customization Profile is used in the in-game Character Editor to setup the character if you
choose this anatomy in the editor for the first time after Begin Play. (See
BP_CharacterCustomization component -> Set Anatomy)
After all the setup you can assign specific anatomies to your Customization Data Assets by modifying their
Anatomies list. E.g., “Human Female Adult” can wear other apparels than “Human Male Adult” because of
their different anatomy, but “Human Female Child” and “Human Male Child” could share most of the child
CDAs because of their similar anatomy.
1.8. Collections V2
They are a part of Customization Data Assets and a small concept of their own. They are used to group CDAs
together and make them visually distinguishable in the character editor.
They e.g., can be used to group common style like “Winter”, “Sport”, and “Evening Wear”. Or, depending on
your gameplay, a common set of logic like “Monk”, “Mage”, “Rogue”, and “Warrior”.
c) The selected collection in the WBP_CDA_CollectionPicker is “Any Collection”, meaning that all
relevant CDAs are shown. This also means that the “Any Collection” must not be specifically assigned
to a CDA.
1.9. BP_LightStudio V3
The Light Studio makes it possible to set up different light settings in the editor viewport and apply them in
editor or in-game afterwards to show see how the character looks in these scenarios.
Each light array can consist of zero or more light structures, which represent the most relevant properties a
light component can get through Blueprint functions. The properties their selves are named as the
corresponding light component properties, therefore should be self-explanatory. Essentially all common
features of lights (like color, temperature, intensity, intensity units, attenuation, shadows, light function
materials and light type specific settings) are supported.
The same applies for the Exponential Height Fog. The Post Process, however, is an actual post process
structure as you might already be familiar with.
Though, the Relative Location and Relative Rotation properties are relative to the BP_LightStudio component,
which is important, because the Light Studio follows the character, e.g., if the player closes the Character
Editor, walks around, and opens the Character Editor at another location and with another rotation.
(See Add Light Studio Profiles to make your own and how to handle relative location and rotation.)
If the game is being played for the first time in editor after Unreal Engine has been launched, all the
Customization Data Assets get automatically loaded into the editor cache, when they are shown by e.g., the
Apparel Picker. To avoid lags or freezes of the game screen during that very first play in editor, we have
introduced a compact progress bar that simply loads every single CDA before the Character Editor uses them
and give appropriate feedback while you are waiting.
Do not worry, the progress bar is not always there. Since UE4 automatically caches the data assets, this
progress bar is only visible at the first play in editor session. It is the same cache as you would open the assets
from the Content Browser.
General Buttons
Character Viewport
V3 R Randomize apparel
Details Panel
The Character Editor is the main widget that hosts all controls that manipulate the
BP_CharacterCustomization component of the controlled character. It is visually divided into three sections:
1. The Profile Manager, which is responsible for saving and loading profiles as well as switching the
anatomy by clicking on the upper left gender icon. If a name is given a save button appears. By
choosing the same name of an already present profile the save will override the existing profile.
2. The Beta Features, which are hidden by default and revealed by clicking on the “Beta Features”
button. They showcase some technical features that are possible with our base body meshes but did
not fit in the ready-to-use details panel on the right.
3. The Details Panel, which hosts all other settings you can control. Many different types of widgets are
prepared for you to explore, extend, and copy. They are described in the following chapters
alphabetically.
They are intended to be as modular as possible. Each of the following Blueprints has an “Initialize” and/or
“UpdateVisuals” function and one or more Event Dispatchers (mostly an “OnValueChanged” or “OnClicked”
dispatcher) to communicate with the WBP_CharacterEditor logic.
• Function: Initialize
Called in “Event Construct” of its own widget to initialize some default states while working in UMG.
Called in WBP_CharacterEditor’s Initialize-function to initialize it with either
CurrentCustomizationProfile values or default values depending on the state of the Character Editor.
• Function: UpdateVisuals
Called at various times to update the visuals after initialization, when other widgets have made
changes to this widget or when the user has given some input to the widgets and changes its values.
2.5. WBP_BlendSpace2D
The Blend Space 2D is the base component of WBP_FloatSpace2D and behaves like a 2D slider. You can move
around the white dot by clicking and dragging. OnValueChanged will give you a vector from (0.0|0.0) to
(1.0|1.0) depending on the location of the dot. (0.0|0.0) is upper left, (1.0|1.0) is lower right.
The CDA Apparel Picker can display all available data assets inheriting the given Class which is a child of
BP_CDA_Apparel and is not flagged as “Debug Asset” in its settings. A WBP_CDA_CollectionPicker can
further define what data assets are displayed. If setup like the image above e.g., to BP_CDA_Apparel_Hat it
displays all hats when the editor is open in-game by default (in Unreal editor it just displays four empty data
assets). The selected apparel will be stored in an Apparel Profile variable.
The Index is defaulted to 0. You are free to use multiple CDA Apparel Pickers for the same class in your
Character Editor. Each additional picker must have an increasing index (0, 1, 2 etc.) always starting at 0! This
way e.g., two pickers could display accessories (which in our examples is the base class for data assets like
rings, necklaces, watches etc.) and in-game you are able to choose a ring and a necklace. We have prepared
the CDA Apparel Picker in a way that pickers with the same class block their siblings’
WBP_CDA_ApparelPicker_MainButtons, so the user cannot select the same e.g., necklace in both pickers.
The picker may host any number of data assets as it can be scrolled horizontally with the mouse wheel (see
In-game Controls). On scroll, the next apparel is selected and set in the current customization profile. By
clicking an apparel button or when loading a profile, the picker automatically scrolls to the selected apparel.
TIP The Vertical Box around the whole Details Panel also reacts on mouse scroll and does not scroll while
the mouse is over a CDA Apparel Picker. Just press and hold the right mouse button to drag the details panel
up and down.
2.7. WBP_CDA_ApparelPicker_MainButton
This Main Button gets generated and populated with data by the Apparel Picker for each available data asset
of the given class. It can be blocked by the above-described mechanism for pickers with the same class. It also
reveals the display name and material variants of the apparel by hovering the mouse over it.
When clicked it sets the selected apparel of its hosting CDA Apparel Picker with a Material Variant Index of -1.
2.8. WBP_CDA_ApparelPicker_VariantButton
This Variant Button gets generated by each Main Button and displays a color and tooltip on mouse over.
When clicked it sets the selected apparel of its hosting CDA Apparel Picker with a Material Variant Index equal
to the button index within the Main Button.
The CDA Collection Picker is used to select a Collections value for either the apparels or hairstyles. It is
initialized in the graphs “Initialize – CDA Apparel Pickers” and “Initialize – CDA Hairstyle Pickers” and
automatically generates its dropdown entries from all Customization Data Assets for the given Anatomy.
Selecting a specific collection in-game will only show the Data Assets that also are assigned to that collection
by calling SetCollection of either the WBP_CDA_ApparelPicker or WBP_CDA_HairstylePicker and re-initializing
the respective picker.
Because we filter the Data Assets by Anatomy and Collection the same time it is possible that some of the
E_CDA_Collection values may be hidden in the WBP_CDA_CollectionPicker e.g., if Anatomy is “Human Female
Adult” but no single Data Asset with that Anatomy is assigned to e.g., “Soldiers”. Then “Soldiers” is not
available in the collection picker.
V3 Loading a profile from the Profile Manager will reset the hairstyle and apparel Collection Picker back to
“Any Collection”, because the loaded profile might have a CDA assigned that is not in the currently selected
collection. If not resetting to “Any Collection” the CDA would not be applied by the respective CDA Picker,
because of the rule “A CDA cannot be applied if it is not visible in the CDA Picker”. (See the note in
WBP_CDA_ApparelPicker (Selecting Apparels))
The CDA Hairstyle Picker works like the CDA Apparel Picker.
2.11. WBP_CDA_HairstylePicker_MainButton
The Main Button works like the CDA Apparel Picker Main Button.
The Expandable Category acts like a dropdown with custom content. Any WBP_TaggedUserWidget (Base
Class of all Editor Controls) is grouped into some of them. It can be expanded/collapsed on runtime by
clicking on the header. If there is any control nested in them with “CanBeRandomized” set to true, the
expansion can only happen on the right half of the header, while the left half of the header is reserved for a
randomize button.
The randomize functionality can be nested between level 0 and 1. E.g., the face controls have several level 1
categories with separate randomize buttons and one level 0 randomize button that controls all subcategories.
• Bottom Padding when Expanded defines pixel spacing below the content when expanded.
NOTE The expansion state is a bit tricky in the UMG editor, thus sometimes you need to recompile the
widget hosting an Expandable Category. Especially, if the categories are nested within other categories or
scroll boxes.
The Facial Anim Button is a beta feature and gets generated depending on the list of Test Animations within
the Character Editor itself. It plays anim sequences on the slot “FacialAnimation” within either the female or
male Anim Blueprint. Note that these are anim sequences and must match the skeleton of the Anim Blueprint.
E.g., female sequences will not play on the male character and vice versa.
The Float Slider is the most frequently used control in the Character Editor. It simply controls any value that is
represented by a float with a basic slider behavior. The value can be formatted.
• Tag is the very first property you should set. It defines what logic will be executed on value change:
o Skin sets a scalar parameter on the Skin material instances (“Body” and “Head”).
o Eyes sets a scalar parameter on the Eye material instances (“Eyes” and “Eyelashes”).
o Age sets the age (only one Float Slider has this tag)
o Size sets the size (only one Float Slider has this tag)
Float Slider
• Parameter Name is relevant for what will be controlled. E.g., what scalar parameter of a material or
what morph target. For the Age and Size tags it is not relevant.
• Default Value sets the slider on a specific value if no Customization Profile is loaded.
• Min Value defines the minimum value on the left side of the slider.
• Max Value defines the maximum value on the right side of the slider.
o Default just displays the value as float with two decimal places.
o Percent (0-100%) displays the value in percentage format without decimal places.
• Custom Min Value visually replaces the Min Value (e.g., the character size of 160,0)
• Custom Max Value visually replaces the Max Value (e.g., the character size of 186,0)
• Custom Fractional Digits sets the shown decimal places (e.g., 0 if displaying integers)
• Custom Format String allows you to print strings before and after the value written as {0} (e.g., the
character size as “{0} cm”, resulting a display minimum value of “160 cm”)
The Float Space 2D is a two-dimensional version of the Float Slider in terms of value output but has no value
formatting options. Since it is only used for beta features the Parameter Name is not in use.
2.16. WBP_HDR_ColorPicker (Selecting Custom HDR Colors with Intensity and Alpha)
The HDR Color Picker is – besides the Float Slider – the second control that changes materials of the
character. It uses our custom HDR Color format, which we do need to save and correctly restore your slider
settings in the HDR Color Picker Dropdown. The picker itself can be customized depending on the type of
color you want to change. Like the Float Slider it comes with a Tag and Parameter Name.
• Tag is the very first property you should set. It defines what logic will be executed on value change:
o Skin sets a color parameter on the Skin material instances (“Body” and “Head”).
o Eyes sets a color parameter on the Eye material instances (“Eyes” and “Eyelashes”).
• Display Name shows a header above the colors. It collapses if empty and “CanAlphaBeToggled” false.
• Default Color sets the picker on a specific value if no Customization Profile is loaded.
• Has Alpha enables an alpha slider in the HDR Color Picker Dropdown.
• Can Alpha be Toggled shows a checkbox besides the header and allows you to set the alpha to 0%
without changing the color itself.
• Color Swatches contain all colors displayed in the picker. They are set by the default Unreal color type
and get converted into our HDR Color format. May sound problematic for some cases, but it is just a
little helper conversion. All values can be gotten and set in the default format as well. The widget is
visually optimized for 10 colors, but more or fewer colors will work neatly.
2.17. WBP_HDR_ColorPicker_ColorSwatch
The Color Swatch gets generated for each Color Swatch entry of the HDR Color Picker. On click it sets the color
of the large swatch in the Color Picker and the specific parameter in the current Customization Profile.
2.18. WBP_HDR_ColorPicker_Dropdown
The Dropdown gets opened by clicking on the large Color Swatch and
controls the color in advanced detail.
This gives you a better control for different color depths and base texture
brightness in your materials and us the ability to restore HDR colors in the
UI.
The Index Picker lets you cycle between the index 0 and a given last index. The only Index Picker is currently
used for changing the skin appearance, better the Skin Material Index.
• Default Index sets the picker on a specific value if no Customization Profile is loaded.
• Last Index is the last index. If reached a press on “Next Index” arrow cycles back to index 0.
The Morph Target Picker is visually identical to the Index Picker, but instead of using a simple last index it can
be populated with a Morph Target Group and an array of IDs. When picking a specific index, it returns both
values concatenated. E.g., Morph Target Group = “face” and selected id = “04” results in “face_04”, always
separated with an underscore (“_”).
• Morph Target Group is the main part of the morph target name.
• Morph Target IDs is the list of names appended to the main part separated by an underscore.
• Default Selected Index sets the picker on a specific value if no Customization Profile is loaded.
The Profile Manager is responsible for saving profiles with a custom name and loading profiles via buttons in
the “Load Profiles” section as well as V2 switching the Anatomy Profiles next to the profile name.
V2 In our showcase we let you switch the gender between “Male” and “Female” and the generation
between “Adult” and “Child”. When switching either gender or generation, the correct anatomy gets
composed and the WBP_CharacterEditor gets refreshed (re-initialized without performing actions that
happen during first initialization after Play-in-editor, like binding all the event dispatchers).
2.22. WBP_ProfileManager_PresetItem
The Preset Item is added to the profile manager “Load Profiles” section and can load a profile that is defined
in BP_CharacterCustomization component -> PresetCustomizationProfiles.
2.23. WBP_ProfileManager_SaveGameItem
The Save Game Item is added to the profile manager “Load Profiles” section and can load a profile that is
available in save game.
The Tagged User Widget is the base class for all widgets that can control values. It has two properties.
• Tag can be used for any differentiation logic between same type of controls and is implemented for
e.g., Float Sliders and HDR Color Pickers.
• Can be Randomized enables the randomize functionality for a control inheriting the Tagged User
Widget and, if true, tells a hosting WBP_CDA_ExpandableCategory to enable its randomize button.
The widget inheriting this class can then implement the “Randomize” function to call custom
randomization code.
3. Tutorials
3.1. Package the Project
Since we make use of the UE4 Asset Registry, the data assets (our so called “Customization Data Assets” or
“CDA”) which come with our product and you might create during development will not always be referenced
by another asset when packaging your game, depending on its usage. To cook them properly and be able to
use them in-game after building and packaging follow these three simple steps:
1. Go to Project Settings.
NOTE Keep in mind, that if you have made any changes to our core logic, of course we cannot guarantee
that the upgrade is even possible, since we do not know what you have changed exactly. Drop us a line and
maybe we can help to figure out what exactly need to be changed on your side, but understand, that perhaps
we cannot help from a time-perspective, if it is mostly your responsibility.
We have updated the Customization Profile structures a lot to add new features like anatomies, beards, and
attachments. We tried our best to keep your Customization Profiles V1 intact in the new version as well.
Hence, we kept all V1 structures and the V1 save game Blueprint in their folder structures.
In the first possible save game loading process (e.g., BP_CharacterCustomization component >
GetSaveGame) we will upgrade the save game that is being loaded (e.g., Character -> ProfileToLoad) to
version 2. In this process we backup your V1 save game by renaming it in case it is not part of your version
control.
If you want to upgrade right away without modifications on your side, close the Unreal Engine, backup the
current Character Editor (e.g., version control), delete the Character Editor folder and add the new version to
your project again. Open the Unreal Engine editor again and begin to play. Your save game will then be
converted automatically.
If you want to upgrade with modifications on your side, track them down. DO NOT start the game or even
have a character in your current map that could load your current V1 save game via Construction Script
unintentionally, before you have fully completed the upgrade preparations, because it might get converted
wrong. Backup the current Character Editor. We recommend comparing your copy of the Character Editor
with a fresh install of the new version in a separate test project. You as the developer or your fellow
developers should know what needs to be done to merge your differences. Assets that have no changes made
by you can simply be removed and replaced with the new version. Remove the old ones instead of overriding
them, since we renamed a few of them, where necessary. Before initializing your character for the first time
(e.g. starting the character or calling the character’s Construction Script) and thus performing the upgrade of
your save game – and in fact the upgrade of the stored Customization Profiles and their sub structures – ,
you might want to add custom logic to BP_CharacterCustomization component -> GetSaveGame and
CharacterEditorFunctionLibrary -> Upgrade Save Game from V1 to V2 to parse your possible changes made to
the profile structures. Look at the functions and adjust them as needed. They are not complicated and simply
transfer the old data to the new structure format.
Please, read this chapter (and if needed the previous chapter) before upgrading to V4.
NOTE As in the previous upgrade, a successful upgrade is not guaranteed, if you have added custom logic.
This time, we have only added the new “Equipment Profile” to the Customization Profile and replaced all
references to CustomizationProfile_V2 with the new CustomizationProfile_V4. The “V4” in here matches the
Character Editor Update version, not the next iteration of the Customization Profile, so there is no “V3”.
As in the previous upgrade, this new upgrade again happens in the first game loading process including the
backup save file.
If you want to upgrade right away without modifications on your side, follow the previous chapter.
If you want to upgrade with modifications on your side, follow the previous chapter. Additionally, if you have
added presets to the DT_PresetCustomizationProfiles that has been added in V2 – or you even have created
new preset data tables, then each of them must be converted manually. We have converted ours beforehand
to DT_PresetCustomizationProfiles_V4 and assigned it to the character, thus if your presets do not appear
right now, do not worry.
In your Windows Explorer find the export location and drag it back into the UE4 Content Browser.
Select FCustomizationProfile_V4 as the data table row type and press “OK”.
Press “OK” on the message about the missing “Equipment” column. It is simple not in your data table just yet.
See the data table popping up in the Content Browser. Rename it to a desired name, save it and open it.
Unfortunately, you must re-assign all Anatomy values, because UE4 cannot import enumerations in data
tables properly. But fortunately, they are still in the exported csv file. Open it with a text editor of your choice
(or Microsoft Excel) and see the original Anatomy values.
Repeat this process for all your preset data tables if you have created some.
After completing the previous steps, go to the BP_Character and/or BP_CharacterCustomization component
and change the Preset Data Table default value to your desired data table to use it in game.
If you want to add the BP_CharacterCustomization component to your character (and optionally
BP_CharacterEditor component), simply recap the BP_Character chapter and re-create the settings,
functions and variables of BP_Character in your custom character Blueprint.
If you want to add character meshes, look at the Anatomy Profiles data table. Here you can set body and
head meshes that will be used for a specifically selected anatomy within the customization.
In general, you can add any custom mesh to the system. Many by using our predefined CDA classes and
others by creating new classes (e.g., shoulder pads, capes, backpacks etc.).
If you already have an Anim Blueprint, especially if it is more complex than ours, and you want to support the
size and aging feature, we recommend to go the more tedious way. Add the CharacterAnimInstanceInterface
to your Anim Blueprint Class Settings and copy these nodes from the Event Graph to yours, to enable basic
communication between the BP_CharacterCustomization component and your Anim Blueprint.
After that, study the nodes of the Anim Graph and copy all relevant nodes to yours and – now the tedious part
– re-create all the variables from Age to Foot Transforms that are now missing in your Anim Blueprint.
Compare our variable default values, with your newly created variables. After copying them, feel free to
adjust them to your skeletons’ needs. (If it is another anatomy, maybe some other values are necessary.)
After completing all this, see Anatomy Profiles to assign the Anim Blueprint to a profile.
If you want to add custom character animations, import them as usual and retarget them to our skeleton or
the skeleton you imported on your own and already prepared the Anim Blueprint for. (See Add your own
skeleton)
If you want to animate your CDAs, that use skeletal meshes (any BP_CDA_Skeletal) you can use the Post
Process Anim Blueprints of their skeletal mesh as part of the new animation workflow. Besides that, you need
to prepare such an Anim Blueprint slightly to make it work properly with the BP_CharacterCustomization
component. As an example, you will see how the CDA_ma_avg_beard_dynamic data asset, that comes with
Character Editor V4 (Animation Update), is animated. The following steps are already done by us but are
written as you would do it yourself, thus you can follow better. Feel free to perform them for your own CDA.
Open CDA_ma_avg_beard_dynamic and see the skeletal mesh that is already assigned. Or create a
BP_CDA_Skeletal (see Add Customization Data Asset) and assign the skeletal mesh you want to animate.
If you want to create your own Anim Blueprint, right click the skeletal mesh > Create > Anim Blueprint.
Rename it as you like. For the beard, we have added the generic “_AnimBlueprint” suffix.
Open the beards’ or your Anim Blueprint, go to its Class Settings. Add the Character Anim Instance Interface.
Add a Skeletal Mesh Component variable to the Anim Blueprint that is called something like “CopyPoseMesh”.
Find the Set Copy Pose Mesh function in the Interfaces section of your Anim Blueprint. Then right click >
Implement Function. This is needed for the BP_CharacterCustomization component to automatically set the
Copy Pose Mesh once the data asset with the animated skeletal mesh is used.
The Event Graph gets focused, and the node “Event Set Copy Pose Mesh” will be placed. Create a “Set” node
for your CopyPoseMesh variable and connect it like this.
Then go to the Anim Graph and place a “Copy Pose From Mesh” node and a “Get Copy Pose Mesh” node.
Place them at the beginning of your event graph (first and second nodes). Transform the Copy Pose with a
“Local to Component” node and perform any animation you like. In the beard example to bones get
controlled by Anim Dynamics nodes to let it swing around. Afterwards transform it back from “Component to
Local” and connect it to the Output Pose.
Open the skeletal mesh you previously created the Anim Blueprint from.
Go to its Asset Details, find the Post Process Anim Blueprint variable, and assign your Anim Blueprint.
Once you select the data asset in game, the Anim Blueprint automatically gets applied as the new anim
instance as well as the Copy Pose Mesh allows your skeletal mesh to follow the main character animations,
while performing its own animations – the Anim Dynamics in this case.
You are free to add any additional animation if you implement the Copy Pose Mesh as described.
3.9. Add Customization Profiles and spawn Characters with them applied
In its Details Panel look for "Saved Profile Data" in the advanced details
(figure to the right). Here you will find all profiles listed in a readable
data format. For shipping builds it is best to store the desired profiles
by "Right-click -> Copy" to any array type of
"FCustomizationProfile_V2" you have created in a custom Blueprint –
or use our predefined data table V2 DT_PresetCustomizationProfiles
(replaces V1 PresetCustomizationData array of the
BP_CharacterCustomization component) (figure to the bottom).
From there, spawn a BP_Character or a properly set up custom character Blueprint. Get its character
customization component and call “Apply Customization Profile" with the desired profile.
You can use any of the profiles stored like above in the data table or even create a profile here in Blueprint. If
you would like to have randomized profiles in Blueprint, you must implement this functionality on your own,
since we currently only support this in combination with the in-game editor’s widget’s randomization.
As described in Customization Data Assets and Children you can create a Child Blueprint of
BP_CustomizationDataAsset or duplicates of already inheriting Blueprint classes. If you need, set up a new
• WBP_CDA_HairstylePicker or
• WBP_CDA_ApparelPicker
Then maybe implement some custom logic in BP_CharacterCustomization component -> (7) UpdateApparel
to handle your new data asset specifically.
All our CDAs are located under /CharacterEditor/CharacterParts/DataAssets/ grouped by their type.
As teased in BP_LightStudio you can create custom presets very easily and do not need to
worry about the relative locations and rotations.
Simply place the Blueprint in the scene like seen on the right. It is not necessary to perfectly
align it with the character but would be a good starting point.
Once placed, you can add any number of lights you want to the arrays
in the Details Panel “Light Studio” section. As described in the main
chapter, all lights and the Exponential Height Fog consist of all possible
Blueprint properties. The Post Process contains an actual post process
structure. Feel free to adjust as you like.
For each light entry a light component is spawned. Place it as you like
and do not worry about the placement of the BP_LightStudio actor. We
fix it later anyway.
If you are done with your setup or like to save an intermediate result,
simply select the character near the BP_LightStudio as your “Focused
Character” and head to the “Light Studio: Export” section. Click on
“Prepare Light Studio Profile for Data Table” button. This will “fix” the
BP_LightStudio location and rotation by placing and rotating it in
alignment to the Focused Character, while transforming all your lights’
relative locations and rotations to preserve your placements.
Now copy the “COPY THIS To The Data Table” structure by right clicking
it. Then open DT_LightStudioProfiles, create a new table row, paste the
copied profile into the row – again by right clicking it – and eventually giving it a Display Name in that row.
Save your data table.
Now either play the game to test your new profile or modify it further. Of course your are also able to tweak
all settings in the data table, but then you do not have the visual preview of the editor viewport.
If you stop working and come back later you can also head to the “Light Studio: Import” section to load one
of the data table rows into the selected BP_LightStudio. The Data Table Handle > Data Table is already
selected. You just need to select the Row Name of your choice and press the “Load Profile from Data Table”
button. Have fun!
NOTE We know that the process of capturing thumbnails is manual and repetitive due to technical
limitations of Unreal’s non-beta features. We do not know if we will improve it in the future. But for now, go
ahead and have fun!
To capture thumbnails for new CDAs we have a level prepared for you. We will setup the Unreal Editor to be
like a little capturing studio for you. It will look like this, covering one and a half screen widths.
3.13.2. BP_ThumbnailStudio
1. Select BP_ThumbnailStudio.
Edit Selected CDAs stops the update from Gender and CDA
Class and allows you to add or remove entries to the Selected
CDAs on your own, if you want to capture e.g., only a single
asset. When adding your own assets to the array, we
recommend not to mix genders or different apparel types,
because all thumbnails are captured from the same position
and angle – it would be a pity if you capture hats and shoes
and do not even see one of them if the camera is at the
wrong position.
Capture Scene updates the Texture Target. The changes can be viewed under References or in
Content Browser when hovering the render texture.
Preload All Data Assets is handy if you want to capture lots of data assets after a fresh editor startup.
Data Assets only get loaded from disk if they are referenced somewhere. Since this is not true for our
assets unless you play in editor it might take a while capturing thumbnails, because they get loaded
one after another. Pressing this button does the job directly for all assets and makes capturing faster.
2. Occasionally press Capture Scene and hover over the Texture Target to approach a position you like to
capture.
TIP Before recapturing thumbnails delete the old ones since a number (1, 2, 3 etc.) gets appended
automatically by the Content Browser and is nothing that we can fix, currently.
5. Once happy with the textures, save and assign them as Thumbnail in their respective data asset.
You can open another Content Browser from Window > Content Browser > Content Browser 2, which
is recommended since in one of them you open the data asset folder (1) and in the other you open
the texture folder (2). Then open the data asset and assign the texture.
Sometimes you want to persist the player across level changes. This can be done by using the Game Instance,
which itself is persisted all the time from game start to game end.
Open it and create a variable called “CustomizationProfile” type of the latest FCustomizationProfile structure.
As of writing this is FCustomizationProfile_V2.
Search for “Game Instance” (1) and assign your newly created Blueprint as the Game Instance Class (2). This
way the game will always start with that instance active.
The following step is rather a matter of taste and can be changed completely by you. For now, we want to be
able to save the customization always when the Character Editor is being closed by the user. Of course, you
can save the customization whenever you desire – come up with creative solutions!
In the Event Graph search for the Close Editor event and drag the OnClosed dispatcher like a variable onto the
graph. Choose “Call” from the context menu and connect it to the Light Studio Initialize node at the very end.
Now comes the loading and saving part in the BP_Character, which will look something like this.
Find Begin Play and place a Sequence node between BP_CharacterCustomization->Initialize and the Switch on
EInitializationBehavior like you see in the image below. The green and yellow commented nodes come now.
Open the context menu by right clicking the graph and search for “Get Game Instance”. Place it and cast it to
our BP_GameInstance, grab its CustomizationProfile variable and feed it into an ApplyCustomizationProfile
function of the BP_CharacterCustomization component. Then connect it to “Then 1 of the sequence.
This way each time the BP_Character calls its Begin Play (when it is spawned, i.e., on level loading) the
Customization Profile that is stored in the Game Instance will be applied to the character.
Now place a “get variable” node for the BP_CharacterEditor, drag out a wire and, in the context menu, search
for “Assign on Closed”. Two nodes will be created: “Bind Event to On Closed” and a custom event that you can
rename to e.g., “SaveCustomizationProfile”.
Place another “Get Game Instance” node, cast it again, but this time pull out a “Set Customization Profile”
node and feed it with the Current Customization Profile from the BP_CharacterCustomization component.
This way each time the OnClosed dispatcher is called by closing the Character Editor, the connected custom
event “SaveCustomizationProfile” (red wire) is called and will save the customization to the Game Instance,
which in turn will be used for the next level change.
Now come up with a creative solution to switch levels or simply use the “Open Level” node and test it.
This is a basic setup of how to integrate ALS V4 with our Character Editor. This integration is far from perfect
as we did not develop ALS V4 and do not know all its details, but hopefully this is a start for you.
After completing this tutorial, you will have our BP_Character with a basic setup for using the same animation
system of ALS V4. We also provide you some first steps into “advanced” topics like the ALS mantle system or
our morph system. For more, it is up to you to dig deeper into ALS – especially ALS_Base_CharacterBP,
ALS_AnimMan_CharacterBP, and ALS_AnimBP may help you.
NOTE All further basic chapters refer to our female character. You may want to repeat these steps for the
male and child assets as well.
You need to add several virtual bones matching the right picture. To achieve this, right click on a bone as the
first connection point -> Add Virtual Bone -> Pick Target Bone… by typing a name and select it in the list
below.
We will show you the steps for the first Virtual Bone “LHS_ik_hand_gun” which starts at “hand_l” and goes to
“hand_r”. Thus, right click on the bone “hand_l” -> Add Virtual Bone -> search for “hand_r” and select it.
Now you will find a blueish bone next to all the finger bones called “VB hand_l_hand_r”. To let it recognize by
ALS V4, rename the “hand_l_hand_r” part to “LHS_ik_hand_gun”.
Follow the same process for all these pairs in the given order. As you may notice, sometimes First Bone and
Target Bone are identical. That is okay. Also left hand (1, 2) and right hand (3, 4) are reversed when it comes
to create their respective handgun virtual bone.
After completing this you need to make sure that the skeleton is prepared for the
same humanoid rig, that ALS is using. In the skeletal editor you have still open go to
Window > Retarget Manager.
3. Double check that all Sources are mapped to a Target (usually the
same name, probably with some letters lowercase or uppercase).
Right click the original ALS_AnimBP in the AdvancedLocomotionV4 folder > Retarget Anim Blueprints >
Duplicate Anim Blueprint and Retarget.
The Select Skeleton window opens. Select SKEL_fe_polyphoria in the left panel (1) and choose a new folder
for the retarget assets (2). The latter is recommended, because all the 122 Animation Sequences and Blend
Spaces get retargeted as well along the AnimBlueprint itself. Then just retarget (3). This may take several
minutes to retarget each asset.
Once completed there is the new ALS_AnimBP right in your chosen folder.
Open the Event Graph of the character and place a Parent: Begin Play node between Event Begin Play and the
Initialize function.
Staying in Event Graph, remove all our “Basic Example Keyboard Movement” nodes as they would conflict
with the ALS inputs.
Enable crouching by selecting the Character Movement component and tick “Can Crouch” in its details.
Change the Anim Instance Class to the ALS_AnimBP, you have just retargeted.
Remove the ALS_AnimMan_CharacterBP (on the left) from the level. Optionally place a generic PlayerStart.
In the World Settings of the level select our BP_Character as Default Pawn Class.
Press “Play in Editor” and jump around as you never did before!
The whole ALS movement relies on the ALS_AnimBP that you have retargeted and used in the previous
chapters. Therefore, none of our logic is attached to it by default as it belongs to a completely different
AnimBlueprint. Look at our ABP_fe_CharacterEditor AnimBlueprint’s EventGraph and AnimGraph for things
you may want to copy. This chapter will explain how to copy the size transforms.
Event Graph
Anim Graph
Open the ABP_fe_CharacterEditor Anim Graph (which you also see on the previous page) and copy all content
in the Size Transform comment.
Open your retargeted female ALS_AnimBP and place all the copied nodes (red box) into its AnimGraph.
Connect our initial Transform (Modify) Bone node to the Two Bone IK node (1) and our last Transform
(Modify) Bone node to the Component To Local node of the pink comment (2). You may figure out a better
place to connect them for organization purposes but this place was a perfect fit for testing this.
You may now have noticed several gray variables after placing the nodes. (Don’t be confused: The image
above is captured with the following steps already performed. Look at the image below.) Compile the
Blueprint to see errors popping up at their positions to better identify them. We will fix them in the next step.
Simply right click on each gray variable and create a new variable from the context menu. This way the
naming and type of the variable is the same of the variable from the original source ABP_fe_CharacterEditor.
After doing this the variable gets its color back.
Repeat this process for each variable. The errors will be gone after you compile again.
Look at the Anim Preview Editor and change it to the “Edit Defaults” mode. Apply all these following values to
your created variables. Be careful, as the order of the input fields may be different, if you have created the
variables in a different order.
If you need foot or age transforms as well, look at the corresponding values in ABP_fe_CharacterEditor.
Go to the AnimBlueprint’s class settings and add the Character Anim Instance Interface (not the Character
Customization Interface!)
Go back to ABP_fe_CharacterEditor’s Event Graph and copy the Event Set Size nodes to your ALS_AnimBP’s
Event Graph.
Also from ABP_fe_CharacterEditor copy the last three nodes from the Event Blueprint Initialize Animation.
Back in your ALS_AnimBP’s Event Graph, arrange the nodes and connect the three stray nodes to the Set
Character node like seen below. This way our Character Customization component can communicate with the
AnimBlueprint.
Now again, press “Play in Editor” and change the size of your character.
NOTE We treat this chapter not as “basic”, because the animations did not get retargeted straight away
with the ALS_AnimBP retargeting and work slightly more technically/dynamically and may require very custom
implementation details if you desire.
We also did not mix it into the “basic” chapters, because for tutorial purposes (and because we cannot deliver
all these ALS-retargeted assets to you) we will work with separate variables instead with our
DT_AnatomyProfiles data table.
This slightly causes “incompleteness”, because only the skeleton, that you have retargeted the upcoming
animation montages of the next pages to, will work with these montages (e.g., if you have retargeted them to
SKEL_fe_polyphoria, they will only work with the female meshes as they rely on that skeleton).
We suggest, if you want to support more than one anatomy, that you extend on your own the FAnatomyProfile
structure, which makes up the row entries of DT_AnatomyProfiles and insert an array or a map of these
mantle asset structures that you will have prepared in several minutes. This way you could fill the so called
GetDataAsset and GetRollAnimation functions right from the current Anatomy Profile of your character.
The mantle information must be delivered by the GetMantleAsset function of the ALS_Base_CharacterBP.
Like you did before for the ALS_AnimBP, retarget the ALS_N_Mantle_1m_Montage_Default,
ALS_N_Mantle_2m_Montage_Default and ALS_N_LandRoll_F_Montage_Default animation montages to our
female, male or child skeleton to the respective folders next to their AnimBlueprints.
Open our BP_Character and head to My Blueprint > Functions. Hover over the “Functions” category and then
click the Override button. Select the functions GetMantleAsset and GetRollAnimation to override them. You
can also type their readable names “Get Ma…” or “Get Roll …” to search in that list.
Open the GetMantleAsset function override and place the following nodes.
• Remove the parent call node that might be there, leaving only the input and return node.
• Grab a wire from Mantle Type input and place a “Switch on MantleType” node.
• Grab a wire from Return Value output and promote it to a new variable. Repeat this another time and
call both variables “Mantle_2m_Default” and “Mantle_1m_Default”.
• Duplicate the Return Node and connect all nodes like this.
Open the GetRollAnimation function and do the same for a variable called “LandRoll_Default”.
In My Blueprint > Variables, search for the same names of the variables that you have just created – AnimMan
has them, too! To make it easier for you, simply copy their whole property values (left) and paste them into
your variables inside the BP_Character (right, 1). The assign the corresponding retargeted animation montage
to the AnimMontage field (2).
Also, assign your retargeted roll animation montage to the LandRoll_Default variable.
And now, you can finally press “Play in Editor” and roll and climb around as you never did before!
NOTE Keep an eye on the Unreal Engine Output Log if something seems wrong. Maybe an animation does
not play, because it is retargeted to the wrong skeleton, that does not match your current anatomy.
ALS V4 uses the hotkey “C” which conflicts with our Character Editor opening. As you open the editor you will
also trigger the ALS “Switch Shoulders” functionality, which in turn, as you close the editor again switches the
ALS camera behavior. Closing our editor does not trigger that functionality again, therefore it is activated.
By default, if you rotate the camera around the ALS character, its head is following your camera direction and
the character is eventually turning itself completely to take a more comfortable pose, if the head would turn
too far. But if you “switch shoulders” it is usually intended to be a first-person mode, where the character
turns more directly to your camera direction resulting in small footsteps, which is not supported by our
character as it stays in third-person mode – thus the animation seems a bit choppy and unwanted (see next
chapter, “Smooth Transitions”).
In case you see this “choppy” behavior it is due to the opening of the character editor. Just use another
hotkey for either the character editor or “Switch Shoulders”.
By default, while in Character Editor you can rotate the character by left and right mouse dragging. Due to the
ALS V4 auto alignment of the character (as described in the caveat above), your character would adjust itself
to the camera and you are kind of not able to change the camera rotation. We suggest that you switch the
camera rotation mode with hotkey “X” and turn the camera around the character instead of rotating the
character itself.
Currently, our assets are not properly set up to support ragdoll physics.
Smooth Transitions
Currently, the AnimMan of ALS has several nice camera montages and transitions for movement changes
between walking and crouching, rolling, or climbing. Our setup may look a little bit choppy but investigate
ALS_AnimMan_CharacterBP and copy the functionality you desire.
Currently, if you change the anatomy via the editor in-game something stops several parts of ALS from
working. E.g., the automatic turning of the character gets caught in an endless loop of not fully turning while
resetting. We could not yet figure out, what is causing this. For now, you should start your character with the
correct anatomy assigned.
The goal of Modular Medieval NPC (released on 23. May 2018, Unreal Engine 4.19) was to enable you to
create NPCs and crowds of people with lots of variations, though the NPCs could also be controlled by the
player and dressed in-game with a basic character editor demo.
The Character Editor (released on 22. Apr. 2020, Unreal Engine 4.24) aims, five engine versions later, for the
creation of hero characters with a higher degree of visual details incl. facial morph targets and a potentially
arbitrary number of apparels attached to the character. The product unfolds its complete power in the
modular in-game character editor as the name says. With that different focus, the changes of Unreal Engine
itself and the more solidified knowledge how to master them, we simply had to create a whole new product
rather than extending the Modular Medieval NPC.
Good News
Assets from our other products can potentially be used with the Character Editor but may require manual
work depending on the asset type or features you would like to transfer. Meshes, textures and materials are
easy to merge with the Character Editor, as they are designed to be cross-pack-compatible. You even may
transfer meshes from this to other packs, of course if you match the engine versions or export them as FBX.
Though, some meshes of older packs may simply do not have features of newer systems (like the facial morph
targets) or are not perfectly compatible as they may have different technical approaches. These features may
be added at some point in time, but we cannot guarantee that. If you have appropriate third-party software,
you can of course add some of these features yourself. Old Blueprints and other logical parts, for the record,
are mostly incompatible with the Character Editor, as they got greatly revamped, overhauled, or extended.
Explanation
Note, that we cannot keep all our packs in sync with the same logical base, on the one hand because of our
full-time jobs, but on the other hand because we strive to deliver you content packs as modular as they can be
in our eyes and just want to develop even more modern products than before. Thus, old systems sometimes
just need to be replaced with newer ones. And because of the nature of Unreal Engine content packs and all
your completely individual customer needs, it is difficult for us to stay compatible between pack versions and
even different products. (See How does the Character Editor differ from Modular Medieval NPC?)
We hope you enjoy the Character Editor as much as we enjoyed developing it! ☺
Not out of the box. You must implement your own solution. We decided against a built-in solution as it
strongly dependent on your specific needs.
As a starting hint for a simple replication during begin play you need a way to store the current customization
profile of each player and load it back in Begin Play for each player as well.
As a starting hint for real-time replication during or after character customization you need a way to replicate
the customization profile right after saving or closing the character editor to each player.