Smoothing transition between Animator and script controlled character

Question

I have a NPC which has a strict match logic (bot player), and I am moving it on FixedUpdate(), However, on certain events in the game I am activating animations which are controlled by the Animator - animations that are not very feasible to script.

So, when I enable the Animator, the position of my character "jumps" to the animation frame position, which causes a very jittery/unsmooth behavior. In order to move between the animations themselves, I use Animator.Crossfade which works great, but does not work on the first animation I play when I enable the Animator.

I am trying to find a way to smooth the transition, e.g. using MoveTowards() to the first frame position of the animation right before it starts playing, but I couldn't find any workaround that solves this case.

Here's an example of the character and the positions - the character has 3 Rigidbodies that I am moving independently.

Origin position when moving with FixedUpdate() (no Animator enabled):

Animation 1st frame position:

P.S: Try setting the animation first frame to the (approximately) last FixedUpdate() cycle is not really an option, since the position is subject to change, significantly.

Any ideas or ways of implementation would be highly appreciated.

Answer 1

Does something like this work? (On mobile atm, so this is a shot in the dark)

float _blendSpeed;
Vector3 _preBlendPosition;
Quaternion _preBlendOrientation;
float _blendInProgress = 1f;


void LateUpdate() {
    if (_blendInProgress >= 1f) return;

    _blendInProgress += Time.deltaTime * blendSpeed;

    float t = Mathf.SmoothStep(0f, 1f, _blendInProgress);

    transform.localPosition = Vector3.Lerp(
         _preBlendPosition, 
         transform.localPositiom, 
         t
    );

    transform.localRotation = Quaternion.Slerp(
        _preBlendOrientation, 
        transform.localRotation, 
        t
    );
}

public void StartBlend(float durationSeconds) {
    _blendSpeed = 1f/durationSeconds;
    _preBlendPosition = transform.localPosition;
    _preBlendOrientation = transform.localRotation;
    _blendInProgress = 0f;
    // Trigger your animation here.
}

The idea is to save a snapshot of your object's position/orientation just before triggering the animation.

Then, each LateUpdate, after the animation has overwritten our position and orientation with the animated values, we blend back toward our snapshot. (This doesn't affect the animated value you get next frame, since it doesn't read back "how successful" its last animated update was)

By varying the blend weight over the chosen duration, we smoothly reduce the influence of the snapshot and let the animation take over, easing at both ends to avoid a harsh snap.

(If you had a script/physics-driven velocity/angular velocity at the moment of transition, you may want to integrate your snapshot forward along that velocity each frame to give it some follow-through and blend-out, rather than a hard stop as the transition starts)

Repeat this for each bone transform that needs to be blended. For objects that have rigid body components, you may want to useMovePosition and MoveRotation instead, with world positions/orientations rather than local, to play nicer with the physics.