COM_Diff/Assembly-CSharp/IKCtrlData.cs

using System;
using UnityEngine;

public abstract class IKCtrlData
{
	public IKCtrlData(FullBodyIKCtrl ik_ctrl, Transform tgt_bone, bool use_old = false, bool attach_ik = false)
	{
		this.MyIKCtrl = ik_ctrl;
		this.UseOldIK = use_old;
		this.m_TargetBone = tgt_bone;
		this.m_AttachPointIK = attach_ik;
		string text = (!this.MyIKCtrl.TgtMaid.boMAN) ? "Bip01" : "ManBip";
		string name = this.m_TargetBone.name;
		Transform transform = this.MyIKCtrl.IKTgtRoot.Find(name);
		if (!transform)
		{
			transform = new GameObject(name).transform;
			transform.transform.SetParent(this.MyIKCtrl.IKTgtRoot, false);
			GameObject gameObject = new GameObject("IKTarget");
			gameObject.transform.SetParent(transform.transform, false);
			this.m_IKTarget = gameObject.transform;
		}
		else
		{
			this.m_IKTarget = transform.Find("IKTarget");
		}
		this.m_BoneTgtPair = new IKCtrlData.BoneTgtPair(this.TargetBone, this.m_IKTarget);
		this.IkCmoInit();
		this.m_PointIK.IKCtrl = ik_ctrl;
		this.m_NextPointIK.IKCtrl = ik_ctrl;
		this.m_RotateIK.IKCtrl = ik_ctrl;
		this.m_NextRotateIK.IKCtrl = ik_ctrl;
	}

	public bool ForceIK
	{
		get
		{
			return this.m_ForceIK;
		}
		set
		{
			this.m_ForceIK = (this.m_ForceIKEnable && value);
		}
	}

	public IKCtrlData.PosRotPair BlendPosRot
	{
		get
		{
			return this.m_BlendPosRot;
		}
	}

	public IKCtrlData.IKParam PointIK
	{
		get
		{
			return (!this.m_PointFlagData.IsFlagOn) ? this.m_PointIK : this.m_NextPointIK;
		}
	}

	public IKCtrlData.IKParam RotateIK
	{
		get
		{
			return (!this.m_RotateFlagData.IsFlagOn) ? this.m_RotateIK : this.m_NextRotateIK;
		}
	}

	public TBody.IKCMO IKCmo
	{
		get
		{
			return this.m_IKCmo;
		}
	}

	public IKCtrlData.Vec3Enable PosEnable
	{
		get
		{
			return this.m_PosEnable;
		}
	}

	public IKCtrlData.Vec3Enable RotEnable
	{
		get
		{
			return this.m_RotEnable;
		}
	}

	public bool IsIKExec
	{
		get
		{
			return this.PointIK.IsIKExec || this.RotateIK.IsIKExec || this.ForceIK;
		}
	}

	public bool IsIKExecTruth
	{
		get
		{
			return this.IsIKExec && (this.PositionWeight > 0f || this.RotationWeight > 0f);
		}
	}

	public bool OldIkExec
	{
		get
		{
			return this.PointIK.IsIKExec && this.PointIK.IsOldIK;
		}
	}

	public bool AttachPointIK
	{
		get
		{
			return this.m_AttachPointIK;
		}
	}

	public Transform IKTarget
	{
		get
		{
			return this.m_IKTarget;
		}
	}

	public IKCtrlData.Vec3Enable OffsetEnable
	{
		get
		{
			return this.m_OffsetEnable;
		}
	}

	public IKCtrlData.ChangeFlagData PointFlagData
	{
		get
		{
			return this.m_PointFlagData;
		}
	}

	public IKCtrlData.ChangeFlagData RotateFlagData
	{
		get
		{
			return this.m_RotateFlagData;
		}
	}

	public virtual Transform TargetBone
	{
		get
		{
			return this.m_TargetBone;
		}
	}

	public bool IsSelfIKAttach { get; protected set; }

	public abstract Transform[] ChainBones { get; }

	public abstract float PositionWeight { get; set; }

	public abstract float RotationWeight { get; set; }

	public static bool operator true(IKCtrlData data)
	{
		return data != null;
	}

	public static bool operator false(IKCtrlData data)
	{
		return data == null;
	}

	public static bool operator !(IKCtrlData data)
	{
		return data == null;
	}

	private void IkCmoInit()
	{
		if (!this.UseOldIK)
		{
			return;
		}
		this.IKCmo.Init(this.TargetBone.parent.parent, this.TargetBone.parent, this.TargetBone, this.MyIKCtrl.TgtBody);
	}

	private void IkCmoPorc(Vector3 tgt, Vector3 vechand_offset)
	{
		if (!this.UseOldIK)
		{
			return;
		}
		for (int i = 0; i < 3; i++)
		{
			this.IKCmo.Porc(this.TargetBone.parent.parent, this.TargetBone.parent, this.TargetBone, tgt, vechand_offset, this);
		}
	}

	private void SetIKPosRot(IKCtrlData.IKParam data, ref Vector3 pos, ref Quaternion rot, bool include_offset = false)
	{
		if (data.Target != null)
		{
			pos = data.Target.position;
			rot = data.Target.rotation;
		}
		else if (data.Tgt_AttachName != string.Empty)
		{
			if (this.MyIKCtrl.TgtBody.goSlot[data.Tgt_AttachSlot].morph != null)
			{
				if (data.TgtMaid != null && data.TgtMaid.body0 != null)
				{
					Vector3 vector;
					data.TgtMaid.body0.goSlot[data.Tgt_AttachSlot].morph.GetAttachPoint(data.Tgt_AttachName, out pos, out rot, out vector, false);
					if (data.MyType == IKCtrlData.IKAttachType.NewPoint && data.AxisTgt)
					{
						rot = data.AxisTgt.rotation;
					}
				}
				else
				{
					data.IsIKExec = false;
					data.Tgt_AttachName = string.Empty;
				}
			}
		}
		else if (this.ForceIK)
		{
			pos = this.m_IKTarget.position;
			rot = this.m_IKTarget.rotation;
		}
		else if (data.BlendWeight != 1f && data.BlendType == IKCtrlData.IKBlendType.IK_To_Detach)
		{
			pos = this.BlendPosRot.pos;
			rot = this.BlendPosRot.rot;
		}
		else
		{
			data.IsIKExec = false;
		}
		if (data.IsIKExec)
		{
			pos = this.GetIKEnable(data.MyType).GetEnable(this.TargetBone.position, pos, false);
			if (include_offset && !data.DoSetOffset)
			{
				data.DoSetOffset = true;
				if (data.IsPointAttach)
				{
					Vector3 start = pos;
					if (this.OffsetWorld)
					{
						pos += data.TgtOffset;
					}
					else if (this.OffsetBone)
					{
						pos -= this.TargetBone.rotation * data.TgtOffset;
					}
					else
					{
						pos += rot * data.TgtOffset;
					}
					Debug.DrawLine(start, pos, Color.white);
				}
				else
				{
					rot *= Quaternion.Euler(this.GetIKEnable(data.MyType).GetEnable(data.TgtOffset, false));
				}
			}
		}
	}

	private void ApplyIKSetting(IKCtrlData.IKParam data)
	{
		if (this.MyIKCtrl.IsUpdateLate)
		{
			return;
		}
		if (data.TgtMaid && data.TgtMaid != this.MyIKCtrl.TgtMaid)
		{
			IKCtrlData ikdata = data.TgtMaid.IKCtrl.GetIKData(data.Tgt_AttachName, false);
			if (ikdata != null && ikdata.IsIKExec)
			{
				IKCtrlData.IKParam ikparam = ikdata.GetIKParam(data.MyType, false, false);
				this.m_EachOtherIK = (ikparam.IsIKExec && ikparam.Target == this.TargetBone);
			}
			if (!data.TgtMaid.body0.LateUpdateEnd && !this.MyIKCtrl.TgtBody.LateUpdateEnd)
			{
				this.MyIKCtrl.IsUpdateLate = true;
				if (data.TgtMaid.IKCtrl.IsIKExec)
				{
					FullBodyIKCtrl ikctrl = data.TgtMaid.IKCtrl;
					ikctrl.PostSolverUpdate = (Action)Delegate.Combine(ikctrl.PostSolverUpdate, new Action(this.MyIKCtrl.LateIKUpdate));
				}
				else
				{
					TBody body = data.TgtMaid.body0;
					body.OnLateUpdateEnd = (Action)Delegate.Combine(body.OnLateUpdateEnd, new Action(this.MyIKCtrl.LateIKUpdate));
				}
				return;
			}
		}
		if (data.BlendType == IKCtrlData.IKBlendType.IK_To_Detach && !data.NeedBlend)
		{
			data.BlendRecet(false);
		}
		data.DoSetOffset = false;
		data.IsIKExec = true;
		Vector3 vector = this.TargetBone.position;
		Quaternion quaternion = this.TargetBone.rotation;
		if (this.GetFlagData(data.MyType).IsEnable)
		{
			if (!this.GetFlagData(data.MyType).BlendCtrlSelf)
			{
				IKCtrlData.IKParam ikparam2 = this.GetIKParam(data.MyType, true, false);
				ikparam2.DoSetOffset = false;
				Vector3 a = vector;
				Quaternion a2 = quaternion;
				this.SetIKPosRot(ikparam2, ref a, ref a2, true);
				IKCtrlData.IKParam ikparam3 = this.GetIKParam(data.MyType, true, true);
				ikparam3.DoSetOffset = false;
				Vector3 b = vector;
				Quaternion b2 = quaternion;
				this.SetIKPosRot(ikparam3, ref b, ref b2, true);
				float num = this.GetFlagData(data.MyType).Value01();
				data.IsIKExec = true;
				if (data.IsPointAttach)
				{
					if (!ikparam2.ExistTgt)
					{
						this.m_PosWeightBase = num;
					}
					else
					{
						this.m_PosWeightBase = 1f;
					}
					vector = Vector3.Lerp(a, b, num);
				}
				else
				{
					if (!ikparam2.ExistTgt)
					{
						this.m_RotWeightBase = num;
					}
					else
					{
						this.m_RotWeightBase = 1f;
					}
					quaternion = Quaternion.Lerp(a2, b2, num);
				}
			}
			else if (this.GetFlagData(data.MyType).IsFlagChange())
			{
				bool isFlagOn = this.GetFlagData(data.MyType).IsFlagOn;
				IKCtrlData.IKParam ikparam4 = this.GetIKParam(data.MyType, true, !isFlagOn);
				IKCtrlData.IKParam ikparam5 = this.GetIKParam(data.MyType, true, isFlagOn);
				ikparam4.BlendRecet(true);
				ikparam5.BlendRecet(true);
				ikparam5.SetLastTarget(ikparam4.Tgt_AttachName, ikparam4.TgtMaid, ikparam4.Target, ikparam4.TgtOffset);
				ikparam5.CheckBlendType(true);
				if (ikparam5.MyType == IKCtrlData.IKAttachType.Rotate)
				{
					this.BlendPosRot.rot = this.m_lastIKPosRot.rot;
				}
				else
				{
					this.BlendPosRot.pos = this.m_lastIKPosRot.pos;
				}
				this.SetIKPosRot(data, ref vector, ref quaternion, false);
			}
			else
			{
				this.SetIKPosRot(data, ref vector, ref quaternion, false);
			}
		}
		else
		{
			this.SetIKPosRot(data, ref vector, ref quaternion, false);
		}
		if (data.IsIKExec)
		{
			if (this.m_EachOtherIK && !data.TgtMaid.IKCtrl.IsUpdateEnd)
			{
				if (data.IsPointAttach)
				{
					vector = Vector3.Lerp(this.TargetBone.position, vector, 0.5f);
				}
				else
				{
					quaternion = Quaternion.Lerp(this.TargetBone.rotation, quaternion, 0.5f);
				}
			}
			if (data.FirstFrame && !data.BlendNow)
			{
				if (data.IsPointAttach)
				{
					this.m_FirstTgtPosRot.pos = vector;
				}
				else
				{
					this.m_FirstTgtPosRot.rot = quaternion;
				}
			}
			if (data.DoAnimation && !data.BlendNow)
			{
				if (!data.DoSetPosRot)
				{
					Transform targetBone = this.TargetBone;
					if (data.IsPointAttach)
					{
						if (!data.FirstFrame)
						{
							this.m_PosRotOffset.pos = targetBone.position - vector - this.m_FirstPosRotOffset.pos;
						}
						else
						{
							this.m_FirstPosRotOffset.pos = targetBone.position - vector;
						}
					}
					else if (!data.FirstFrame)
					{
						this.m_PosRotOffset.rot = targetBone.rotation * Quaternion.Inverse(quaternion) * Quaternion.Inverse(this.m_FirstPosRotOffset.rot);
					}
					else
					{
						this.m_FirstPosRotOffset.rot = targetBone.rotation * Quaternion.Inverse(quaternion);
					}
				}
			}
			else
			{
				this.m_PosRotOffset.Recet();
			}
			this.SetTargetTransform(data, vector, quaternion);
			if (!data.BlendNow)
			{
				data.FirstFrame = false;
			}
			if (data.IsTgtAxis)
			{
				KasaiUtility.DrawAxis(vector, quaternion, 0.125f);
			}
			if (!data.DoSetPosRot)
			{
				data.ElapsedTime += Time.deltaTime;
				if (data.BlendType == IKCtrlData.IKBlendType.IK_To_Detach && data.ElapsedTime >= this.MyIKCtrl.BlendTime)
				{
					data.BlendRecet(false);
				}
			}
			data.DoSetPosRot = true;
		}
	}

	protected bool IsEachBoneIK(IKCtrlData.IKParam param)
	{
		return param.IsIKExec && param.Target == this.TargetBone;
	}

	protected virtual void SetTargetTransform(IKCtrlData.IKParam data, Vector3 pos, Quaternion rot)
	{
		switch (data.MyType)
		{
		case IKCtrlData.IKAttachType.Point:
			pos += this.m_PosRotOffset.pos;
			Debug.DrawLine(pos, pos + rot * Vector3.forward * 0.2f, Color.cyan);
			if (!data.DoSetOffset)
			{
				this.IkCmoPorc(pos, data.TgtOffset);
			}
			else
			{
				this.IkCmoPorc(pos, Vector3.zero);
			}
			break;
		case IKCtrlData.IKAttachType.Rotate:
			rot *= this.m_PosRotOffset.rot;
			if (!data.DoSetOffset)
			{
				rot *= Quaternion.Euler(this.GetIKEnable(data.MyType).GetEnable(data.TgtOffset, false));
			}
			this.m_IKTarget.rotation = rot;
			if (data.BlendType == IKCtrlData.IKBlendType.IK_To_IK)
			{
				this.m_IKTarget.rotation = Quaternion.Lerp(this.BlendPosRot.rot, this.m_IKTarget.rotation, data.BlendWeight);
				this.RotationWeight = this.m_RotWeightBase;
			}
			else if (data.BlendType == IKCtrlData.IKBlendType.IK_To_Detach)
			{
				this.RotationWeight = this.m_RotWeightBase * (1f - data.BlendWeight);
			}
			else
			{
				this.RotationWeight = this.m_RotWeightBase * data.BlendWeight;
			}
			break;
		case IKCtrlData.IKAttachType.NewPoint:
			pos += this.m_PosRotOffset.pos;
			if (!data.DoSetOffset)
			{
				Vector3 start = pos;
				if (this.OffsetWorld)
				{
					pos += data.TgtOffset;
				}
				else if (this.OffsetBone)
				{
					pos -= this.TargetBone.rotation * data.TgtOffset;
				}
				else
				{
					pos += rot * data.TgtOffset;
				}
				Debug.DrawLine(start, pos, Color.white);
			}
			this.m_IKTarget.position = pos;
			if (data.BlendType == IKCtrlData.IKBlendType.IK_To_IK)
			{
				this.m_IKTarget.position = Vector3.Lerp(this.BlendPosRot.pos, this.m_IKTarget.position, data.BlendWeight);
				this.PositionWeight = this.m_PosWeightBase;
			}
			else if (data.BlendType == IKCtrlData.IKBlendType.IK_To_Detach)
			{
				this.PositionWeight = this.m_PosWeightBase * (1f - data.BlendWeight);
			}
			else
			{
				this.PositionWeight = this.m_PosWeightBase * data.BlendWeight;
			}
			break;
		}
		data.DoSetOffset = true;
	}

	public IKCtrlData.IKParam GetIKParam(IKCtrlData.IKAttachType attach_type, bool ignore_flag = false, bool is_next = false)
	{
		if (ignore_flag)
		{
			if (attach_type == IKCtrlData.IKAttachType.Rotate)
			{
				return (!is_next) ? this.m_RotateIK : this.m_NextRotateIK;
			}
			return (!is_next) ? this.m_PointIK : this.m_NextPointIK;
		}
		else
		{
			if (attach_type == IKCtrlData.IKAttachType.Rotate)
			{
				return this.RotateIK;
			}
			return this.PointIK;
		}
	}

	public IKCtrlData.IKParam GetNextIKParam(IKCtrlData.IKAttachType attach_type)
	{
		return this.GetIKParam(attach_type, true, true);
	}

	public IKCtrlData.ChangeFlagData GetFlagData(IKCtrlData.IKAttachType attach_type)
	{
		if (attach_type == IKCtrlData.IKAttachType.Rotate)
		{
			return this.m_RotateFlagData;
		}
		return this.m_PointFlagData;
	}

	public IKCtrlData.Vec3Enable GetIKEnable(IKCtrlData.IKAttachType attach_type)
	{
		if (attach_type == IKCtrlData.IKAttachType.Rotate)
		{
			return this.RotEnable;
		}
		return this.PosEnable;
	}

	public void SetFlagTarget(IKCtrlData.IKAttachType attach_type, string name)
	{
		if (this.MyIKCtrl.TgtMaid.boMAN)
		{
			this.GetFlagData(attach_type).Target = this.MyIKCtrl.TgtBody.GetBone(name);
		}
		else
		{
			this.GetFlagData(attach_type).Target = this.MyIKCtrl.GetSTFlagObj(name);
		}
	}

	public void SetIKSetting(IKCtrlData.IKAttachType attachType, bool is_another, Maid tgt_maid, int slot_no, string attach_name, Transform axis_bone, Vector3 f_vecOffset, bool do_animation = false)
	{
		this.SetIKSetting(attachType, is_another, tgt_maid, slot_no, attach_name, axis_bone, null, f_vecOffset, do_animation);
	}

	public void SetIKSetting(IKCtrlData.IKAttachType attachType, bool is_another, Maid tgt_maid, Transform target, Vector3 f_vecOffset, bool do_animation = false)
	{
		this.SetIKSetting(attachType, is_another, tgt_maid, -1, string.Empty, null, target, f_vecOffset, do_animation);
	}

	public void SetIKSetting(IKCtrlData.IKAttachType attachType, bool is_another, Transform target, Vector3 f_vecOffset, bool do_animation = false)
	{
		this.SetIKSetting(attachType, is_another, null, -1, string.Empty, null, target, f_vecOffset, do_animation);
	}

	public void SetIKSetting(IKCtrlData.IKAttachType attachType, bool is_another, Maid tgt_maid, string bone_name, Transform target, Vector3 f_vecOffset, bool do_animation = false)
	{
		this.SetIKSetting(attachType, is_another, tgt_maid, -1, bone_name, null, target, f_vecOffset, do_animation);
	}

	public virtual void Update()
	{
	}

	public virtual void ApplyIKSetting()
	{
		if (this.ForceIK)
		{
			this.PointIK.ChangePointType(IKCtrlData.IKAttachType.NewPoint);
		}
		if (!this.MyIKCtrl.IsUpdateEnd)
		{
			float num = 0f;
			this.RotationWeight = num;
			this.PositionWeight = num;
			this.m_BoneTgtPair.Cppy();
			this.m_EachOtherIK = false;
			this.ForceIK |= this.MyIKCtrl.AllForceIK;
		}
		this.ApplyIKSetting(this.PointIK);
		this.ApplyIKSetting(this.RotateIK);
	}

	public virtual void SetIKSetting(IKCtrlData.IKAttachType attachType, bool is_next, Maid tgt_maid, int slot_no, string attach_name, Transform axis_bone, Transform target, Vector3 f_vecOffset, bool do_animation = false)
	{
		this.GetIKParam(attachType, true, is_next).ChangePointType(attachType);
		if (this.GetIKParam(attachType, true, is_next).MyType != attachType)
		{
			return;
		}
		this.MyIKCtrl.IKActive = true;
		this.BlendPosRot.Copy(this.m_lastIKPosRot);
		this.m_PosRotOffset.Recet();
		this.m_FirstPosRotOffset.Recet();
		this.m_FirstTgtPosRot.Recet();
		if (!target && !string.IsNullOrEmpty(attach_name))
		{
			this.IsSelfIKAttach |= (tgt_maid == this.MyIKCtrl.TgtMaid);
		}
		this.GetIKParam(attachType, true, is_next).SetIKSetting(tgt_maid, slot_no, attach_name, axis_bone, target, f_vecOffset, do_animation);
		this.GetFlagData(attachType).IsFlagChange();
	}

	public virtual void Detach(IKCtrlData.IKAttachType attachType)
	{
		this.OffsetBone = false;
		this.OffsetWorld = false;
		this.ForceIK = false;
		this.m_BoneTgtPair.PosOffset = Vector3.zero;
		this.IsSelfIKAttach = false;
		this.BlendPosRot.Copy(this.m_lastIKPosRot);
		this.GetFlagData(attachType).Reset();
		this.GetIKParam(attachType, true, false).Detach();
		this.GetIKParam(attachType, true, true).Detach();
	}

	public virtual void LateUpdate()
	{
		if (this.IsIKExec && this.m_DrawLine && !this.MyIKCtrl.IsUpdateLate)
		{
			if (this.PositionWeight > 0f || this.RotationWeight > 0f)
			{
				KasaiUtility.DrawObjAxis(this.TargetBone, 0.0625f);
			}
			if (!this.OldIkExec && (this.PositionWeight > 0f || this.RotationWeight > 0f))
			{
				Color color = (!this.PointIK.IsIKExec) ? Color.cyan : Color.yellow;
				color.a = ((!this.PointIK.IsIKExec) ? this.RotationWeight : this.PositionWeight);
				for (int i = 0; i < this.ChainBones.Length - 1; i++)
				{
					Debug.DrawLine(this.ChainBones[i].position, this.ChainBones[i + 1].position, color);
				}
			}
		}
		this.m_lastIKPosRot.Copy(this.m_TargetBone);
		this.PointIK.DoSetPosRot = (this.RotateIK.DoSetPosRot = false);
	}

	public virtual void SetTargetOffset(Vector3 offset, bool inverse = false)
	{
		if (this.IsIKExec)
		{
			return;
		}
		this.m_BoneTgtPair.PosOffset = this.m_OffsetEnable.GetEnable(offset, inverse);
	}

	[SerializeField]
	[Header("位置IK")]
	private IKCtrlData.IKParam m_PointIK = new IKCtrlData.IKParam(IKCtrlData.IKAttachType.NewPoint, false);

	[SerializeField]
	private IKCtrlData.IKParam m_NextPointIK = new IKCtrlData.IKParam(IKCtrlData.IKAttachType.NewPoint, true);

	[SerializeField]
	private IKCtrlData.Vec3Enable m_PosEnable = new IKCtrlData.Vec3Enable();

	[SerializeField]
	[Header("回転IK")]
	private IKCtrlData.IKParam m_RotateIK = new IKCtrlData.IKParam(IKCtrlData.IKAttachType.Rotate, false);

	[SerializeField]
	private IKCtrlData.IKParam m_NextRotateIK = new IKCtrlData.IKParam(IKCtrlData.IKAttachType.Rotate, true);

	[SerializeField]
	private IKCtrlData.Vec3Enable m_RotEnable = new IKCtrlData.Vec3Enable();

	private TBody.IKCMO m_IKCmo = new TBody.IKCMO();

	private IKCtrlData.PosRotPair m_BlendPosRot = new IKCtrlData.PosRotPair();

	[SerializeField]
	[Space]
	private IKCtrlData.PosRotPair m_PosRotOffset = new IKCtrlData.PosRotPair();

	private IKCtrlData.PosRotPair m_FirstPosRotOffset = new IKCtrlData.PosRotPair();

	[SerializeField]
	private bool m_AttachPointIK;

	[SerializeField]
	private Transform m_TargetBone;

	[SerializeField]
	private Transform m_IKTarget;

	[SerializeField]
	private bool m_DrawLine = true;

	private IKCtrlData.BoneTgtPair m_BoneTgtPair;

	protected IKCtrlData.PosRotPair m_FirstTgtPosRot = new IKCtrlData.PosRotPair();

	protected IKCtrlData.PosRotPair m_lastIKPosRot = new IKCtrlData.PosRotPair();

	[SerializeField]
	[Range(0f, 1f)]
	protected float m_PosWeightBase = 1f;

	[SerializeField]
	[Range(0f, 1f)]
	protected float m_RotWeightBase = 1f;

	[SerializeField]
	protected bool m_ForceIK;

	protected bool m_ForceIKEnable;

	protected bool m_EachOtherIK;

	protected IKCtrlData.Vec3Enable m_OffsetEnable = new IKCtrlData.Vec3Enable();

	[SerializeField]
	[Header("フラグ情報")]
	protected IKCtrlData.ChangeFlagData m_PointFlagData = new IKCtrlData.ChangeFlagData();

	[SerializeField]
	protected IKCtrlData.ChangeFlagData m_RotateFlagData = new IKCtrlData.ChangeFlagData();

	[Space]
	public bool OffsetWorld;

	public bool OffsetBone;

	public readonly FullBodyIKCtrl MyIKCtrl;

	public readonly bool UseOldIK;

	public enum IKAttachType
	{
		Point,
		Rotate,
		NewPoint
	}

	public enum IKBlendType
	{
		Detach_To_IK,
		IK_To_IK,
		IK_To_Detach,
		Not_Blend
	}

	[Serializable]
	public class Vec3Enable
	{
		public bool AnyDisable
		{
			get
			{
				return !this.EnableX || !this.EnableY || !this.EnableZ;
			}
		}

		public Vector3 GetEnable(Vector3 pos, bool inverse = false)
		{
			if (this.EnableX == inverse)
			{
				pos.x = 0f;
			}
			if (this.EnableY == inverse)
			{
				pos.y = 0f;
			}
			if (this.EnableZ == inverse)
			{
				pos.z = 0f;
			}
			return pos;
		}

		public Vector3 GetEnable(Vector3 from, Vector3 to, bool inverse = false)
		{
			if (this.EnableX == inverse)
			{
				to.x = from.x;
			}
			if (this.EnableY == inverse)
			{
				to.y = from.y;
			}
			if (this.EnableZ == inverse)
			{
				to.z = from.z;
			}
			return to;
		}

		public void Recet()
		{
			this.EnableX = (this.EnableY = (this.EnableZ = true));
		}

		public void Copy(IKCtrlData.Vec3Enable cpy)
		{
			this.EnableX = cpy.EnableX;
			this.EnableY = cpy.EnableY;
			this.EnableZ = cpy.EnableZ;
		}

		public bool EnableX = true;

		public bool EnableY = true;

		public bool EnableZ = true;
	}

	[Serializable]
	public class PosRotPair
	{
		public void Recet()
		{
			this.pos = Vector3.zero;
			this.rot = new Quaternion(0f, 0f, 0f, 1f);
		}

		public void Copy(IKCtrlData.PosRotPair pair)
		{
			this.pos = pair.pos;
			this.rot = pair.rot;
		}

		public void Copy(Transform transform)
		{
			this.pos = transform.position;
			this.rot = transform.rotation;
		}

		public void DrawAxis()
		{
			KasaiUtility.DrawAxis(this.pos, this.rot, 0.0625f);
		}

		public Vector3 pos = Vector3.zero;

		public Quaternion rot = new Quaternion(0f, 0f, 0f, 1f);
	}

	public class BoneTgtPair
	{
		public BoneTgtPair(Transform bone, Transform target)
		{
			this.Bone = bone;
			this.Target = target;
		}

		public void Cppy()
		{
			this.Target.position = this.Bone.position + this.PosOffset;
			this.Target.rotation = this.Bone.rotation;
		}

		public readonly Transform Bone;

		public readonly Transform Target;

		public Vector3 PosOffset = Vector3.zero;
	}

	[Serializable]
	public class ChangeFlagData
	{
		public bool IsEnable
		{
			get
			{
				return this.Target != null;
			}
		}

		public bool IsFlagOn
		{
			get
			{
				return this.IsEnable && this.Value() >= this.OnValue;
			}
		}

		public float Value()
		{
			if (!this.Target)
			{
				return 0f;
			}
			Vector3 vector = KasaiUtility.Vec3Multiply(this.Target.localPosition, this.Axis);
			return vector.magnitude * Vector3.Dot(this.Axis, vector.normalized);
		}

		public float Value01()
		{
			return Mathf.Clamp01(this.Value() / this.OnValue);
		}

		public bool IsFlagChange()
		{
			if (!this.Target)
			{
				return false;
			}
			bool cunnretFlag = this.m_CunnretFlag;
			this.m_CunnretFlag = this.IsFlagOn;
			return cunnretFlag != this.m_CunnretFlag;
		}

		public void Reset()
		{
			this.Target = null;
			this.m_CunnretFlag = false;
			this.BlendCtrlSelf = false;
		}

		private bool m_CunnretFlag;

		public Transform Target;

		public Vector3 Axis = Vector3.forward;

		public float OnValue = 0.1f;

		[HideInInspector]
		public bool BlendCtrlSelf;
	}

	[Serializable]
	public class IKParam
	{
		public IKParam(IKCtrlData.IKAttachType type, bool is_next = false)
		{
			this.MyType = type;
			this.IsNext = is_next;
			this.BlendType = IKCtrlData.IKBlendType.Not_Blend;
		}

		public float BlendTime
		{
			get
			{
				return (!this.IKCtrl) ? -1f : this.IKCtrl.BlendTime;
			}
		}

		public IKCtrlData.IKAttachType MyType { get; private set; }

		public IKCtrlData.IKBlendType BlendType { get; private set; }

		public bool DoIKBlend
		{
			get
			{
				return this.m_DoIKBlend && this.BlendTime > 0f;
			}
		}

		public bool IsPointAttach
		{
			get
			{
				return this.MyType != IKCtrlData.IKAttachType.Rotate;
			}
		}

		public bool NeedBlend
		{
			get
			{
				return this.BlendTime > 0f;
			}
		}

		public float BlendWeight
		{
			get
			{
				return (!this.NeedBlend || !this.DoIKBlend) ? 1f : Mathf.Clamp01(this.ElapsedTime / this.BlendTime);
			}
		}

		public bool BlendNow
		{
			get
			{
				return this.NeedBlend && this.ElapsedTime <= this.BlendTime;
			}
		}

		public bool IsOldIK
		{
			get
			{
				return this.MyType == IKCtrlData.IKAttachType.Point;
			}
		}

		public bool ExistTgt
		{
			get
			{
				return this.Target != null || !string.IsNullOrEmpty(this.Tgt_AttachName);
			}
		}

		public void ChangePointType(IKCtrlData.IKAttachType type)
		{
			if (this.MyType == IKCtrlData.IKAttachType.Rotate)
			{
				return;
			}
			this.MyType = type;
		}

		public bool IsEachOtherIK(bool check_update = false)
		{
			return this.TgtMaid && this.TgtMaid.IKCtrl.IsIKExec && this.TgtMaid.IKCtrl.IsUpdateEnd == check_update;
		}

		public void CheckBlendType(bool check_time = true)
		{
			this.BlendType = IKCtrlData.IKBlendType.IK_To_IK;
			this.m_DoIKBlend = true;
			float num = Vector3.Distance(this.m_lastOffset, this.TgtOffset);
			if (this.m_lastTarget)
			{
				if (!this.Target && string.IsNullOrEmpty(this.Tgt_AttachName))
				{
					this.BlendType = IKCtrlData.IKBlendType.IK_To_Detach;
				}
				else if (this.Target)
				{
					this.m_DoIKBlend = (this.m_lastTarget != this.Target || num > 0.01f);
				}
			}
			else if (!string.IsNullOrEmpty(this.m_lastAttachName))
			{
				if (string.IsNullOrEmpty(this.Tgt_AttachName) && !this.Target)
				{
					this.BlendType = IKCtrlData.IKBlendType.IK_To_Detach;
				}
				else if (!this.Target)
				{
					this.m_DoIKBlend = (this.m_lastAttachName != this.Tgt_AttachName || this.m_lastTgtMaid != this.TgtMaid || num > 0.01f);
				}
			}
			else
			{
				this.BlendType = IKCtrlData.IKBlendType.Detach_To_IK;
				if (!this.Target && string.IsNullOrEmpty(this.Tgt_AttachName))
				{
					this.BlendType = IKCtrlData.IKBlendType.Not_Blend;
					this.m_DoIKBlend = false;
				}
			}
		}

		public void SetLastTarget(string attach_name, Maid maid, Transform target, Vector3 offset)
		{
			this.m_lastAttachName = attach_name;
			this.m_lastTgtMaid = maid;
			this.m_lastTarget = target;
			this.m_lastOffset = offset;
		}

		public void BlendRecet(bool elpsed_only = false)
		{
			this.ElapsedTime = 0f;
			if (!elpsed_only)
			{
				this.m_DoIKBlend = false;
				this.BlendType = IKCtrlData.IKBlendType.Not_Blend;
			}
		}

		public void SetIKSetting(Maid tgt_maid, int slot_no, string attach_name, Transform axis_bone, Transform target, Vector3 f_vecOffset, bool do_animation)
		{
			this.SetLastTarget(this.Tgt_AttachName, this.TgtMaid, this.Target, this.TgtOffset);
			this.TgtMaid = tgt_maid;
			this.Tgt_AttachSlot = slot_no;
			this.Tgt_AttachName = attach_name;
			this.Target = target;
			this.AxisTgt = axis_bone;
			if (this.IsPointAttach)
			{
				this.TgtOffset = f_vecOffset;
			}
			else
			{
				this.TgtOffset = KasaiUtility.AngleRimmit360(f_vecOffset);
			}
			this.BlendRecet(false);
			this.CheckBlendType(true);
			this.DoAnimation = do_animation;
			this.IsIKExec = true;
			this.FirstFrame = true;
		}

		public void Detach()
		{
			this.BlendRecet(false);
			this.SetLastTarget(this.Tgt_AttachName, this.TgtMaid, this.Target, this.TgtOffset);
			this.TgtMaid = null;
			this.Tgt_AttachSlot = -1;
			this.Tgt_AttachName = string.Empty;
			this.Target = null;
			this.AxisTgt = null;
			this.TgtOffset = Vector3.zero;
			this.CheckBlendType(true);
			this.DoSetOffset = false;
			this.DoSetPosRot = false;
			this.DoAnimation = false;
			this.IsIKExec = false;
			this.FirstFrame = false;
		}

		private string m_lastAttachName = string.Empty;

		private Transform m_lastTarget;

		private Maid m_lastTgtMaid;

		private Vector3 m_lastOffset = Vector3.zero;

		private bool m_DoIKBlend;

		public Transform Target;

		public Vector3 TgtOffset;

		public int Tgt_AttachSlot = -1;

		public string Tgt_AttachName = string.Empty;

		public Maid TgtMaid;

		public bool IsTgtAxis;

		public bool IsIKExec;

		public Transform AxisTgt;

		public float ElapsedTime;

		[HideInInspector]
		public bool FirstFrame;

		public bool DoAnimation;

		[HideInInspector]
		public bool DoSetPosRot;

		[HideInInspector]
		public bool DoSetOffset;

		[HideInInspector]
		public FullBodyIKCtrl IKCtrl;

		public readonly bool IsNext;
	}
}