/// <inheritdoc />
public override MultiAimConstraintJob Create(Animator animator, ref T data, Component component)
{
var job = new MultiAimConstraintJob();
job.driven = ReadWriteTransformHandle.Bind(animator, data.constrainedObject);
job.drivenParent = ReadOnlyTransformHandle.Bind(animator, data.constrainedObject.parent);
job.aimAxis = data.aimAxis;
job.upAxis = data.upAxis;
job.worldUpType = (MultiAimConstraintJob.WorldUpType)data.worldUpType;
job.worldUpAxis = data.worldUpAxis;
job.worldUpObject = ReadOnlyTransformHandle.Bind(animator, data.worldUpObject);
WeightedTransformArray sourceObjects = data.sourceObjects;
WeightedTransformArrayBinder.BindReadOnlyTransforms(animator, component, sourceObjects, out job.sourceTransforms);
WeightedTransformArrayBinder.BindWeights(animator, component, sourceObjects, data.sourceObjectsProperty, out job.sourceWeights);
job.sourceOffsets = new NativeArray <Quaternion>(sourceObjects.Count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
job.weightBuffer = new NativeArray <float>(sourceObjects.Count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
for (int i = 0; i < sourceObjects.Count; ++i)
{
if (data.maintainOffset)
{
var constrainedAim = data.constrainedObject.rotation * data.aimAxis;
job.sourceOffsets[i] = QuaternionExt.FromToRotation(
sourceObjects[i].transform.position - data.constrainedObject.position,
constrainedAim
);
}
else
{
job.sourceOffsets[i] = Quaternion.identity;
}
}
job.minLimit = FloatProperty.Bind(animator, component, data.minLimitFloatProperty);
job.maxLimit = FloatProperty.Bind(animator, component, data.maxLimitFloatProperty);
job.drivenOffset = Vector3Property.Bind(animator, component, data.offsetVector3Property);
job.axesMask = new Vector3(
System.Convert.ToSingle(data.constrainedXAxis),
System.Convert.ToSingle(data.constrainedYAxis),
System.Convert.ToSingle(data.constrainedZAxis)
);
return(job);
}
public override MultiAimConstraintJob Create(Animator animator, ref T data)
{
var job = new MultiAimConstraintJob();
var cacheBuilder = new AnimationJobCacheBuilder();
job.driven = TransformHandle.Bind(animator, data.constrainedObject);
job.drivenParent = TransformHandle.Bind(animator, data.constrainedObject.parent);
job.drivenOffset = cacheBuilder.Add(data.offset);
job.limitsIdx = cacheBuilder.Add(data.limits);
job.aimAxis = data.aimAxis;
var src = data.sourceObjects;
var srcWeights = data.sourceWeights;
job.sources = new NativeArray <TransformHandle>(src.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
job.sourceOffsets = new NativeArray <Quaternion>(src.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
job.sourceWeightStartIdx = cacheBuilder.AllocateChunk(src.Length);
for (int i = 0; i < src.Length; ++i)
{
job.sources[i] = TransformHandle.Bind(animator, src[i]);
cacheBuilder.SetValue(job.sourceWeightStartIdx, i, srcWeights[i]);
if (data.maintainOffset)
{
var constrainedAim = data.constrainedObject.rotation * data.aimAxis;
job.sourceOffsets[i] = QuaternionExt.FromToRotation(
src[i].position - data.constrainedObject.position,
constrainedAim
);
}
else
{
job.sourceOffsets[i] = Quaternion.identity;
}
}
job.axesMask = new Vector3(
System.Convert.ToSingle(data.constrainedXAxis),
System.Convert.ToSingle(data.constrainedYAxis),
System.Convert.ToSingle(data.constrainedZAxis)
);
job.cache = cacheBuilder.Build();
return(job);
}
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 jobWeight = stream.GetInputWeight(0);
if (jobWeight > 0f)
{
for (int i = 0; i < chain.Length; ++i)
{
linkPositions[i] = chain[i].GetPosition(stream);
}
int tipIndex = chain.Length - 1;
if (AnimationRuntimeUtils.SolveFABRIK(linkPositions, linkLengths, target.GetPosition(stream) + targetOffset.translation,
cache.GetRaw(toleranceIdx), maxReach, (int)cache.GetRaw(maxIterationsIdx)))
{
var chainRWeight = cache.GetRaw(chainRotationWeightIdx) * jobWeight;
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];
chain[i].SetRotation(stream, QuaternionExt.FromToRotation(prevDir, newDir) * chain[i].GetRotation(stream));
}
}
chain[tipIndex].SetRotation(
stream,
Quaternion.Lerp(
chain[tipIndex].GetRotation(stream),
target.GetRotation(stream) * targetOffset.rotation,
cache.GetRaw(tipRotationWeightIdx) * jobWeight
)
);
}
else
{
for (int i = 0; i < chain.Length; ++i)
{
AnimationRuntimeUtils.PassThrough(stream, chain[i]);
}
}
}
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);
}
/// <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;
}
var worldUpVector = ComputeWorldUpVector(stream);
var upVector = AnimationRuntimeUtils.Select(Vector3.zero, upAxis, axesMask);
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;
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 fromDir = drivenLRot * aimAxis;
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
);
if (worldUpType != WorldUpType.None && Vector3.Dot(upVector, upVector) > k_Epsilon)
{
var wupProject = Vector3.Cross(Vector3.Cross(drivenParentInvRot * worldUpVector, toDir).normalized, toDir).normalized;
var rupProject = Vector3.Cross(Vector3.Cross(drivenLRot * rotToSource * upVector, toDir).normalized, toDir).normalized;
rotToSource = QuaternionExt.FromToRotation(rupProject, wupProject) * rotToSource;
}
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);
}
}
