| public GetEffector ( FullBodyBipedEffector effector ) : RootMotion.FinalIK.IKEffector | ||
| effector | FullBodyBipedEffector | |
| Résultat | RootMotion.FinalIK.IKEffector | |
public Transform target; // The target
#endregion Fields
#region Methods
// Update IK position, rotation and weight
public void Update(IKSolverFullBodyBiped solver, float weight)
{
solver.GetEffector(effector).position = target.position;
solver.GetEffector(effector).rotation = target.rotation;
solver.GetEffector(effector).positionWeight = positionWeight * weight;
solver.GetEffector(effector).rotationWeight = rotationWeight * weight;
}
public void Apply(IKSolverFullBodyBiped solver, float weight, Quaternion rotation)
{
solver.GetEffector(this.effector).positionOffset += rotation * this.offset * weight;
Vector3 a = solver.GetRoot().position + rotation * this.pin;
Vector3 vector = a - solver.GetEffector(this.effector).bone.position;
Vector3 vector2 = this.pinWeight * Mathf.Abs(weight);
solver.GetEffector(this.effector).positionOffset = new Vector3(Mathf.Lerp(solver.GetEffector(this.effector).positionOffset.x, vector.x, vector2.x), Mathf.Lerp(solver.GetEffector(this.effector).positionOffset.y, vector.y, vector2.y), Mathf.Lerp(solver.GetEffector(this.effector).positionOffset.z, vector.z, vector2.z));
}
// Update this body, apply the offset to the effector
public void Update(IKSolverFullBodyBiped solver, float weight, float deltaTime)
{
if (transform == null)
{
return;
}
// If first update, set this body to Transform
if (firstUpdate)
{
Reset();
firstUpdate = false;
}
// Acceleration
direction = Vector3.Lerp(direction, ((transform.position - lazyPoint) / deltaTime) * 0.01f, deltaTime * acceleration);
// Lazy follow
lazyPoint += direction * deltaTime * speed;
// Match velocity
delta = transform.position - lastPosition;
lazyPoint += delta * matchVelocity;
// Gravity
lazyPoint.y += gravity * deltaTime;
// Apply position offset to the effector
foreach (EffectorLink effectorLink in effectorLinks)
{
solver.GetEffector(effectorLink.effector).positionOffset += (lazyPoint - transform.position) * effectorLink.weight * weight;
}
lastPosition = transform.position;
}
// Update the Body
public void Update(IKSolverFullBodyBiped solver, float w, float deltaTime) {
if (transform == null || relativeTo == null) return;
// Find the relative position of the transform
Vector3 relativePos = relativeTo.InverseTransformDirection(transform.position - relativeTo.position);
// Initiating
if (firstUpdate) {
lastRelativePos = relativePos;
firstUpdate = false;
}
// Find how much the relative position has changed
Vector3 delta = (relativePos - lastRelativePos) / deltaTime;
// Smooth the change
smoothDelta = speed <= 0f? delta: Vector3.Lerp(smoothDelta, delta, deltaTime * speed);
// Convert to world space
Vector3 worldDelta = relativeTo.TransformDirection(smoothDelta);
// Extract horizontal and vertical offset
Vector3 offset = V3Tools.ExtractVertical(worldDelta, solver.GetRoot().up, verticalWeight) + V3Tools.ExtractHorizontal(worldDelta, solver.GetRoot().up, horizontalWeight);
// Apply the amplitude to the effector links
for (int i = 0; i < effectorLinks.Length; i++) {
solver.GetEffector(effectorLinks[i].effector).positionOffset += offset * w * effectorLinks[i].weight;
}
lastRelativePos = relativePos;
}
public void Update(IKSolverFullBodyBiped solver, float w, float deltaTime)
{
if (this.transform == null || this.relativeTo == null)
{
return;
}
Vector3 a = this.relativeTo.InverseTransformDirection(this.transform.position - this.relativeTo.position);
if (this.firstUpdate)
{
this.lastRelativePos = a;
this.firstUpdate = false;
}
Vector3 vector = (a - this.lastRelativePos) / deltaTime;
this.smoothDelta = ((this.speed > 0f) ? Vector3.Lerp(this.smoothDelta, vector, deltaTime * this.speed) : vector);
Vector3 v = this.relativeTo.TransformDirection(this.smoothDelta);
Vector3 a2 = V3Tools.ExtractVertical(v, solver.GetRoot().up, this.verticalWeight) + V3Tools.ExtractHorizontal(v, solver.GetRoot().up, this.horizontalWeight);
for (int i = 0; i < this.effectorLinks.Length; i++)
{
solver.GetEffector(this.effectorLinks[i].effector).positionOffset += a2 * w * this.effectorLinks[i].weight;
}
this.lastRelativePos = a;
}
// Apply offset to FBBIK effectors
public void Apply(IKSolverFullBodyBiped solver, Quaternion rotation, float masterWeight)
{
foreach (EffectorLink e in effectorLinks)
{
solver.GetEffector(e.effector).positionOffset += rotation * (offset * masterWeight * e.weight);
}
}
// Update this body, apply the offset to the effector
public void Update(IKSolverFullBodyBiped solver, float weight, float deltaTime) {
if (transform == null) return;
// If first update, set this body to Transform
if (firstUpdate) {
Reset();
firstUpdate = false;
}
// Acceleration
direction = Vector3.Lerp(direction, ((transform.position - lazyPoint) / deltaTime) * 0.01f, deltaTime * acceleration);
// Lazy follow
lazyPoint += direction * deltaTime * speed;
// Match velocity
delta = transform.position - lastPosition;
lazyPoint += delta * matchVelocity;
// Gravity
lazyPoint.y += gravity * deltaTime;
// Apply position offset to the effector
foreach (EffectorLink effectorLink in effectorLinks) {
solver.GetEffector(effectorLink.effector).positionOffset += (lazyPoint - transform.position) * effectorLink.weight * weight;
}
lastPosition = transform.position;
}
// Apply offset to FBBIK effectors
public void Apply(IKSolverFullBodyBiped solver, Quaternion rotation, float masterWeight, float length, float timeLeft) {
additiveOffset = Vector3.Lerp(Vector3.zero, additiveOffset, timeLeft / length);
lastOffset = (rotation * (offset * masterWeight)) + (rotation * additiveOffset);
foreach (EffectorLink e in effectorLinks) {
solver.GetEffector(e.effector).positionOffset += lastOffset * e.weight;
}
}
// Apply the curve to the specified solver, effector, with the value and weight.
private void Apply(IKSolverFullBodyBiped solver, FullBodyBipedEffector effector, WeightCurve.Type type, float value, float weight)
{
switch (type)
{
case WeightCurve.Type.PositionWeight:
solver.GetEffector(effector).positionWeight = Mathf.Lerp(solver.GetEffector(effector).positionWeight, value, weight);
return;
case WeightCurve.Type.RotationWeight:
solver.GetEffector(effector).rotationWeight = Mathf.Lerp(solver.GetEffector(effector).rotationWeight, value, weight);
return;
case WeightCurve.Type.PositionOffsetX:
solver.GetEffector(effector).position += solver.GetRoot().rotation *Vector3.right *value *weight;
return;
case WeightCurve.Type.PositionOffsetY:
solver.GetEffector(effector).position += solver.GetRoot().rotation *Vector3.up *value *weight;
return;
case WeightCurve.Type.PositionOffsetZ:
solver.GetEffector(effector).position += solver.GetRoot().rotation *Vector3.forward *value *weight;
return;
case WeightCurve.Type.Pull:
solver.GetChain(effector).pull = Mathf.Lerp(solver.GetChain(effector).pull, value, weight);
return;
case WeightCurve.Type.Reach:
solver.GetChain(effector).reach = Mathf.Lerp(solver.GetChain(effector).reach, value, weight);
return;
}
}
public void Apply(IKSolverFullBodyBiped solver, Quaternion rotation, float masterWeight, float length, float timeLeft)
{
this.additiveOffset = Vector3.Lerp(Vector3.zero, this.additiveOffset, timeLeft / length);
this.lastOffset = rotation * (this.offset * masterWeight) + rotation * this.additiveOffset;
foreach (Recoil.RecoilOffset.EffectorLink effectorLink in this.effectorLinks)
{
solver.GetEffector(effectorLink.effector).positionOffset += this.lastOffset * effectorLink.weight;
}
}
// Apply offset to FBBIK effectors
public void Apply(IKSolverFullBodyBiped solver, Quaternion rotation, float masterWeight, float length, float timeLeft)
{
additiveOffset = Vector3.Lerp(Vector3.zero, additiveOffset, timeLeft / length);
lastOffset = (rotation * (offset * masterWeight)) + (rotation * additiveOffset);
foreach (EffectorLink e in effectorLinks)
{
solver.GetEffector(e.effector).positionOffset += lastOffset * e.weight;
}
}
// Initiate this, get the default values
public void Initiate(IKSolverFullBodyBiped solver)
{
// Find the effector if we haven't already
if (effector == null)
{
effector = solver.GetEffector(effectorType);
poser = effector.bone.GetComponent <Poser>();
}
defaultPull = solver.GetChain(effectorType).pull;
defaultReach = solver.GetChain(effectorType).reach;
}
public void Initiate(InteractionSystem interactionSystem, IKSolverFullBodyBiped solver)
{
this.interactionSystem = interactionSystem;
if (this.effector == null)
{
this.effector = solver.GetEffector(this.effectorType);
this.poser = this.effector.bone.GetComponent <Poser>();
}
this.defaultPull = solver.GetChain(this.effectorType).pull;
this.defaultReach = solver.GetChain(this.effectorType).reach;
this.defaultPush = solver.GetChain(this.effectorType).push;
this.defaultPushParent = solver.GetChain(this.effectorType).pushParent;
}
// Initiate this, get the default values
public void Initiate(InteractionSystem interactionSystem, IKSolverFullBodyBiped solver) {
this.interactionSystem = interactionSystem;
// Find the effector if we haven't already
if (effector == null) {
effector = solver.GetEffector(effectorType);
poser = effector.bone.GetComponent<Poser>();
}
defaultPull = solver.GetChain(effectorType).pull;
defaultReach = solver.GetChain(effectorType).reach;
defaultPush = solver.GetChain(effectorType).push;
defaultPushParent = solver.GetChain(effectorType).pushParent;
}
// Apply the curve to the specified solver, effector, with the value and weight.
private void Apply(IKSolverFullBodyBiped solver, FullBodyBipedEffector effector, WeightCurve.Type type, float value, float weight)
{
switch (type)
{
case WeightCurve.Type.PositionWeight:
solver.GetEffector(effector).positionWeight = Mathf.Lerp(solver.GetEffector(effector).positionWeight, value, weight);
return;
case WeightCurve.Type.RotationWeight:
solver.GetEffector(effector).rotationWeight = Mathf.Lerp(solver.GetEffector(effector).rotationWeight, value, weight);
return;
case WeightCurve.Type.PositionOffsetX:
Vector3 xOffset = (positionOffsetSpace != null ? positionOffsetSpace.rotation : solver.GetRoot().rotation) * Vector3.right * value;
solver.GetEffector(effector).position += xOffset * weight;
//solver.GetEffector(effector).positionOffset += xOffset;
return;
case WeightCurve.Type.PositionOffsetY:
Vector3 yOffset = (positionOffsetSpace != null ? positionOffsetSpace.rotation : solver.GetRoot().rotation) * Vector3.up * value;
solver.GetEffector(effector).position += yOffset * weight;
//solver.GetEffector(effector).positionOffset += yOffset;
return;
case WeightCurve.Type.PositionOffsetZ:
Vector3 zOffset = (positionOffsetSpace != null ? positionOffsetSpace.rotation : solver.GetRoot().rotation) * Vector3.forward * value;
solver.GetEffector(effector).position += zOffset * weight;
//solver.GetEffector(effector).positionOffset += zOffset;
return;
case WeightCurve.Type.Pull:
solver.GetChain(effector).pull = Mathf.Lerp(solver.GetChain(effector).pull, value, weight);
return;
case WeightCurve.Type.Reach:
solver.GetChain(effector).reach = Mathf.Lerp(solver.GetChain(effector).reach, value, weight);
return;
case WeightCurve.Type.Push:
solver.GetChain(effector).push = Mathf.Lerp(solver.GetChain(effector).push, value, weight);
return;
case WeightCurve.Type.PushParent:
solver.GetChain(effector).pushParent = Mathf.Lerp(solver.GetChain(effector).pushParent, value, weight);
return;
case WeightCurve.Type.BendGoalWeight:
solver.GetChain(effector).bendConstraint.weight = Mathf.Lerp(solver.GetChain(effector).bendConstraint.weight, value, weight);
return;
}
}
// Initiate this, get the default values
public void Initiate(InteractionSystem interactionSystem, IKSolverFullBodyBiped solver)
{
this.interactionSystem = interactionSystem;
// Find the effector if we haven't already
if (effector == null)
{
effector = solver.GetEffector(effectorType);
poser = effector.bone.GetComponent <Poser>();
}
defaultPull = solver.GetChain(effectorType).pull;
defaultReach = solver.GetChain(effectorType).reach;
defaultPush = solver.GetChain(effectorType).push;
defaultPushParent = solver.GetChain(effectorType).pushParent;
}
public void Solve(IKSolverFullBodyBiped solver, float weight)
{
// Get the offset to interpolate to
offsetTarget = GetOffsetTarget(solver);
// Interpolating the offset value
float smoothDampTime = offsetTarget.sqrMagnitude > offset.sqrMagnitude? smoothTimeIn: smoothTimeOut;
offset = Vector3.SmoothDamp(offset, offsetTarget, ref offsetV, smoothDampTime);
// Apply offset to the FBBIK effectors
foreach (EffectorLink link in effectors)
{
solver.GetEffector(link.effector).positionOffset += offset * weight * link.weight;
}
}
private void Apply(IKSolverFullBodyBiped solver, FullBodyBipedEffector effector, InteractionObject.WeightCurve.Type type, float value, float weight)
{
switch (type)
{
case InteractionObject.WeightCurve.Type.PositionWeight:
solver.GetEffector(effector).positionWeight = Mathf.Lerp(solver.GetEffector(effector).positionWeight, value, weight);
return;
case InteractionObject.WeightCurve.Type.RotationWeight:
solver.GetEffector(effector).rotationWeight = Mathf.Lerp(solver.GetEffector(effector).rotationWeight, value, weight);
return;
case InteractionObject.WeightCurve.Type.PositionOffsetX:
solver.GetEffector(effector).position += ((this.positionOffsetSpace != null) ? this.positionOffsetSpace.rotation : solver.GetRoot().rotation) * Vector3.right * value * weight;
return;
case InteractionObject.WeightCurve.Type.PositionOffsetY:
solver.GetEffector(effector).position += ((this.positionOffsetSpace != null) ? this.positionOffsetSpace.rotation : solver.GetRoot().rotation) * Vector3.up * value * weight;
return;
case InteractionObject.WeightCurve.Type.PositionOffsetZ:
solver.GetEffector(effector).position += ((this.positionOffsetSpace != null) ? this.positionOffsetSpace.rotation : solver.GetRoot().rotation) * Vector3.forward * value * weight;
return;
case InteractionObject.WeightCurve.Type.Pull:
solver.GetChain(effector).pull = Mathf.Lerp(solver.GetChain(effector).pull, value, weight);
return;
case InteractionObject.WeightCurve.Type.Reach:
solver.GetChain(effector).reach = Mathf.Lerp(solver.GetChain(effector).reach, value, weight);
return;
case InteractionObject.WeightCurve.Type.RotateBoneWeight:
return;
case InteractionObject.WeightCurve.Type.Push:
solver.GetChain(effector).push = Mathf.Lerp(solver.GetChain(effector).push, value, weight);
return;
case InteractionObject.WeightCurve.Type.PushParent:
solver.GetChain(effector).pushParent = Mathf.Lerp(solver.GetChain(effector).pushParent, value, weight);
return;
default:
return;
}
}
public void Update(IKSolverFullBodyBiped solver, float weight, float deltaTime)
{
if (this.transform == null)
{
return;
}
if (this.firstUpdate)
{
this.Reset();
this.firstUpdate = false;
}
this.direction = Vector3.Lerp(this.direction, (this.transform.position - this.lazyPoint) / deltaTime * 0.01f, deltaTime * this.acceleration);
this.lazyPoint += this.direction * deltaTime * this.speed;
this.delta = this.transform.position - this.lastPosition;
this.lazyPoint += this.delta * this.matchVelocity;
this.lazyPoint.y = this.lazyPoint.y + this.gravity * deltaTime;
foreach (Inertia.Body.EffectorLink effectorLink in this.effectorLinks)
{
solver.GetEffector(effectorLink.effector).positionOffset += (this.lazyPoint - this.transform.position) * effectorLink.weight * weight;
}
this.lastPosition = this.transform.position;
}
public Vector3 pinWeight; // Pin weight vector
// Apply positionOffset to the effector
public void Apply(IKSolverFullBodyBiped solver, float weight, Quaternion rotation) {
// Offset
solver.GetEffector(effector).positionOffset += rotation * offset * weight;
// Calculating pinned position
Vector3 pinPosition = solver.GetRoot().position + rotation * pin;
Vector3 pinPositionOffset = pinPosition - solver.GetEffector(effector).bone.position;
Vector3 pinWeightVector = pinWeight * Mathf.Abs(weight);
// Lerping to pinned position
solver.GetEffector(effector).positionOffset = new Vector3(
Mathf.Lerp(solver.GetEffector(effector).positionOffset.x, pinPositionOffset.x, pinWeightVector.x),
Mathf.Lerp(solver.GetEffector(effector).positionOffset.y, pinPositionOffset.y, pinWeightVector.y),
Mathf.Lerp(solver.GetEffector(effector).positionOffset.z, pinPositionOffset.z, pinWeightVector.z)
);
}
// Update the Body
public void Update(IKSolverFullBodyBiped solver, float w, float deltaTime)
{
if (transform == null || relativeTo == null)
{
return;
}
// Find the relative position of the transform
Vector3 relativePos = relativeTo.InverseTransformDirection(transform.position - relativeTo.position);
// Initiating
if (firstUpdate)
{
lastRelativePos = relativePos;
firstUpdate = false;
}
// Find how much the relative position has changed
Vector3 delta = (relativePos - lastRelativePos) / deltaTime;
// Smooth the change
smoothDelta = speed <= 0f? delta: Vector3.Lerp(smoothDelta, delta, deltaTime * speed);
// Convert to world space
Vector3 worldDelta = relativeTo.TransformDirection(smoothDelta);
// Extract horizontal and vertical offset
Vector3 offset = V3Tools.ExtractVertical(worldDelta, solver.GetRoot().up, verticalWeight) + V3Tools.ExtractHorizontal(worldDelta, solver.GetRoot().up, horizontalWeight);
// Apply the amplitude to the effector links
for (int i = 0; i < effectorLinks.Length; i++)
{
solver.GetEffector(effectorLinks[i].effector).positionOffset += offset * w * effectorLinks[i].weight;
}
lastRelativePos = relativePos;
}
public Vector3 pinWeight; // Pin weight vector
// Apply positionOffset to the effector
public void Apply(IKSolverFullBodyBiped solver, float weight, Quaternion rotation)
{
// Offset
solver.GetEffector(effector).positionOffset += rotation * offset * weight;
// Calculating pinned position
Vector3 pinPosition = solver.GetRoot().position + rotation * pin;
Vector3 pinPositionOffset = pinPosition - solver.GetEffector(effector).bone.position;
Vector3 pinWeightVector = pinWeight * Mathf.Abs(weight);
// Lerping to pinned position
solver.GetEffector(effector).positionOffset = new Vector3(
Mathf.Lerp(solver.GetEffector(effector).positionOffset.x, pinPositionOffset.x, pinWeightVector.x),
Mathf.Lerp(solver.GetEffector(effector).positionOffset.y, pinPositionOffset.y, pinWeightVector.y),
Mathf.Lerp(solver.GetEffector(effector).positionOffset.z, pinPositionOffset.z, pinWeightVector.z)
);
}
// Initiate this, get the default values
public void Initiate(IKSolverFullBodyBiped solver)
{
// Find the effector if we haven't already
if (effector == null) {
effector = solver.GetEffector(effectorType);
poser = effector.bone.GetComponent<Poser>();
}
defaultPull = solver.GetChain(effectorType).pull;
defaultReach = solver.GetChain(effectorType).reach;
}
// Apply an offset to this effector
public void Apply(IKSolverFullBodyBiped solver, Vector3 offset, float crossFader)
{
current = Vector3.Lerp(lastValue, offset * weight, crossFader);
solver.GetEffector(effector).positionOffset += current;
}
public void Apply(IKSolverFullBodyBiped solver, Vector3 offset, float crossFader)
{
this.current = Vector3.Lerp(this.lastValue, offset * this.weight, crossFader);
solver.GetEffector(this.effector).positionOffset += this.current;
}
// Update this body, apply the offset to the effector
public void Update(IKSolverFullBodyBiped solver, float weight)
{
// If first update, set this body to Transform
if (firstUpdate) {
Reset();
firstUpdate = false;
}
// not using Time.deltaTime or Time.fixedDeltaTime here, because we don't know if animatePhysics is true or not on the character, so we have to keep track of time ourselves.
float deltaTime = Time.time - lastTime;
// Acceleration
direction = Vector3.Lerp(direction, transform.position - lazyPoint, deltaTime * acceleration);
// Lazy follow
lazyPoint += direction * deltaTime * speed;
// Match velocity
delta = transform.position - lastPosition;
lazyPoint += delta * matchVelocity;
// Gravity
lazyPoint.y += gravity * deltaTime;
// Apply position offset to the effector
foreach (EffectorLink effectorLink in effectorLinks) {
solver.GetEffector(effectorLink.effector).positionOffset += (lazyPoint - transform.position) * effectorLink.weight * weight;
}
lastPosition = transform.position;
lastTime = Time.time;
}
// Update and Apply the position offset to the effector
public void Update(IKSolverFullBodyBiped solver, Vector3 offsetTarget, float weight)
{
// Lerping offset to the offset target
offset = Vector3.Lerp(offset, offsetTarget * multiplier, Time.deltaTime * speed);
// Apply gravity
Vector3 g = (solver.GetRoot().up * gravity) * offset.magnitude;
// Apply the offset to the effector
solver.GetEffector(effector).positionOffset += (offset * weight * this.weight) + (g * weight);
}
// Apply offset to FBBIK effectors
public void Apply(IKSolverFullBodyBiped solver, Quaternion rotation, float masterWeight)
{
foreach (EffectorLink e in effectorLinks) {
solver.GetEffector(e.effector).positionOffset += rotation * (offset * masterWeight * e.weight);
}
}
// Apply the curve to the specified solver, effector, with the value and weight.
private void Apply(IKSolverFullBodyBiped solver, FullBodyBipedEffector effector, WeightCurve.Type type, float value, float weight) {
switch(type) {
case WeightCurve.Type.PositionWeight:
solver.GetEffector(effector).positionWeight = Mathf.Lerp(solver.GetEffector(effector).positionWeight, value, weight);
return;
case WeightCurve.Type.RotationWeight:
solver.GetEffector(effector).rotationWeight = Mathf.Lerp(solver.GetEffector(effector).rotationWeight, value, weight);
return;
case WeightCurve.Type.PositionOffsetX:
solver.GetEffector(effector).position += (positionOffsetSpace != null? positionOffsetSpace.rotation: solver.GetRoot().rotation) * Vector3.right * value * weight;
return;
case WeightCurve.Type.PositionOffsetY:
solver.GetEffector(effector).position += (positionOffsetSpace != null? positionOffsetSpace.rotation: solver.GetRoot().rotation) * Vector3.up * value * weight;
return;
case WeightCurve.Type.PositionOffsetZ:
solver.GetEffector(effector).position += (positionOffsetSpace != null? positionOffsetSpace.rotation: solver.GetRoot().rotation) * Vector3.forward * value * weight;
return;
case WeightCurve.Type.Pull:
solver.GetChain(effector).pull = Mathf.Lerp(solver.GetChain(effector).pull, value, weight);
return;
case WeightCurve.Type.Reach:
solver.GetChain(effector).reach = Mathf.Lerp(solver.GetChain(effector).reach, value, weight);
return;
case WeightCurve.Type.Push:
solver.GetChain(effector).push = Mathf.Lerp(solver.GetChain(effector).push, value, weight);
return;
case WeightCurve.Type.PushParent:
solver.GetChain(effector).pushParent = Mathf.Lerp(solver.GetChain(effector).pushParent, value, weight);
return;
}
}
// Set effector position and rotation weight to match the value, multiply with the weight of this Absorber
public void SetEffectorWeights(IKSolverFullBodyBiped solver, float w) {
solver.GetEffector(effector).positionWeight = w * weight;
solver.GetEffector(effector).rotationWeight = w * weight;
}
// Set effector position and rotation to match it's bone
public void SetToBone(IKSolverFullBodyBiped solver) {
// Using world space position and rotation here for the sake of simplicity of the demo
// Ideally we should use position and rotation relative to character's root, so we could move around while doing this.
solver.GetEffector(effector).position = solver.GetEffector(effector).bone.position;
solver.GetEffector(effector).rotation = solver.GetEffector(effector).bone.rotation;
}