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)
{
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;
Vector3 currentWPos = driven.GetPosition(stream);
Vector3 accumPos = currentWPos;
for (int i = 0; i < sourceTransforms.Length; ++i)
{
var normalizedWeight = weightBuffer[i] * weightScale;
if (normalizedWeight < k_Epsilon)
{
continue;
}
ReadOnlyTransformHandle sourceTransform = sourceTransforms[i];
accumPos += (sourceTransform.GetPosition(stream) + sourceOffsets[i] - currentWPos) * normalizedWeight;
// Required to update handles with binding info.
sourceTransforms[i] = sourceTransform;
}
// Convert accumPos to local space
if (drivenParent.IsValid(stream))
{
drivenParent.GetGlobalTR(stream, out Vector3 parentWPos, out Quaternion parentWRot);
var parentTx = new AffineTransform(parentWPos, parentWRot);
accumPos = parentTx.InverseTransform(accumPos);
}
Vector3 currentLPos = driven.GetLocalPosition(stream);
if (Vector3.Dot(axesMask, axesMask) < 3f)
{
accumPos = AnimationRuntimeUtils.Lerp(currentLPos, accumPos, axesMask);
}
driven.SetLocalPosition(stream, Vector3.Lerp(currentLPos, accumPos + drivenOffset.Get(stream), w));
}
else
{
AnimationRuntimeUtils.PassThrough(stream, driven);
}
}
public static void SolveTwoBoneIK(
AnimationStream stream,
ReadWriteTransformHandle root,
ReadWriteTransformHandle mid,
ReadWriteTransformHandle tip,
ReadOnlyTransformHandle target,
ReadOnlyTransformHandle hint,
float posWeight,
float rotWeight,
float hintWeight,
AffineTransform targetOffset
)
{
Vector3 aPosition = root.GetPosition(stream);
Vector3 bPosition = mid.GetPosition(stream);
Vector3 cPosition = tip.GetPosition(stream);
target.GetGlobalTR(stream, out Vector3 targetPos, out Quaternion targetRot);
Vector3 tPosition = Vector3.Lerp(cPosition, targetPos + targetOffset.translation, posWeight);
Quaternion tRotation = Quaternion.Lerp(tip.GetRotation(stream), targetRot * targetOffset.rotation, rotWeight);
bool hasHint = hint.IsValid(stream) && hintWeight > 0f;
Vector3 ab = bPosition - aPosition;
Vector3 bc = cPosition - bPosition;
Vector3 ac = cPosition - aPosition;
Vector3 at = tPosition - aPosition;
float abLen = ab.magnitude;
float bcLen = bc.magnitude;
float acLen = ac.magnitude;
float atLen = at.magnitude;
float oldAbcAngle = TriangleAngle(acLen, abLen, bcLen);
float newAbcAngle = TriangleAngle(atLen, abLen, bcLen);
// Bend normal strategy is to take whatever has been provided in the animation
// stream to minimize configuration changes, however if this is collinear
// try computing a bend normal given the desired target position.
// If this also fails, try resolving axis using hint if provided.
Vector3 axis = Vector3.Cross(ab, bc);
if (axis.sqrMagnitude < k_SqrEpsilon)
{
axis = hasHint ? Vector3.Cross(hint.GetPosition(stream) - aPosition, bc) : Vector3.zero;
if (axis.sqrMagnitude < k_SqrEpsilon)
{
axis = Vector3.Cross(at, bc);
}
if (axis.sqrMagnitude < k_SqrEpsilon)
{
axis = Vector3.up;
}
}
axis = Vector3.Normalize(axis);
float a = 0.5f * (oldAbcAngle - newAbcAngle);
float sin = Mathf.Sin(a);
float cos = Mathf.Cos(a);
Quaternion deltaR = new Quaternion(axis.x * sin, axis.y * sin, axis.z * sin, cos);
mid.SetRotation(stream, deltaR * mid.GetRotation(stream));
cPosition = tip.GetPosition(stream);
ac = cPosition - aPosition;
root.SetRotation(stream, QuaternionExt.FromToRotation(ac, at) * root.GetRotation(stream));
if (hasHint)
{
float acSqrMag = ac.sqrMagnitude;
if (acSqrMag > 0f)
{
bPosition = mid.GetPosition(stream);
cPosition = tip.GetPosition(stream);
ab = bPosition - aPosition;
ac = cPosition - aPosition;
Vector3 acNorm = ac / Mathf.Sqrt(acSqrMag);
Vector3 ah = hint.GetPosition(stream) - aPosition;
Vector3 abProj = ab - acNorm * Vector3.Dot(ab, acNorm);
Vector3 ahProj = ah - acNorm * Vector3.Dot(ah, acNorm);
float maxReach = abLen + bcLen;
if (abProj.sqrMagnitude > (maxReach * maxReach * 0.001f) && ahProj.sqrMagnitude > 0f)
{
Quaternion hintR = QuaternionExt.FromToRotation(abProj, ahProj);
hintR.x *= hintWeight;
hintR.y *= hintWeight;
hintR.z *= hintWeight;
root.SetRotation(stream, hintR * root.GetRotation(stream));
}
}
}
tip.SetRotation(stream, tRotation);
}
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;
float accumWeights = 0f;
var accumTx = new AffineTransform(Vector3.zero, QuaternionExt.zero);
for (int i = 0; i < sourceTransforms.Length; ++i)
{
ReadOnlyTransformHandle sourceTransform = sourceTransforms[i];
var normalizedWeight = weightBuffer[i] * weightScale;
if (normalizedWeight < k_Epsilon)
{
continue;
}
sourceTransform.GetGlobalTR(stream, out Vector3 srcWPos, out Quaternion srcWRot);
var sourceTx = new AffineTransform(srcWPos, srcWRot);
sourceTx *= sourceOffsets[i];
accumTx.translation += sourceTx.translation * normalizedWeight;
accumTx.rotation = QuaternionExt.Add(accumTx.rotation, QuaternionExt.Scale(sourceTx.rotation, normalizedWeight));
// Required to update handles with binding info.
sourceTransforms[i] = sourceTransform;
accumWeights += normalizedWeight;
}
accumTx.rotation = QuaternionExt.NormalizeSafe(accumTx.rotation);
if (accumWeights < 1f)
{
driven.GetGlobalTR(stream, out Vector3 currentWPos, out Quaternion currentWRot);
accumTx.translation += currentWPos * (1f - accumWeights);
accumTx.rotation = Quaternion.Lerp(currentWRot, accumTx.rotation, accumWeights);
}
// Convert accumTx to local space
if (drivenParent.IsValid(stream))
{
drivenParent.GetGlobalTR(stream, out Vector3 parentWPos, out Quaternion parentWRot);
var parentTx = new AffineTransform(parentWPos, parentWRot);
accumTx = parentTx.InverseMul(accumTx);
}
driven.GetLocalTRS(stream, out Vector3 currentLPos, out Quaternion currentLRot, out Vector3 currentLScale);
if (Vector3.Dot(positionAxesMask, positionAxesMask) < 3f)
{
accumTx.translation = AnimationRuntimeUtils.Lerp(currentLPos, accumTx.translation, positionAxesMask);
}
if (Vector3.Dot(rotationAxesMask, rotationAxesMask) < 3f)
{
accumTx.rotation = Quaternion.Euler(AnimationRuntimeUtils.Lerp(currentLRot.eulerAngles, accumTx.rotation.eulerAngles, rotationAxesMask));
}
driven.SetLocalTRS(
stream,
Vector3.Lerp(currentLPos, accumTx.translation, w),
Quaternion.Lerp(currentLRot, accumTx.rotation, w),
currentLScale
);
}
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)
{
AffineTransform overrideTx;
if (source.IsValid(stream))
{
source.GetLocalTRS(stream, out Vector3 srcLPos, out Quaternion srcLRot, out _);
var sourceLocalTx = new AffineTransform(srcLPos, srcLRot);
var sourceToSpaceRot = cache.Get <Quaternion>(sourceToCurrSpaceRotIdx);
overrideTx = Quaternion.Inverse(sourceToSpaceRot) * (sourceInvLocalBindTx * sourceLocalTx) * sourceToSpaceRot;
}
else
{
overrideTx = new AffineTransform(position.Get(stream), Quaternion.Euler(rotation.Get(stream)));
}
Space overrideSpace = (Space)cache.GetRaw(spaceIdx);
var posW = positionWeight.Get(stream) * w;
var rotW = rotationWeight.Get(stream) * w;
switch (overrideSpace)
{
case Space.World:
{
driven.GetGlobalTR(stream, out Vector3 drivenWPos, out Quaternion drivenWRot);
driven.SetGlobalTR(
stream,
Vector3.Lerp(drivenWPos, overrideTx.translation, posW),
Quaternion.Lerp(drivenWRot, overrideTx.rotation, rotW)
);
}
break;
case Space.Local:
{
driven.GetLocalTRS(stream, out Vector3 drivenLPos, out Quaternion drivenLRot, out Vector3 drivenLScale);
driven.SetLocalTRS(
stream,
Vector3.Lerp(drivenLPos, overrideTx.translation, posW),
Quaternion.Lerp(drivenLRot, overrideTx.rotation, rotW),
drivenLScale
);
}
break;
case Space.Pivot:
{
driven.GetLocalTRS(stream, out Vector3 drivenLPos, out Quaternion drivenLRot, out Vector3 drivenLScale);
var drivenLocalTx = new AffineTransform(drivenLPos, drivenLRot);
overrideTx = drivenLocalTx * overrideTx;
driven.SetLocalTRS(
stream,
Vector3.Lerp(drivenLocalTx.translation, overrideTx.translation, posW),
Quaternion.Lerp(drivenLocalTx.rotation, overrideTx.rotation, rotW),
drivenLScale
);
}
break;
default:
break;
}
}
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);
}
}