adminandClaude Opus 4.8
def10541ab
Replace the hard pose snap with a 2-input AnimationMixerPlayable crossfade: the running pose moves to input 0 (keeping its play time), the new pose to input 1, weight ramps over poseBlendDuration (smoothstep). Per-frame rest reset stays, so empty/partial clips still resolve to rest during and after the blend. Ceiling Y-offset now eases via MoveTowards (ceilingOffsetSpeed) on enter/exit/pose-change instead of snapping. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
349 lines
14 KiB
C#
349 lines
14 KiB
C#
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.Animations;
|
|
using UnityEngine.Playables;
|
|
#if ENABLE_INPUT_SYSTEM
|
|
using UnityEngine.InputSystem;
|
|
#endif
|
|
|
|
/// <summary>
|
|
/// Sits next to the <see cref="PlayerCharacterController"/> and holds a list of <see cref="PlayerPose"/>s
|
|
/// plus the active index. The active pose is held continuously — while idle, walking, and sprinting
|
|
/// alike — so cycling to the next pose, or the sprint reset to the default pose, shows up
|
|
/// immediately instead of only once the player comes to a stop. One key cycles to the next pose
|
|
/// (wrapping), and sprinting in any state (ground, air, wall, ceiling) snaps the selection back to the default pose.
|
|
///
|
|
/// The pose clip is played through a tiny <see cref="PlayableGraph"/> (a two-input
|
|
/// <see cref="AnimationMixerPlayable"/> on an <see cref="AnimationPlayableOutput"/>) that overrides
|
|
/// the Animator Controller's run/idle animation for as long as a pose is selected (it only hands the
|
|
/// rig back when the list is empty / the clip is null). Switching pose crossfades the outgoing and
|
|
/// incoming clips over <see cref="poseBlendDuration"/> instead of snapping. The per-pose ceiling
|
|
/// y-offset is eased toward its target and routed through the controller (the single writer of the
|
|
/// model-offset transform) so it composes with the wall-lean instead of fighting it.
|
|
/// </summary>
|
|
[RequireComponent(typeof(PlayerCharacterController))]
|
|
[DisallowMultipleComponent]
|
|
// Run after PlayerCharacterController (default order 0) so the ceiling / sprint state polled below is
|
|
// this frame's, and the ceiling offset resolves without a one-frame seam.
|
|
[DefaultExecutionOrder(100)]
|
|
public partial class PlayerPoseController : MonoBehaviour
|
|
{
|
|
[Header("Poses")]
|
|
[Tooltip("Selectable poses. Index 0 is the default pose that sprinting resets to.")]
|
|
[SerializeField] private List<PlayerPose> poses = new();
|
|
|
|
[Tooltip("Index the selection resets to while sprinting in any state (the default/standard pose).")]
|
|
[Min(0)]
|
|
[SerializeField] private int defaultPoseIndex = 0;
|
|
|
|
[Header("Input")]
|
|
#if ENABLE_INPUT_SYSTEM
|
|
[Tooltip("Key that cycles to the next pose (wraps at the end of the list).")]
|
|
[SerializeField] private Key cycleKey = Key.C;
|
|
#else
|
|
[Tooltip("Key that cycles to the next pose (wraps at the end of the list).")]
|
|
[SerializeField] private KeyCode cycleKey = KeyCode.C;
|
|
#endif
|
|
|
|
[Header("Transitions")]
|
|
[Tooltip("Seconds to crossfade from the previous pose to a newly selected one. 0 = instant snap.")]
|
|
[Min(0f)]
|
|
[SerializeField] private float poseBlendDuration = 0.2f;
|
|
|
|
[Tooltip("Approach speed (local units/sec) for easing the ceiling y-offset toward its target. 0 = instant.")]
|
|
[Min(0f)]
|
|
[SerializeField] private float ceilingOffsetSpeed = 4f;
|
|
|
|
private PlayerCharacterController _player;
|
|
private Animator _animator;
|
|
private string _graphName; // cached so building the graph allocates no string from the Update path
|
|
|
|
private int _currentIndex;
|
|
|
|
// Playables: a 2-input AnimationMixerPlayable that overrides the Animator Controller. Input 1 holds
|
|
// the current ("to") pose; input 0 holds the outgoing ("from") pose during a crossfade and is empty
|
|
// once the blend completes. Blending both inputs over a per-frame rest baseline (see below) makes
|
|
// poses interpolate instead of snapping; an empty/partial "to" clip still resolves to rest.
|
|
private PlayableGraph _graph;
|
|
private AnimationPlayableOutput _output;
|
|
private AnimationMixerPlayable _mixer;
|
|
private AnimationClipPlayable _fromPlayable;
|
|
private AnimationClipPlayable _toPlayable;
|
|
private AnimationClip _toClip; // the clip currently targeted (held on input 1)
|
|
private bool _posePlaying;
|
|
private float _blend; // 0..1 weight of the "to" input; 1 = fully on the target pose
|
|
private bool _blending;
|
|
|
|
private float _ceilingOffset; // eased local-up offset currently fed to the controller
|
|
|
|
// Rest pose snapshot of the whole Animator subtree, taken in Awake before the Animator first
|
|
// evaluates. An AnimationClipPlayable only writes the bones its curves cover, so a clip that
|
|
// doesn't key a bone (an empty clip like the T-pose, or a partial one) would otherwise leave that
|
|
// bone frozen on the previous animation. Restoring this before each pose start makes every pose
|
|
// define the full body. meshOffsetTarget is an ancestor of the Animator, so it is never in this
|
|
// set and the controller's lean/ceiling offset stays untouched.
|
|
private Transform[] _restBones;
|
|
private Vector3[] _restPos;
|
|
private Quaternion[] _restRot;
|
|
private Vector3[] _restScale;
|
|
|
|
/// <summary>Index of the currently selected pose.</summary>
|
|
public int CurrentIndex => _currentIndex;
|
|
|
|
void Awake()
|
|
{
|
|
_player = GetComponent<PlayerCharacterController>();
|
|
_animator = _player ? _player.animator : null;
|
|
_graphName = $"{name}-Pose";
|
|
if (_animator)
|
|
CaptureRestPose();
|
|
else
|
|
Debug.LogWarning("[PlayerPoseController] No Animator on the PlayerCharacterController; poses cannot play.", this);
|
|
}
|
|
|
|
void Update()
|
|
{
|
|
if (CycleKeyPressed())
|
|
NextPose();
|
|
|
|
// Sprinting in any state (ground, air, wall, ceiling) snaps the selection back to the default
|
|
// pose. Held continuously below, so the reset shows up immediately, not only once back on the floor.
|
|
if (_player.IsSprinting)
|
|
_currentIndex = WrapIndex(defaultPoseIndex);
|
|
|
|
PlayerPose pose = ActivePose();
|
|
|
|
// Hold the pose continuously — idle, walking, and sprinting alike — so a selection change
|
|
// (cycling, or the sprint reset to the default pose above) shows immediately instead of only
|
|
// once the player stops. PlayPose hands the rig back to the controller only when there is no
|
|
// clip to play (empty list / null clip).
|
|
PlayPose(pose ? pose.Clip : null);
|
|
|
|
// Tell the controller the pose graph owns the Animator output so it stops poking the run-bool
|
|
// (moot while overridden, and it would warn every frame). Read next frame, when this matches
|
|
// the bound-graph state (both only change here).
|
|
_player.AnimatorOverridden = _posePlaying;
|
|
|
|
// Ceiling y-offset: only while stuck to the ceiling. Ease toward the target instead of
|
|
// snapping, so entering and leaving the ceiling (and switching ceiling poses) glides. Routed
|
|
// through the controller so it shares the wall-lean's single write of the model transform.
|
|
float ceilingTarget = (pose && _player.IsOnCeiling) ? pose.CeilingYOffset : 0f;
|
|
_ceilingOffset = ceilingOffsetSpeed > 0f
|
|
? Mathf.MoveTowards(_ceilingOffset, ceilingTarget, ceilingOffsetSpeed * Time.deltaTime)
|
|
: ceilingTarget;
|
|
_player.SetPoseLocalYOffset(_ceilingOffset);
|
|
}
|
|
|
|
void OnDisable()
|
|
{
|
|
// Hand the rig back to the Animator Controller and never leak a graph; rebuilt lazily on the
|
|
// next idle frame. Also clear any ceiling offset we were holding.
|
|
ReleasePose();
|
|
_ceilingOffset = 0f;
|
|
if (_player)
|
|
{
|
|
_player.SetPoseLocalYOffset(0f);
|
|
_player.AnimatorOverridden = false;
|
|
}
|
|
}
|
|
|
|
/// <summary>Advances to the next pose, wrapping at the end of the list.</summary>
|
|
public void NextPose() => SetPoseIndex(_currentIndex + 1);
|
|
|
|
/// <summary>Steps back to the previous pose, wrapping at the start of the list.</summary>
|
|
public void PreviousPose() => SetPoseIndex(_currentIndex - 1);
|
|
|
|
/// <summary>Selects a pose by index, wrapping into range so cycling never goes out of bounds.</summary>
|
|
public void SetPoseIndex(int index) => _currentIndex = WrapIndex(index);
|
|
|
|
private int WrapIndex(int index)
|
|
{
|
|
int count = poses.Count;
|
|
if (count == 0) return 0;
|
|
return ((index % count) + count) % count;
|
|
}
|
|
|
|
private PlayerPose ActivePose()
|
|
{
|
|
if (poses.Count == 0) return null;
|
|
return poses[Mathf.Clamp(_currentIndex, 0, poses.Count - 1)];
|
|
}
|
|
|
|
private bool CycleKeyPressed()
|
|
{
|
|
#if ENABLE_INPUT_SYSTEM
|
|
var keyboard = Keyboard.current;
|
|
return keyboard != null && keyboard[cycleKey].wasPressedThisFrame;
|
|
#else
|
|
return Input.GetKeyDown(cycleKey);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// Plays and holds the given clip, overriding the Animator Controller. Switching to a different
|
|
/// clip crossfades from the current pose over <see cref="poseBlendDuration"/> (the first pose, or a
|
|
/// zero duration, appears instantly). Called every frame: it starts a transition on a clip change,
|
|
/// advances any in-flight blend, and re-snaps un-keyed bones to rest before the graph evaluates. A
|
|
/// null clip (or no animator) releases back to the controller.
|
|
/// </summary>
|
|
private void PlayPose(AnimationClip clip)
|
|
{
|
|
if (!clip || !_animator)
|
|
{
|
|
ReleasePose();
|
|
return;
|
|
}
|
|
|
|
EnsureGraph();
|
|
|
|
if (!(_posePlaying && _toClip == clip))
|
|
BeginTransition(clip);
|
|
|
|
AdvanceBlend(Time.deltaTime);
|
|
|
|
// Snap un-keyed bones to rest every frame, so each mixer input blends relative to rest: a
|
|
// partial or empty clip (e.g. the T-pose) defines the whole body, and a crossfade interpolates
|
|
// both poses against the same baseline. The graph overrides the keyed bones, weighted, when it
|
|
// evaluates later this frame.
|
|
ResetToRestPose();
|
|
|
|
if (!_graph.IsPlaying())
|
|
_graph.Play();
|
|
|
|
_posePlaying = true;
|
|
}
|
|
|
|
/// <summary>Builds the graph (a 2-input mixer feeding the Animator output) lazily if it isn't alive yet.</summary>
|
|
private void EnsureGraph()
|
|
{
|
|
if (_graph.IsValid())
|
|
return;
|
|
_graph = PlayableGraph.Create(_graphName);
|
|
_graph.SetTimeUpdateMode(DirectorUpdateMode.GameTime);
|
|
_mixer = AnimationMixerPlayable.Create(_graph, 2);
|
|
_output = AnimationPlayableOutput.Create(_graph, "Pose", _animator);
|
|
_output.SetSourcePlayable(_mixer);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Starts a crossfade to <paramref name="clip"/>: the in-flight target becomes the outgoing pose on
|
|
/// input 0 (carrying its playback time), the new clip goes on input 1, and the blend ramps up from
|
|
/// 0. The first pose (or a zero duration) snaps in at full weight with no fade-from-nothing.
|
|
/// </summary>
|
|
private void BeginTransition(AnimationClip clip)
|
|
{
|
|
bool hadPose = _posePlaying && _toPlayable.IsValid();
|
|
|
|
// Drop the previous outgoing pose (already faded out, or none) before reusing input 0.
|
|
if (_fromPlayable.IsValid())
|
|
{
|
|
_mixer.DisconnectInput(0);
|
|
_graph.DestroyPlayable(_fromPlayable);
|
|
_fromPlayable = default;
|
|
}
|
|
|
|
if (hadPose)
|
|
{
|
|
// Move the current target from input 1 to input 0 so it becomes the outgoing pose without a
|
|
// recreate (its animation time carries over, no jump).
|
|
_mixer.DisconnectInput(1);
|
|
_fromPlayable = _toPlayable;
|
|
_mixer.ConnectInput(0, _fromPlayable, 0);
|
|
}
|
|
|
|
_toPlayable = AnimationClipPlayable.Create(_graph, clip);
|
|
_mixer.ConnectInput(1, _toPlayable, 0);
|
|
_toClip = clip;
|
|
|
|
_blend = (hadPose && poseBlendDuration > 0f) ? 0f : 1f;
|
|
_blending = _blend < 1f;
|
|
ApplyBlendWeights();
|
|
}
|
|
|
|
/// <summary>Advances an in-flight crossfade and drops the outgoing pose once it has fully faded.</summary>
|
|
private void AdvanceBlend(float dt)
|
|
{
|
|
if (!_blending)
|
|
return;
|
|
_blend = poseBlendDuration > 0f ? Mathf.MoveTowards(_blend, 1f, dt / poseBlendDuration) : 1f;
|
|
if (_blend >= 1f)
|
|
{
|
|
_blend = 1f;
|
|
_blending = false;
|
|
if (_fromPlayable.IsValid())
|
|
{
|
|
_mixer.DisconnectInput(0);
|
|
_graph.DestroyPlayable(_fromPlayable);
|
|
_fromPlayable = default;
|
|
}
|
|
}
|
|
ApplyBlendWeights();
|
|
}
|
|
|
|
/// <summary>Pushes the current blend onto the mixer inputs (smoothstepped while a "from" pose exists).</summary>
|
|
private void ApplyBlendWeights()
|
|
{
|
|
if (!_mixer.IsValid())
|
|
return;
|
|
bool hasFrom = _fromPlayable.IsValid();
|
|
float w = hasFrom ? Mathf.SmoothStep(0f, 1f, _blend) : 1f;
|
|
_mixer.SetInputWeight(0, hasFrom ? 1f - w : 0f);
|
|
_mixer.SetInputWeight(1, _toPlayable.IsValid() ? w : 0f);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Snapshots every transform a pose clip can address (the Animator's whole subtree) in its
|
|
/// authored rest pose. Taken in Awake before the Animator first evaluates, so it captures the rig
|
|
/// at rest (the paintman rig's rest pose is its T-pose).
|
|
/// </summary>
|
|
private void CaptureRestPose()
|
|
{
|
|
_restBones = _animator.transform.GetComponentsInChildren<Transform>(true);
|
|
int n = _restBones.Length;
|
|
_restPos = new Vector3[n];
|
|
_restRot = new Quaternion[n];
|
|
_restScale = new Vector3[n];
|
|
for (int i = 0; i < n; i++)
|
|
{
|
|
Transform t = _restBones[i];
|
|
_restPos[i] = t.localPosition;
|
|
_restRot[i] = t.localRotation;
|
|
_restScale[i] = t.localScale;
|
|
}
|
|
}
|
|
|
|
/// <summary>Restores the captured rest pose so an empty or partial pose clip fully defines the body.</summary>
|
|
private void ResetToRestPose()
|
|
{
|
|
if (_restBones == null)
|
|
return;
|
|
for (int i = 0; i < _restBones.Length; i++)
|
|
{
|
|
Transform t = _restBones[i];
|
|
if (!t)
|
|
continue;
|
|
t.localPosition = _restPos[i];
|
|
t.localRotation = _restRot[i];
|
|
t.localScale = _restScale[i];
|
|
}
|
|
}
|
|
|
|
/// <summary>Destroys the graph so the Animator Controller (run/idle) drives the rig again.</summary>
|
|
private void ReleasePose()
|
|
{
|
|
if (!_posePlaying)
|
|
return;
|
|
if (_graph.IsValid())
|
|
_graph.Destroy();
|
|
_graph = default;
|
|
_output = default;
|
|
_mixer = default;
|
|
_fromPlayable = default;
|
|
_toPlayable = default;
|
|
_toClip = null;
|
|
_blend = 0f;
|
|
_blending = false;
|
|
_posePlaying = false;
|
|
}
|
|
}
|