Physical Animation

Overview

A character that has chains attached to the arms that are driven by physics, with the rest of the body driven by blended animations and inverse kinematics.

A character that is using physics to simulate the whole body.

Pipeline

The physics for the skeleton is calculated based on whether the bone is fixed or not. Fixed bones are never simulated by physics and will be driven by the blended animation and inverse kinematic system. Unfixed bones will be simulated by physics.

Workflow

Controlling Physics

Types of Physics

1. Kinematic ("fixed")
   • Goes exactly where you say
   • Ignores collisions
   • Pushes objects it hits very hard
2. Dynamic ("unfixed")
   • Responds realistically to collisions
   • Need to use forces or constraints to control it

Physics Objects

1. Forces
   • Used to apply a constant force (such as gravity or wind)
2. Impulse
   • Used to apply a one off force (such as explosions or gun shots)
3. Constraint
   • Used to apply a continuous force (such as joints or springs)

Partial physical simulation on skeletal meshes

This also means you should create a PhysicsAsset for the skeletal mesh using the PhAT tool, including the bones that you want to be physical simulated. You can preview how these physics parts will look in PhAT by 'fixing' all but those bodies (which can be easily done by right-clicking in the tree view and choosing Unfix All Bodies Below.. or Fix All Bodies Below... You can also set the fixed status of individual rigid bodies by clicking on the bone and checking or unchecking the Fixed property.

During simulation in the tool, you can assign an AnimSet in the Preview Anim Set option, and pick an animation (such as a run cycle) from the drop down on the tool bar to loop. Press the play button to loop the animation, or the stop button to stop the animation. You can change the animation on the fly without having to stop the simulation. You can also check the Blend On Poke property, which will allow you to use the left mouse button to poke the skeletal mesh and have it blend between partial and full physical simulation.

Make sure to assign the PhysicsAsset to your character in game, and set bHasPhysicsAssetInstance to true.

Now when you run the game, and type nxvis collision in the console, you should see white shapes for the physics objects of your character. However they aren't physically simulating just yet.

What needs to be considered is how the physics for these bones will be blended into the animations of your character. Normally you use the PhysicsWeight parameter on the skeletal mesh component to choose how much to blend between the output of the physics engine and the output of the animation system. In this case, you want to have these particular bones to always use the output of the physics engine, even when PhysicsWeight is zero. To do this, there is a parameter called bAlwaysFullAnimWeight on each rigid body within the physics asset. Set this to true for all these bones. You will also need to set bEnableFullAnimWeightBodies to true on the skeletal mesh component.

When an actor's physics is PHYS_RigidBody, rigid bodies default to the fixed state that is defined in the physics asset. However, characters that are running around are normally are usually in PHYS_Walking or PHYS_Falling etc, all rigid bodies default to fixed; regardless of what is defined in the physics asset. In order to have the physics simulate on our these rigid bodies, it is required to explicitly 'unfix' them in code. There is a helpful function called SetFullAnimWeightBonesFixed within PhysicsAssetInstance. If you look at SkeletalMeshActor you can see an example of unfixing the flagged rigid bodies inside PostBeginPlay.

simulated event PostBeginPlay()
{
  // grab the current mesh for replication
  if (Role == ROLE_Authority && SkeletalMeshComponent != None)
  {
    ReplicatedMesh = SkeletalMeshComponent.SkeletalMesh;
  }

  // Unfix bodies flagged as 'full anim weight'
  if (SkeletalMeshComponent != None &&
      //SkeletalMeshComponent.bEnableFullAnimWeightBodies &&
      SkeletalMeshComponent.PhysicsAssetInstance != None)
  {
    SkeletalMeshComponent.PhysicsAssetInstance.SetFullAnimWeightBonesFixed(FALSE, SkeletalMeshComponent);
  }

  if(bHidden)
  {
    SkeletalMeshComponent.SetClothFrozen(TRUE);
  }
}

Once you have done all of these steps, you should see your parts moving physically in-game. If there are problems, it is good to use the nxvis collision option. If you are not seeing any white shapes, then there is something wrong with the physics asset, or the way it is assigned, or perhaps there is no PhysicsAssetInstance for some reason. If you see white shapes, but the rigid bodies are not being simulated, then there is something wrong with the unfixing of these rigid bodies. If you see the white rigid bodies moving correctly, but the bones are not, there is something wrong with them being blended into the final result.

Having partial physics simulation on skeletal meshes that are attached using Unreal attachment methods to other skeletal meshes can be tricky. This is mainly a problem when the base skeletal mesh component uses physics as well - for example if you wanted to attach a ponytail skeletal mesh to a character skeletal mesh, and the character then falls down using physics. This will usually result in a one-frame lag between the ponytail and the head, because Unreal code has to execute after the body has been simulated in order to update the fixed body location of the pony tail root to the attached location. One way to get around this is to instead create a physics joint between the pony tail and the head in code, rather than using Unreal attachment methods. This is a little complex though - an example can be seen in the UT hoverboard function SetHoverboardRiderPhysics, where the feet of a physics rider are jointed to the physics hoverboard. Or you can set bForceUpdateAttachmentsInTick to reupdate attachments; but this can be expensive.

A final thing you may want to adjust is collision. To have rigid bodies collide with the rest characters animated physics bodies, you will first need to set BlockRigidBody to true. Then you need to make sure that whatever RBChannel is set to is also set to true in the RBCollideWithChannels container. For a character, this is normally RBCC_Pawn. Currently it is not easy to have rigid bodies parts collide only with their owners limbs, and not with limbs of other characters. In this example, one of the chains that is attached to the characters arms is colliding with the crate below.

Full physical simulation on skeletal meshes

• bHasPhysicsAssetInstance must be true. This will ensure that the physics sub system instances the physics asset for this skeletal mesh. This is not necessary for per-bone line checks on the skeletal mesh.
• The actor that owns the skeletal mesh does not require the physics mode be set to PHYS_RigidBody. This just ensures that the actor's location and rotation matches the root body's location and rotation.
• Unfix the rigid body instances that you want to be dynamic by calling SetFixed(false) which is defined in RB_BodyInstance.
• Ensure physics is blended in for those bodies
  • Set PhysicsWeight to a value greater than zero in the skeletal mesh component.
  • Set bEnableFullAnimWeightBodies to true in the skeletal mesh component.
  • Set bAlwaysFullAnimWeight to true in RB_BodySetup.

simulated function bool Died(Controller Killer, class<DamageType> DamageType, vector HitLocation)
{
  if (Super.Died(Killer, DamageType, HitLocation))
  {
    Mesh.MinDistFactorForKinematicUpdate = 0.f;
    Mesh.SetRBChannel(RBCC_Pawn);
    Mesh.SetRBCollidesWithChannel(RBCC_Default, true);
    Mesh.SetRBCollidesWithChannel(RBCC_Pawn, false);
    Mesh.SetRBCollidesWithChannel(RBCC_Vehicle, false);
    Mesh.SetRBCollidesWithChannel(RBCC_Untitled3, false);
    Mesh.SetRBCollidesWithChannel(RBCC_BlockingVolume, true);
    Mesh.ForceSkelUpdate();
    Mesh.SetTickGroup(TG_PostAsyncWork);
    CollisionComponent = Mesh;
    CylinderComponent.SetActorCollision(false, false);
    Mesh.SetActorCollision(true, false);
    Mesh.SetTraceBlocking(true, true);
    SetPhysics(PHYS_RigidBody);
    Mesh.PhysicsWeight = 1.0;

    if (Mesh.bNotUpdatingKinematicDueToDistance)
    {
      Mesh.UpdateRBBonesFromSpaceBases(true, true);
    }

    Mesh.PhysicsAssetInstance.SetAllBodiesFixed(false);
    Mesh.bUpdateKinematicBonesFromAnimation = false;
    Mesh.SetRBLinearVelocity(Velocity, false);
    Mesh.ScriptRigidBodyCollisionThreshold = MaxFallSpeed;
    Mesh.SetNotifyRigidBodyCollision(true);
    Mesh.WakeRigidBody();

    return true;
  }

  return false;
}

You can of course reverse the process to allow a rag dolled character to get back up again.

Unreal Editor

• SkeletalMeshActor and its children are capable of using physics to simulate some bones on skeletal meshes.
• KAsset and its children may be placed in the level to do full physics simulation on skeletal meshes.

Useful console commands

• nxvis collision - shows the collision bodies used by the physics simulation. Use this over show collision, as show collision only shows the collision hulls used for the Unreal physics sub system.

• show bones - shows the bone's location and rotation used to render the animated skeletal mesh.

• show prephysbones - shows the bone's location and rotation after blended animation and inverse kinematics is applied but before physics is applied. Notice how the bones of the chains is pointing straight out, this is because there is no predefined animations made for them. But after physics is applied, the chains are in the correct position.

Examples

Unrealscript

class HitReactionPawn extends SkeletalMeshCinematicActor;

// Death animation
var(HitReaction) Name DeathAnimName;
// Bone names to unfix when hit reaction is simulated
var(HitReaction) array<Name> UnfixedBodyNames;
// Bone names to enable springs when hit reaction is simulated
var(HitReaction) array<Name> EnabledSpringBodyNames;
// Linear bone spring strength to use when hit reaction is simulated
var(HitReaction) float LinearBoneSpringStrength;
// Angular bone spring strength to use when hit reaction is simulated
var(HitReaction) float AngularBoneSpringStrength;
// Radius of the force to apply
var(HitReaction) float ForceRadius;
// Force amplification
var(HitReaction) float ForceAmplification;
// Maximum amount of force that can be applied
var(HitReaction) float MaximumForceThatCanBeApplied;
// Blend in time for the hit reaction
var(HitReaction) float PhysicsBlendInTime;
// Physics simulation time for the hit reaction
var(HitReaction) float PhysicsTime;
// Blend out time for the hit reaction
var(HitReaction) float PhysicsBlendOutTime;
// Full body rag doll
var(HitReaction) bool FullBodyRagdoll;

var Name PreviousAnimName;

event TakeDamage(int DamageAmount, Controller EventInstigator, vector HitLocation, vector Momentum, class<DamageType> DamageType, optional TraceHitInfo HitInfo, optional Actor DamageCauser)
{
  local AnimNodeSequence AnimNodeSequence;

  Super.TakeDamage(DamageAmount, EventInstigator, HitLocation, Momentum, DamageType, HitInfo, DamageCauser);

  if (SkeletalMeshComponent == None || SkeletalMeshComponent.PhysicsAssetInstance == None)
  {
    return;
  }

  if (IsTimerActive(NameOf(SimulatingPhysicsBlendIn)) || IsTimerActive(NameOf(SimulatingPhysics)) || IsTimerActive(NameOf(SimulatedPhysicsBlendOut)))
  {
    return;
  }

  if (FullBodyRagdoll)
  {
    if (DeathAnimName != '')
    {
      AnimNodeSequence = AnimNodeSequence(SkeletalMeshComponent.Animations);

      if (AnimNodeSequence != None)
      {
        PreviousAnimName = AnimNodeSequence.AnimSeqName;
        AnimNodeSequence.SetAnim(DeathAnimName);
        AnimNodeSequence.PlayAnim();
        AnimNodeSequence.bCauseActorAnimEnd = true;
        return;
      }
    }
    else
    {
      TurnOnRagdoll(Normal(Momentum) * FMin(DamageAmount * ForceAmplification, MaximumForceThatCanBeApplied));
    }
  }
  else
  {
    if (DeathAnimName != '')
    {
      AnimNodeSequence = AnimNodeSequence(SkeletalMeshComponent.Animations);

      if (AnimNodeSequence != None)
      {
        PreviousAnimName = AnimNodeSequence.AnimSeqName;
        AnimNodeSequence.SetAnim(DeathAnimName);
        AnimNodeSequence.PlayAnim();
        AnimNodeSequence.bCauseActorAnimEnd = true;
        return;
      }
    }
    else
    {
      TurnOnRagdoll(Vect(0.f, 0.f, 0.f));
      // Apply the impulse
      SkeletalMeshComponent.AddRadialImpulse(HitLocation - (Normal(Momentum) * 16.f), ForceRadius, FMin(DamageAmount * ForceAmplification, MaximumForceThatCanBeApplied), RIF_Linear, true);
      // Wake up the rigid body
      SkeletalMeshComponent.WakeRigidBody();
    }
  }

  BlendInPhysics();
}

event OnAnimEnd(AnimNodeSequence AnimNodeSequence, float PlayedTime, float ExcessTime)
{
  TurnOnRagdoll(Vect(0.f, 0.f, 0.f));
  BlendInPhysics();
  AnimNodeSequence.bCauseActorAnimEnd = false;
}

function TurnOnRagdoll(Vector RBLinearVelocity)
{
  // Force update the skeleton
  SkeletalMeshComponent.ForceSkelUpdate();

  // Fix the bodies that don't need to play a part in the physical hit reaction
  if (UnfixedBodyNames.Length > 0)
  {
    SkeletalMeshComponent.PhysicsAssetInstance.SetNamedBodiesFixed(false, UnfixedBodyNames, SkeletalMeshComponent,, true);
  }
  else
  {
    SkeletalMeshComponent.PhysicsAssetInstance.SetAllBodiesFixed(false);
  }

  // Enable springs on bodies that are required in the physical hit reaction
  if (EnabledSpringBodyNames.Length > 0)
  {
    SkeletalMeshComponent.PhysicsAssetInstance.SetNamedRBBoneSprings(true, EnabledSpringBodyNames, LinearBoneSpringStrength, AngularBoneSpringStrength, SkeletalMeshComponent);
  }

  SkeletalMeshComponent.bUpdateKinematicBonesFromAnimation = false;
  SkeletalMeshComponent.SetRBLinearVelocity(RBLinearVelocity, true);
  SkeletalMeshComponent.WakeRigidBody();
}

function BlendInPhysics()
{
  // Set the timer for the physics to blend in
  if (PhysicsBlendInTime > 0.f)
  {
    SetTimer(PhysicsBlendInTime, false, NameOf(SimulatingPhysicsBlendIn));
  }
  else
  {
    SkeletalMeshComponent.PhysicsWeight = 1.f;
    SimulatingPhysicsBlendIn();
  }
}


function SimulatingPhysicsBlendIn()
{
  if (PhysicsTime == 0.f)
  {
    SimulatingPhysics();
  }
  else
  {
    // Set the timer for the physics to stay
    SetTimer(PhysicsTime, false, NameOf(SimulatingPhysics));
  }
}

function SimulatingPhysics()
{
  local AnimNodeSequence AnimNodeSequence;

  // Set the timer for the physics to blend out
  SetTimer(PhysicsBlendOutTime, false, NameOf(SimulatedPhysicsBlendOut));

  if (PreviousAnimName != '')
  {
    AnimNodeSequence = AnimNodeSequence(SkeletalMeshComponent.Animations);

    if (AnimNodeSequence != None)
    {
      AnimNodeSequence.SetAnim(PreviousAnimName);
      AnimNodeSequence.PlayAnim(true);
    }
  }
}

function SimulatedPhysicsBlendOut()
{
  // Set physics weight to zero
  SkeletalMeshComponent.PhysicsWeight = 0.f;
  SkeletalMeshComponent.ForceSkelUpdate();

  if (FullBodyRagdoll)
  {
    SkeletalMeshComponent.PhysicsAssetInstance.SetAllBodiesFixed(true);
    SkeletalMeshComponent.bUpdateKinematicBonesFromAnimation = true;
  }
  else
  {
    SkeletalMeshComponent.bUpdateKinematicBonesFromAnimation = true;

    if (UnfixedBodyNames.Length > 0)
    {
      SkeletalMeshComponent.PhysicsAssetInstance.SetNamedBodiesFixed(true, UnfixedBodyNames, SkeletalMeshComponent,, true);
    }
    else
    {
      SkeletalMeshComponent.PhysicsAssetInstance.SetAllBodiesFixed(true);
    }

    // Disable springs on bodies that were required in the physical hit reaction
    if (EnabledSpringBodyNames.Length > 0)
    {
      SkeletalMeshComponent.PhysicsAssetInstance.SetNamedRBBoneSprings(false, EnabledSpringBodyNames, 0.f, 0.f, SkeletalMeshComponent);
    }
  }

  // Put the rigid body to sleep
  SkeletalMeshComponent.PutRigidBodyToSleep();
}

function Tick(float DeltaTime)
{
  Super.Tick(DeltaTime);

  if (IsTimerActive(NameOf(SimulatingPhysicsBlendIn)))
  {
    // Blending in physics
    SkeletalMeshComponent.PhysicsWeight = GetTimerCount(NameOf(SimulatingPhysicsBlendIn)) / GetTimerRate(NameOf(SimulatingPhysicsBlendIn));
  }
  else if (IsTimerActive(NameOf(SimulatedPhysicsBlendOut)))
  {
    // Blending out physics
    SkeletalMeshComponent.PhysicsWeight = 1.f - (GetTimerCount(NameOf(SimulatedPhysicsBlendOut)) / GetTimerRate(NameOf(SimulatedPhysicsBlendOut)));
  }
}

defaultproperties
{
  Begin Object Name=SkeletalMeshComponent0
    bHasPhysicsAssetInstance=true
    bUpdateJointsFromAnimation=true
  End Object

  ForceRadius=64.f
}

Physically simulated hit reactions

Arcade simulation

This simulation will only apply physical changes to the upper part of the body, enable stiff angular springs in the hands and head to keep the gun and head pointing in the right direction.

The properties of HitReactionPawn to achieve this are:

Unrealscript logic flow:

• TakeDamage is called when the player shoots the HitReactionPawn
• Check if there is a valid skeletal mesh component, physical asset instance and if the script is not currently in the middle of simulating physics
• FullBodyRagdoll is false and DeathAnimName is empty, thus turn on physics, apply a radial impulse to simulate the weapon hit and wake up the rigid body
  • Unfix bodies defined in UnfixedBodyNames. If that is empty, it will unfix all bodies.
  • Enable bone springs is defined in EnabledSpringBodyNames, and set the strengths of them using LinearBoneSpringStrength and AngularBoneSpringStrength.
  • Bones no longer need to be updated via the animation, bUpdateKinematicBonesFromAnimation is set false.
• Blend In timer is set.
• When blend in timer is called, it will call the physics stay timer.
• When physics stay timer is called, it will call the blend out timer.
• After blending out, the process above is reversed.
• If the blend in timer is running, or the blend out timer is running, tick blends between animation and physics by adjusting the PhysicsWeight by finding the percentage of time passed with the timers.

The neck and right clavicle bones are less likely to be affected by the player's shots, but the rest of the upper body reacts according.

Realistic simulation

The properties of HitReactionPawn to achieve this are:

The unrealscript logic flow is the same above however, bone springs and their strengths have been set. This helps keep those bones as close as possible to the animation without it being too stiff.

The whole body is affected by the player's shot. Additional logic could be added to cause the affected pawn to trip and fall if desired (Blend into another animation, blend out physics, after some times blend in physics again to simulate the fall).

Death animations that blend into a rag doll

The properties of HitReactionPawn to achieve this are:

Unrealscript logic flow:

• TakeDamage is called when the player shoots the HitReactionPawn
• Check if there is a valid skeletal mesh component, physical asset instance and if the script is not currently in the middle of simulating physics
• FullBodyRagdoll is false and DeathAnimName is not empty.
• Play the death animation and ensure that the anim node sequence that is playing it will call OnAnimEnd when the animation finishes.
• When OnAnimEnd is called, enable physics. For best results, do not set a blend in time otherwise the death sequence can be odd!
  • Unfix bodies defined in UnfixedBodyNames. If that is empty, it will unfix all bodies.
  • Enable bone springs is defined in EnabledSpringBodyNames, and set the strengths of them using LinearBoneSpringStrength and AngularBoneSpringStrength.
  • Bones no longer need to be updated via the animation, bUpdateKinematicBonesFromAnimation is set false.
• Blend In timer is set.
• When blend in timer is called, it will call the physics stay timer.
• When physics stay timer is called, it will call the blend out timer.
• After blending out, the process above is reversed.
• If the blend in timer is running, or the blend out timer is running, tick blends between animation and physics by adjusting the PhysicsWeight by finding the percentage of time passed with the timers.

This allows animators to create animated sequences which handle the initial fall, so that it feels like the body is reacting to the fall as well. In this case, there is a special animation played back when the body is continuously hit by the Stinger weapon in Unreal Tournament 3. Rag doll simulation begins at the end of the animation.

Downloads

• Download the content used in this document. Please compile the UDN package before loading PhysicalAnimationBMap.udk.