Workflow · Updated May 16, 2026

System Link — Sequencer Animation Authoring Workflow

System Link — Sequencer Animation Authoring Workflow

#Overview

This doc covers how to author weapon and character animations in Sequencer for SystemLink without hitting the TransformableComponentHandle ... encountered during serialization without being previously harvested crash.

The pipeline is:

  1. Open the authoring map
  1. Create the sequence asset (Content Browser, not via in-level Cinematics)
  1. Add rig actors as Spawnables
  1. Drop in the source animation
  1. Bake to Control Rig
  1. Add constraints (weapon-to-hand, IK, etc.)
  1. Layer additive refinements
  1. Bake to AnimSequence
  1. Save and close

The single non-negotiable rule:

Every binding in the sequence must be a Spawnable before you add a constraint that touches it.

#Why Spawnables

Every binding in Sequencer is one of two types:

PossessableSpawnable
Lives in levelYesNo (only while sequence is open/playing)
Self-contained in sequence assetNoYes
Constraint refs serialize cleanlyNoYes
Visible in level when sequence is closedYesNo

A Possessable binding stores a reference out of the sequence to an actor that exists in the .umap. A Spawnable stores the actor template inside the sequence asset.

When you add a constraint in Sequencer (parent, attach, transform constraint, etc.), UE creates a TransformableComponentHandle referencing the constrained component. On save, that handle must be "harvested" into the sequence's package. If the component lives in the level (.umap) instead of the sequence (.uasset), harvest fails — first as Invalid serialization log errors, then as an EXCEPTION_ILLEGAL_INSTRUCTION editor crash on the next save or load.

Spawnables avoid this entirely because the component lives in the same package as the constraint that references it.

#Standard Authoring Workflow

#1. Open the authoring map

Open /Game/Dev/AnimationEditing/AnimationEditingMap. This is the scratch map used only for animation authoring.

Do not place rig actors in this map for use in sequences. The map exists for lighting reference and the sequence editor camera — nothing in the level should be dragged into a sequence.

#2. Create the sequence asset from the Content Browser

Navigate to /Game/Dev/AnimationEditing/Sequences/<Weapon>/ (e.g. Shotgun/).

Right-click empty space → Cinematics → Level Sequence → name it following the convention:

  • LS_FP_<Weapon>_<Action> — first-person view animations
  • LS_TP_<Weapon>_<Action> — third-person view animations

Do not use the toolbar Cinematics → Add Level Sequence dropdown — that path drops a Level Sequence Actor into the level, which is unnecessary for authoring and adds clutter to the map.

#3. Add rig actors as Spawnables

Open the new sequence (double-click). You'll get an empty Sequencer panel.

From the Content Browser, drag the Skeletal Mesh asset (not a level actor) directly into the Sequencer track list:

  • SK_MasterChief (or whichever character mesh applies)
  • SK_<Weapon> (e.g. SK_Shotgun)

UE auto-creates a Spawnable binding for each one. Confirm the lightning-bolt icon next to each binding name. If you accidentally dragged an actor in from the level and got a Possessable instead, right-click the binding → Convert → Spawnable immediately.

#4. Drop in the source animation

Drag the base AnimSequence (e.g. MC_TP_Shotgun_Idle) onto the character's spawnable binding. This creates an Animation track playing that anim.

If you have multiple source anims (idle + additive blend), add them as separate tracks on the same binding.

#5. Bake to Control Rig

Right-click the character's Animation track → Bake to Control Rig → pick the appropriate Control Rig asset for the skeleton.

The Animation track is replaced with a Control Rig track containing per-control keyframes. This is fully editable.

Spawnable status of the binding does not change — Control Rig data is sequence-internal regardless of binding type.

#6. Add constraints

For weapon-to-hand parenting or other transform constraints:

  1. Select the weapon's spawnable binding
  1. Right-click → Constraints → Parent (or whichever constraint type)
  1. Pick the target socket/bone on the character

Verify both source and target bindings are Spawnables before doing this. A single Possessable in the chain re-introduces the crash.

Constraints can also be added per-keyframe via the Constraints Manager panel (Window → Virtual Production → Constraints Manager).

#7. Layer additive refinements

Right-click the Control Rig track → Add Layer to create an additive layer on top of the baked animation. Use layers for hand pose tweaks, recoil offsets, and other refinements without touching the base motion.

Multiple layers can be stacked. They evaluate top-down.

#8. Bake to AnimSequence

When the animation is final:

  1. Right-click the character's Control Rig track → Bake Animation Sequence
  1. Save to Content/SystemLink/Characters/MasterChief/Anims/Weapons/<Weapon>/ with the project naming convention (e.g. MC_TP_Shotgun_Idle)
  1. Pick the correct skeleton when prompted

This is the asset that the AnimBP / weapon system consumes. The Level Sequence itself is authoring-only — it does not ship.

#9. Save and close

Save the sequence (Ctrl+S with the Sequencer tab focused, or save from the Content Browser).

When you close the sequence, the spawnable rig actors vanish from the level. This is correct behavior — they only exist while the sequence is open. The baked AnimSequence asset is the persistent output.

#What To Avoid

These patterns reliably break the workflow:

  • Don't drag SkeletalMeshActors from the level into the sequence. That creates a Possessable, and any constraint you add later will fail to harvest on save.
  • Don't place rig actors in AnimationEditingMap for the sequence to bind to. The map should be empty of anything sequence-related.
  • Don't use the Cinematics → Add Level Sequence toolbar button. It adds a Level Sequence Actor to the level that you don't need for authoring.
  • Don't add constraints before confirming all involved bindings are Spawnables. Once a corrupt constraint reference is in the sequence, the only reliable fix is deleting the entire sequence — load fails the same way save does, so there's no editor-side recovery.
  • Don't Convert to Possessable after authoring constraints. Going the other direction (Possessable → Spawnable) is safe; this direction re-introduces the bug.

#Recovery

If a sequence starts producing TransformableComponentHandle ... encountered during serialization without being previously harvested errors in the Output Log:

  1. Stop saving. The asset may still be openable if you haven't saved since the errors started. If so, fix it (see below) and save once cleanly.
  1. If the editor crashed on save: the asset is likely unrecoverable. Loading it will crash the editor the same way saving did. Close the editor, delete the .uasset from disk, restart, rebuild.
  1. If you can still open it: convert any remaining Possessable bindings to Spawnables, then delete and re-add any constraints. Save once.

The Constraints Manager panel (Window → Virtual Production → Constraints Manager) lists every active constraint in the open sequence — useful for spotting orphan constraints whose target actor was deleted from the level.

#File Layout


Content/Dev/AnimationEditing/

├── AnimationEditingMap.umap            # authoring scratch map — keep empty of rig actors

└── Sequences/

    ├── AssaultRifle/

    │   └── LS_*.uasset                 # authoring sequences (not shipped)

    └── Shotgun/

        └── LS_*.uasset



Content/SystemLink/Characters/MasterChief/Anims/Weapons/<Weapon>/

└── MC_*_*.uasset                       # baked AnimSequences (shipped, consumed by AnimBPs)

Authoring sequences live under Content/Dev/. They are tools, not gameplay assets, and don't need to be polished or version-controlled aggressively. The baked AnimSequence under Content/SystemLink/ is the canonical output that the gameplay code references.