UMA - Unity Multipurpose Avatar

UMA - Unity Multipurpose Avatar

UMA version 1.0.1.0R Unity 4.3

What is UMA?

UMA - Unity Multipurpose Avatar, is an open avatar creation framework, it provides both base code and example content to create avatars. Using the UMA pack, it ́s possible to customize the code and content for your own projects, and share or sell your creations through Unity Asset Store.

Overview

Avatars generated by UMA framework

Close on detailed avatar

UMA works both on Unity PRO and free licences, but benefits from PRO features for accelerating UMA creation steps.

This project has been updated for Unity 4.3, as it will require access to the Mecanim avatar API on following releases.

UMA can be integrated and used on mobile, standalone and web player builds and included shaders require Shader Model 2 or superior. It has not been tested on console builds. If you re targeting old devices, it ́s recommended to reduce texture resolution and take other optimizations measures to avoid memory issues.

UMA is designed to support multiplayer games, so it provides code to pack all necessary UMA data to share the same avatar between clients and server. It may be necessary to implement a custom solution depending on your needs to optimize and reduce serialized data.

Performance and memory usage

UMA framework provides a set of high resolution content, flexible enough for generating a crowd with tons of random avatars or high quality customized avatars for cutscenes. Source textures are provided for generating final atlas resolution of up to 4096x4096. Depending on the amount of extra content being imported to the project, it might be necessary to handle memory management or reduce texture resolution.

Every UMA avatar created has it ́s own unique mesh and Atlas texture, requiring extra memory. The standard atlas resolution of 2048x2048 is recommended for creating a small number of avatars, for games creating on a huge amount of avatars, using lower atlas
resolution or sharing mesh
and atlas data will be
necessary.
UMA was initially planned to
provide 50 avatars on screen,
but the latest version can
easily handle a hundred of
unique avatars.

100 Avatars in real time

Free and PRO license differences for UMA

UMA results on PRO and Free licenses are meant to be as similar as possible,
however calculating a UMA atlas can be handled differently. For PRO it ́s possible to
create the atlas using RenderTextures, so texture calculation is very fast. For Free
license, it requires processing each pixel individually, so it takes considerably more
time and processing power. It ́s possible to split this calculation over as many frames
as necessary to avoid drastically lowering frame rate, but higher resolution textures
will require a considerable amount of time to be processed. The gameObject
UMAGenerator provides an option for using PRO or Free, I ́ve left this as a way PRO
users testing performance of content on indie projects, for example. The Free license
users need to uncheck the usePRO checkbox on UMAGenerator.

How does UMA work?

Creating 3d characters is a time consuming process that requires a number of
different knowledge areas. Usually, each character is created based on an unique mesh
and rig and is individually skinned and textured.

When developing games that might require a huge amount of avatars, it ́s
expected to develop a solution to handle avatar creation in an efficient way. Usually
they start from a set of base meshes and follow standards to be able to share body
parts and content. Each project ends up with a different solution, and it ́s hard to
share content or code between them.

UMA is meant to provide an open and flexible solution, which makes it possible
to share content and code between different projects, resulting in a powerful tool for
the entire community.

UMA has two main goals: Sharing content across avatars that uses same base
mesh and optimizing created avatars, while providing the ability to change avatar
shape in realtime.

To achieve that, I ́ve created a special rig structure that handles bone
deformation in a strategic way that makes it possible to deform UMA shape based on
changes on bones position, scale and rotation.

UMA example avatars are based on two base meshes, a male and a female.
Each of them can share clothing and accessories, and can be used as a base on the
creation of new meshes for different races.

Because clothes and accessories are skinned to UMA base mehes, they receive
the same influece of UMA body shape, so any mesh deforms to any UMA body.

This way, if you have an armor or dress, it can be shared between all male or
female avatars, even if they have very different body shapes.

many different textures when generating the final atlas. Those extra textures can be
used to create even more variation to each avatar, and can be used for clothes, details
and many other possibilities.

UMA optimization
occurs in many steps: Each
UMA avatar can have an
unique texture atlas providing
all necessary texture data, this
makes it possible to have each
UMA generating a single
drawcall, in the case of a single
material being used.

All UMA parts are baked
together into one final mesh,
which reduces the calculations
involved in processing. Joen
Joensen from Unity team
implemented an advanced
skinned mesh combiner to
accomplish this.

UMA avatars generated based on same content and different shapes

On UMA latest version, the old CombineInstance() code is still available in case
there ́s no intention on using extra bones that would be dinamically included on
avatar. The legacy code requires less processing time, but provides limited results.

How content is created?

Set of High poly meshes based on UMA final clothes.

Creating content for UMA doesn ́t require much extra knowledge beyond the
usual asset creation pipeline. There are three main type of content: Base meshes, Slots
and Overlays.

Base Meshes

UMA provides two starting base meshes, a male and a female. It ́s possible to
create completely different and unique base meshes and still take advantage of UMA.
As all content uses base meshes as reference, if you create a minotaur base mesh and
are able to keep the same data from the original male torso base mesh, all clothes
based on that male torso can be shared with the new Minotaur mesh.

For a completely different race, such as horses, you will need unique content.
This could then be shared with
other similar races, like unicorns
and even dragons. Male and
female Base meshes were created
considering the average volume
those bodies would be able to
reach using the adjustments in the
UMA rig.

Uma Female and Male base meshes.

Slots

All UMA content that provides a mesh is a slot. Slots are basically containers
holding all necessary data to be combined with the rest of an UMA avatar.

For example the base meshes provided are normally split into several pieces,
such as head, torso and legs... and then implemented as slots which can be combined
in many different ways.

An UMA avatar is in fact, the combination of many different slots, some of
them carrying body parts, others providing clothing or accessories. Lots of UMA
variation can be created simply by combining different slots for each avatar.

Slots also have a material sample, which is usually then combined with all other
slots that share same material. Female eyelashes for example, have a unique
transparent material that can be shared with transparent hair. It ́s necessary to set a
material sample for all slots, as those are used to consider how meshes will be
combined. In many cases, the same material sample can be used for all slots.

UMA standard avatar material uses a similar version of Unity ́s Bumped
Specular Shader, but UMA project provides many other options.

The big difference
between body parts and other
content is that body parts need
to be combined in a way that
the seams wouldn ́t be visible.
To handle this, it ́s important
that the vertices along mesh
seams share the same position
and normal values to avoid
lightning artifacts.

Example of Male slots.

To handle that, we provide a tool for importing meshes that recalculate the
normal and tangent data based on a reference mesh. UMA MaterialBuilder will be
explained in following pages.

Overlays

Each slot requires at least one
overlay set but usually receives a list
of them. Overlays carries all the
necessary textures to generate the
final material(s) and might have extra
information on how they are mapped.
The first overlay in the list provides
the base textures, and all other
overlays included are combined with
the first one, in sequence, generating
the final atlas.

UMA standard shader requires
two textures provided by overlays,
one texture for Diffuse color (RGB) +
overlay mask (A) and one texture for
Normal map(GA), Specular (R) and
Gloss (B). These non-standard textures
let us compress a lot of information in
only two textures, reducing final
memory usage.

Together, Joen Joensen and I have worked on “UMA u ”,
that receives 3 standard textures for Diffuse(RGB) + mask(A), Normal map(RGB) and
specular(RGB) + gloss(A), and compacts the data into the two textures described
above. In the process, the specular color is reduced to one channel of data, the
resulting average color of the 3 channels provided.

FwgPT' “BfC Au
M ” http://www.manufato.com/?p=902, Joen and I worked together to reach
two shader that handle specular color based on diffuse color reference resulting in
Dielectric and conductor materials.

I ́ve already managed to integrate some of the most common Unity shaders
into UMA and the adjusts required are quite simple. Even more advanced shaders can
be integrated and used, keep in mind it ́s possible to provide extra textures on each

Example of overlay composition

overlay, this way, it ́s possible to include displacement maps, Sub surface scattering
masks or any necessary data.

Asset creation pipeline

UMA project provides an UMA content creator pack, it ́s a zipped folder with all
necessary base meshes and textures for creating your own content. It provides:

- base diffuse, specular and normal map textures
- UV layout reference images
- Male and female base meshes in .OBJ
- Rigged and Skinned base meshes in .FBX file format
- .ZTL files for Zbrush users

- An open .Blend file for blender users

I ́ve spent a long time recording and producing video tutorials
(http://www.youtube.com/user/fernandoribeirogames) to cover all the basic process of
content creation, but the knowledge for actually working on any 3d software is
prerequisite.

The overall knowledge for generating UMA content is 3d modeling, rigging,
skinning and texturing. It ́s also possible to work on existing content already available.
For example, if you have an tshirt slot, with the right texture work it ́s possible to
provide an chain mail overlay without extra knowledge of modeling, rigging or
skinning.

Texturing and UV mapping

Both UMA male and female base textures have a specific resolution. Below is
the list of those base texture sizes in
pixels:

- Head : 2048x1024
- Body : 2048x2048
- InnerMouth : 512x512
- Eyes : 512x512

Male body UV layout

Those values are specific to the provided base meshes as a standard for anyone
creating content for them. If you plan following a different standard, it ́s possible to
use any different resolution.

When creating new content for UMA, if you ́re aware it will be covering an area
of UMA body texture, it ́s possible to use that UV area for the new content texture, if it
offers enough space. This example can be seen on Female tshirt and hair, both of them
save atlas space, having those textures as overlays for body base texture instead of
being base textures themselves.

Also, any overlay texture and it ́s covered base textures don ́t need to keep the
same size. For example, FemaleUnderwear01 overlay covers only the left half of the
base, so it ́s possible to have that overlay with half the width of body base texture.

The Rect provided together with the overlay elements is responsible for keeping
information of the positioning adjust of the cropped overlay, relative to base texture
coordinates.

It ́s possible to provide overlays that will receive color adjusts at atlas creation.
In those cases, usually the predominant color is white or gray in those areas, to have a
neutral influence over final color.

Above image illustrates the use of a cropped overlay in junction with Eye base texture to
generate iris color variation

In other hand, UMA 1.0.1.0R don ́t support combining textures with different
original size: Even cropping an overlay removing the unused masked area, the original
overlay size should be the same of the base texture. So if you provide a cropped
overlay for eyebrows, it requires a Rect data relative to the 2048x1024 head reference
texture. Providing a non cropped overlay with smaller or bigger resolution than the
base overlay might generate error messages.

3d modeling

It ́s possible to integrate any 3d mesh into an UMA avatar, it ́s important to
follow the same optimization guidelines usually used for traditional characters and
clothes, as topology and vertex count. I ́ve included meshes with both uniform and non
uniform polygon placement, it ́s important to keep in mind when each case can be
used. The same way, I ́ve worked
both on meshes mostly quad based,
and meshes entirely based on tris
before exporting process. All
content can be integrated despite
those differences, but stretched
polygons might cause poor lightning
results, especially visible when not
using normal maps.

Female and Male jeans completely different topology

Rigging and skinning

This is where all the UMA magic happens. All shape variations we can achieve
on UMA avatars are a consequence of changing bone scales, positions and rotations. A
mesh correctly following those changes depends on rigging and skinning entirely and
an incorrect skinning process might lead to issues such as a clothing pieces not
following the same shape variation as the body.

I ́ve provided base meshes with rig and skin data because most 3d software has
specific tools that allow users to transfer bone weight data between different meshes
avoiding most of the time consuming process involved. I ́ve shown this being done in
Blender at some video tutorials (http://www.youtube.com/watch?v=ImD6APS0xek), but
the same can be done with XSI Gator or other specific solutions.

For dresses or armor, simply projecting those values might not be enough, and
skinning knowledge may be necessary for best results following body variations.
fu guwg f
wuf-

uf g T f UMAg,f u
able to change the arm scale both in uniform and non-uniform ways, but having an
non-uniform scale deforms all child bones too, so those changes need to be applied to
the child bones working in pair. It ́s also important to keep in mind it ́s always these
child bones that carry the skinning data, as it will always change directly, and under the
influence of the parent bone.

Male jeans skinning and male base mesh skinning. Skinning Data has been projected with
Blender Transfer weights tool

3D software

Blender is UMA standard content creation software, because it ́s open source
and accessible for all developers. Being the standard means I ́ll provide most of the 3d
tutorials on this specific application but keep in mind most of the available softwares
have a set of tools to handle what I ́m doing in blender.

Initially, I planned including here the standard import and export setting for
each 3d software I manage testing the integration with UMA, but as you ́re going to
notice, importing setting mostly depends where those files where generated, so it ́s
hard having an standard. For export setting, I ́ll explain the specific setting for
exporting content for UMA base mesh.

Blender

Importing files: Blender has a huge limitation: it can ́t
import fbx files (Update: On Blender latest version, fbx import
is already being integrated), so it will be harder sharing
skinned and rigged models from other 3d application to
Blender. Importing obj files is a straightforward process, and
blender provides settings for definning forward axis and up
axis, covering different coordinate systems. It ́s usually a good

g “Keep Vert Order”, f u
of mesh vertices, this is specially important working with
zbrush and other sculpting tools.

Exporting files: Exporting fbx files of rigged and
u qu g “forward axis” “Z

forward” “Up Axis” “Y Up”

It ́s very important when exporting content being sure
both it ́s position, rotation and scale are normalized, this
means you need to bake all those into vertices position. This

w “Ctrl+A” “Object/Apply”

You usually don ́t need including animations when
exporting clothes and acessories, but it ́s really important that
the rig is exported along with the mesh for your content.
Including the rig might raise the disk space required by that
file, so it ́s usually a good idea to keep a bundle of meshes on
the same fbx file whenever possible.

3ds max

Importing files: I ́ll focus on
gf f “Content

creator pack”, w
exported from blender, there ́s a
small change required when
importing base mesh fbx files to
3 ,u “units”
“Centimeters”
size.

As you can see on the
following image, the fbx file (upper
mesh) has the correct rotation and
is fully rigged and skinned. The Obj (lower mesh) file requires
manual rotation adjusts after importing process.

3 f “skinwrap” u
for copying skinning data between UMA base mesh and your
own content.

Exporting files: The same warning I ́ve provided for
blender users apply here too: It ́s very important when
exporting content being sure both it ́s position, rotation and
scale are normalized. It ́s possible to adjust mesh pivot using

“Affect Pivot Only” u T ́ f ju
required when creating your own content, the Z rotation
value of the mesh should be set to 180 degrees, this is
usually done entering Affect Pivot Only mode and rotating
the pivot itself.

When exporting the fbx files, you need
to have both your content mesh and rig
selected. It ́s usually a good idea not including
the cameras and lights on the fbx files. For

g, u “automatic”
“Up Axis” “Z up”

Animation

UMA is integrated with an
humanoid mecanim avatar, opening a
huge list of animations that can be
retargeted to any UMA avatar. Both Male
and Female UMA prefabs had their
mecanim avatar settings adjusted. UMA
rig provides enough bones do handle
facial animation, the same techniques
required for facial animation on any
mecanim avatars apply to UMA.

Slots that provide extra bones not
linked to humanoid mecanim avatar
require extra adjusts to properly receive
animation, as animation data won ́t be
retargeted to those bones.

Mecanim avatar creation API

Example of bone driven facial animation

Mecanim

Unity 4.2 provides an Mecanim avatar creation API, this is necessary to recreate
mecanim avatars based on changes UMA rig might have received. Before unity 4.2, this
was not possible and I had to use LateUpdate to keep bone changes, consuming extra
processing time and possibly breaking Mecanim IK depending on the kind of changes
bones received. UMA latest version already integrates Mecanim avatar creation and
provides full suport to IK and Root motion thanks to Joen Joensen and Mecanim team
help.

Overview

UMA Components

Joen provided a diagram for the beta group showing the relationship between
the various parts of the UMA framework. I ́ve included a new version here to help
explaining how avatars are created.

Libraries

All avatars created need to have access to a set of necessary data: Races, Slots
and Overlays. Each library provides a list of each of those within an dictionary, being
the key an string with the name of the element, and the value the element data itself.

For projects with big amount of content as mmo games, you probably don't
want everything loaded in memory and loading/unloading assets might become
necessary, this case requires implementing custom libraries.

- race library

Each RaceData on the race library provides a prefab with all shared scripts,
avatar data and etc, one or more DNAConvertes and a list of the name of bones that
require being updated.

As you ́ve noticed, I ́ve separated male and female as two different race datas.
This is because each race provides an specific base mesh and rig/skinning data, and
usually require specific content. Using unique base meshes for male and female gave
me the possibility of reaching a better silhouette and topology for each of them.

DNAC g u “height” “armSize”
to bone deformation and shape changes. It ́s possible to have two different races with
u “height” “armSize”, u f erting those values

in different ways.

- Slot library

Each slot provides a skinnedMeshRenderer and a material sample, as explained
earlier. If you ́re planning on inluding extra bones on any Slot, it will be necessary to
u J ́ “UMA u ” for generating the slotData, as it is responsible for
identifying if there ́s any extra bone and listing all their transforms.

The first overlay in the slotData ́s overlayList provides the base textures, and all
other overlays included are combined with the first one, in sequence, generating the
final atlas.

- Overlay library

Overlay library gives access to all available overlayData , This library might use a
huge amount of memory depending of the project, as it keeps direct reference to
texture files. By default all UMA textures are provided with read/write tag checked,
but this is only necessary if you ́re using free license.

Each overlay have an color that can be used to tint it ́s first texture on
textureList. Usually this value is set by code, at the moment the overlay is being
included on the slot.

The Color32 arrays channelMask and channelAdditiveMask gives exceptional
control over adjusting texture channels. Each color here will change the overlay
texture from overlayList sharing the same index. With this, it ́s possible to adjust each
texture channel of each overlay of an atlas.

For example, if we consider reducing the gloss value of a hair texture, we could
set an channelMask second color (index 1, relative to second texture, where normal
map,s u g ) “” wervalue.

Functions public void SetColor(int overlay, Color32 color) and public void
SetAdditive(int overlay, Color32 color) on overlayData are responsible for setting those
values. We could have something like hairOverlay. SetColor(1 , new
Color32(255,255,50,255)); to reduce gloss value on above mentioned example.

The rect value is specially useful if you ́re providing an overlay that covers a
small area of the base texture. Both male and female
eyebrows cover only a small part of the head base
texture, and it would be a waste of memory having a

huge texture with most of it ́s area completely
masked.

The x value is the horizontal offset of the
cropped overlay, y value is the vertical offset, and
width/height are relative to cropped overlay size.

cropped overlay being combined to base texture

I ́ve managed to include on Overlay library a set of buttons to adjust all overlay
textures in a single click, this is specially usefull to reduce the resolution of all textures
or set their compression.

UMA shape

- UMADna

Being able to adjust avatar shape in real time, even if the avatar share both
texture atlas and mesh is very powerful. This is possible because we use bone changes
to deform both the avatar body mesh and it ́s clothes. To archive those bone changes, we
need to know both which bones should be adjusted and how this should happend.

UMADna holds the values from changes an avatar can receive, and we provide an
UMADnaHumanoid class inheriting from UMADna as example of how this works. Both male
and female avatars uses this UMADnaHumanoid to define their shape values.

If you consider the winged humanoid on the diagram image, it might be possible to
have a single UMADnaWinged being used by both male and female wings. This class would

u“z”,“z”“lg”

- DnaConverterBehaviour

The DnaConverterBehaviour is responsible for converting the Dna values to bone
changes, This is where the code for deforming bones is kept. We provide both an
HumanFemaleDNAConverterBehaviour and HumanMaleDNAConverterBehaviour inheriting
from DnaConverterBehaviour and as you can see, male and female avatars share the same
shape values, but resulting bone changes are specific to gender.

Creating UMA avatar

UMAGenerator

UMAGenerator provides all necessary functions and methods to handle avatar
creation. Creating an avatar is done in 3 steps: calculating it ́s final mesh and rig,
processing it ́s texture atlas and updating it ́s shape.

umaDirtyList keeps track of all UMA avatars that need to be created or
updated, in documentation following pages it will be clear how and avatar is included
on list.

Both usePRO and convertRenderTexture visible as checkboxes on unity editor
are very important. If you have an Unity PRO license and usePRO enabled, it ́s possible
to create the atlas using RenderTextures, so texture calculation is very fast. For Free
license, it requires processing each pixel individually, so it takes considerably more
time and processing power. It ́s possible to split this calculation over as many frames

as necessary to avoid drastically lowering frame rate, but higher resolution textures
will require a considerable amount of time to be processed.

convertRenderTexture is useful in case you ́re working with Unity PRO, but
don ́t want the final atlas being a RenderTexture instead of Texture2D. This might be
the case if you ́re planning compressing the atlas. Keep in mind this process is heavy
and might bring slowdowns on 2048x2048 atlases. it ́s Also known that RenderTexture
data won ́t be kept on Webplayer after window is resized or on builds when for
example accessing task manager, in those cases atlas would have to be recalculated or
converted from RenderTexture to Texture2D to avoid the problem.

textureNameList provides a solution if you ́re planning using extra textures that
should be baked on atlases and applied to your sample materials. Usually we have
_MainTex and _BumpTex, and if your sample material shader require both of them,
atlas will search on overlays ́ textureList index 0 and 1 for those two. In case you add a
third texture name, for example _DetailTex, and provides a shader requesting this
data, overlays using this shader are expected to provide the extra texture on
corresponding index.

maxMeshUpdates and maxPixels defines how many meshes will be baked and
how many pixels can be processed on a single update step. Setting maxPixels is only
necessary when not using usePRO. If you ́re targeting mobile or old devices, it ́s
important to profile the performance and adjust those values. It might also be useful
to adapt those values dinamically depending on actual performance for the specific
device running the project.

atlasResolution is very important, it defines maximum resolution of the atlases
generated. If you need very detailed textures, you might want to increase this to 4096,
but keep in mind the memory used for high resolution textures is really big, specially if
not compressed. It ́s possible to adjust overall overlays resolution to fit smaller atlases,
this will be covered on following pages. Setting atlas
resolution to small values but not adjusting textures
resolution accordingly will generate errors on
project, as not all textures will fit atlas.

FitAtlas Forces final atlas to fit Atlas
resolution in case the resulting atlas size would be
larger than maximum size.

AtlasCrop Final atlas unused texture space
will be cropped. If you need the resulting atlas being
a square texture, this is not recommended.

UMAGenerator

UMACrowd

UMACrowd is an example of how UMA avatars can be randomly created based
on content we have on libraries. Both colors and shape values don ́t have any
elaborated creation method. In most games you will need a color palette and more
control over shape and cloth combinations.

First of all, UMACrowd needs to keep track of SlotLibrary, OverlayLibrary,
RaceLibrary and UMAGenerator. You can consider UMACrowd as a chef with access to
all necessary ingredients and tools to cook an unique meal. Each UMA avatar, or meal
if you wish, is created based on an specific recipe the chef writes based on available
ingredients and how they are combined. UMAGenerator is the available tool the chef
uses to actually cook the meal, and bake an UMA avatar.

atlasResolutionScale This value changes the overall texture size of all overlays
an UMA avatar receives, reducing final atlas size. If you ́re planning on having a lot of
UMA avatars with unique atlases, it might be necessary considering a lower value here.
Usually the values we set here are 1.0f, 0.5f, 0.25f, 0.125f and 0.0625f, as those are
also the values for getting the correct mipmap on Free license. As default, it ́s set to
0.5f, with atlas resolution of 2048.

generateUMA , visible as a checkbox at Unity Editor, checking it generates one
random UMA avatar.

generateLotsUMA, visible as a checkbox at Unity Editor, checking it generates a
groupd of random UMA avatar, based on below Vector2 value.

umaCrowdSize defines the amount of UMA avatars created on column and row.
Default values are 4x4, resulting in 16 UMA avatars.

randomDNA visible as a checkbox at Unity Editor, checking it generates random
shapes for avatars, otherside all avatars will have neutral shape.

useLegacyCombine On UMA latest version,
the old CombineInstance() code is still available in
case there ́s no intention on using extra bones
that would be dinamically included on avatar. The
legacy code requires less processing time, but
provides limited results.

zeroPoint Defines the position where UMA
avatars are created. If it ́s empty, defaulf value is
Vector3.Zero.

UMACrowd

UMACustomization

UMACustomization exemplify changing avatar shape after it ́s creation.
Following the same concept, it ́s possible to change UMA slots and overlays, triggering
them to update with the new content. At the example scene, right clicking on any UMA
avatar updates UMACustomization sliders with its specific shape, after that it ́s
possible to use sliders to change any shape value.

UMACustomization generates a rough example of sliders based on GUITextures
as reference of how to handle changing UMA shape based on user input, but it ́s clear
each project will require a custom approach to handle both GUI and user input.

Exchanging UMA cloth and acessories means changing the array of slots used
for creating an UMA avatar and including that avatar on umaDirtyList at
UMAGenerator to get updated.

UMACustomization

UMAData

UMAData provides many functions, methods and classes being used on avatar
creation as an standard for sharing information.

Each avatar has it ́s own UMAData, that ́s why manually duplicating avatars on
Unity editor might generate errors when trying to access any avatar data, as their
UMAData has not been properly set.

́ f “ ” UMAData. Both isShapeDirty,
isMeshDirty and isTextureDirty are responsible to keep track of what needs to be updated or
recalculated on this UMA avatar.

isShapeDirty means shape data needs to be recalculated. This is usually set when any
DNA value received changes that require updating UMA bones.

isMeshDirty should be set true when UMAData received slot changes and avatar mesh
requires being baked again. This also applies if overlays have changed as most likely atlases
and in consequence mesh uv will require to be recalculated.

isTextureDirty means atlases require being recalculated. On UMA actual stage, the
entire atlases are generated from scratch, but it ́s possible to keep track of changes and
implement an advanced solution forcing atlas recalculation on specific areas only.

useLegacyCode is set by UMACrowd when creating the avatar, but can be set directly
on UMAData.

animationController can be an unique
animator for each avatar. This is necessary because
when the avatar shape changes and a new mecanim
avatar is created, the animation controller need to be
set back.

umaPackRecipe was created considering that
all necessary data to recreate an UMA avatar might
need to be saved or shared on multiplayer games.
What umaPackRecipe provides is the minimum
necessary data for serialization, usually an array with
the names of slots, overlays and DNAs, and the extra
changes that had been applied to those. All this data
can then be unpacked into an umaRecipe. In the
process, respective libraries provides elements based
on serialized names and extra changes are applied to
those.

UMAData

Credits

Without Caitlyn Meeks-Ferragallo (Unity Asset Store Manager) and Jay Santos
(Unity Field Engineer), UMA probably wouldn ́t reach Asset Store any time soon, and
even if it did, it wouldn ́t have the same quality and flexibility it provides today.

Unity sponsored this project, making it possible to be available at Unity Asset
Store for free. In the last months, I ́ve received a huge help from Joen Joensen (Unity
Software Developer, QA), he both provided feedback for UMA code and included his
own scripts to the project.

Development

Fernando Cardoso Emiliano Ribeiro (Huika Game Studio) - UMA Developer
Joen Joensen (Unity Software Developer, QA) - Software architect

3rd party scripts

Aras Pranckevicius (NeARAZ) - HUDFPS
Joen Joensen - WorkerCoroutine, UMATextureImporter, SkinnedMeshCombiner
Sven Magnus - MaxRectsBinPack

A huge thanks for the following beta testers and forum members

Breyer, Cynel, ecurtz, FlorianSchmoldt, janpec, J f Ší , SinisterMephisto, Tesla Coil,
virror, Whippets.