feat(Runtime): All animation rigging jobs use the weight field

Summary: Our animation rigging jobs don't respect the weight parameter for the most part, and we should use it so that people can reduce the effect of each constraint.

Reviewed By: andkim-meta

Differential Revision: D46653823

fbshipit-source-id: 2a6dc96a662aff7ae03db0fe65f343f7412f6d6c

Author: sohailshafiiWk

Runtime/Scripts/AnimationRigging/DeformationJob.cs

@@ -172,11 +172,11 @@ public void ProcessAnimation(AnimationStream stream)
                 if (SpineCorrectionType != DeformationData.SpineTranslationCorrectionType.None &&
                     (!CorrectSpineOnce || (CorrectSpineOnce && !_correctedSpine)))
                 {
-                    ProcessSpineCorrection(stream);
+                    ProcessSpineCorrection(stream, weight);
                     _correctedSpine = true;
                 }
-                ProcessDeformation(stream);
-                ProcessArms(stream);
+                ProcessDeformation(stream, weight);
+                ProcessArms(stream, weight);
             }
             else
             {
@@ -195,7 +195,7 @@ public void ProcessAnimation(AnimationStream stream)
             }
         }
 
-        private void ProcessSpineCorrection(AnimationStream stream)
+        private void ProcessSpineCorrection(AnimationStream stream, float weight)
         {
             var currentDirection = HipsToHeadBones[HipsBonesIndex].GetPosition(stream) -
                                          HipsToHeadBones[HeadBonesIndex].GetPosition(stream);
@@ -211,13 +211,13 @@ private void ProcessSpineCorrection(AnimationStream stream)
                 }
 
                 var bone = HipsToHeadBones[i];
-                var targetPos = bone.GetPosition(stream);
-                bone.SetPosition(stream, targetPos + offset);
+                var currentPosition = bone.GetPosition(stream);
+                bone.SetPosition(stream, Vector3.Lerp(currentPosition, currentPosition + offset, weight));
                 HipsToHeadBones[i] = bone;
             }
         }
 
-        private void ProcessDeformation(AnimationStream stream)
+        private void ProcessDeformation(AnimationStream stream, float weight)
         {
             for (int i = 0; i < StartBones.Length; i++)
             {
@@ -246,20 +246,22 @@ private void ProcessDeformation(AnimationStream stream)
                 {
                     BonePositions[i] = targetPos;
                 }
-                EndBones[i].SetPosition(stream, BonePositions[i]);
+                EndBones[i].SetPosition(stream, Vector3.Lerp(startPos, BonePositions[i], weight));
             }
 
             _initializedBonePositions = true;
         }
 
-        private void ProcessArms(AnimationStream stream)
+        private void ProcessArms(AnimationStream stream, float weight)
         {
             var leftLowerArmPos = LeftLowerArmBone.GetPosition(stream);
             var rightLowerArmPos = RightLowerArmBone.GetPosition(stream);
             var leftArmOffset = LeftUpperArmBone.GetPosition(stream) - _originalLeftUpperArmPos;
             var rightArmOffset = RightUpperArmBone.GetPosition(stream) - _originalRightUpperArmPos;
-            LeftLowerArmBone.SetPosition(stream, leftLowerArmPos + leftArmOffset * LeftArmOffsetWeight);
-            RightLowerArmBone.SetPosition(stream, rightLowerArmPos + rightArmOffset * RightArmOffsetWeight);
+            LeftLowerArmBone.SetPosition(stream,
+                Vector3.Lerp(leftLowerArmPos, leftLowerArmPos + leftArmOffset * LeftArmOffsetWeight, weight));
+            RightLowerArmBone.SetPosition(stream,
+                Vector3.Lerp(rightLowerArmPos, rightLowerArmPos + rightArmOffset * RightArmOffsetWeight, weight));
         }
     }
 

Runtime/Scripts/AnimationRigging/GroundingJob.cs

@@ -104,16 +104,20 @@ public void ProcessAnimation(AnimationStream stream)
                 // Leg position + rotation.
                 var hipsLocalRotation = Hips.GetLocalRotation(stream);
                 var hipsLocalPosition = Hips.GetLocalPosition(stream);
-                Leg.SetLocalPosition(stream, hipsLocalPosition + hipsLocalRotation * LegPosOffset);
-                Leg.SetLocalRotation(stream, hipsLocalRotation * LegRotOffset);
+                Leg.SetLocalPosition(stream,
+                    Vector3.Lerp(hipsLocalPosition,
+                        hipsLocalPosition + hipsLocalRotation * LegPosOffset, weight));
+                Leg.SetLocalRotation(stream,
+                    Quaternion.Slerp(hipsLocalRotation,
+                        hipsLocalRotation * LegRotOffset, weight));
 
                 // Foot position.
                 if (IsGrounding[0])
                 {
                     var footPos = Vector3.Lerp(_prevFootPos, TargetFootPos[0], MoveProgress[0]);
                     float footDist = Vector3.Distance(_prevFootPos, TargetFootPos[0]);
                     footPos.y += StepHeight * Mathf.Clamp01(footDist / StepHeightScaleDist) * StepProgress[0];
-                    FootTarget.SetPosition(stream, footPos);
+                    FootTarget.SetPosition(stream, Vector3.Lerp(FootTarget.GetPosition(stream), footPos, weight));
                 }
 
                 // Record foot position.
@@ -125,7 +129,8 @@ public void ProcessAnimation(AnimationStream stream)
                 // Foot rotation.
                 var lookRot = Quaternion.LookRotation(HipsTarget.GetLocalPosition(stream) - KneeTarget.GetLocalPosition(stream)) *
                                         FootRotationOffset;
-                FootTarget.SetRotation(stream, lookRot);
+                FootTarget.SetRotation(stream,
+                    Quaternion.Slerp(FootTarget.GetRotation(stream), lookRot, weight));
             }
             else
             {

Runtime/Scripts/AnimationRigging/HipPinningJob.cs

@@ -62,13 +62,15 @@ public void ProcessAnimation(AnimationStream stream)
                         if (bone.IsValid(stream))
                         {
                             var bonePos = bone.GetLocalPosition(stream);
-                            bone.SetLocalPosition(stream, bonePos + hipPosDelta);
+                            bone.SetLocalPosition(stream,
+                                Vector3.Lerp(bonePos, bonePos + hipPosDelta, weight));
                         }
                     }
                 }
 
                 // Set the hips position.
-                Hips.SetLocalPosition(stream, TargetHipPos[0]);
+                Hips.SetLocalPosition(stream,
+                    Vector3.Lerp(trackedHipPos, TargetHipPos[0], weight));
             }
             else
             {

Runtime/Scripts/AnimationRigging/TwistDistributionJob.cs

@@ -106,15 +106,18 @@ public void ProcessAnimation(AnimationStream stream)
                     ReadWriteTransformHandle twistTransform = TwistTransforms[i];
 
                     // Apply spacing
-                    twistTransform.SetPosition(stream, SpacingPositions[i]);
+                    twistTransform.SetPosition(stream,
+                        Vector3.Lerp(twistTransform.GetPosition(stream), SpacingPositions[i], weight));
 
                     // Apply twist
                     Quaternion twistRotation = Quaternion.LookRotation(SegmentDirections[0], SegmentUpAxis[i]);
                     Quaternion targetRotation = Quaternion.Slerp(
                         parentRotation * TwistBindRotations[i],
                         twistRotation * TwistAxisOffset,
                         WeightBuffer[i] * weight);
-                    twistTransform.SetLocalRotation(stream, inverseParentRotation * targetRotation);
+                    twistTransform.SetLocalRotation(stream,
+                        Quaternion.Slerp(twistTransform.GetLocalRotation(stream),
+                            inverseParentRotation * targetRotation, weight));
                     TwistTransforms[i] = twistTransform;
                 }
             }