protected override RigRemapData CreateGraph(Entity entity, ref Rig rig, ProcessDefaultAnimationGraph graphSystem, ref RigRemapSetup setup)
{
var set = graphSystem.Set;
var debugEntity = RigUtils.InstantiateDebugRigEntity(
setup.SrcRig,
EntityManager,
new BoneRendererProperties {
BoneShape = BoneRendererUtils.BoneShape.Line, Color = new float4(0f, 1f, 0f, 0.5f), Size = 1f
}
);
PostUpdateCommands.AddComponent(debugEntity, new LocalToParent {
Value = float4x4.identity
});
PostUpdateCommands.AddComponent(debugEntity, new Parent {
Value = entity
});
var data = new RigRemapData();
data.DeltaTimeNode = set.Create <ConvertDeltaTimeToFloatNode>();
data.ClipPlayerNode = set.Create <ClipPlayerNode>();
data.RemapperNode = set.Create <RigRemapperNode>();
data.EntityNode = set.CreateComponentNode(entity);
data.DebugEntityNode = set.CreateComponentNode(debugEntity);
set.SetData(data.ClipPlayerNode, ClipPlayerNode.KernelPorts.Speed, 1.0f);
// Connect kernel ports
set.Connect(data.DeltaTimeNode, ConvertDeltaTimeToFloatNode.KernelPorts.Output, data.ClipPlayerNode, ClipPlayerNode.KernelPorts.DeltaTime);
set.Connect(data.ClipPlayerNode, ClipPlayerNode.KernelPorts.Output, data.RemapperNode, RigRemapperNode.KernelPorts.Input);
// Connect EntityNode
set.Connect(data.EntityNode, data.DeltaTimeNode, ConvertDeltaTimeToFloatNode.KernelPorts.Input);
set.Connect(data.RemapperNode, RigRemapperNode.KernelPorts.Output, data.EntityNode, NodeSet.ConnectionType.Feedback);
// Connect DebugEntityNode
set.Connect(data.ClipPlayerNode, ClipPlayerNode.KernelPorts.Output, data.DebugEntityNode);
// Send messages
set.SendMessage(data.ClipPlayerNode, ClipPlayerNode.SimulationPorts.Configuration, new ClipConfiguration {
Mask = ClipConfigurationMask.LoopTime
});
set.SendMessage(data.ClipPlayerNode, ClipPlayerNode.SimulationPorts.Rig, new Rig {
Value = setup.SrcRig
});
set.SendMessage(data.ClipPlayerNode, ClipPlayerNode.SimulationPorts.Clip, setup.SrcClip);
set.SendMessage(data.RemapperNode, RigRemapperNode.SimulationPorts.SourceRig, new Rig {
Value = setup.SrcRig
});
set.SendMessage(data.RemapperNode, RigRemapperNode.SimulationPorts.DestinationRig, rig);
set.SendMessage(data.RemapperNode, RigRemapperNode.SimulationPorts.RemapTable, setup.RemapTable);
return(data);
}
protected override RetargetData CreateGraph(Entity entity, ref Rig rig, PreAnimationGraphSystem graphSystem, ref RetargetSetup setup)
{
var set = graphSystem.Set;
var debugEntity = RigUtils.InstantiateDebugRigEntity(
setup.SrcRig,
EntityManager,
new BoneRendererProperties { BoneShape = BoneRendererUtils.BoneShape.Line, Color = new float4(0f, 1f, 0f, 0.5f), Size = 1f }
);
if (EntityManager.HasComponent<Translation>(entity))
{
PostUpdateCommands.AddComponent(
debugEntity,
EntityManager.GetComponentData<Translation>(entity)
);
}
var data = new RetargetData();
data.DeltaTimeNode = set.Create<DeltaTimeNode>();
data.ClipPlayerNode = set.Create<ClipPlayerNode>();
data.RemapperNode = set.Create<RigRemapperNode>();
data.EntityNode = set.CreateComponentNode(entity);
data.DebugEntityNode = set.CreateComponentNode(debugEntity);
set.SetData(data.ClipPlayerNode, ClipPlayerNode.KernelPorts.Speed, 1.0f);
// Connect kernel ports
set.Connect(data.DeltaTimeNode, DeltaTimeNode.KernelPorts.DeltaTime, data.ClipPlayerNode, ClipPlayerNode.KernelPorts.DeltaTime);
set.Connect(data.ClipPlayerNode, ClipPlayerNode.KernelPorts.Output, data.RemapperNode, RigRemapperNode.KernelPorts.Input);
// Connect EntityNode
set.Connect(data.RemapperNode, RigRemapperNode.KernelPorts.Output, data.EntityNode);
// Connect DebugEntityNode
set.Connect(data.ClipPlayerNode, ClipPlayerNode.KernelPorts.Output, data.DebugEntityNode);
// Send messages
set.SendMessage(data.ClipPlayerNode, ClipPlayerNode.SimulationPorts.Configuration, new ClipConfiguration { Mask = ClipConfigurationMask.LoopTime });
set.SendMessage(data.ClipPlayerNode, ClipPlayerNode.SimulationPorts.Rig, new Rig { Value = setup.SrcRig });
set.SendMessage(data.ClipPlayerNode, ClipPlayerNode.SimulationPorts.Clip, setup.SrcClip);
set.SendMessage(data.RemapperNode, RigRemapperNode.SimulationPorts.SourceRig, new Rig { Value = setup.SrcRig });
set.SendMessage(data.RemapperNode, RigRemapperNode.SimulationPorts.DestinationRig, rig);
set.SendMessage(data.RemapperNode, RigRemapperNode.SimulationPorts.RemapTable, setup.RemapTable);
PostUpdateCommands.AddComponent(entity, graphSystem.Tag);
PostUpdateCommands.AddComponent(debugEntity, graphSystem.Tag);
return data;
}
protected override RetargetData CreateGraph(Entity entity, NodeSet set, ref RetargetSetup setup)
{
var srcClip = ClipManager.Instance.GetClipFor(setup.SrcRig, setup.SrcClip);
var data = new RetargetData();
data.DeltaTimeNode = set.Create <DeltaTimeNode>();
data.ClipPlayerNode = set.Create <ClipPlayerNode>();
data.RemapperNode = set.Create <RigRemapperNode>();
set.SendMessage(data.ClipPlayerNode, (InputPortID)ClipPlayerNode.SimulationPorts.Speed, 1.0f);
// Connect kernel ports
set.Connect(data.DeltaTimeNode, (OutputPortID)DeltaTimeNode.KernelPorts.DeltaTime, data.ClipPlayerNode, (InputPortID)ClipPlayerNode.KernelPorts.DeltaTime);
set.Connect(data.ClipPlayerNode, (OutputPortID)ClipPlayerNode.KernelPorts.Output, data.RemapperNode, (InputPortID)RigRemapperNode.KernelPorts.Input);
// Send messages
set.SendMessage(data.ClipPlayerNode, (InputPortID)ClipPlayerNode.SimulationPorts.Configuration, new ClipConfiguration {
Mask = (int)ClipConfigurationMask.LoopTime
});
set.SendMessage(data.ClipPlayerNode, (InputPortID)ClipPlayerNode.SimulationPorts.ClipInstance, srcClip);
set.SendMessage(data.RemapperNode, (InputPortID)RigRemapperNode.SimulationPorts.SourceRigDefinition, setup.SrcRig);
set.SendMessage(data.RemapperNode, (InputPortID)RigRemapperNode.SimulationPorts.DestinationRigDefinition, setup.DstRig);
set.SendMessage(data.RemapperNode, (InputPortID)RigRemapperNode.SimulationPorts.RemapTable, setup.RemapTable);
data.Output.Buffer = set.CreateGraphValue <Buffer <float> >(data.RemapperNode, (OutputPortID)RigRemapperNode.KernelPorts.Output);
data.DebugOutput.Buffer = set.CreateGraphValue <Buffer <float> >(data.ClipPlayerNode, (OutputPortID)ClipPlayerNode.KernelPorts.Output);
var debugEntity = RigUtils.InstantiateDebugRigEntity(
setup.SrcRig,
EntityManager,
new BoneRendererProperties {
BoneShape = BoneRendererUtils.BoneShape.Line, Color = new float4(0f, 1f, 0f, 0.5f), Size = 1f
}
);
if (EntityManager.HasComponent <Translation>(entity))
{
PostUpdateCommands.AddComponent(
debugEntity,
EntityManager.GetComponentData <Translation>(entity)
);
}
PostUpdateCommands.AddComponent(entity, data.Output);
PostUpdateCommands.AddComponent(debugEntity, data.DebugOutput);
return(data);
}
private void CreateDebugBoneRig(Entity entity, ref Rig rig)
{
var ecb = EsBufferSystem.CreateCommandBuffer();
var debugEntityRig = RigUtils.InstantiateDebugRigEntity(rig.Value, EntityManager,
new BoneRendererProperties
{
BoneShape = BoneRendererUtils.BoneShape.Line, Color = new float4(0, 1, 0, 1), Size = 1
});
ecb.AddComponent(debugEntityRig, new LocalToParent {
Value = float4x4.identity
});
ecb.AddComponent(debugEntityRig, new Parent {
Value = entity
});
}
protected override FKGraphData CreateGraph(Entity entity, ref Rig rig, PreAnimationGraphSystem graphSystem, ref FKGraphSetup setup)
{
var set = graphSystem.Set;
var debugEntity = RigUtils.InstantiateDebugRigEntity(
rig,
EntityManager,
new BoneRendererProperties {
BoneShape = BoneRendererUtils.BoneShape.Line, Color = math.float4(1f, 0f, 0f, 1f), Size = 1f
}
);
if (EntityManager.HasComponent <Translation>(entity))
{
float3 t = EntityManager.GetComponentData <Translation>(entity).Value;
PostUpdateCommands.AddComponent(
debugEntity,
new Translation {
Value = t - math.float3(0f, 0f, 0.5f)
}
);
}
var data = new FKGraphData();
data.DeltaTimeNode = set.Create <DeltaTimeNode>();
data.ClipNode = set.Create <ClipPlayerNode>();
data.EntityNode = set.CreateComponentNode(entity);
data.DebugEntityNode = set.CreateComponentNode(debugEntity);
set.Connect(data.DeltaTimeNode, DeltaTimeNode.KernelPorts.DeltaTime, data.ClipNode, ClipPlayerNode.KernelPorts.DeltaTime);
set.Connect(data.ClipNode, ClipPlayerNode.KernelPorts.Output, data.EntityNode);
set.Connect(data.ClipNode, ClipPlayerNode.KernelPorts.Output, data.DebugEntityNode);
set.SetData(data.ClipNode, ClipPlayerNode.KernelPorts.Speed, 1.0f);
set.SendMessage(data.ClipNode, ClipPlayerNode.SimulationPorts.Configuration, new ClipConfiguration {
Mask = ClipConfigurationMask.LoopTime | ClipConfigurationMask.LoopValues
});
set.SendMessage(data.ClipNode, ClipPlayerNode.SimulationPorts.Rig, rig);
set.SendMessage(data.ClipNode, ClipPlayerNode.SimulationPorts.Clip, setup.Clip);
PostUpdateCommands.AddComponent(entity, graphSystem.Tag);
return(data);
}
private static void TransferMotionToConstraint(RigBuilder rigBuilder, IEnumerable <Rig> rigs)
{
var constraints = new List <IRigConstraint>();
foreach (var rig in rigs)
{
constraints.AddRange(RigUtils.GetConstraints(rig));
}
var clip = AnimationWindowUtils.activeAnimationClip;
// Make sure we have a clip selected
if (clip == null)
{
throw new InvalidOperationException(
"There is no clip to work on." +
" The animation window must be open with an active clip!");
}
AnimationClip editableClip = clip;
if (!GetEditableClip(ref editableClip))
{
return;
}
AnimationClip defaultPoseClip = CreateDefaultPose(rigBuilder);
Undo.RegisterCompleteObjectUndo(editableClip, kBakeToConstraintUndoLabel);
var animator = rigBuilder.GetComponent <Animator>();
if (editableClip != clip)
{
AddClipToAnimatorController(animator, editableClip);
}
var bindingsToRemove = new HashSet <EditorCurveBinding>();
// Remove weight curve & force constraint to be active
if (Preferences.forceConstraintWeightOnBake)
{
AnimationCurve oneWeightCurve = AnimationCurve.Constant(0f, editableClip.length, 1f);
foreach (var rig in rigs)
{
AnimationUtility.SetEditorCurve(editableClip, GetWeightCurveBinding(rigBuilder, rig), oneWeightCurve);
}
}
foreach (IRigConstraint constraint in constraints)
{
var bakeParameters = FindBakeParameters(constraint);
if (bakeParameters == null || !bakeParameters.canBakeToConstraint)
{
continue;
}
// Flush out animation mode modifications
AnimationMode.BeginSampling();
AnimationMode.EndSampling();
var bindings = bakeParameters.GetSourceCurveBindings(rigBuilder, constraint);
BakeToConstraint(rigBuilder, constraint, editableClip, defaultPoseClip, bindings, Preferences.bakeToConstraintCurveFilterOptions);
bindingsToRemove.UnionWith(bakeParameters.GetConstrainedCurveBindings(rigBuilder, constraint));
}
if (Preferences.bakeToConstraintAndRemoveCurves)
{
RemoveCurves(editableClip, bindingsToRemove);
}
}
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);
}
protected override FeatherBlendData CreateGraph(Entity entity, ref Rig rig, PreAnimationGraphSystem graphSystem, ref FeatherBlendSetup setup)
{
var set = graphSystem.Set;
var debugClip1Entity = RigUtils.InstantiateDebugRigEntity(
rig,
EntityManager,
new BoneRendererProperties {
BoneShape = BoneRendererUtils.BoneShape.Line, Color = new float4(1f, 0f, 0f, 1f), Size = 1f
}
);
var debugClip2Entity = RigUtils.InstantiateDebugRigEntity(
rig,
EntityManager,
new BoneRendererProperties {
BoneShape = BoneRendererUtils.BoneShape.Line, Color = new float4(0f, 0f, 1f, 1f), Size = 1f
}
);
if (EntityManager.HasComponent <Translation>(entity))
{
float3 t = EntityManager.GetComponentData <Translation>(entity).Value;
float3 offset = new float3(1.5f, 0f, 0f);
PostUpdateCommands.AddComponent(
debugClip1Entity,
new Translation {
Value = t - offset
}
);
PostUpdateCommands.AddComponent(
debugClip2Entity,
new Translation {
Value = t + offset
}
);
}
var data = new FeatherBlendData();
// Create the nodes.
data.DeltaTimeNode = set.Create <DeltaTimeNode>();
data.Clip1Node = set.Create <ClipPlayerNode>();
data.Clip2Node = set.Create <ClipPlayerNode>();
data.FeatherBlendNode = set.Create <ChannelWeightMixerNode>();
data.WeightBuilderNode = set.Create <WeightBuilderNode>();
data.EntityNode = set.CreateComponentNode(entity);
data.DebugClip1EntityNode = set.CreateComponentNode(debugClip1Entity);
data.DebugClip2EntityNode = set.CreateComponentNode(debugClip2Entity);
// Connect the nodes. The DeltaTimeNode output is used to evaluate the clips in the ClipNodes,
// and the ClipNodes' outputs are blended in the FeatherBlendNode, each channel being weighted
// depending on the value of the corresponding element in the weight buffer output by the WeightBuilderNode.
set.Connect(data.DeltaTimeNode, DeltaTimeNode.KernelPorts.DeltaTime, data.Clip1Node, ClipPlayerNode.KernelPorts.DeltaTime);
set.Connect(data.DeltaTimeNode, DeltaTimeNode.KernelPorts.DeltaTime, data.Clip2Node, ClipPlayerNode.KernelPorts.DeltaTime);
set.Connect(data.Clip1Node, ClipPlayerNode.KernelPorts.Output, data.FeatherBlendNode, ChannelWeightMixerNode.KernelPorts.Input0);
set.Connect(data.Clip2Node, ClipPlayerNode.KernelPorts.Output, data.FeatherBlendNode, ChannelWeightMixerNode.KernelPorts.Input1);
set.Connect(data.WeightBuilderNode, WeightBuilderNode.KernelPorts.Output, data.FeatherBlendNode, ChannelWeightMixerNode.KernelPorts.WeightMasks);
set.SetData(data.WeightBuilderNode, WeightBuilderNode.KernelPorts.DefaultWeight, setup.DefaultWeight);
set.SetData(data.FeatherBlendNode, ChannelWeightMixerNode.KernelPorts.Weight, 1.0f);
set.SetData(data.Clip1Node, ClipPlayerNode.KernelPorts.Speed, 1.0f);
set.SetData(data.Clip2Node, ClipPlayerNode.KernelPorts.Speed, 1.0f);
// Set the port arrays for the WightBuilderNode.
var weightLength = setup.WeightTable.Value.Weights.Length;
set.SetPortArraySize(data.WeightBuilderNode, WeightBuilderNode.KernelPorts.ChannelIndices, (ushort)weightLength);
set.SetPortArraySize(data.WeightBuilderNode, WeightBuilderNode.KernelPorts.ChannelWeights, (ushort)weightLength);
for (ushort i = 0; i < weightLength; ++i)
{
var w = setup.WeightTable.Value.Weights[i];
set.SetData(data.WeightBuilderNode, WeightBuilderNode.KernelPorts.ChannelIndices, i, w.Index);
set.SetData(data.WeightBuilderNode, WeightBuilderNode.KernelPorts.ChannelWeights, i, w.Weight);
}
// Connect RigEntity component data
set.Connect(data.FeatherBlendNode, ChannelWeightMixerNode.KernelPorts.Output, data.EntityNode);
// Connect Debug1Entity component data
set.Connect(data.Clip1Node, ClipPlayerNode.KernelPorts.Output, data.DebugClip1EntityNode);
// Connect Debug2Entity component data
set.Connect(data.Clip2Node, ClipPlayerNode.KernelPorts.Output, data.DebugClip2EntityNode);
// Send messages to setup constant data in the nodes.
set.SendMessage(data.Clip1Node, ClipPlayerNode.SimulationPorts.Configuration, new ClipConfiguration {
Mask = ClipConfigurationMask.LoopTime
});
set.SendMessage(data.Clip2Node, ClipPlayerNode.SimulationPorts.Configuration, new ClipConfiguration {
Mask = ClipConfigurationMask.LoopTime
});
set.SendMessage(data.Clip1Node, ClipPlayerNode.SimulationPorts.Rig, rig);
set.SendMessage(data.Clip1Node, ClipPlayerNode.SimulationPorts.Clip, setup.Clip1);
set.SendMessage(data.Clip2Node, ClipPlayerNode.SimulationPorts.Rig, rig);
set.SendMessage(data.Clip2Node, ClipPlayerNode.SimulationPorts.Clip, setup.Clip2);
set.SendMessage(data.FeatherBlendNode, ChannelWeightMixerNode.SimulationPorts.Rig, rig);
set.SendMessage(data.WeightBuilderNode, WeightBuilderNode.SimulationPorts.Rig, rig);
PostUpdateCommands.AddComponent(entity, graphSystem.Tag);
PostUpdateCommands.AddComponent(debugClip1Entity, graphSystem.Tag);
PostUpdateCommands.AddComponent(debugClip2Entity, graphSystem.Tag);
return(data);
}
