public void ProcessAnimation(AnimationStream stream)
{
float w = jobWeight.Get(stream);
if (w > 0f)
{
//We only need to process if the weight is greater than 0
float minOffset = offsetFromGround.Get(stream);
Vector3 normal = groundNormal.Get(stream);
float angle = Vector3.Angle(Vector3.up, normal);
float offset = minOffset / math.sin(math.radians(90 - angle));
Vector3 targetPosition = groundPoint.Get(stream) + Vector3.up * offset;
Vector3 sourcePosition = source.GetPosition(stream);
if (targetPosition.y > sourcePosition.y)
{
constrained.SetPosition(stream, math.lerp(sourcePosition, targetPosition, w));
Quaternion rotation = quaternion.LookRotation(source.GetRotation(stream) * Vector3.forward, normal);
constrained.SetRotation(stream, rotation);
}
else
{
constrained.SetPosition(stream, sourcePosition);
constrained.SetRotation(stream, source.GetRotation(stream));
}
}
}
Vector3 ComputeWorldUpVector(AnimationStream stream)
{
var result = Vector3.up;
switch (worldUpType)
{
case WorldUpType.None:
result = Vector3.zero;
break;
case WorldUpType.SceneUp:
// the scene Up vector and the World Up vector are the same thing
break;
case WorldUpType.ObjectUp:
{
// the target's Up vector points to the up object
var referencePos = Vector3.zero;
if (worldUpObject.IsValid(stream))
{
referencePos = worldUpObject.GetPosition(stream);
}
var targetPos = driven.GetPosition(stream);
result = (referencePos - targetPos).normalized;
break;
}
case WorldUpType.ObjectRotationUp:
{
var upRotation = Quaternion.identity;
if (worldUpObject.IsValid(stream))
{
upRotation = worldUpObject.GetRotation(stream);
}
// if no object is specified, the up vector is defined relative to the scene world space
result = upRotation * worldUpAxis;
break;
}
case WorldUpType.Vector:
result = worldUpAxis;
break;
default:
break;
}
return(result);
}
public void ProcessAnimation(AnimationStream stream)
{
float w = jobWeight.Get(stream);
if (w > 0f)
{
for (int i = 0; i < chain.Length; ++i)
{
var handle = chain[i];
linkPositions[i] = handle.GetPosition(stream);
chain[i] = handle;
}
int tipIndex = chain.Length - 1;
if (AnimationRuntimeUtils.SolveFABRIK(ref linkPositions, ref linkLengths, target.GetPosition(stream) + targetOffset.translation,
cache.GetRaw(toleranceIdx), maxReach, (int)cache.GetRaw(maxIterationsIdx)))
{
var chainRWeight = chainRotationWeight.Get(stream) * w;
for (int i = 0; i < tipIndex; ++i)
{
var prevDir = chain[i + 1].GetPosition(stream) - chain[i].GetPosition(stream);
var newDir = linkPositions[i + 1] - linkPositions[i];
var rot = chain[i].GetRotation(stream);
chain[i].SetRotation(stream, Quaternion.Lerp(rot, QuaternionExt.FromToRotation(prevDir, newDir) * rot, chainRWeight));
}
}
chain[tipIndex].SetRotation(
stream,
Quaternion.Lerp(
chain[tipIndex].GetRotation(stream),
target.GetRotation(stream) * targetOffset.rotation,
tipRotationWeight.Get(stream) * w
)
);
}
else
{
for (int i = 0; i < chain.Length; ++i)
{
AnimationRuntimeUtils.PassThrough(stream, chain[i]);
}
}
}
public void ProcessAnimation(AnimationStream stream)
{
float w = jobWeight.Get(stream);
if (w > 0f)
{
if (blendPosition.Get(stream))
{
Vector3 posBlend = Vector3.Lerp(
sourceA.GetPosition(stream) + sourceAOffset.translation,
sourceB.GetPosition(stream) + sourceBOffset.translation,
positionWeight.Get(stream)
);
driven.SetPosition(stream, Vector3.Lerp(driven.GetPosition(stream), posBlend, w));
}
else
{
driven.SetLocalPosition(stream, driven.GetLocalPosition(stream));
}
if (blendRotation.Get(stream))
{
Quaternion rotBlend = Quaternion.Lerp(
sourceA.GetRotation(stream) * sourceAOffset.rotation,
sourceB.GetRotation(stream) * sourceBOffset.rotation,
rotationWeight.Get(stream)
);
driven.SetRotation(stream, Quaternion.Lerp(driven.GetRotation(stream), rotBlend, w));
}
else
{
driven.SetLocalRotation(stream, driven.GetLocalRotation(stream));
}
}
else
{
AnimationRuntimeUtils.PassThrough(stream, driven);
}
}
public void ProcessAnimation(AnimationStream stream)
{
float w = jobWeight.Get(stream);
if (w > 0f)
{
AnimationStreamHandleUtility.ReadFloats(stream, sourceWeights, weightBuffer);
float sumWeights = AnimationRuntimeUtils.Sum(weightBuffer);
if (sumWeights < k_Epsilon)
{
AnimationRuntimeUtils.PassThrough(stream, driven);
return;
}
float weightScale = sumWeights > 1f ? 1f / sumWeights : 1f;
Vector2 minMaxAngles = new Vector2(minLimit.Get(stream), maxLimit.Get(stream));
var drivenWPos = driven.GetPosition(stream);
var drivenLRot = driven.GetLocalRotation(stream);
var drivenParentInvRot = Quaternion.Inverse(drivenParent.GetRotation(stream));
Quaternion accumDeltaRot = QuaternionExt.zero;
var fromDir = drivenLRot * aimAxis;
float accumWeights = 0f;
for (int i = 0; i < sourceTransforms.Length; ++i)
{
var normalizedWeight = weightBuffer[i] * weightScale;
if (normalizedWeight < k_Epsilon)
{
continue;
}
ReadOnlyTransformHandle sourceTransform = sourceTransforms[i];
var toDir = drivenParentInvRot * (sourceTransform.GetPosition(stream) - drivenWPos);
if (toDir.sqrMagnitude < k_Epsilon)
{
continue;
}
var crossDir = Vector3.Cross(fromDir, toDir).normalized;
if (Vector3.Dot(axesMask, axesMask) < 3f)
{
crossDir = AnimationRuntimeUtils.Select(Vector3.zero, crossDir, axesMask).normalized;
if (Vector3.Dot(crossDir, crossDir) > k_Epsilon)
{
fromDir = AnimationRuntimeUtils.ProjectOnPlane(fromDir, crossDir);
toDir = AnimationRuntimeUtils.ProjectOnPlane(toDir, crossDir);
}
else
{
toDir = fromDir;
}
}
var rotToSource = Quaternion.AngleAxis(
Mathf.Clamp(Vector3.Angle(fromDir, toDir), minMaxAngles.x, minMaxAngles.y),
crossDir
);
accumDeltaRot = QuaternionExt.Add(
accumDeltaRot,
QuaternionExt.Scale(sourceOffsets[i] * rotToSource, normalizedWeight)
);
// Required to update handles with binding info.
sourceTransforms[i] = sourceTransform;
accumWeights += normalizedWeight;
}
accumDeltaRot = QuaternionExt.NormalizeSafe(accumDeltaRot);
if (accumWeights < 1f)
{
accumDeltaRot = Quaternion.Lerp(Quaternion.identity, accumDeltaRot, accumWeights);
}
Quaternion newRot = accumDeltaRot * drivenLRot;
if (Vector3.Dot(axesMask, axesMask) < 3f)
{
newRot = Quaternion.Euler(AnimationRuntimeUtils.Select(drivenLRot.eulerAngles, newRot.eulerAngles, axesMask));
}
var offset = drivenOffset.Get(stream);
if (Vector3.Dot(offset, offset) > 0f)
{
newRot *= Quaternion.Euler(offset);
}
driven.SetLocalRotation(stream, Quaternion.Lerp(drivenLRot, newRot, w));
}
else
{
AnimationRuntimeUtils.PassThrough(stream, driven);
}
}
/// <summary>
/// Defines what to do when processing the animation.
/// </summary>
/// <param name="stream">The animation stream to work on.</param>
public void ProcessAnimation(AnimationStream stream)
{
float w = jobWeight.Get(stream);
if (w > 0f)
{
AnimationStreamHandleUtility.ReadFloats(stream, sourceWeights, weightBuffer);
float sumWeights = AnimationRuntimeUtils.Sum(weightBuffer);
if (sumWeights < k_Epsilon)
{
AnimationRuntimeUtils.PassThrough(stream, driven);
return;
}
float weightScale = sumWeights > 1f ? 1f / sumWeights : 1f;
float accumWeights = 0f;
Quaternion accumRot = QuaternionExt.zero;
for (int i = 0; i < sourceTransforms.Length; ++i)
{
var normalizedWeight = weightBuffer[i] * weightScale;
if (normalizedWeight < k_Epsilon)
{
continue;
}
ReadOnlyTransformHandle sourceTransform = sourceTransforms[i];
accumRot = QuaternionExt.Add(accumRot, QuaternionExt.Scale(sourceTransform.GetRotation(stream) * sourceOffsets[i], normalizedWeight));
// Required to update handles with binding info.
sourceTransforms[i] = sourceTransform;
accumWeights += normalizedWeight;
}
accumRot = QuaternionExt.NormalizeSafe(accumRot);
if (accumWeights < 1f)
{
accumRot = Quaternion.Lerp(driven.GetRotation(stream), accumRot, accumWeights);
}
// Convert accumRot to local space
if (drivenParent.IsValid(stream))
{
accumRot = Quaternion.Inverse(drivenParent.GetRotation(stream)) * accumRot;
}
Quaternion currentLRot = driven.GetLocalRotation(stream);
if (Vector3.Dot(axesMask, axesMask) < 3f)
{
accumRot = Quaternion.Euler(AnimationRuntimeUtils.Lerp(currentLRot.eulerAngles, accumRot.eulerAngles, axesMask));
}
var offset = drivenOffset.Get(stream);
if (Vector3.Dot(offset, offset) > 0f)
{
accumRot *= Quaternion.Euler(offset);
}
driven.SetLocalRotation(stream, Quaternion.Lerp(currentLRot, accumRot, w));
}
else
{
AnimationRuntimeUtils.PassThrough(stream, driven);
}
}
public void ProcessAnimation(AnimationStream stream)
{
float w = jobWeight.Get(stream);
if (w > 0f)
{
AnimationStreamHandleUtility.ReadFloats(stream, sourceWeights, weightBuffer);
float sumWeights = AnimationRuntimeUtils.Sum(weightBuffer);
if (sumWeights < k_Epsilon)
{
return;
}
float weightScale = sumWeights > 1f ? 1f / sumWeights : 1f;
Vector2 minMaxAngles = new Vector2(minLimit.Get(stream), maxLimit.Get(stream));
driven.GetGlobalTR(stream, out Vector3 currentWPos, out Quaternion currentWRot);
Vector3 currentDir = currentWRot * aimAxis;
Quaternion accumDeltaRot = QuaternionExt.zero;
float accumWeights = 0f;
for (int i = 0; i < sourceTransforms.Length; ++i)
{
var normalizedWeight = weightBuffer[i] * weightScale;
if (normalizedWeight < k_Epsilon)
{
continue;
}
ReadOnlyTransformHandle sourceTransform = sourceTransforms[i];
var toDir = sourceTransform.GetPosition(stream) - currentWPos;
if (toDir.sqrMagnitude < k_Epsilon)
{
continue;
}
var rotToSource = Quaternion.AngleAxis(
Mathf.Clamp(Vector3.Angle(currentDir, toDir), minMaxAngles.x, minMaxAngles.y),
Vector3.Cross(currentDir, toDir).normalized
);
accumDeltaRot = QuaternionExt.Add(
accumDeltaRot,
QuaternionExt.Scale(sourceOffsets[i] * rotToSource, normalizedWeight)
);
// Required to update handles with binding info.
sourceTransforms[i] = sourceTransform;
accumWeights += normalizedWeight;
}
accumDeltaRot = QuaternionExt.NormalizeSafe(accumDeltaRot);
if (accumWeights < 1f)
{
accumDeltaRot = Quaternion.Lerp(Quaternion.identity, accumDeltaRot, accumWeights);
}
Quaternion newRot = accumDeltaRot * currentWRot;
// Convert newRot to local space
if (drivenParent.IsValid(stream))
{
newRot = Quaternion.Inverse(drivenParent.GetRotation(stream)) * newRot;
}
Quaternion currentLRot = driven.GetLocalRotation(stream);
if (Vector3.Dot(axesMask, axesMask) < 3f)
{
newRot = Quaternion.Euler(AnimationRuntimeUtils.Lerp(currentLRot.eulerAngles, newRot.eulerAngles, axesMask));
}
var offset = drivenOffset.Get(stream);
if (Vector3.Dot(offset, offset) > 0f)
{
newRot *= Quaternion.Euler(offset);
}
driven.SetLocalRotation(stream, Quaternion.Lerp(currentLRot, newRot, w));
}
else
{
AnimationRuntimeUtils.PassThrough(stream, driven);
}
}