A Mesh Config Override is a project-level configuration provided by the Futureverse Execution Controller that enables a game or experience to substitute its own fully-authorized rig—complete with
project-specific gameplay configurations—in place of the default skeleton embedded within a UBF spawned model.
This rig is typically a pre-defined skeleton tailored to the project’s domain requirements. For example:
One game may include socket attachments on bones with specific transforms to correctly align weapons like swords or shields.
Another game might configure different physics materials or collision properties on certain bones for ragdoll effects or hit reactions.
Still others may add runtime components, such as floppy-ear simulation scripts, spring bones, or IK targets, already wired into their rigs.
These configurations are unique to each project and are injected through Mesh Config Overrides, ensuring that runtime UBF assets are seamlessly adapted to the environment they’re deployed in.
This capability is critical because UBF assets are intentionally built to be engine-agnostic and cross-compatible. As such, they cannot include game-specific rigging conventions, socket placements,
physics systems, or animation retargeting setups. Mesh Config Overrides serve as a clean injection point where projects can introduce that specialized configuration without modifying the core UBF blueprints themselves.
Mesh Configs are collection-scoped, meaning they are registered and applied based on the NFT’s collection ID. This allows a project to define completely different rigs and behaviors for distinct avatar lines.
At runtime, the process of applying a Mesh Config Override begins when a UBF blueprint executes a Create Mesh Config node. This node exposes an optional field called the Config Override Key.
If a key is provided, it tells the Execution Controller to check its internal registry for a Mesh Config entry that matches the given key.
If a match is found, the Execution Controller overrides the default behavior by discarding the auto-generated skeleton that would normally be attached to the mesh.
Instead, it rebinds the mesh to the pre-defined rig and avatar specified in the Mesh Config.
This pre-defined skeleton includes all gameplay-specific configuration, such as sockets, bone transforms, physics profiles, and attached components.
Additionally, this override ensures that the mesh is fully prepared to integrate with the project’s animation system and runtime logic—no additional manual configuration is needed.
Futureverse Execution Controllers follow a consistent logic for applying Mesh Config Overrides across both Unity and Unreal Engine. While the underlying principles remain the same—resolving a registered config
and applying a custom rig—the implementation details differ slightly per engine.
The following sections outline the setup process for each engine.
In Unity, Mesh Config Overrides are implemented using a custom ScriptableObject called a Mesh Config. This object links a runtime rig prefab and its associated Avatar to a specific mesh or character
definition used in your UBF graphs. The process begins by preparing the required rig asset, then creating and registering the config so it can be resolved at runtime.
Step 1: Import Your Rig
Begin by importing your FBX file containing the rig or skeleton you wish to use as the base for runtime retargeting. Ensure that this rig represents the structure you expect your character or asset to
follow at runtime. For example, if you are supporting the Party Bear collection, import the Party Bear rig as your base.
Set the Rig Import Settings of the FBX to Humanoid. This ensures Unity generates a compatible Avatar asset, which is critical for retargeting animations through Unity’s Animator system.
Make sure the Avatar maps correctly to the expected humanoid bone structure.
Step 2: Create a Mesh Config Asset
Once your rig and Avatar are ready, right-click in the Project window and choose:
Create → UBF → Mesh Config
This will generate a new Mesh Config ScriptableObject with two main fields:
Rig Prefab: This is a prefab version of your imported rig, prepared for runtime use (e.g., Partybear_RuntimeRig).
Avatar: This should reference the Avatar created during FBX import, configured to match the rig’s bone hierarchy.
This Mesh Config asset defines what runtime rig and animation avatar will be applied when the override is triggered.
Step 3: Register the Mesh Config
To make the Mesh Config discoverable at runtime:
Open Project Settings → UBF → Mesh Configs
In the Mesh Configs array, add a new entry.
Assign your Mesh Config asset and provide a unique key.
NOTE: The defined key must exactly match the value used in the Config Override Key input of the CreateMeshConfig node within your UBF blueprint.
At runtime, when a CreateMeshConfig node is reached in the executed UBF graph, the registered Mesh Config entries will be searched for a matching key. If a corresponding Mesh Config is found, its associated Rig Prefab is instantiated in the scene under the UBFRuntimeController.
This rig then serves as the base onto which the UBF asset will be applied. Typically, the output of the CreateMeshConfig node is passed into subsequent SpawnMesh nodes. If so, any SkinnedMeshRenderers generated by UBF are correctly retargeted to the specified rig’s bone structure and transform hierarchy.
NOTE: If your prefab doesn’t include visible mesh components, adding a MeshRenderer can help with debugging or animation previews.
Now that the rig is being spawned at runtime, it can be animated using Unity’s Animator system. The object instantiated by the CreateMeshConfig node is placed under the same root hierarchy as the graph’s execution context—typically a child of the UBFRuntimeController. If you parent the UBFRuntimeController under a GameObject with an Animator component, Unity will treat the spawned rig as part of the animation hierarchy.
The CreateMeshConfig node also performs a runtime scan for an Animator component in the parent hierarchy of the spawned rig. If it finds one, it automatically injects the Avatar from the Mesh Config into the Animator’s Avatar field. This setup enables the Animator to recognize the custom rig and play animations immediately.
In Unreal Engine, Mesh Config Overrides are implemented using a project-level configuration system exposed through the UBF Execution Controller plugin.
This system allows you to define a custom skeleton setup—typically including a rig, optional physics assets, and animation blueprints—and associate it with a specific mesh or character definition used in your UBF graphs.
The process begins by preparing your skeleton assets and assigning them to the appropriate mesh keys so they can be resolved at runtime.
To configure Mesh Config Overrides in Unreal Engine, begin by importing the skeletal assets you intend to use. These may include a custom skeleton (USkeleton), optional PhysicsAsset, and an Animation Blueprint that governs how your rig behaves at runtime.
Once your assets are prepared, navigate to Project Settings → Game → UBF MeshConfig Settings. This section allows you to register all project-level Mesh Config entries via the MeshConfigMap array.
Each Mesh Config entry is registered using a mesh resource ID — a unique string which should match the value used in your UBF graph’s CreateMeshConfig node.
For each entry, populate the FMeshConfigData struct with the following fields:
Skeleton: The Unreal Engine USkeleton asset to be used for the mesh, replacing any default or auto-generated skeleton.
Physics Asset(optional): Physics data to support ragdoll behavior or physical simulations.
Animation Blueprint(optional): The UAnimBlueprint class used to control the rig’s runtime animation behavior.
At runtime, when the CreateMeshConfig node is triggered within a UBF graph, the Execution Controller uses the provided key to search the MeshConfigMap.
If a match is found, the engine will override the default skeleton and bind the mesh to the custom rig defined in the config.
Child blueprints (e.g., accessories or nested attachments) can also inherit the parent’s mesh config - ensuring consistency across composite assets like avatars with equipment or layered body parts.
These configs are particularly powerful for avatars with shared skeletons across multiple body parts. For example, upper and lower body meshes for a Party Bear can all target the
same runtime skeleton and share animation logic seamlessly.
Once the rig is spawned, you can take control over animation by assigning a custom Animation Blueprint to the skeletal mesh component.
This is typically handled using the OnComplete output of a RenderItem node or graph callback. Once rendering is complete, your game logic can
locate the mesh component and inject animation classes, control parameters, or attach gameplay logic.
