// The custom constructor
public Foot(IKSolver solver, Transform transform)
{
this.solver = solver;
this.transform = transform;
this.leg = null;
rotation = transform.rotation;
}
/*
* Initiating the chain.
* */
public void Initiate(IKSolver solver, FBIKChain[] chain)
{
initiated = false;
foreach (IKSolver.Node node in nodes)
{
node.solverPosition = node.transform.position;
}
// Calculating bone lengths
for (int i = 0; i < nodes.Length - 1; i++)
{
nodes[i].length = Vector3.Distance(nodes[i].transform.position, nodes[i + 1].transform.position);
if (nodes[i].length == 0)
{
return;
}
}
for (int i = 0; i < children.Length; i++)
{
chain[children[i]].rootLength = (chain[children[i]].nodes[0].transform.position - nodes[nodes.Length - 1].transform.position).magnitude;
if (chain[children[i]].rootLength == 0f)
{
return;
}
}
// Initiating child constraints
InitiateConstraints(solver);
initiated = true;
}
public void Start()
{
this.animator = base.GetComponent <Animator>();
this.allIKComponents = base.GetComponentsInChildren <IK>();
this.disabledIKComponents = new bool[this.allIKComponents.Length];
this.fixTransforms = new bool[this.allIKComponents.Length];
if (this.ik != null)
{
IKSolver iksolver = this.ik.GetIKSolver();
iksolver.OnPostUpdate = (IKSolver.UpdateDelegate)Delegate.Combine(iksolver.OnPostUpdate, new IKSolver.UpdateDelegate(this.AfterLastIK));
}
Rigidbody[] componentsInChildren = base.GetComponentsInChildren <Rigidbody>();
int num = (componentsInChildren[0].gameObject == base.gameObject) ? 1 : 0;
this.rigidbones = new RagdollUtility.Rigidbone[(num == 0) ? componentsInChildren.Length : (componentsInChildren.Length - 1)];
for (int i = 0; i < this.rigidbones.Length; i++)
{
this.rigidbones[i] = new RagdollUtility.Rigidbone(componentsInChildren[i + num]);
}
Transform[] componentsInChildren2 = base.GetComponentsInChildren <Transform>();
this.children = new RagdollUtility.Child[componentsInChildren2.Length - 1];
for (int j = 0; j < this.children.Length; j++)
{
this.children[j] = new RagdollUtility.Child(componentsInChildren2[j + 1]);
}
}
private void Initiate()
{
this.feet = new Transform[this.legs.Length];
this.footRotations = new Quaternion[this.legs.Length];
for (int i = 0; i < this.feet.Length; i++)
{
this.footRotations[i] = Quaternion.identity;
}
for (int j = 0; j < this.legs.Length; j++)
{
IKSolver.Point[] points = this.legs[j].GetIKSolver().GetPoints();
this.feet[j] = points[points.Length - 1].transform;
IKSolver iksolver = this.legs[j].GetIKSolver();
iksolver.OnPreUpdate = (IKSolver.UpdateDelegate)Delegate.Combine(iksolver.OnPreUpdate, new IKSolver.UpdateDelegate(this.OnSolverUpdate));
IKSolver iksolver2 = this.legs[j].GetIKSolver();
iksolver2.OnPostUpdate = (IKSolver.UpdateDelegate)Delegate.Combine(iksolver2.OnPostUpdate, new IKSolver.UpdateDelegate(this.OnPostSolverUpdate));
}
this.animatedPelvisLocalPosition = this.pelvis.localPosition;
this.solver.Initiate(base.transform, this.feet);
for (int k = 0; k < this.legs.Length; k++)
{
if (this.legs[k] is LegIK)
{
this.solver.legs[k].invertFootCenter = true;
}
}
this.initiated = true;
}
public Grounding.Leg leg; // 0x20
// Constructors
public Foot(IKSolver solver, Transform transform)
{
this.solver = default;
this.transform = default;
rotation = default;
leg = default;
} // 0x0000000180044650-0x00000001800446E0
/*
* Initiating the chain.
* */
public void Initiate(IKSolver solver, FBIKChain[] chain)
{
initiated = false;
foreach (IKSolver.Node node in nodes)
{
node.solverPosition = node.transform.position;
}
// Calculating bone lengths
CalculateBoneLengths(chain);
// Initiating child constraints
foreach (ChildConstraint c in childConstraints)
{
c.Initiate(solver as IKSolverFullBody);
}
// Initiating the bend constraint
if (nodes.Length == 3)
{
bendConstraint.SetBones(nodes[0].transform, nodes[1].transform, nodes[2].transform);
bendConstraint.Initiate(solver as IKSolverFullBody);
}
crossFades = new float[children.Length];
initiated = true;
}
/*
* Initiating child constraints
* */
public void InitiateConstraints(IKSolver solver)
{
foreach (ChildConstraint c in childConstraints)
{
c.Initiate(solver as IKSolverFullBody);
}
}
/// <summary>
/// Determines whether this IKMappingSpine is valid
/// </summary>
public override bool IsValid(IKSolver solver, Warning.Logger logger) {
if (!base.IsValid(solver, logger)) return false;
foreach (Transform spineBone in spineBones) if (spineBone == null) {
if (logger != null) logger("Spine bones contains a null reference.");
return false;
}
int nodes = 0;
for (int i = 0; i < spineBones.Length; i++) {
if (solver.GetPoint(spineBones[i]) != null) nodes ++;
}
if (nodes == 0) {
if (logger != null) logger("IKMappingSpine does not contain any nodes.");
return false;
}
if (leftUpperArmBone == null) {
if (logger != null) logger("IKMappingSpine is missing the left upper arm bone.");
return false;
}
if (rightUpperArmBone == null) {
if (logger != null) logger("IKMappingSpine is missing the right upper arm bone.");
return false;
}
if (leftThighBone == null) {
if (logger != null) logger("IKMappingSpine is missing the left thigh bone.");
return false;
}
if (rightThighBone == null) {
if (logger != null) logger("IKMappingSpine is missing the right thigh bone.");
return false;
}
if (solver.GetPoint(leftUpperArmBone) == null) {
if (logger != null) logger("Full Body IK is missing the left upper arm node.");
return false;
}
if (solver.GetPoint(rightUpperArmBone) == null) {
if (logger != null) logger("Full Body IK is missing the right upper arm node.");
return false;
}
if (solver.GetPoint(leftThighBone) == null) {
if (logger != null) logger("Full Body IK is missing the left thigh node.");
return false;
}
if (solver.GetPoint(rightThighBone) == null) {
if (logger != null) logger("Full Body IK is missing the right thigh node.");
return false;
}
return true;
}
private void OnDestroy()
{
if (this.ik != null)
{
IKSolver iksolver = this.ik.GetIKSolver();
iksolver.OnPostUpdate = (IKSolver.UpdateDelegate)Delegate.Remove(iksolver.OnPostUpdate, new IKSolver.UpdateDelegate(this.AfterLastIK));
}
}
public void Initiate(Transform transform, IKSolver solver)
{
this.transform = transform;
IKSolver.Point point = solver.GetPoint(transform);
if (point != null)
{
this.node = (point as IKSolver.Node);
}
}
public float weight = 1f; // Added in 0.2
/// <summary>
/// Determines whether this IKMappingLimb is valid
/// </summary>
public override bool IsValid(IKSolver solver, Warning.Logger logger = null) {
if (!base.IsValid(solver, logger)) return false;
if (!BoneIsValid(bone1, solver, logger)) return false;
if (!BoneIsValid(bone2, solver, logger)) return false;
if (!BoneIsValid(bone3, solver, logger)) return false;
return true;
}
public float weight = 1f; // Added in 0.2
/// <summary>
/// Determines whether this IKMappingLimb is valid
/// </summary>
public override bool IsValid(IKSolver solver, ref string message) {
if (!base.IsValid(solver, ref message)) return false;
if (!BoneIsValid(bone1, solver, ref message)) return false;
if (!BoneIsValid(bone2, solver, ref message)) return false;
if (!BoneIsValid(bone3, solver, ref message)) return false;
return true;
}
public override bool IsValid(bool log)
{
if (!this.spineIsValid)
{
if (log)
{
base.LogWarning("IKSolverLookAt spine setup is invalid. Can't initiate solver.");
}
return(false);
}
if (!this.headIsValid)
{
if (log)
{
base.LogWarning("IKSolverLookAt head transform is null. Can't initiate solver.");
}
return(false);
}
if (!this.eyesIsValid)
{
if (log)
{
base.LogWarning("IKSolverLookAt eyes setup is invalid. Can't initiate solver.");
}
return(false);
}
if (this.spineIsEmpty && this.headIsEmpty && this.eyesIsEmpty)
{
if (log)
{
base.LogWarning("IKSolverLookAt spine, head and eyes are empty. There is nothing for the solver to solve.");
}
return(false);
}
Transform transform = IKSolver.ContainsDuplicateBone(this.spine);
if (transform != null)
{
if (log)
{
base.LogWarning(transform.name + " is represented multiple times in a single IK chain. Can't initiate solver.");
}
return(false);
}
Transform transform2 = IKSolver.ContainsDuplicateBone(this.eyes);
if (transform2 != null)
{
if (log)
{
base.LogWarning(transform2.name + " is represented multiple times in a single IK chain. Can't initiate solver.");
}
return(false);
}
return(true);
}
/// <summary>
/// Determines whether this IKMappingBone is valid.
/// </summary>
public override bool IsValid(IKSolver solver, Warning.Logger logger) {
if (!base.IsValid(solver, logger)) return false;
if (bone == null) {
if (logger != null) logger("IKMappingBone's bone is null.");
return false;
}
return true;
}
/*
* Make sure the bones are in valid Hierarchy
* */
public static bool HierarchyIsValid(IKSolver.Bone[] bones)
{
for (int i = 1; i < bones.Length; i++) {
// If parent bone is not an ancestor of bone, the hierarchy is invalid
if (!Hierarchy.IsAncestor(bones[i].transform, bones[i - 1].transform)) {
return false;
}
}
return true;
}
/// <summary>
/// Determines whether this IKMappingBone is valid.
/// </summary>
public override bool IsValid(IKSolver solver, ref string message) {
if (!base.IsValid(solver, ref message)) return false;
if (bone == null) {
message = "IKMappingBone's bone is null.";
return false;
}
return true;
}
/*
* Add points to array
* */
public static IKSolver.Point[] AddPoints(ref IKSolver.Point[] array, IKSolver.Point[] addPoints)
{
Array.Resize(ref array, array.Length + addPoints.Length);
int added = 0;
for (int i = array.Length - addPoints.Length; i < array.Length; i++) {
array[i] = addPoints[added];
added ++;
}
return array;
}
protected bool BoneIsValid(Transform bone, IKSolver solver, Warning.Logger logger = null)
{
if (bone == null) {
if (logger != null) logger("IKMappingLimb contains a null reference.");
return false;
}
if (solver.GetPoint(bone) == null) {
if (logger != null) logger("IKMappingLimb is referencing to a bone '" + bone.name + "' that does not excist in the Node Chain.");
return false;
}
return true;
}
/*
* Determines whether this IKEffector is valid or not.
* */
public bool IsValid(IKSolver solver, ref string message)
{
if (bone == null)
{
message = "IK Effector bone is null.";
return(false);
}
if (solver.GetPoint(bone) == null)
{
message = "IK Effector is referencing to a bone '" + bone.name + "' that does not excist in the Node Chain.";
return(false);
}
foreach (Transform b in childBones)
{
if (b == null)
{
message = "IK Effector contains a null reference.";
return(false);
}
}
foreach (Transform b in childBones)
{
if (solver.GetPoint(b) == null)
{
message = "IK Effector is referencing to a bone '" + b.name + "' that does not excist in the Node Chain.";
return(false);
}
}
if (planeBone1 != null && solver.GetPoint(planeBone1) == null)
{
message = "IK Effector is referencing to a bone '" + planeBone1.name + "' that does not excist in the Node Chain.";
return(false);
}
if (planeBone2 != null && solver.GetPoint(planeBone2) == null)
{
message = "IK Effector is referencing to a bone '" + planeBone2.name + "' that does not excist in the Node Chain.";
return(false);
}
if (planeBone3 != null && solver.GetPoint(planeBone3) == null)
{
message = "IK Effector is referencing to a bone '" + planeBone3.name + "' that does not excist in the Node Chain.";
return(false);
}
return(true);
}
private void DestroyLegs(IK[] ikComponents)
{
foreach (IK ik in ikComponents)
{
if (ik != null)
{
IKSolver iksolver = ik.GetIKSolver();
iksolver.OnPreUpdate = (IKSolver.UpdateDelegate)Delegate.Remove(iksolver.OnPreUpdate, new IKSolver.UpdateDelegate(this.OnSolverUpdate));
IKSolver iksolver2 = ik.GetIKSolver();
iksolver2.OnPostUpdate = (IKSolver.UpdateDelegate)Delegate.Remove(iksolver2.OnPostUpdate, new IKSolver.UpdateDelegate(this.OnPostSolverUpdate));
}
}
}
public override bool IsValid(IKSolver solver, ref string message)
{
if (!base.IsValid(solver, ref message))
{
return(false);
}
if (this.bone == null)
{
message = "IKMappingBone's bone is null.";
return(false);
}
return(true);
}
/*
* Initiate the effector, set default values
* */
public void Initiate(IKSolver solver)
{
this.solver = solver;
position = bone.position;
rotation = bone.rotation;
animatedPlaneRotation = Quaternion.identity;
// Getting the node
node = solver.GetPoint(bone) as IKSolver.Node;
// Child nodes
if (childNodes == null || childNodes.Length != childBones.Length)
{
childNodes = new IKSolver.Node[childBones.Length];
}
for (int i = 0; i < childBones.Length; i++)
{
childNodes[i] = solver.GetPoint(childBones[i]) as IKSolver.Node;
}
if (localPositions == null || localPositions.Length != childBones.Length)
{
localPositions = new Vector3[childBones.Length];
}
// Plane nodes
usePlaneNodes = false;
if (planeBone1 != null)
{
planeNode1 = solver.GetPoint(planeBone1) as IKSolver.Node;
if (planeBone2 != null)
{
planeNode2 = solver.GetPoint(planeBone2) as IKSolver.Node;
if (planeBone3 != null)
{
planeNode3 = solver.GetPoint(planeBone3) as IKSolver.Node;
usePlaneNodes = true;
}
}
isEndEffector = true;
}
else
{
isEndEffector = false;
}
}
private void DestroyLegs(IK[] ikComponents)
{
for (int i = 0; i < ikComponents.Length; i++)
{
IK iK = ikComponents[i];
if (iK != null)
{
IKSolver expr_1F = iK.GetIKSolver();
expr_1F.OnPreUpdate = (IKSolver.UpdateDelegate)Delegate.Remove(expr_1F.OnPreUpdate, new IKSolver.UpdateDelegate(this.OnSolverUpdate));
IKSolver expr_46 = iK.GetIKSolver();
expr_46.OnPostUpdate = (IKSolver.UpdateDelegate)Delegate.Remove(expr_46.OnPostUpdate, new IKSolver.UpdateDelegate(this.OnPostSolverUpdate));
}
}
}
protected virtual void AddWarningBox(IKSolver solver) {
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal("Box");
EditorGUILayout.LabelField("Invalid/incomplete setup, can't initiate solver.");
if (GUILayout.Button("What's wrong?")) {
Warning.logged = false;
solver.IsValid(true);
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
}
private Transform[] InitiateFeet(IK[] ikComponents, ref GrounderQuadruped.Foot[] f, int indexOffset)
{
Transform[] array = new Transform[ikComponents.Length];
for (int i = 0; i < ikComponents.Length; i++)
{
IKSolver.Point[] points = ikComponents[i].GetIKSolver().GetPoints();
f[i + indexOffset] = new GrounderQuadruped.Foot(ikComponents[i].GetIKSolver(), points[points.Length - 1].transform);
array[i] = f[i + indexOffset].transform;
IKSolver solver = f[i + indexOffset].solver;
solver.OnPreUpdate = (IKSolver.UpdateDelegate)Delegate.Combine(solver.OnPreUpdate, new IKSolver.UpdateDelegate(this.OnSolverUpdate));
IKSolver solver2 = f[i + indexOffset].solver;
solver2.OnPostUpdate = (IKSolver.UpdateDelegate)Delegate.Combine(solver2.OnPostUpdate, new IKSolver.UpdateDelegate(this.OnPostSolverUpdate));
}
return(array);
}
/*
* Initiating the chain.
* */
public void Initiate(IKSolver solver, FBIKChain[] chain)
{
initiated = false;
foreach (IKSolver.Node node in nodes)
{
node.solverPosition = node.transform.position;
}
// Calculating bone lengths
length = 0f;
for (int i = 0; i < nodes.Length - 1; i++)
{
nodes[i].length = Vector3.Distance(nodes[i].transform.position, nodes[i + 1].transform.position);
length += nodes[i].length;
if (nodes[i].length == 0)
{
return;
}
}
for (int i = 0; i < children.Length; i++)
{
chain[children[i]].rootLength = (chain[children[i]].nodes[0].transform.position - nodes[nodes.Length - 1].transform.position).magnitude;
if (chain[children[i]].rootLength == 0f)
{
return;
}
}
// Initiating child constraints
foreach (ChildConstraint c in childConstraints)
{
c.Initiate(solver as IKSolverFullBody);
}
// Initiating the bend constraint
if (nodes.Length == 3)
{
bendConstraint.SetBones(nodes[0].transform, nodes[1].transform, nodes[2].transform);
bendConstraint.Initiate(solver as IKSolverFullBody);
}
crossFades = new float[children.Length];
initiated = true;
}
private void OnDestroy()
{
if (this.initiated)
{
foreach (IK ik in this.legs)
{
if (ik != null)
{
IKSolver iksolver = ik.GetIKSolver();
iksolver.OnPreUpdate = (IKSolver.UpdateDelegate)Delegate.Remove(iksolver.OnPreUpdate, new IKSolver.UpdateDelegate(this.OnSolverUpdate));
IKSolver iksolver2 = ik.GetIKSolver();
iksolver2.OnPostUpdate = (IKSolver.UpdateDelegate)Delegate.Remove(iksolver2.OnPostUpdate, new IKSolver.UpdateDelegate(this.OnPostSolverUpdate));
}
}
}
}
public override bool IsValid(IKSolver solver, Warning.Logger logger = null)
{
if (!base.IsValid(solver, logger))
{
return(false);
}
if (this.bone == null)
{
if (logger != null)
{
logger("IKMappingBone's bone is null.");
}
return(false);
}
return(true);
}
// Override the default warning box
protected override void AddWarningBox(IKSolver solver)
{
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal("Box");
EditorGUILayout.LabelField("Invalid/incomplete setup, can't initiate solver.");
if (GUILayout.Button("What's wrong?"))
{
Warning.logged = false;
IsValidAndInitiated(true);
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
}
public bool IsValid(IKSolver solver, ref string message)
{
if (this.bone == null)
{
message = "IK Effector bone is null.";
return(false);
}
if (solver.GetPoint(this.bone) == null)
{
message = "IK Effector is referencing to a bone '" + this.bone.name + "' that does not excist in the Node Chain.";
return(false);
}
Transform[] array = this.childBones;
for (int i = 0; i < array.Length; i++)
{
if (array[i] == null)
{
message = "IK Effector contains a null reference.";
return(false);
}
}
foreach (Transform transform in this.childBones)
{
if (solver.GetPoint(transform) == null)
{
message = "IK Effector is referencing to a bone '" + transform.name + "' that does not excist in the Node Chain.";
return(false);
}
}
if (this.planeBone1 != null && solver.GetPoint(this.planeBone1) == null)
{
message = "IK Effector is referencing to a bone '" + this.planeBone1.name + "' that does not excist in the Node Chain.";
return(false);
}
if (this.planeBone2 != null && solver.GetPoint(this.planeBone2) == null)
{
message = "IK Effector is referencing to a bone '" + this.planeBone2.name + "' that does not excist in the Node Chain.";
return(false);
}
if (this.planeBone3 != null && solver.GetPoint(this.planeBone3) == null)
{
message = "IK Effector is referencing to a bone '" + this.planeBone3.name + "' that does not excist in the Node Chain.";
return(false);
}
return(true);
}
public override bool IsValid(ref string message)
{
if (this.bones.Length == 0)
{
message = "IK chain has no Bones.";
return(false);
}
if (this.bones.Length < this.minBones)
{
message = "IK chain has less than " + this.minBones + " Bones.";
return(false);
}
IKSolver.Bone[] array = this.bones;
for (int i = 0; i < array.Length; i++)
{
if (array[i].transform == null)
{
message = "One of the Bones is null.";
return(false);
}
}
Transform transform = IKSolver.ContainsDuplicateBone(this.bones);
if (transform != null)
{
message = transform.name + " is represented multiple times in the Bones.";
return(false);
}
if (!this.allowCommonParent && !IKSolver.HierarchyIsValid(this.bones))
{
message = "Invalid bone hierarchy detected. IK requires for it's bones to be parented to each other in descending order.";
return(false);
}
if (!this.boneLengthCanBeZero)
{
for (int j = 0; j < this.bones.Length - 1; j++)
{
if ((this.bones[j].transform.position - this.bones[j + 1].transform.position).magnitude == 0f)
{
message = "Bone " + j + " length is zero.";
return(false);
}
}
}
return(true);
}
private void OnDestroy()
{
if (this.initiated)
{
IK[] array = this.legs;
for (int i = 0; i < array.Length; i++)
{
IK iK = array[i];
if (iK != null)
{
IKSolver expr_2F = iK.GetIKSolver();
expr_2F.OnPreUpdate = (IKSolver.UpdateDelegate)Delegate.Remove(expr_2F.OnPreUpdate, new IKSolver.UpdateDelegate(this.OnSolverUpdate));
IKSolver expr_56 = iK.GetIKSolver();
expr_56.OnPostUpdate = (IKSolver.UpdateDelegate)Delegate.Remove(expr_56.OnPostUpdate, new IKSolver.UpdateDelegate(this.OnPostSolverUpdate));
}
}
}
}
protected bool BoneIsValid(Transform bone, IKSolver solver, Warning.Logger logger = null)
{
if (bone == null)
{
if (logger != null)
{
logger("IKMappingLimb contains a null reference.");
}
return(false);
}
if (solver.GetPoint(bone) == null)
{
if (logger != null)
{
logger("IKMappingLimb is referencing to a bone '" + bone.name + "' that does not excist in the Node Chain.");
}
return(false);
}
return(true);
}
public override bool IsValid(ref string message)
{
if (!this.spineIsValid)
{
message = "IKSolverLookAt spine setup is invalid. Can't initiate solver.";
return(false);
}
if (!this.headIsValid)
{
message = "IKSolverLookAt head transform is null. Can't initiate solver.";
return(false);
}
if (!this.eyesIsValid)
{
message = "IKSolverLookAt eyes setup is invalid. Can't initiate solver.";
return(false);
}
if (this.spineIsEmpty && this.headIsEmpty && this.eyesIsEmpty)
{
message = "IKSolverLookAt eyes setup is invalid. Can't initiate solver.";
return(false);
}
IKSolver.Bone[] bones = this.spine;
Transform transform = IKSolver.ContainsDuplicateBone(bones);
if (transform != null)
{
message = transform.name + " is represented multiple times in a single IK chain. Can't initiate solver.";
return(false);
}
bones = this.eyes;
Transform transform2 = IKSolver.ContainsDuplicateBone(bones);
if (transform2 != null)
{
message = transform2.name + " is represented multiple times in a single IK chain. Can't initiate solver.";
return(false);
}
return(true);
}
public float weight = 1f; // Added in 0.2
/// <summary>
/// Determines whether this IKMappingLimb is valid
/// </summary>
public override bool IsValid(IKSolver solver, Warning.Logger logger = null)
{
if (!base.IsValid(solver, logger))
{
return(false);
}
if (!BoneIsValid(bone1, solver, logger))
{
return(false);
}
if (!BoneIsValid(bone2, solver, logger))
{
return(false);
}
if (!BoneIsValid(bone3, solver, logger))
{
return(false);
}
return(true);
}
public void Initiate(IKSolver solver)
{
this.solver = solver;
this.position = this.bone.position;
this.rotation = this.bone.rotation;
this.animatedPlaneRotation = Quaternion.identity;
this.node = (solver.GetPoint(this.bone) as IKSolver.Node);
if (this.childNodes == null || this.childNodes.Length != this.childBones.Length)
{
this.childNodes = new IKSolver.Node[this.childBones.Length];
}
for (int i = 0; i < this.childBones.Length; i++)
{
this.childNodes[i] = (solver.GetPoint(this.childBones[i]) as IKSolver.Node);
}
if (this.localPositions == null || this.localPositions.Length != this.childBones.Length)
{
this.localPositions = new Vector3[this.childBones.Length];
}
this.usePlaneNodes = false;
if (this.planeBone1 != null)
{
this.planeNode1 = (solver.GetPoint(this.planeBone1) as IKSolver.Node);
if (this.planeBone2 != null)
{
this.planeNode2 = (solver.GetPoint(this.planeBone2) as IKSolver.Node);
if (this.planeBone3 != null)
{
this.planeNode3 = (solver.GetPoint(this.planeBone3) as IKSolver.Node);
this.usePlaneNodes = true;
}
}
this.isEndEffector = true;
}
else
{
this.isEndEffector = false;
}
}
// Solves a 3D CCD iteration virtually using solverPosition/solverRotation without considering rotation limits.
public static void SolveVirtual(IKSolver.Bone[] bones, Vector3 targetPosition, float weight)
{
for (int i = bones.Length - 2; i > -1; i--)
{
float w = bones[i].weight * weight;
if (w > 0f)
{
Vector3 toLastBone = bones[bones.Length - 1].solverPosition - bones[i].solverPosition;
Vector3 toTarget = targetPosition - bones[i].solverPosition;
// Get the rotation to direct the last bone to the target
Quaternion r = Quaternion.FromToRotation(toLastBone, toTarget);
if (w < 1f)
{
r = Quaternion.Lerp(Quaternion.identity, r, w);
}
IKSolver.SolverRotateBonesAroundPoint(bones, i, bones[i].solverPosition, r);
}
}
}
public float weight = 1f; // Added in 0.2
/// <summary>
/// Determines whether this IKMappingLimb is valid
/// </summary>
public override bool IsValid(IKSolver solver, ref string message)
{
if (!base.IsValid(solver, ref message))
{
return(false);
}
if (!BoneIsValid(bone1, solver, ref message))
{
return(false);
}
if (!BoneIsValid(bone2, solver, ref message))
{
return(false);
}
if (!BoneIsValid(bone3, solver, ref message))
{
return(false);
}
return(true);
}
public void Initiate(IKSolver solver, FBIKChain[] chain)
{
this.initiated = false;
IKSolver.Node[] array = this.nodes;
for (int i = 0; i < array.Length; i++)
{
IKSolver.Node node = array[i];
node.solverPosition = node.transform.position;
}
this.CalculateBoneLengths(chain);
FBIKChain.ChildConstraint[] array2 = this.childConstraints;
for (int j = 0; j < array2.Length; j++)
{
FBIKChain.ChildConstraint childConstraint = array2[j];
childConstraint.Initiate(solver as IKSolverFullBody);
}
if (this.nodes.Length == 3)
{
this.bendConstraint.SetBones(this.nodes[0].transform, this.nodes[1].transform, this.nodes[2].transform);
this.bendConstraint.Initiate(solver as IKSolverFullBody);
}
this.crossFades = new float[this.children.Length];
this.initiated = true;
}
/*
* Initiate the effector, set default values
* */
public void Initiate(IKSolver solver) {
this.solver = solver;
position = bone.position;
rotation = bone.rotation;
animatedPlaneRotation = Quaternion.identity;
// Getting the node
node = solver.GetPoint(bone) as IKSolver.Node;
// Child nodes
if (childNodes == null || childNodes.Length != childBones.Length) childNodes = new IKSolver.Node[childBones.Length];
for (int i = 0; i < childBones.Length; i++) {
childNodes[i] = solver.GetPoint(childBones[i]) as IKSolver.Node;
}
if (localPositions == null || localPositions.Length != childBones.Length) localPositions = new Vector3[childBones.Length];
// Plane nodes
usePlaneNodes = false;
if (planeBone1 != null) {
planeNode1 = solver.GetPoint(planeBone1) as IKSolver.Node;
if (planeBone2 != null) {
planeNode2 = solver.GetPoint(planeBone2) as IKSolver.Node;
if (planeBone3 != null) {
planeNode3 = solver.GetPoint(planeBone3) as IKSolver.Node;
usePlaneNodes = true;
}
}
isEndEffector = true;
} else isEndEffector = false;
}
/*
* Solve simple linear constraint
* */
private void SolveLinearConstraint(IKSolver.Node node1, IKSolver.Node node2, float crossFade, float distance) {
Vector3 dir = node2.solverPosition - node1.solverPosition;
float mag = dir.magnitude;
if (distance == mag) return;
if (mag == 0f) return;
Vector3 offset = dir * (1f - distance / mag);
node1.solverPosition += offset * crossFade;
node2.solverPosition -= offset * (1f - crossFade);
}
public void Initiate(Transform transform, IKSolver solver) {
this.transform = transform;
IKSolver.Point point = solver.GetPoint(transform);
if (point != null) this.node = point as IKSolver.Node;
}
/*
* Determines whether this IKEffector is valid or not.
* */
public bool IsValid(IKSolver solver, Warning.Logger logger) {
if (bone == null) {
if (logger != null) logger("IK Effector bone is null.");
return false;
}
if (solver.GetPoint(bone) == null) {
if (logger != null) logger("IK Effector is referencing to a bone '" + bone.name + "' that does not excist in the Node Chain.");
return false;
}
foreach (Transform b in childBones) {
if (b == null) {
if (logger != null) logger("IK Effector contains a null reference.");
return false;
}
}
foreach (Transform b in childBones) {
if (solver.GetPoint(b) == null) {
if (logger != null) logger("IK Effector is referencing to a bone '" + b.name + "' that does not excist in the Node Chain.");
return false;
}
}
if (planeBone1 != null && solver.GetPoint(planeBone1) == null) {
if (logger != null) logger("IK Effector is referencing to a bone '" + planeBone1.name + "' that does not excist in the Node Chain.");
return false;
}
if (planeBone2 != null && solver.GetPoint(planeBone2) == null) {
if (logger != null) logger("IK Effector is referencing to a bone '" + planeBone2.name + "' that does not excist in the Node Chain.");
return false;
}
if (planeBone3 != null && solver.GetPoint(planeBone3) == null) {
if (logger != null) logger("IK Effector is referencing to a bone '" + planeBone3.name + "' that does not excist in the Node Chain.");
return false;
}
return true;
}
/// <summary>
/// Determines whether this IKMapping is valid.
/// </summary>
public virtual bool IsValid(IKSolver solver, Warning.Logger logger) {
return true;
}
public void Initiate(IKSolver solver) {
this.solver = solver;
OnInitiate();
}
/*
* Sets the 3 points defining a plane for this bone
* */
public void SetPlane(IKSolver.Node planeNode1, IKSolver.Node planeNode2, IKSolver.Node planeNode3) {
this.planeNode1 = planeNode1;
this.planeNode2 = planeNode2;
this.planeNode3 = planeNode3;
UpdatePlane(true, true);
}
/*
* Moves the bone to the solver position of it's node
* */
public void FixToNode(float weight, IKSolver.Node fixNode) {
if (fixNode == null) fixNode = node;
if (weight >= 1f) {
transform.position = fixNode.solverPosition;
return;
}
transform.position = Vector3.Lerp(transform.position, fixNode.solverPosition, weight);
}
/*
* Solve simple linear constraint
* */
private static void SolveLinearConstraint(IKSolver.Node node1, IKSolver.Node node2, float crossFade, float distance)
{
float currentDistance = Vector3.Distance(node1.solverPosition, node2.solverPosition);
float force = 1f - distance / currentDistance;
if (force == 0) return;
Vector3 offset = (node2.solverPosition - node1.solverPosition) * force;
node1.solverPosition += offset * crossFade;
node2.solverPosition -= offset * (1f - crossFade);
}
/*
* Calculates the bend direction based on the law of cosines (from IKSolverTrigonometric).
* */
protected Vector3 GetBendDirection(Vector3 direction, float directionMagnitude, IKSolver.Node node1, IKSolver.Node node2)
{
float sqrMag1 = node1.length * node1.length;
float sqrMag2 = node2.length * node2.length;
float x = ((directionMagnitude * directionMagnitude) + sqrMag1 - sqrMag2) / 2f / directionMagnitude;
float y = (float)Math.Sqrt(Mathf.Clamp(sqrMag1 - x * x, 0, Mathf.Infinity));
return Quaternion.LookRotation(direction) * new Vector3(0f, y, x);
}
/*
* Initiating the chain.
* */
public void Initiate(IKSolver solver, FBIKChain[] chain)
{
initiated = false;
foreach (IKSolver.Node node in nodes) {
node.solverPosition = node.transform.position;
}
// Calculating bone lengths
for (int i = 0; i < nodes.Length - 1; i++) {
nodes[i].length = Vector3.Distance(nodes[i].transform.position, nodes[i + 1].transform.position);
if (nodes[i].length == 0) return;
}
for (int i = 0; i < children.Length; i++) {
chain[children[i]].rootLength = (chain[children[i]].nodes[0].transform.position - nodes[nodes.Length - 1].transform.position).magnitude;
if (chain[children[i]].rootLength == 0f) return;
}
// Initiating child constraints
InitiateConstraints(solver);
initiated = true;
}
/*
* Rotating bone to get transform aim closer to target
* */
private void RotateToTarget(Vector3 targetPosition, IKSolver.Bone bone, float weight)
{
Quaternion rotationOffset = Quaternion.FromToRotation(transformAxis, targetPosition - transform.position);
bone.transform.rotation = Quaternion.Lerp(Quaternion.identity, rotationOffset, weight) * bone.transform.rotation;
if (useRotationLimits && bone.rotationLimit != null) bone.rotationLimit.Apply();
}
/*
* Rotating bone to get transform aim closer to target
* */
private void RotateToTarget(Vector3 targetPosition, IKSolver.Bone bone, float weight) {
// Swing
if (XY) {
/*
if (weight >= 0f) {
Vector3 dir = transformAxis;
Vector3 targetDir = targetPosition - transform.position;
float angleDir = Mathf.Atan2(dir.x, dir.y) * Mathf.Rad2Deg;
float angleTarget = Mathf.Atan2(targetDir.x, targetDir.y) * Mathf.Rad2Deg;
bone.transform.rotation = Quaternion.AngleAxis((angleTarget - angleDir) * weight, Vector3.back) * bone.transform.rotation;
}
*/
if (weight >= 0f) {
Vector3 dir = transformAxis;
Vector3 targetDir = targetPosition - transform.position;
float angleDir = Mathf.Atan2(dir.x, dir.y) * Mathf.Rad2Deg;
float angleTarget = Mathf.Atan2(targetDir.x, targetDir.y) * Mathf.Rad2Deg;
bone.transform.rotation = Quaternion.AngleAxis(Mathf.DeltaAngle(angleDir, angleTarget), Vector3.back) * bone.transform.rotation;
}
} else {
if (weight >= 0f) {
Quaternion rotationOffset = Quaternion.FromToRotation(transformAxis, targetPosition - transform.position);
if (weight >= 1f) {
bone.transform.rotation = rotationOffset * bone.transform.rotation;
} else {
bone.transform.rotation = Quaternion.Lerp(Quaternion.identity, rotationOffset, weight) * bone.transform.rotation;
}
}
// Pole
if (poleWeight > 0f) {
Vector3 poleDirection = polePosition - transform.position;
// Ortho-normalize to transform axis to make this a twisting only operation
Vector3 poleDirOrtho = poleDirection;
Vector3 normal = transformAxis;
Vector3.OrthoNormalize(ref normal, ref poleDirOrtho);
Quaternion toPole = Quaternion.FromToRotation(transformPoleAxis, poleDirOrtho);
bone.transform.rotation = Quaternion.Lerp(Quaternion.identity, toPole, weight * poleWeight) * bone.transform.rotation;
}
}
if (useRotationLimits && bone.rotationLimit != null) bone.rotationLimit.Apply();
}
/*
* Initiating the chain.
* */
public void Initiate(IKSolver solver, FBIKChain[] chain) {
initiated = false;
foreach (IKSolver.Node node in nodes) {
node.solverPosition = node.transform.position;
}
// Calculating bone lengths
CalculateBoneLengths(chain);
// Initiating child constraints
foreach (ChildConstraint c in childConstraints) c.Initiate(solver as IKSolverFullBody);
// Initiating the bend constraint
if (nodes.Length == 3) {
bendConstraint.SetBones(nodes[0].transform, nodes[1].transform, nodes[2].transform);
bendConstraint.Initiate(solver as IKSolverFullBody);
}
crossFades = new float[children.Length];
initiated = true;
}
/*
* Rotating bone to get transform aim closer to target
* */
private void RotateToTarget(Vector3 targetPosition, IKSolver.Bone bone, float weight) {
// Swing
if (weight >= 0f) {
Quaternion rotationOffset = Quaternion.FromToRotation(transformAxis, targetPosition - transform.position);
bone.transform.rotation = Quaternion.Lerp(Quaternion.identity, rotationOffset, weight) * bone.transform.rotation;
}
// Pole
if (poleWeight > 0f) {
Vector3 poleDirection = polePosition - transform.position;
// Ortho-normalize to transform axis to make this a twisting only operation
Vector3 poleDirOrtho = poleDirection;
Vector3 normal = transformAxis;
Vector3.OrthoNormalize(ref normal, ref poleDirOrtho);
Quaternion toPole = Quaternion.FromToRotation(transformPoleAxis, poleDirOrtho);
bone.transform.rotation = Quaternion.Lerp(Quaternion.identity, toPole, weight * poleWeight) * bone.transform.rotation;
}
if (useRotationLimits && bone.rotationLimit != null) bone.rotationLimit.Apply();
}
private static Vector3 GetNodePosition(IKSolver.Node node) {
if (Application.isPlaying) return node.solverPosition;
return node.transform.position;
}
/*
* Moves the bone to the solver position of it's node
* */
public void FixToNode(float weight, IKSolver.Node fixNode = null)
{
if (fixNode == null) fixNode = node;
transform.position = Vector3.Lerp(transform.position, fixNode.solverPosition, weight);
}
private void AddPointsToArray(ref IKSolver.Point[] array, FABRIKChain chain)
{
IKSolver.Point[] chainArray = chain.ik.solver.GetPoints();
Array.Resize(ref array, array.Length + chainArray.Length);
int a = 0;
for (int i = array.Length - chainArray.Length; i < array.Length; i++) {
array[i] = chainArray[a];
a++;
}
}
/*
* Initiating child constraints
* */
public void InitiateConstraints(IKSolver solver)
{
foreach (ChildConstraint c in childConstraints) c.Initiate(solver as IKSolverFullBody);
}
// The custom constructor
public Foot (IKSolver solver, Transform transform) {
this.solver = solver;
this.transform = transform;
this.leg = null;
rotation = transform.rotation;
}
/// <summary>
/// Determines whether this IKMapping is valid.
/// </summary>
public virtual bool IsValid(IKSolver solver, ref string message) {
return true;
}