public override HandConstraintJob Create(Animator animator, ref HandConstraintData data, Component component)
{
var job = new HandConstraintJob();
job.ProximalThumb = ReadWriteTransformHandle.Bind(animator, data.ProximalThumb);
job.IntermediateThumb = ReadWriteTransformHandle.Bind(animator, data.IntermediateThumb);
job.DistalThumb = ReadWriteTransformHandle.Bind(animator, data.DistalThumb);
job.ProximalIndex = ReadWriteTransformHandle.Bind(animator, data.ProximalIndex);
job.IntermediateIndex = ReadWriteTransformHandle.Bind(animator, data.IntermediateIndex);
job.DistalIndex = ReadWriteTransformHandle.Bind(animator, data.DistalIndex);
job.ProximalMiddle = ReadWriteTransformHandle.Bind(animator, data.ProximalMiddle);
job.IntermediateMiddle = ReadWriteTransformHandle.Bind(animator, data.IntermediateMiddle);
job.DistalMiddle = ReadWriteTransformHandle.Bind(animator, data.DistalMiddle);
job.ProximalRing = ReadWriteTransformHandle.Bind(animator, data.ProximalRing);
job.IntermediateRing = ReadWriteTransformHandle.Bind(animator, data.IntermediateRing);
job.DistalRing = ReadWriteTransformHandle.Bind(animator, data.DistalRing);
job.ProximalLittle = ReadWriteTransformHandle.Bind(animator, data.ProximalLittle);
job.IntermediateLittle = ReadWriteTransformHandle.Bind(animator, data.IntermediateLittle);
job.DistalLittle = ReadWriteTransformHandle.Bind(animator, data.DistalLittle);
job.ProximalThumbXRotationRange = data.ProximalThumbXRotationRange;
job.ProximalThumbZRotationRange = data.ProximalThumbZRotationRange;
job.IntermediateThumbXRotationRange = data.IntermediateThumbXRotationRange;
job.DistalThumbXRotationRange = data.DistalThumbXRotationRange;
job.ProximalIndexZRotationRange = data.ProximalIndexZRotationRange;
job.ProximalIndexYRotationRange = data.ProximalIndexYRotationRange;
job.IntermediateIndexZRotationRange = data.IntermediateIndexZRotationRange;
job.DistalIndexZRotationRange = data.DistalIndexZRotationRange;
job.ProximalMiddleZRotationRange = data.ProximalMiddleZRotationRange;
job.ProximalMiddleYRotationRange = data.ProximalMiddleYRotationRange;
job.IntermediateMiddleZRotationRange = data.IntermediateMiddleZRotationRange;
job.DistalMiddleZRotationRange = data.DistalMiddleZRotationRange;
job.ProximalRingZRotationRange = data.ProximalRingZRotationRange;
job.ProximalRingYRotationRange = data.ProximalRingYRotationRange;
job.IntermediateRingZRotationRange = data.IntermediateRingZRotationRange;
job.DistalRingZRotationRange = data.DistalRingZRotationRange;
job.ProximalLittleZRotationRange = data.ProximalLittleZRotationRange;
job.ProximalLittleYRotationRange = data.ProximalLittleYRotationRange;
job.IntermediateLittleZRotationRange = data.IntermediateLittleZRotationRange;
job.DistalLittleZRotationRange = data.DistalLittleZRotationRange;
job.thumbAmount = FloatProperty.Bind(animator, component, data.thumbAmountProperty);
job.indexAmount = FloatProperty.Bind(animator, component, data.indexAmountProperty);
job.middleAmount = FloatProperty.Bind(animator, component, data.middleAmountProperty);
job.ringAmount = FloatProperty.Bind(animator, component, data.ringAmountProperty);
job.littleAmount = FloatProperty.Bind(animator, component, data.littleAmountProperty);
job.allAmount = FloatProperty.Bind(animator, component, data.allAmountProperty);
job.spreadAmount = FloatProperty.Bind(animator, component, data.spreadAmountProperty);
return(job);
}
public void ProcessAnimation(AnimationStream stream)
{
jobWeight.Set(stream, 1f);
var drivenPos = driven.GetLocalPosition(stream);
var offset = drivenOffset.Get(stream);
var lPos = drivenPos - offset;
var parentTx = new AffineTransform();
if (drivenParent.IsValid(stream))
{
drivenParent.GetGlobalTR(stream, out Vector3 parentWPos, out Quaternion parentWRot);
parentTx = new AffineTransform(parentWPos, parentWRot);
}
var wPos = parentTx.Transform(lPos);
for (int i = 0; i < sourceTransforms.Length; ++i)
{
sourceWeights[i].SetFloat(stream, 1f);
ReadWriteTransformHandle sourceTransform = sourceTransforms[i];
sourceTransform.SetPosition(stream, wPos - sourceOffsets[i]);
// Required to update handles with binding info.
sourceTransforms[i] = sourceTransform;
}
}
public override FootIKConstraintJob Create(Animator animator, ref FootIKConstraintData data, Component component)
{
var job = new FootIKConstraintJob();
job.leftToe = ReadOnlyTransformHandle.Bind(animator, data.leftToe);
job.leftAnkle = ReadOnlyTransformHandle.Bind(animator, data.leftAnkle);
job.rightToe = ReadOnlyTransformHandle.Bind(animator, data.rightToe);
job.rightAnkle = ReadOnlyTransformHandle.Bind(animator, data.rightAnkle);
job.leftEffector = ReadWriteTransformHandle.Bind(animator, data.leftEffector);
job.rightEffector = ReadWriteTransformHandle.Bind(animator, data.rightEffector);
job.hips = ReadWriteTransformHandle.Bind(animator, data.hips);
job.weightShiftAngle = FloatProperty.Bind(animator, component, data.weightShiftAngleProperty);
job.weightShiftHorizontal = FloatProperty.Bind(animator, component, data.weightShiftHorizontalProperty);
job.weightShiftVertical = FloatProperty.Bind(animator, component, data.weightShiftVerticalProperty);
job.maxFootRotationOffset = FloatProperty.Bind(animator, component, data.maxFootRotationOffsetProperty);
job.ikOffset = Vector2Property.Bind(animator, component, data.ikOffsetProperty);
job.normalLeftFoot = Vector3Property.Bind(animator, component, data.normalLeftFootProperty);
job.normalRightFoot = Vector3Property.Bind(animator, component, data.normalRightFootProperty);
return(job);
}
public override TwoBoneIKInverseConstraintJob Create(Animator animator, ref T data, Component component)
{
var job = new TwoBoneIKInverseConstraintJob();
job.root = ReadOnlyTransformHandle.Bind(animator, data.root);
job.mid = ReadOnlyTransformHandle.Bind(animator, data.mid);
job.tip = ReadOnlyTransformHandle.Bind(animator, data.tip);
job.target = ReadWriteTransformHandle.Bind(animator, data.target);
if (data.hint != null)
{
job.hint = ReadWriteTransformHandle.Bind(animator, data.hint);
}
job.targetOffset = AffineTransform.identity;
if (data.maintainTargetPositionOffset)
{
job.targetOffset.translation = -(data.tip.position - data.target.position);
}
if (data.maintainTargetRotationOffset)
{
job.targetOffset.rotation = Quaternion.Inverse(data.tip.rotation) * data.target.rotation;
}
job.targetPositionWeight = FloatProperty.Bind(animator, component, data.targetPositionWeightFloatProperty);
job.targetRotationWeight = FloatProperty.Bind(animator, component, data.targetRotationWeightFloatProperty);
job.hintWeight = FloatProperty.Bind(animator, component, data.hintWeightFloatProperty);
job.linkLengths[0] = Vector3.Distance(data.root.position, data.mid.position);
job.linkLengths[1] = Vector3.Distance(data.mid.position, data.tip.position);
return(job);
}
/// <inheritdoc />
public override BlendConstraintJob Create(Animator animator, ref T data, Component component)
{
var job = new BlendConstraintJob();
job.driven = ReadWriteTransformHandle.Bind(animator, data.constrainedObject);
job.sourceA = ReadOnlyTransformHandle.Bind(animator, data.sourceObjectA);
job.sourceB = ReadOnlyTransformHandle.Bind(animator, data.sourceObjectB);
job.sourceAOffset = job.sourceBOffset = AffineTransform.identity;
if (data.maintainPositionOffsets)
{
var drivenPos = data.constrainedObject.position;
job.sourceAOffset.translation = drivenPos - data.sourceObjectA.position;
job.sourceBOffset.translation = drivenPos - data.sourceObjectB.position;
}
if (data.maintainRotationOffsets)
{
var drivenRot = data.constrainedObject.rotation;
job.sourceAOffset.rotation = Quaternion.Inverse(data.sourceObjectA.rotation) * drivenRot;
job.sourceBOffset.rotation = Quaternion.Inverse(data.sourceObjectB.rotation) * drivenRot;
}
job.blendPosition = BoolProperty.Bind(animator, component, data.blendPositionBoolProperty);
job.blendRotation = BoolProperty.Bind(animator, component, data.blendRotationBoolProperty);
job.positionWeight = FloatProperty.Bind(animator, component, data.positionWeightFloatProperty);
job.rotationWeight = FloatProperty.Bind(animator, component, data.rotationWeightFloatProperty);
return(job);
}
/// <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)
{
jobWeight.Set(stream, 1f);
var lRot = driven.GetLocalRotation(stream);
var offset = drivenOffset.Get(stream);
if (Vector3.Dot(offset, offset) > 0f)
{
lRot *= Quaternion.Inverse(Quaternion.Euler(offset));
}
var wRot = lRot;
if (drivenParent.IsValid(stream))
{
wRot = drivenParent.GetRotation(stream) * wRot;
}
for (int i = 0; i < sourceTransforms.Length; ++i)
{
sourceWeights[i].SetFloat(stream, 1f);
ReadWriteTransformHandle sourceTransform = sourceTransforms[i];
sourceTransform.SetRotation(stream, wRot * sourceOffsets[i]);
// Required to update handles with binding info.
sourceTransforms[i] = sourceTransform;
}
}
/// <inheritdoc />
public override DampedTransformJob Create(Animator animator, ref T data, Component component)
{
var job = new DampedTransformJob();
job.driven = ReadWriteTransformHandle.Bind(animator, data.constrainedObject);
job.source = ReadOnlyTransformHandle.Bind(animator, data.sourceObject);
var drivenTx = new AffineTransform(data.constrainedObject.position, data.constrainedObject.rotation);
var sourceTx = new AffineTransform(data.sourceObject.position, data.sourceObject.rotation);
job.localBindTx = sourceTx.InverseMul(drivenTx);
job.prevDrivenTx = drivenTx;
job.dampPosition = FloatProperty.Bind(animator, component, data.dampPositionFloatProperty);
job.dampRotation = FloatProperty.Bind(animator, component, data.dampRotationFloatProperty);
if (data.maintainAim && AnimationRuntimeUtils.SqrDistance(data.constrainedObject.position, data.sourceObject.position) > 0f)
{
job.aimBindAxis = Quaternion.Inverse(data.constrainedObject.rotation) * (sourceTx.translation - drivenTx.translation).normalized;
}
else
{
job.aimBindAxis = Vector3.zero;
}
return(job);
}
public override RoboticArmIKJob Create(Animator animator, ref RoboticArmIKData data, Component component)
{
var jointArray = new NativeArray <ReadWriteTransformHandle>(data.m_Joints.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
for (int i = 0; i < data.m_Joints.Length - 1; i++)
{
jointArray[i] = ReadWriteTransformHandle.Bind(animator, data.m_Joints[i]);
data.l[i] = Vector3.Distance(data.m_Joints[i + 1].position, data.m_Joints[i].position);
}
var thetaArray = new NativeArray <double>(data.theta.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
var lArray = new NativeArray <float>(data.l.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
for (int i = 0; i < data.l.Length; i++)
{
lArray[i] = data.l[i];
}
for (int i = 0; i < data.theta.Length; i++)
{
thetaArray[i] = data.theta[i];
}
return(new RoboticArmIKJob()
{
target = ReadWriteTransformHandle.Bind(animator, data.m_Target),
joints = jointArray,
theta = thetaArray,
l = lArray,
C3 = data.C3,
offset = data.m_Joints[1].position
});
}
public override HandConstraintJob Create(Animator animator, ref HandConstraintData data, Component component)
{
var job = new HandConstraintJob();
job.ProximalThumb = ReadWriteTransformHandle.Bind(animator, data.ProximalThumb);
job.IntermediateThumb = ReadWriteTransformHandle.Bind(animator, data.IntermediateThumb);
job.DistalThumb = ReadWriteTransformHandle.Bind(animator, data.DistalThumb);
job.ProximalIndex = ReadWriteTransformHandle.Bind(animator, data.ProximalIndex);
job.IntermediateIndex = ReadWriteTransformHandle.Bind(animator, data.IntermediateIndex);
job.DistalIndex = ReadWriteTransformHandle.Bind(animator, data.DistalIndex);
job.ProximalMiddle = ReadWriteTransformHandle.Bind(animator, data.ProximalMiddle);
job.IntermediateMiddle = ReadWriteTransformHandle.Bind(animator, data.IntermediateMiddle);
job.DistalMiddle = ReadWriteTransformHandle.Bind(animator, data.DistalMiddle);
job.ProximalRing = ReadWriteTransformHandle.Bind(animator, data.ProximalRing);
job.IntermediateRing = ReadWriteTransformHandle.Bind(animator, data.IntermediateRing);
job.DistalRing = ReadWriteTransformHandle.Bind(animator, data.DistalRing);
job.ProximalLittle = ReadWriteTransformHandle.Bind(animator, data.ProximalLittle);
job.IntermediateLittle = ReadWriteTransformHandle.Bind(animator, data.IntermediateLittle);
job.DistalLittle = ReadWriteTransformHandle.Bind(animator, data.DistalLittle);
job.ProximalThumbXRotationRange = data.ProximalThumbXRotationRange;
job.ProximalThumbZRotationRange = data.ProximalThumbZRotationRange;
job.IntermediateThumbXRotationRange = data.IntermediateThumbXRotationRange;
job.DistalThumbXRotationRange = data.DistalThumbXRotationRange;
job.ProximalIndexXRotationRange = data.ProximalIndexXRotationRange;
job.ProximalIndexZRotationRange = data.ProximalIndexZRotationRange;
job.IntermediateIndexXRotationRange = data.IntermediateIndexXRotationRange;
job.DistalIndexXRotationRange = data.DistalIndexXRotationRange;
job.ProximalMiddleXRotationRange = data.ProximalMiddleXRotationRange;
job.ProximalMiddleZRotationRange = data.ProximalMiddleZRotationRange;
job.IntermediateMiddleXRotationRange = data.IntermediateMiddleXRotationRange;
job.DistalMiddleXRotationRange = data.DistalMiddleXRotationRange;
job.ProximalRingXRotationRange = data.ProximalRingXRotationRange;
job.ProximalRingZRotationRange = data.ProximalRingZRotationRange;
job.IntermediateRingXRotationRange = data.IntermediateRingXRotationRange;
job.DistalRingXRotationRange = data.DistalRingXRotationRange;
job.ProximalLittleXRotationRange = data.ProximalLittleXRotationRange;
job.ProximalLittleZRotationRange = data.ProximalLittleZRotationRange;
job.IntermediateLittleXRotationRange = data.IntermediateLittleXRotationRange;
job.DistalLittleXRotationRange = data.DistalLittleXRotationRange;
job.ThumbHandle = ReadWriteTransformHandle.Bind(animator, data.ThumbHandle);
job.IndexHandle = ReadWriteTransformHandle.Bind(animator, data.IndexHandle);
job.MiddleHandle = ReadWriteTransformHandle.Bind(animator, data.MiddleHandle);
job.RingHandle = ReadWriteTransformHandle.Bind(animator, data.RingHandle);
job.LittleHandle = ReadWriteTransformHandle.Bind(animator, data.LittleHandle);
job.HandleA = ReadWriteTransformHandle.Bind(animator, data.HandleA);
job.HandleB = ReadWriteTransformHandle.Bind(animator, data.HandleB);
return(job);
}
/// <inheritdoc />
public override MultiReferentialInverseConstraintJob Create(Animator animator, ref T data, Component component)
{
var job = new MultiReferentialInverseConstraintJob();
var sources = data.sourceObjects;
job.sources = new NativeArray<ReadWriteTransformHandle>(sources.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
job.offsetTx = new NativeArray<AffineTransform>(sources.Length - 1, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
var sourceBindTx = new AffineTransform[sources.Length];
for (int i = 0; i < sources.Length; ++i)
{
job.sources[i] = ReadWriteTransformHandle.Bind(animator, sources[i].transform);
sourceBindTx[i] = new AffineTransform(sources[i].position, sources[i].rotation);
}
int offset = 0;
var invDriverTx = sourceBindTx[0].Inverse();
for (int i = 1; i < sourceBindTx.Length; ++i)
{
job.offsetTx[offset] = invDriverTx * sourceBindTx[i];
offset++;
}
return job;
}
public override HelloWorldJob Create(Animator animator, ref HelloWorldData data, Component component)
{
return(new HelloWorldJob()
{
constrained = ReadWriteTransformHandle.Bind(animator, data.constrainedObject),
source = ReadOnlyTransformHandle.Bind(animator, data.sourceObject)
});
}
public override PositionToRotationConstraintJob Create(Animator animator, ref PositionToRotationConstraintData data, Component component)
{
var job = new PositionToRotationConstraintJob();
job.constrained = ReadWriteTransformHandle.Bind(animator, data.constrainedObject);
job.source = ReadWriteTransformHandle.Bind(animator, data.sourceObject);
return(job);
}
public override RestrictMotionJob Create(Animator animator, ref T data, Component component)
{
var job = new RestrictMotionJob {
driven = ReadWriteTransformHandle.Bind(animator, data.ConstrainedObject),
minimumHeight = data.MinimumHeight
};
return(job);
}
public override OverrideTransformJob Create(Animator animator, ref T data, Component component)
{
var job = new OverrideTransformJob();
var cacheBuilder = new AnimationJobCacheBuilder();
job.driven = ReadWriteTransformHandle.Bind(animator, data.constrainedObject);
if (data.sourceObject != null)
{
// Cache source to possible space rotation offsets (world, local and pivot)
// at bind time so we can switch dynamically between them at runtime.
job.source = ReadOnlyTransformHandle.Bind(animator, data.sourceObject);
var sourceLocalTx = new AffineTransform(data.sourceObject.localPosition, data.sourceObject.localRotation);
job.sourceInvLocalBindTx = sourceLocalTx.Inverse();
var sourceWorldTx = new AffineTransform(data.sourceObject.position, data.sourceObject.rotation);
var drivenWorldTx = new AffineTransform(data.constrainedObject.position, data.constrainedObject.rotation);
job.sourceToWorldRot = sourceWorldTx.Inverse().rotation;
job.sourceToPivotRot = sourceWorldTx.InverseMul(drivenWorldTx).rotation;
var drivenParent = data.constrainedObject.parent;
if (drivenParent != null)
{
var drivenParentWorldTx = new AffineTransform(drivenParent.position, drivenParent.rotation);
job.sourceToLocalRot = sourceWorldTx.InverseMul(drivenParentWorldTx).rotation;
}
else
{
job.sourceToLocalRot = job.sourceToPivotRot;
}
}
job.spaceIdx = cacheBuilder.Add(data.space);
if (data.space == (int)OverrideTransformJob.Space.Pivot)
{
job.sourceToCurrSpaceRotIdx = cacheBuilder.Add(job.sourceToPivotRot);
}
else if (data.space == (int)OverrideTransformJob.Space.Local)
{
job.sourceToCurrSpaceRotIdx = cacheBuilder.Add(job.sourceToLocalRot);
}
else
{
job.sourceToCurrSpaceRotIdx = cacheBuilder.Add(job.sourceToWorldRot);
}
job.position = Vector3Property.Bind(animator, component, data.positionVector3Property);
job.rotation = Vector3Property.Bind(animator, component, data.rotationVector3Property);
job.positionWeight = FloatProperty.Bind(animator, component, data.positionWeightFloatProperty);
job.rotationWeight = FloatProperty.Bind(animator, component, data.rotationWeightFloatProperty);
job.cache = cacheBuilder.Build();
return(job);
}
public override CopyLocationStep0Job Create(Animator animator, ref CopyLocationStep0Data data, Component component)
{
return(new CopyLocationStep0Job()
{
constrained = ReadWriteTransformHandle.Bind(animator, data.constrainedObject),
source = ReadOnlyTransformHandle.Bind(animator, data.sourceObject)
// TODO : Update binder code to add our new toggles
});
}
public override CopyLocationJob Create(Animator animator, ref CopyLocationData data, Component component)
{
return(new CopyLocationJob()
{
constrained = ReadWriteTransformHandle.Bind(animator, data.constrainedObject),
source = ReadOnlyTransformHandle.Bind(animator, data.sourceObject),
// Bind data.invert to job.invert so values can be resolved from the AnimationStream
invert = Vector3BoolProperty.Bind(animator, component, PropertyUtils.ConstructConstraintDataPropertyName(nameof(data.invert)))
});
}
public override TwistChainInverseConstraintJob Create(Animator animator, ref T data, Component component)
{
var job = new TwistChainInverseConstraintJob();
job.root = ReadOnlyTransformHandle.Bind(animator, data.root);
job.tip = ReadOnlyTransformHandle.Bind(animator, data.tip);
job.rootTarget = ReadWriteTransformHandle.Bind(animator, data.rootTarget);
job.tipTarget = ReadWriteTransformHandle.Bind(animator, data.tipTarget);
return(job);
}
/// <summary>
/// Create a ReadWriteTransformHandle representing the new binding between the Animator and a Transform already bound to the Animator.
/// </summary>
/// <param name="animator">The Animator on which to bind the new handle.</param>
/// <param name="transform">The Transform to bind.</param>
/// <returns>Returns the ReadWriteTransformHandle that represents the new binding.</returns>
public static ReadWriteTransformHandle Bind(Animator animator, Transform transform)
{
ReadWriteTransformHandle handle = new ReadWriteTransformHandle();
if (transform == null || !transform.IsChildOf(animator.transform))
{
return(handle);
}
handle.m_Handle = animator.BindStreamTransform(transform);
return(handle);
}
public override RotationBlendSliderConstraintJob Create(Animator animator, ref RotationBlendSliderConstraintData data, Component component)
{
var job = new RotationBlendSliderConstraintJob();
job.Target = ReadWriteTransformHandle.Bind(animator, data.Target);
job.SourceA = ReadOnlyTransformHandle.Bind(animator, data.SourceA);
job.SourceB = ReadOnlyTransformHandle.Bind(animator, data.SourceB);
job.Slider = ReadWriteTransformHandle.Bind(animator, data.Slider);
return(job);
}
public override FootIKConstraintJob Create(Animator animator, ref FootIKConstraintData data, Component component)
{
var job = new FootIKConstraintJob();
job.FootIKTarget = ReadWriteTransformHandle.Bind(animator, data.FootIKTarget);
job.FootControllerBase = ReadOnlyTransformHandle.Bind(animator, data.FootControllerBase);
job.FootRollCursor = ReadWriteTransformHandle.Bind(animator, data.FootRollCursor);
job.ToeEnd = ReadOnlyTransformHandle.Bind(animator, data.ToeEnd);
job.FootHeel = ReadOnlyTransformHandle.Bind(animator, data.FootHeel);
job.FootLeftSide = ReadOnlyTransformHandle.Bind(animator, data.FootLeftSide);
job.FootRightSide = ReadOnlyTransformHandle.Bind(animator, data.FootRightSide);
return(job);
}
public override PBDBonesJob Create(Animator animator, ref T data, Component component)
{
var job = new PBDBonesJob {
boneChain = new NativeArray <ReadWriteTransformHandle>(data.BoneChain.Length, Allocator.Persistent),
restLengths = new NativeArray <float>(data.BoneChain.Length - 1, Allocator.Persistent),
tipTarget = ReadOnlyTransformHandle.Bind(animator, data.TipTarget),
minimumHeight = data.MinimumHeight,
iterationCount = data.IterationCount
};
for (var i = 0; i < data.BoneChain.Length; i++)
{
job.boneChain[i] = ReadWriteTransformHandle.Bind(animator, data.BoneChain[i]);
}
for (var i = 0; i < data.BoneChain.Length - 1; i++)
{
job.restLengths[i] = distance(data.BoneChain[i].position, data.BoneChain[i + 1].position);
}
return(job);
}
public override RemapTransformJob Create(Animator animator, ref RemapTransformData data, Component component)
{
Vector2[] fromRange = new Vector2[] { data.fromXRange, data.fromYRange, data.fromZRange };
return(new RemapTransformJob()
{
destination = ReadWriteTransformHandle.Bind(animator, data.destinationObject),
source = ReadOnlyTransformHandle.Bind(animator, data.sourceObject),
sourceMapping = data.sourceMapping,
destinationMapping = data.destinationMapping,
offsetPos = data.destinationObject.localPosition,
offsetRot = data.destinationObject.localEulerAngles,
lastRotation = data.sourceObject.localEulerAngles,
extrapolate = data.m_Extrapolate,
toX = Convert(data.toX),
toY = Convert(data.toY),
toZ = Convert(data.toZ),
xMapping = math.abs(fromRange[(int)data.toX].x - fromRange[(int)data.toX].y) > 0 ? new float4(fromRange[(int)data.toX].x, fromRange[(int)data.toX].y, data.toXRange.x, data.toXRange.y) : new float4(0, 0, 0, 0),
yMapping = math.abs(fromRange[(int)data.toY].x - fromRange[(int)data.toY].y) > 0 ? new float4(fromRange[(int)data.toY].x, fromRange[(int)data.toY].y, data.toYRange.x, data.toYRange.y) : new float4(0, 0, 0, 0),
zMapping = math.abs(fromRange[(int)data.toZ].x - fromRange[(int)data.toZ].y) > 0 ? new float4(fromRange[(int)data.toZ].x, fromRange[(int)data.toZ].y, data.toZRange.x, data.toZRange.y) : new float4(0, 0, 0, 0)
});
}
public override TwoBoneIKFKConstraintJob Create(Animator animator, ref TwoBoneIKFKConstraintData data, Component component)
{
var job = new TwoBoneIKFKConstraintJob();
job.Root = ReadWriteTransformHandle.Bind(animator, data.Root);
job.Mid = ReadWriteTransformHandle.Bind(animator, data.Mid);
job.Tip = ReadWriteTransformHandle.Bind(animator, data.Tip);
job.IK_Target = ReadOnlyTransformHandle.Bind(animator, data.IK_Target);
if (data.IK_Hint != null)
{
job.IK_Hint = ReadOnlyTransformHandle.Bind(animator, data.IK_Hint);
}
job.FK_Root = ReadOnlyTransformHandle.Bind(animator, data.FK_Root);
job.FK_Mid = ReadOnlyTransformHandle.Bind(animator, data.FK_Mid);
job.Slider = ReadWriteTransformHandle.Bind(animator, data.Slider);
job.LinkLengths[0] = Vector3.Distance(data.Root.position, data.Mid.position);
job.LinkLengths[1] = Vector3.Distance(data.Mid.position, data.Tip.position);
return(job);
}
