COM_Diff/Assembly-CSharp/FreeFBIKEffector.cs

using System;
using RootMotion;
using RootMotion.FinalIK;
using UnityEngine;

[Serializable]
public class FreeFBIKEffector
{
	public FreeFBIKEffector(FullBodyBipedIK ik_ctrl, Transform bone, Transform ik_target, bool is_upper)
	{
		this.ik = ik_ctrl;
		this.Bone = bone;
		this.Target = ik_target;
		this.IsUpperBody = is_upper;
		IKSolverFullBodyBiped solver = this.ik.solver;
		solver.OnStoreDefaultLocalState = (IKSolver.UpdateDelegate)Delegate.Combine(solver.OnStoreDefaultLocalState, new IKSolver.UpdateDelegate(this.OnStoreDefaultLocalState));
		IKSolverFullBodyBiped solver2 = this.ik.solver;
		solver2.OnFixTransforms = (IKSolver.UpdateDelegate)Delegate.Combine(solver2.OnFixTransforms, new IKSolver.UpdateDelegate(this.OnFixTransforms));
		this.boneRotationRelativeToRoot = Quaternion.Inverse(this.ik.references.root.rotation) * this.Bone.rotation;
	}

	public Vector3 TargetPos
	{
		get
		{
			return this.Target.position;
		}
	}

	private Transform m_leftNearBone
	{
		get
		{
			return (!this.IsUpperBody) ? this.ik.references.leftThigh : this.ik.references.leftUpperArm;
		}
	}

	private Transform m_rightNearBone
	{
		get
		{
			return (!this.IsUpperBody) ? this.ik.references.rightThigh : this.ik.references.rightUpperArm;
		}
	}

	private IKEffector m_leftNearEffector
	{
		get
		{
			return (!this.IsUpperBody) ? this.ik.solver.leftThighEffector : this.ik.solver.leftShoulderEffector;
		}
	}

	private IKEffector m_rightNearEffector
	{
		get
		{
			return (!this.IsUpperBody) ? this.ik.solver.rightThighEffector : this.ik.solver.rightShoulderEffector;
		}
	}

	private Transform m_leftFarBone
	{
		get
		{
			return (!this.IsUpperBody) ? this.ik.references.leftUpperArm : this.ik.references.leftThigh;
		}
	}

	private Transform m_rightFarBone
	{
		get
		{
			return (!this.IsUpperBody) ? this.ik.references.rightUpperArm : this.ik.references.rightThigh;
		}
	}

	private IKEffector m_leftFarEffector
	{
		get
		{
			return (!this.IsUpperBody) ? this.ik.solver.leftShoulderEffector : this.ik.solver.leftThighEffector;
		}
	}

	private IKEffector m_rightFarEffector
	{
		get
		{
			return (!this.IsUpperBody) ? this.ik.solver.rightShoulderEffector : this.ik.solver.rightThighEffector;
		}
	}

	private void OnStoreDefaultLocalState()
	{
		if (this.positionWeight <= 0f)
		{
			return;
		}
		foreach (FreeFBIKEffector.BendBone bendBone in this.bendBones)
		{
			if (bendBone != null)
			{
				bendBone.StoreDefaultLocalState();
			}
		}
		this.ccdDefaultLocalRotations = new Quaternion[this.CCDBones.Length];
		for (int j = 0; j < this.CCDBones.Length; j++)
		{
			if (this.CCDBones[j] != null)
			{
				this.ccdDefaultLocalRotations[j] = this.CCDBones[j].localRotation;
			}
		}
		this.boneLocalPosition = this.Bone.localPosition;
		this.boneLocalRotation = this.Bone.localRotation;
		this.stretchLocalPositions = new Vector3[this.stretchBones.Length];
		this.stretchLocalRotations = new Quaternion[this.stretchBones.Length];
		for (int k = 0; k < this.stretchBones.Length; k++)
		{
			if (this.stretchBones[k] != null)
			{
				this.stretchLocalPositions[k] = this.stretchBones[k].localPosition;
				this.stretchLocalRotations[k] = this.stretchBones[k].localRotation;
			}
		}
		this.chestLocalPositions = new Vector3[this.chestBones.Length];
		this.chestLocalRotations = new Quaternion[this.chestBones.Length];
		for (int l = 0; l < this.chestBones.Length; l++)
		{
			if (this.chestBones[l] != null)
			{
				this.chestLocalPositions[l] = this.chestBones[l].localPosition;
				this.chestLocalRotations[l] = this.chestBones[l].localRotation;
			}
		}
		this.bendBonesCount = this.bendBones.Length;
		this.ccdBonesCount = this.CCDBones.Length;
		this.stretchBonesCount = this.stretchBones.Length;
		this.chestBonesCount = this.chestBones.Length;
	}

	private void OnFixTransforms()
	{
		if (this.positionWeight <= 0f)
		{
			return;
		}
		foreach (FreeFBIKEffector.BendBone bendBone in this.bendBones)
		{
			if (bendBone != null)
			{
				bendBone.FixTransforms();
			}
		}
		for (int j = 0; j < this.CCDBones.Length; j++)
		{
			if (this.CCDBones[j] != null)
			{
				this.CCDBones[j].localRotation = this.ccdDefaultLocalRotations[j];
			}
		}
		this.Bone.localPosition = this.boneLocalPosition;
		this.Bone.localRotation = this.boneLocalRotation;
		for (int k = 0; k < this.stretchBones.Length; k++)
		{
			if (this.stretchBones[k] != null)
			{
				this.stretchBones[k].localPosition = this.stretchLocalPositions[k];
				this.stretchBones[k].localRotation = this.stretchLocalRotations[k];
			}
		}
		for (int l = 0; l < this.chestBones.Length; l++)
		{
			if (this.chestBones[l] != null)
			{
				this.chestBones[l].localPosition = this.chestLocalPositions[l];
				this.chestBones[l].localRotation = this.chestLocalRotations[l];
			}
		}
	}

	public void OnPreRead()
	{
		if (this.positionWeight <= 0f)
		{
			return;
		}
		if (this.bendBonesCount != this.bendBones.Length || this.ccdBonesCount != this.CCDBones.Length || this.stretchBonesCount != this.stretchBones.Length || this.chestBonesCount != this.chestBones.Length)
		{
			this.OnStoreDefaultLocalState();
		}
		this.ChestDirection();
		this.SpineBend();
		this.CCDPass();
		this.offset = this.TargetPos - this.Bone.position;
		this.nearBoneDist = Vector3.Distance(this.m_leftNearBone.position, this.m_rightNearBone.position);
		this.leftNearBoneDist = Vector3.Distance(this.Bone.position, this.m_leftNearBone.position);
		this.rightNearBoneDist = Vector3.Distance(this.Bone.position, this.m_rightNearBone.position);
		this.boneToBody = this.ik.solver.rootNode.position - this.Bone.position;
		this.boneToLeftFarBone = this.m_leftFarBone.position - this.Bone.position;
		this.boneToRightFarBone = this.m_rightFarBone.position - this.Bone.position;
		this.leftNearBonePos = this.m_leftNearBone.position + this.offset * this.bodyWeight;
		this.rightNearBonePos = this.m_rightNearBone.position + this.offset * this.bodyWeight;
		this.chestRotation = Quaternion.LookRotation(this.Bone.position - this.m_leftNearBone.position, this.m_rightNearBone.position - this.m_leftNearBone.position);
	}

	private void SpineBend()
	{
		float num = this.bendWeight * this.ik.solver.IKPositionWeight;
		if (num <= 0f)
		{
			return;
		}
		if (this.bendBones.Length == 0)
		{
			return;
		}
		Quaternion quaternion = this.Target.rotation * Quaternion.Inverse(this.ik.references.root.rotation * this.boneRotationRelativeToRoot);
		quaternion = QuaTools.ClampRotation(quaternion, this.bodyClampWeight, 2);
		float num2 = 1f / (float)this.bendBones.Length;
		for (int i = 0; i < this.bendBones.Length; i++)
		{
			if (this.bendBones[i].transform != null)
			{
				this.bendBones[i].transform.rotation = Quaternion.Lerp(Quaternion.identity, quaternion, num2 * this.bendBones[i].weight * num) * this.bendBones[i].transform.rotation;
			}
		}
	}

	private void CCDPass()
	{
		float num = this.CCDWeight * this.ik.solver.IKPositionWeight;
		if (num <= 0f)
		{
			return;
		}
		for (int i = this.CCDBones.Length - 1; i > -1; i--)
		{
			Quaternion quaternion = Quaternion.FromToRotation(this.Bone.position - this.CCDBones[i].position, this.TargetPos - this.CCDBones[i].position) * this.CCDBones[i].rotation;
			float num2 = Mathf.Lerp((float)((this.CCDBones.Length - i) / this.CCDBones.Length), 1f, this.roll);
			float num3 = Quaternion.Angle(Quaternion.identity, quaternion);
			num3 = Mathf.Lerp(0f, num3, (this.damper - num3) / this.damper);
			this.CCDBones[i].rotation = Quaternion.RotateTowards(this.CCDBones[i].rotation, quaternion, num3 * num * num2);
		}
	}

	public void Iterate()
	{
		if (this.positionWeight <= 0f)
		{
			return;
		}
		this.leftNearBonePos = this.TargetPos + (this.leftNearBonePos - this.TargetPos).normalized * this.leftNearBoneDist;
		this.rightNearBonePos = this.TargetPos + (this.rightNearBonePos - this.TargetPos).normalized * this.rightNearBoneDist;
		this.Solve(ref this.leftNearBonePos, ref this.rightNearBonePos, this.nearBoneDist);
		this.LerpSolverPosition(this.m_leftNearEffector, this.leftNearBonePos, this.positionWeight * this.ik.solver.IKPositionWeight, this.m_leftNearEffector.positionOffset);
		this.LerpSolverPosition(this.m_rightNearEffector, this.rightNearBonePos, this.positionWeight * this.ik.solver.IKPositionWeight, this.m_rightNearEffector.positionOffset);
		Quaternion to = Quaternion.LookRotation(this.TargetPos - this.leftNearBonePos, this.rightNearBonePos - this.leftNearBonePos);
		Quaternion quaternion = QuaTools.FromToRotation(this.chestRotation, to);
		Vector3 b = quaternion * this.boneToBody;
		this.LerpSolverPosition(this.ik.solver.bodyEffector, this.TargetPos + b, this.positionWeight * this.ik.solver.IKPositionWeight, this.ik.solver.bodyEffector.positionOffset - this.ik.solver.pullBodyOffset);
		Quaternion rotation = Quaternion.Lerp(Quaternion.identity, quaternion, this.farBoneWeight);
		Vector3 b2 = rotation * this.boneToLeftFarBone;
		Vector3 b3 = rotation * this.boneToRightFarBone;
		this.LerpSolverPosition(this.m_leftFarEffector, this.TargetPos + b2, this.positionWeight * this.ik.solver.IKPositionWeight, this.ik.solver.bodyEffector.positionOffset - this.ik.solver.pullBodyOffset + this.ik.solver.leftThighEffector.positionOffset);
		this.LerpSolverPosition(this.m_rightFarEffector, this.TargetPos + b3, this.positionWeight * this.ik.solver.IKPositionWeight, this.ik.solver.bodyEffector.positionOffset - this.ik.solver.pullBodyOffset + this.m_rightFarEffector.positionOffset);
	}

	private void ChestDirection()
	{
		float num = this.chestDirectionWeight * this.ik.solver.IKPositionWeight;
		if (num <= 0f)
		{
			return;
		}
		bool flag = false;
		this.chestDirection = V3Tools.ClampDirection(this.chestDirection, this.ik.references.root.forward, 0.45f, 2, out flag);
		if (this.chestDirection == Vector3.zero)
		{
			return;
		}
		Quaternion quaternion = Quaternion.FromToRotation(this.ik.references.root.forward, this.chestDirection);
		quaternion = Quaternion.Lerp(Quaternion.identity, quaternion, num * (1f / (float)this.chestBones.Length));
		foreach (Transform transform in this.chestBones)
		{
			transform.rotation = quaternion * transform.rotation;
		}
	}

	private void PostStretching()
	{
		float num = this.postStretchWeight * this.ik.solver.IKPositionWeight;
		if (num > 0f)
		{
			Vector3 a = Vector3.ClampMagnitude(this.TargetPos - this.Bone.position, this.maxStretch);
			a *= num;
			this.stretchDamper = Mathf.Max(this.stretchDamper, 0f);
			if (this.stretchDamper > 0f)
			{
				a /= (1f + a.magnitude) * (1f + this.stretchDamper);
			}
			for (int i = 0; i < this.stretchBones.Length; i++)
			{
				if (this.stretchBones[i] != null)
				{
					this.stretchBones[i].position += a / (float)this.stretchBones.Length;
				}
			}
		}
		if (this.fixBone && this.ik.solver.IKPositionWeight > 0f)
		{
			this.Bone.position = this.TargetPos;
		}
	}

	private void LerpSolverPosition(IKEffector effector, Vector3 position, float weight, Vector3 offset)
	{
		if (effector.target)
		{
			Vector3 position2 = effector.target.position;
			effector.target.position = Vector3.Lerp(effector.target.position, position + offset, weight);
		}
		else
		{
			effector.GetNode(this.ik.solver).solverPosition = Vector3.Lerp(effector.bone.position, position + offset, weight);
		}
	}

	private void Solve(ref Vector3 pos1, ref Vector3 pos2, float nominalDistance)
	{
		Vector3 a = pos2 - pos1;
		float magnitude = a.magnitude;
		if (magnitude == nominalDistance)
		{
			return;
		}
		if (magnitude == 0f)
		{
			return;
		}
		float num = 1f;
		num *= 1f - nominalDistance / magnitude;
		Vector3 b = a * num * 0.5f;
		pos1 += b;
		pos2 -= b;
	}

	[Tooltip("Reference to the FBBIK component.")]
	public FullBodyBipedIK ik;

	[LargeHeader("Position")]
	[Tooltip("Master weight for positioning the head.")]
	[Range(0f, 1f)]
	public float positionWeight = 1f;

	[Tooltip("The weight of moving the body along with the head")]
	[Range(0f, 1f)]
	public float bodyWeight = 1f;

	[Tooltip("The weight of moving the thighs along with the head")]
	[Range(0f, 1f)]
	public float farBoneWeight = 1f;

	[LargeHeader("Rotation")]
	[Tooltip("Clamping the rotation of the body")]
	[Range(0f, 1f)]
	public float bodyClampWeight = 0.5f;

	[Tooltip("Clamping the rotation of the head")]
	[Range(0f, 1f)]
	public float boneClampWeight = 0.5f;

	[Tooltip("The master weight of bending/twisting the spine to the rotation of the head effector. This is similar to CCD, but uses the rotation of the head effector not the position.")]
	[Range(0f, 1f)]
	public float bendWeight = 1f;

	[Tooltip("The bones to use for bending.")]
	public FreeFBIKEffector.BendBone[] bendBones = new FreeFBIKEffector.BendBone[0];

	[LargeHeader("CCD")]
	[Tooltip("Optional. The master weight of the CCD (Cyclic Coordinate Descent) IK effect that bends the spine towards the head effector before FBBIK solves.")]
	[Range(0f, 1f)]
	public float CCDWeight = 1f;

	[Tooltip("The weight of rolling the bones in towards the target")]
	[Range(0f, 1f)]
	public float roll;

	[Tooltip("Smoothing the CCD effect.")]
	[Range(0f, 1000f)]
	public float damper = 500f;

	[Tooltip("Bones to use for the CCD pass. Assign spine and/or neck bones.")]
	public Transform[] CCDBones = new Transform[0];

	[LargeHeader("Stretching")]
	[Tooltip("Stretching the spine/neck to help reach the target. This is useful for making sure the head stays locked relative to the VR headset. NB! Stretching is done after FBBIK has solved so if you have the hand effectors pinned and spine bones included in the 'Stretch Bones', the hands might become offset from their target positions.")]
	[Range(0f, 1f)]
	public float postStretchWeight = 1f;

	[Tooltip("Stretch magnitude limit.")]
	public float maxStretch = 0.1f;

	[Tooltip("If > 0, dampers the stretching effect.")]
	public float stretchDamper;

	[Tooltip("If true, will fix head position to this Transform no matter what. Good for making sure the head will not budge away from the VR headset")]
	public bool fixBone;

	[Tooltip("Bones to use for stretching. The more bones you add, the less noticable the effect.")]
	public Transform[] stretchBones = new Transform[0];

	[LargeHeader("Chest Direction")]
	public Vector3 chestDirection = Vector3.forward;

	[Range(0f, 1f)]
	public float chestDirectionWeight = 1f;

	public Transform[] chestBones = new Transform[0];

	private Vector3 offset;

	private Vector3 boneToBody;

	private Vector3 nearCenterToBone;

	private Vector3 boneToLeftFarBone;

	private Vector3 boneToRightFarBone;

	private Vector3 leftNearBonePos;

	private Vector3 rightNearBonePos;

	private float nearBoneDist;

	private float leftNearBoneDist;

	private float rightNearBoneDist;

	private Quaternion chestRotation;

	private Quaternion boneRotationRelativeToRoot;

	private Quaternion[] ccdDefaultLocalRotations = new Quaternion[0];

	private Vector3 boneLocalPosition;

	private Quaternion boneLocalRotation;

	private Vector3[] stretchLocalPositions = new Vector3[0];

	private Quaternion[] stretchLocalRotations = new Quaternion[0];

	private Vector3[] chestLocalPositions = new Vector3[0];

	private Quaternion[] chestLocalRotations = new Quaternion[0];

	private int bendBonesCount;

	private int ccdBonesCount;

	private int stretchBonesCount;

	private int chestBonesCount;

	public readonly bool IsUpperBody;

	public readonly Transform Target;

	public readonly Transform Bone;

	[Serializable]
	public class BendBone
	{
		public BendBone()
		{
		}

		public BendBone(Transform transform, float weight)
		{
			this.transform = transform;
			this.weight = weight;
		}

		public void StoreDefaultLocalState()
		{
			this.defaultLocalRotation = this.transform.localRotation;
		}

		public void FixTransforms()
		{
			this.transform.localRotation = this.defaultLocalRotation;
		}

		[Tooltip("Assign spine and/or neck bones.")]
		public Transform transform;

		[Tooltip("The weight of rotating this bone.")]
		[Range(0f, 1f)]
		public float weight = 0.5f;

		private Quaternion defaultLocalRotation = Quaternion.identity;
	}
}