private static void BakeToSkeleton(RigBuilder rigBuilder, IRigConstraint constraint, AnimationClip clip, AnimationClip defaultPoseClip, IEnumerable <EditorCurveBinding> bindings, CurveFilterOptions filterOptions)
{
// Make sure the base constraint is valid
if (constraint == null || !constraint.IsValid())
{
throw new InvalidOperationException(
string.Format("The rig constraint {0} is not a valid constraint.",
constraint != null ? constraint.ToString() : ""));
}
var overrides = new Dictionary <IRigConstraint, IRigConstraint>();
using (var graph = new EvaluationGraph(rigBuilder, clip, defaultPoseClip, overrides, constraint))
{
BakeCurvesToClip(clip, bindings, rigBuilder, graph, filterOptions);
}
}
internal static IBakeParameters FindBakeParameters(IRigConstraint constraint)
{
var constraintType = constraint.GetType();
var bakeParametersTypes = TypeCache.GetTypesWithAttribute <BakeParametersAttribute>();
foreach (var bakeParametersType in bakeParametersTypes)
{
if (!typeof(IBakeParameters).IsAssignableFrom(bakeParametersType))
{
continue;
}
var attribute = bakeParametersType.GetCustomAttribute <BakeParametersAttribute>();
if (attribute.constraintType == constraintType)
{
return((IBakeParameters)Activator.CreateInstance(bakeParametersType));
}
}
return(null);
}
private static IRigConstraint FindInverseRigConstraint(IRigConstraint constraint)
{
if (constraint == null)
{
return(null);
}
var inverseConstraintTypes = TypeCache.GetTypesWithAttribute <InverseRigConstraintAttribute>();
foreach (var inverseConstraintType in inverseConstraintTypes)
{
var attribute = inverseConstraintType.GetCustomAttribute <InverseRigConstraintAttribute>();
if (attribute.baseConstraint == constraint.GetType())
{
return((IRigConstraint)Activator.CreateInstance(inverseConstraintType, new object[] { constraint }));
}
}
return(null);
}
private static void BakeToConstraint(RigBuilder rigBuilder, IRigConstraint constraint, AnimationClip clip, AnimationClip defaultPoseClip, IEnumerable <EditorCurveBinding> bindings, CurveFilterOptions filterOptions)
{
// Make sure the base constraint is valid
if (constraint == null || !constraint.IsValid())
{
throw new InvalidOperationException(
string.Format("The rig constraint {0} is not a valid constraint.",
constraint != null ? constraint.ToString() : ""));
}
// Check if the constraint is inverse solvable
var inverseConstraint = FindInverseRigConstraint(constraint);
if (inverseConstraint == null)
{
throw new InvalidOperationException(
string.Format("No inverse rig constraint could be found for {0}.",
constraint.ToString()));
}
else if (!inverseConstraint.IsValid())
{
throw new InvalidOperationException(
string.Format("The inverse rig constrain {1} for {0} is not a valid constraint.",
constraint.ToString(),
inverseConstraint.ToString()));
}
var overrides = new Dictionary <IRigConstraint, IRigConstraint>();
overrides.Add(constraint, inverseConstraint);
using (var graph = new EvaluationGraph(rigBuilder, clip, defaultPoseClip, overrides, constraint))
{
BakeCurvesToClip(clip, bindings, rigBuilder, graph, filterOptions);
}
}
public EvaluationGraph(RigBuilder rigBuilder, AnimationClip clip, AnimationClip defaultPoseClip, IReadOnlyDictionary <IRigConstraint, IRigConstraint> overrides, IRigConstraint lastConstraint = null)
{
m_SyncSceneToStreamLayer = new SyncSceneToStreamLayer();
bool stopBuilding = false;
var layers = rigBuilder.layers;
m_RigLayers = new List <IRigLayer>(layers.Count);
for (int i = 0; i < layers.Count; ++i)
{
if (stopBuilding == true)
{
break;
}
if (layers[i].rig == null || !layers[i].active)
{
continue;
}
IRigConstraint[] constraints = RigUtils.GetConstraints(layers[i].rig);
if (constraints == null || constraints.Length == 0)
{
continue;
}
var newConstraints = new List <IRigConstraint>(constraints.Length);
foreach (IRigConstraint constraint in constraints)
{
if (overrides.TryGetValue(constraint, out IRigConstraint newConstraint))
{
if (newConstraint != null)
{
newConstraints.Add(newConstraint);
}
}
else
{
newConstraints.Add(constraint);
}
if (constraint == lastConstraint)
{
stopBuilding = true;
break;
}
}
m_RigLayers.Add(new OverrideRigLayer(layers[i].rig, newConstraints.ToArray()));
}
m_Graph = PlayableGraph.Create("Evaluation-Graph");
m_Graph.SetTimeUpdateMode(DirectorUpdateMode.Manual);
var animator = rigBuilder.GetComponent <Animator>();
m_Clip = clip;
var settings = AnimationUtility.GetAnimationClipSettings(m_Clip);
m_ClipLoopTime = settings.loopTime;
// Override loop time in clip asset.
settings.loopTime = false;
AnimationUtility.SetAnimationClipSettings(m_Clip, settings);
var defaultPosePlayable = AnimationClipPlayable.Create(m_Graph, defaultPoseClip);
var clipPlayable = AnimationClipPlayable.Create(m_Graph, m_Clip);
defaultPosePlayable.SetApplyFootIK(false);
clipPlayable.SetApplyFootIK(false);
AnimationLayerMixerPlayable mixer = AnimationLayerMixerPlayable.Create(m_Graph, 2);
mixer.ConnectInput(0, defaultPosePlayable, 0, 1.0f);
mixer.ConnectInput(1, clipPlayable, 0, 1.0f);
Playable inputPlayable = mixer;
var playableChains = RigBuilderUtils.BuildPlayables(animator, m_Graph, m_RigLayers, m_SyncSceneToStreamLayer);
foreach (var chain in playableChains)
{
if (!chain.IsValid())
{
continue;
}
chain.playables[0].AddInput(inputPlayable, 0, 1);
inputPlayable = chain.playables[chain.playables.Length - 1];
}
var output = AnimationPlayableOutput.Create(m_Graph, "bake-output", animator);
output.SetSourcePlayable(inputPlayable);
}
/// <inheritdoc />
IEnumerable <EditorCurveBinding> IBakeParameters.GetConstrainedCurveBindings(RigBuilder rigBuilder, IRigConstraint constraint)
{
Debug.Assert(constraint is T);
T tConstraint = (T)constraint;
return(GetConstrainedCurveBindings(rigBuilder, tConstraint));
}
