COM_Diff/Assembly-CSharp/IKManager.cs

using System;
using System.Collections;
using System.Collections.Generic;
using RootMotion.FinalIK;
using UnityEngine;
using wf;

public class IKManager : MonoBehaviour
{
	public static Dictionary<IKManager.BoneType, KeyValuePair<IKManager.BoneSetType, GameObject>> CreateBoneDic(Maid maid)
	{
		if (maid == null)
		{
			return null;
		}
		NDebug.Assert(maid.body0 != null, "[body0] it does not end load.");
		return new Dictionary<IKManager.BoneType, KeyValuePair<IKManager.BoneSetType, GameObject>>
		{
			{
				IKManager.BoneType.TopFixed,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01").parent.gameObject)
			},
			{
				IKManager.BoneType.Root,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01").gameObject)
			},
			{
				IKManager.BoneType.Head,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 Head").gameObject)
			},
			{
				IKManager.BoneType.Neck,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 Neck").gameObject)
			},
			{
				IKManager.BoneType.Pelvis,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 Pelvis").gameObject)
			},
			{
				IKManager.BoneType.Spine0,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 Spine").gameObject)
			},
			{
				IKManager.BoneType.Spine1,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 Spine0a").gameObject)
			},
			{
				IKManager.BoneType.Spine2,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 Spine1").gameObject)
			},
			{
				IKManager.BoneType.Spine3,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 Spine1a").gameObject)
			},
			{
				IKManager.BoneType.Bust_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Mune_R").gameObject)
			},
			{
				IKManager.BoneType.Clavicle_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 R Clavicle").gameObject)
			},
			{
				IKManager.BoneType.UpperArm_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 R UpperArm").gameObject)
			},
			{
				IKManager.BoneType.Forearm_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 R Forearm").gameObject)
			},
			{
				IKManager.BoneType.Hand_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 R Hand").gameObject)
			},
			{
				IKManager.BoneType.Bust_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Mune_L").gameObject)
			},
			{
				IKManager.BoneType.Clavicle_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 L Clavicle").gameObject)
			},
			{
				IKManager.BoneType.UpperArm_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 L UpperArm").gameObject)
			},
			{
				IKManager.BoneType.Forearm_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 L Forearm").gameObject)
			},
			{
				IKManager.BoneType.Hand_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 L Hand").gameObject)
			},
			{
				IKManager.BoneType.Hip_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Hip_R").gameObject)
			},
			{
				IKManager.BoneType.Thigh_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 R Thigh").gameObject)
			},
			{
				IKManager.BoneType.Calf_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 R Calf").gameObject)
			},
			{
				IKManager.BoneType.Foot_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 R Foot").gameObject)
			},
			{
				IKManager.BoneType.Hip_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Hip_L").gameObject)
			},
			{
				IKManager.BoneType.Thigh_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 L Thigh").gameObject)
			},
			{
				IKManager.BoneType.Calf_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 L Calf").gameObject)
			},
			{
				IKManager.BoneType.Foot_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.Body, maid.body0.GetBone("Bip01 L Foot").gameObject)
			},
			{
				IKManager.BoneType.Finger0_Root_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightArmFinger, maid.body0.GetBone("Bip01 R Finger0").gameObject)
			},
			{
				IKManager.BoneType.Finger0_0_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightArmFinger, maid.body0.GetBone("Bip01 R Finger01").gameObject)
			},
			{
				IKManager.BoneType.Finger0_1_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightArmFinger, maid.body0.GetBone("Bip01 R Finger02").gameObject)
			},
			{
				IKManager.BoneType.Finger1_Root_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightArmFinger, maid.body0.GetBone("Bip01 R Finger1").gameObject)
			},
			{
				IKManager.BoneType.Finger1_0_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightArmFinger, maid.body0.GetBone("Bip01 R Finger11").gameObject)
			},
			{
				IKManager.BoneType.Finger1_1_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightArmFinger, maid.body0.GetBone("Bip01 R Finger12").gameObject)
			},
			{
				IKManager.BoneType.Finger2_Root_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightArmFinger, maid.body0.GetBone("Bip01 R Finger2").gameObject)
			},
			{
				IKManager.BoneType.Finger2_0_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightArmFinger, maid.body0.GetBone("Bip01 R Finger21").gameObject)
			},
			{
				IKManager.BoneType.Finger2_1_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightArmFinger, maid.body0.GetBone("Bip01 R Finger22").gameObject)
			},
			{
				IKManager.BoneType.Finger3_Root_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightArmFinger, maid.body0.GetBone("Bip01 R Finger3").gameObject)
			},
			{
				IKManager.BoneType.Finger3_0_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightArmFinger, maid.body0.GetBone("Bip01 R Finger31").gameObject)
			},
			{
				IKManager.BoneType.Finger3_1_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightArmFinger, maid.body0.GetBone("Bip01 R Finger32").gameObject)
			},
			{
				IKManager.BoneType.Finger4_Root_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightArmFinger, maid.body0.GetBone("Bip01 R Finger4").gameObject)
			},
			{
				IKManager.BoneType.Finger4_0_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightArmFinger, maid.body0.GetBone("Bip01 R Finger41").gameObject)
			},
			{
				IKManager.BoneType.Finger4_1_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightArmFinger, maid.body0.GetBone("Bip01 R Finger42").gameObject)
			},
			{
				IKManager.BoneType.Finger0_Root_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftArmFinger, maid.body0.GetBone("Bip01 L Finger0").gameObject)
			},
			{
				IKManager.BoneType.Finger0_0_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftArmFinger, maid.body0.GetBone("Bip01 L Finger01").gameObject)
			},
			{
				IKManager.BoneType.Finger0_1_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftArmFinger, maid.body0.GetBone("Bip01 L Finger02").gameObject)
			},
			{
				IKManager.BoneType.Finger1_Root_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftArmFinger, maid.body0.GetBone("Bip01 L Finger1").gameObject)
			},
			{
				IKManager.BoneType.Finger1_0_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftArmFinger, maid.body0.GetBone("Bip01 L Finger11").gameObject)
			},
			{
				IKManager.BoneType.Finger1_1_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftArmFinger, maid.body0.GetBone("Bip01 L Finger12").gameObject)
			},
			{
				IKManager.BoneType.Finger2_Root_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftArmFinger, maid.body0.GetBone("Bip01 L Finger2").gameObject)
			},
			{
				IKManager.BoneType.Finger2_0_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftArmFinger, maid.body0.GetBone("Bip01 L Finger21").gameObject)
			},
			{
				IKManager.BoneType.Finger2_1_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftArmFinger, maid.body0.GetBone("Bip01 L Finger22").gameObject)
			},
			{
				IKManager.BoneType.Finger3_Root_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftArmFinger, maid.body0.GetBone("Bip01 L Finger3").gameObject)
			},
			{
				IKManager.BoneType.Finger3_0_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftArmFinger, maid.body0.GetBone("Bip01 L Finger31").gameObject)
			},
			{
				IKManager.BoneType.Finger3_1_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftArmFinger, maid.body0.GetBone("Bip01 L Finger32").gameObject)
			},
			{
				IKManager.BoneType.Finger4_Root_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftArmFinger, maid.body0.GetBone("Bip01 L Finger4").gameObject)
			},
			{
				IKManager.BoneType.Finger4_0_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftArmFinger, maid.body0.GetBone("Bip01 L Finger41").gameObject)
			},
			{
				IKManager.BoneType.Finger4_1_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftArmFinger, maid.body0.GetBone("Bip01 L Finger42").gameObject)
			},
			{
				IKManager.BoneType.Toe0_Root_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightLegFinger, maid.body0.GetBone("Bip01 R Toe2").gameObject)
			},
			{
				IKManager.BoneType.Toe0_0_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightLegFinger, maid.body0.GetBone("Bip01 R Toe21").gameObject)
			},
			{
				IKManager.BoneType.Toe1_Root_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightLegFinger, maid.body0.GetBone("Bip01 R Toe1").gameObject)
			},
			{
				IKManager.BoneType.Toe1_0_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightLegFinger, maid.body0.GetBone("Bip01 R Toe11").gameObject)
			},
			{
				IKManager.BoneType.Toe2_Root_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightLegFinger, maid.body0.GetBone("Bip01 R Toe0").gameObject)
			},
			{
				IKManager.BoneType.Toe2_0_R,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightLegFinger, maid.body0.GetBone("Bip01 R Toe01").gameObject)
			},
			{
				IKManager.BoneType.Toe0_Root_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.RightLegFinger, maid.body0.GetBone("Bip01 L Toe2").gameObject)
			},
			{
				IKManager.BoneType.Toe0_0_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftLegFinger, maid.body0.GetBone("Bip01 L Toe21").gameObject)
			},
			{
				IKManager.BoneType.Toe1_Root_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftLegFinger, maid.body0.GetBone("Bip01 L Toe1").gameObject)
			},
			{
				IKManager.BoneType.Toe1_0_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftLegFinger, maid.body0.GetBone("Bip01 L Toe11").gameObject)
			},
			{
				IKManager.BoneType.Toe2_Root_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftLegFinger, maid.body0.GetBone("Bip01 L Toe0").gameObject)
			},
			{
				IKManager.BoneType.Toe2_0_L,
				new KeyValuePair<IKManager.BoneSetType, GameObject>(IKManager.BoneSetType.LeftLegFinger, maid.body0.GetBone("Bip01 L Toe01").gameObject)
			}
		};
	}

	public void Awake()
	{
	}

	public void SetMaid(Maid target_maid)
	{
		if (this.bone_dic_.Count != 0)
		{
			return;
		}
		StopWatch stopWatch = new StopWatch();
		this.maid = target_maid;
		if (this.maid == null)
		{
			return;
		}
		NDebug.Assert(this.maid.body0 != null, "[body0] it does not end load.");
		this.cache_bone_data_ = this.maid.gameObject.GetComponent<CacheBoneDataArray>();
		if (this.cache_bone_data_ == null)
		{
			this.cache_bone_data_ = this.maid.gameObject.AddComponent<CacheBoneDataArray>();
			this.cache_bone_data_.CreateCache(this.maid.body0.GetBone("Bip01"));
		}
		this.bone_dic_ = IKManager.CreateBoneDic(this.maid);
		List<KeyValuePair<int, IKManager.BoneType>> list = new List<KeyValuePair<int, IKManager.BoneType>>();
		Transform transform = this.bone_dic_[IKManager.BoneType.TopFixed].Value.transform;
		foreach (KeyValuePair<IKManager.BoneType, KeyValuePair<IKManager.BoneSetType, GameObject>> keyValuePair in this.bone_dic_)
		{
			Transform transform2 = keyValuePair.Value.Value.transform;
			int num = 0;
			while (!(transform2 == transform))
			{
				transform2 = transform2.parent;
				num++;
			}
			list.Add(new KeyValuePair<int, IKManager.BoneType>(num, keyValuePair.Key));
		}
		list.Sort((KeyValuePair<int, IKManager.BoneType> a, KeyValuePair<int, IKManager.BoneType> b) => a.Key - b.Key);
		this.sort_bone_list_ = new List<KeyValuePair<IKManager.BoneType, GameObject>>();
		foreach (KeyValuePair<int, IKManager.BoneType> keyValuePair2 in list)
		{
			this.sort_bone_list_.Add(new KeyValuePair<IKManager.BoneType, GameObject>(keyValuePair2.Value, this.bone_dic_[keyValuePair2.Value].Value));
		}
		this.limb_control_list_ = new List<LimbControl>();
		IEnumerator enumerator3 = Enum.GetValues(typeof(LimbControl.Type)).GetEnumerator();
		try
		{
			while (enumerator3.MoveNext())
			{
				object obj = enumerator3.Current;
				LimbControl.Type type = (LimbControl.Type)obj;
				LimbControl limbControl = base.gameObject.AddComponent<LimbControl>();
				limbControl.Initialize(this, type);
				this.limb_control_list_.Add(limbControl);
			}
		}
		finally
		{
			IDisposable disposable;
			if ((disposable = (enumerator3 as IDisposable)) != null)
			{
				disposable.Dispose();
			}
		}
		this.root_drag_point_ = IKManager.CreateIKDragPoint(this.GetBone(IKManager.BoneType.Root), this.maid);
		this.root_drag_point_.PositonCorrectionEnabled = false;
		this.root_drag_point_.cur_drag_event = delegate
		{
			this.root_drag_point_.target_ik_point_trans.position = this.root_drag_point_.transform.position;
		};
		this.root_drag_point_.drag_end_event = delegate
		{
			this.HistoryPush();
		};
		this.AddLimitComponen();
		this.gizmo_render_list_ = new List<GizmoRenderTarget>();
		this.gizmo_render_dic_ = new Dictionary<IKManager.BoneType, GizmoRenderTarget>();
		foreach (KeyValuePair<IKManager.BoneType, KeyValuePair<IKManager.BoneSetType, GameObject>> keyValuePair3 in this.bone_dic_)
		{
			GameObject gameObject = new GameObject();
			gameObject.transform.SetParent(base.transform, false);
			gameObject.name = keyValuePair3.Value.ToString();
			GizmoRenderTarget gizmoRenderTarget = gameObject.AddComponent<GizmoRenderTarget>();
			gizmoRenderTarget.ik_mgr = this;
			this.gizmo_render_list_.Add(gizmoRenderTarget);
			this.gizmo_render_dic_.Add(keyValuePair3.Key, gizmoRenderTarget);
			gizmoRenderTarget.target_trans = keyValuePair3.Value.Value.transform;
			gizmoRenderTarget.offsetScale = 0.2f;
			gizmoRenderTarget.lineRSelectedThick = 0.2f;
			RotationLimitHinge component = keyValuePair3.Value.Value.GetComponent<RotationLimitHinge>();
			if (component != null)
			{
				Vector3 axis = component.axis;
				if (axis.x != 0f && axis.y == 0f && axis.z == 0f)
				{
					gizmoRenderTarget.VisibleRotateY = (gizmoRenderTarget.VisibleRotateZ = false);
				}
				else if (axis.x == 0f && axis.y != 0f && axis.z == 0f)
				{
					gizmoRenderTarget.VisibleRotateX = (gizmoRenderTarget.VisibleRotateZ = false);
				}
				else if (axis.x == 0f && axis.y == 0f && axis.z != 0f)
				{
					gizmoRenderTarget.VisibleRotateX = (gizmoRenderTarget.VisibleRotateY = false);
				}
			}
		}
		this.finger_blend_ = base.gameObject.AddComponent<FingerBlend>();
		this.finger_blend_.SetIKManager(this);
		FingerBlend.BaseFinger right_arm_finger = this.finger_blend_.right_arm_finger;
		bool enabled = false;
		this.finger_blend_.left_arm_finger.enabled = enabled;
		right_arm_finger.enabled = enabled;
		FingerBlend.BaseFinger right_leg_finger = this.finger_blend_.right_leg_finger;
		enabled = false;
		this.finger_blend_.left_leg_finger.enabled = enabled;
		right_leg_finger.enabled = enabled;
	}

	public void Flip()
	{
		if (IKManager.notFlipTypes == null || IKManager.notFlipTypes.Count <= 0)
		{
			IKManager.notFlipTypes.Add(IKManager.BoneType.TopFixed);
			IKManager.notFlipTypes.Add(IKManager.BoneType.Head);
			IKManager.notFlipTypes.Add(IKManager.BoneType.Bust_R);
			IKManager.notFlipTypes.Add(IKManager.BoneType.Bust_L);
			for (int i = 27; i <= 68; i++)
			{
				IKManager.notFlipTypes.Add((IKManager.BoneType)i);
			}
		}
		if (IKManager.swapFlipDic == null || IKManager.swapFlipDic.Count <= 0)
		{
			IKManager.swapFlipDic.Add(IKManager.BoneType.Clavicle_R, IKManager.BoneType.Clavicle_L);
			IKManager.swapFlipDic.Add(IKManager.BoneType.UpperArm_R, IKManager.BoneType.UpperArm_L);
			IKManager.swapFlipDic.Add(IKManager.BoneType.Forearm_R, IKManager.BoneType.Forearm_L);
			IKManager.swapFlipDic.Add(IKManager.BoneType.Thigh_R, IKManager.BoneType.Thigh_L);
			IKManager.swapFlipDic.Add(IKManager.BoneType.Calf_R, IKManager.BoneType.Calf_L);
			IKManager.swapFlipDic.Add(IKManager.BoneType.Hand_R, IKManager.BoneType.Hand_L);
			IKManager.swapFlipDic.Add(IKManager.BoneType.Foot_R, IKManager.BoneType.Foot_L);
			List<KeyValuePair<IKManager.BoneType, IKManager.BoneType>> list = new List<KeyValuePair<IKManager.BoneType, IKManager.BoneType>>();
			foreach (KeyValuePair<IKManager.BoneType, IKManager.BoneType> keyValuePair in IKManager.swapFlipDic)
			{
				list.Add(new KeyValuePair<IKManager.BoneType, IKManager.BoneType>(keyValuePair.Value, keyValuePair.Key));
			}
			foreach (KeyValuePair<IKManager.BoneType, IKManager.BoneType> keyValuePair2 in list)
			{
				IKManager.swapFlipDic.Add(keyValuePair2.Key, keyValuePair2.Value);
			}
		}
		Dictionary<IKManager.BoneType, Vector3> dictionary = new Dictionary<IKManager.BoneType, Vector3>();
		for (int j = 0; j <= 68; j++)
		{
			IKManager.BoneType boneType = (IKManager.BoneType)j;
			if (!IKManager.notFlipTypes.Contains(boneType))
			{
				Transform transform = this.bone_dic_[boneType].Value.transform;
				dictionary.Add(boneType, transform.rotation.eulerAngles);
			}
		}
		Quaternion rotation = Quaternion.identity;
		Vector3 vector = Vector3.zero;
		for (int k = 0; k < this.sort_bone_list_.Count; k++)
		{
			IKManager.BoneType key = this.sort_bone_list_[k].Key;
			if (!IKManager.notFlipTypes.Contains(key))
			{
				vector = dictionary[key];
				if (key == IKManager.BoneType.Root)
				{
					rotation = Quaternion.Euler(360f - (vector.x + 270f) - 270f, 360f - (vector.y + 90f) - 90f, 360f - vector.z);
				}
				else
				{
					if (IKManager.swapFlipDic.ContainsKey(key))
					{
						vector = dictionary[IKManager.swapFlipDic[key]];
					}
					rotation = Quaternion.Euler(360f - vector.x, 360f - (vector.y + 90f) - 90f, vector.z);
				}
				this.bone_dic_[key].Value.transform.rotation = rotation;
			}
		}
		byte[] binary = this.finger_blend_.right_arm_finger.GetBinary();
		byte[] binary2 = this.finger_blend_.left_arm_finger.GetBinary();
		this.finger_blend_.right_arm_finger.SetBinary(binary2, true);
		this.finger_blend_.left_arm_finger.SetBinary(binary, true);
		binary = this.finger_blend_.right_leg_finger.GetBinary();
		binary2 = this.finger_blend_.left_leg_finger.GetBinary();
		this.finger_blend_.right_leg_finger.SetBinary(binary2, true);
		this.finger_blend_.left_leg_finger.SetBinary(binary, true);
	}

	public void SetRotateVisibleBone(IKManager.BoneType bone_type, bool visible)
	{
		this.gizmo_render_dic_[bone_type].Visible = visible;
	}

	public void SetRotateVisibleBoneSet(IKManager.BoneSetType bone_set_type, bool visible)
	{
		HashSet<Transform> hashSet = new HashSet<Transform>();
		foreach (KeyValuePair<IKManager.BoneType, KeyValuePair<IKManager.BoneSetType, GameObject>> keyValuePair in this.bone_dic_)
		{
			KeyValuePair<IKManager.BoneSetType, GameObject> value = keyValuePair.Value;
			if (value.Key == bone_set_type)
			{
				hashSet.Add(value.Value.transform);
			}
		}
		for (int i = 0; i < this.gizmo_render_list_.Count; i++)
		{
			if (hashSet.Contains(this.gizmo_render_list_[i].target_trans))
			{
				this.gizmo_render_list_[i].Visible = visible;
			}
		}
	}

	public void SetTransAxisVisibleBoneSet(IKManager.BoneSetType bone_set_type, bool visible)
	{
		HashSet<LimbControl.Type> hashSet = new HashSet<LimbControl.Type>();
		switch (bone_set_type)
		{
		case IKManager.BoneSetType.Body:
			hashSet.Add(LimbControl.Type.Arm_L);
			hashSet.Add(LimbControl.Type.Arm_R);
			hashSet.Add(LimbControl.Type.Foot_L);
			hashSet.Add(LimbControl.Type.Foot_R);
			break;
		case IKManager.BoneSetType.RightArmFinger:
			for (int i = 2; i <= 6; i++)
			{
				hashSet.Add((LimbControl.Type)i);
			}
			break;
		case IKManager.BoneSetType.LeftArmFinger:
			for (int j = 12; j <= 16; j++)
			{
				hashSet.Add((LimbControl.Type)j);
			}
			break;
		case IKManager.BoneSetType.RightLegFinger:
			for (int k = 7; k <= 9; k++)
			{
				hashSet.Add((LimbControl.Type)k);
			}
			break;
		case IKManager.BoneSetType.LeftLegFinger:
			for (int l = 17; l <= 19; l++)
			{
				hashSet.Add((LimbControl.Type)l);
			}
			break;
		}
		foreach (LimbControl limbControl in this.limb_control_list_)
		{
			if (hashSet.Contains(limbControl.type))
			{
				limbControl.visible = visible;
			}
		}
	}

	public void SetTransAxisVisibleRoot(bool visible)
	{
		this.root_drag_point_.visible = visible;
	}

	public void OnDestroy()
	{
		if (this.root_drag_point_ != null)
		{
			UnityEngine.Object.Destroy(this.root_drag_point_.gameObject);
		}
		foreach (LimbControl obj in this.limb_control_list_)
		{
			UnityEngine.Object.Destroy(obj);
		}
		foreach (GizmoRenderTarget gizmoRenderTarget in this.gizmo_render_list_)
		{
			UnityEngine.Object.Destroy(gizmoRenderTarget.gameObject);
		}
		this.gizmo_render_dic_.Clear();
		if (this.maid != null)
		{
			UnityEngine.Object.Destroy(this.cache_bone_data_);
			GameObject gameObject = GameObject.Find("IKDragPointParent/" + this.maid.status.guid);
			if (gameObject != null)
			{
				UnityEngine.Object.Destroy(gameObject.gameObject);
			}
		}
		if (this.finger_blend_ != null)
		{
			UnityEngine.Object.Destroy(this.finger_blend_);
		}
	}

	public void HistoryNew()
	{
		if (this.undo_backup_list_.Count == 0)
		{
			this.HistoryClear();
			this.HistoryPush();
		}
	}

	public void HistoryClear()
	{
		this.undo_backup_list_.Clear();
		this.history_point = 0;
	}

	public void HistoryPush()
	{
		if (this.maid == null)
		{
			return;
		}
		byte[] frameBinary = this.cache_bone_data.GetFrameBinary(true, true);
		if (this.undo_backup_list_.Count == 0 || frameBinary != this.undo_backup_list_[this.undo_backup_list_.Count - 1])
		{
			if (this.history_point < this.undo_backup_list_.Count)
			{
				this.undo_backup_list_.RemoveRange(this.history_point, this.undo_backup_list_.Count - this.history_point);
			}
			this.undo_backup_list_.Add(frameBinary);
			this.history_point++;
			if (200 <= this.undo_backup_list_.Count)
			{
				this.undo_backup_list_.RemoveAt(0);
				this.history_point--;
			}
		}
	}

	public bool HistoryUndo()
	{
		if (this.history_point <= 1)
		{
			return false;
		}
		this.history_point--;
		this.cache_bone_data.SetFrameBinary(this.undo_backup_list_[this.history_point - 1]);
		return true;
	}

	public bool HistoryRedo()
	{
		if (this.undo_backup_list_.Count <= this.history_point)
		{
			return false;
		}
		this.history_point++;
		this.cache_bone_data.SetFrameBinary(this.undo_backup_list_[this.history_point - 1]);
		return true;
	}

	public GameObject GetBone(IKManager.BoneType bone_type)
	{
		return (!this.bone_dic_.ContainsKey(bone_type)) ? null : this.bone_dic_[bone_type].Value;
	}

	public CacheBoneDataArray cache_bone_data
	{
		get
		{
			return this.cache_bone_data_;
		}
	}

	public Maid maid { get; private set; }

	public FingerBlend finger_blend
	{
		get
		{
			return this.finger_blend_;
		}
	}

	private void AddLimitComponen()
	{
		Action<IKManager.BoneType, Vector3, float, float> action = delegate(IKManager.BoneType target_bone, Vector3 axis, float limit, float twist_limit)
		{
			Transform transform = this.GetBone(target_bone).gameObject.transform;
			Quaternion localRotation = transform.localRotation;
			transform.localRotation = Quaternion.identity;
			RotationLimitAngle rotationLimitAngle = transform.gameObject.AddComponent<RotationLimitAngle>();
			rotationLimitAngle.axis = axis;
			rotationLimitAngle.limit = limit;
			rotationLimitAngle.twistLimit = twist_limit;
			transform.localRotation = localRotation;
			rotationLimitAngle.enabled = false;
		};
		Action<IKManager.BoneType, Vector3, Vector2> action2 = delegate(IKManager.BoneType target_bone, Vector3 axis, Vector2 min_max)
		{
			Transform transform = this.GetBone(target_bone).gameObject.transform;
			Quaternion localRotation = transform.localRotation;
			transform.localRotation = Quaternion.identity;
			RotationLimitHinge rotationLimitHinge = transform.gameObject.AddComponent<RotationLimitHinge>();
			rotationLimitHinge.axis = axis;
			rotationLimitHinge.min = min_max.x;
			rotationLimitHinge.max = min_max.y;
			transform.localRotation = localRotation;
			rotationLimitHinge.enabled = false;
		};
		action(IKManager.BoneType.Neck, new Vector3(-1f, 0f, 0f), 85f, 80f);
		action2(IKManager.BoneType.Forearm_L, new Vector3(0f, 0f, 1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Forearm_R, new Vector3(0f, 0f, 1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Calf_L, new Vector3(0f, 0f, 1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Calf_R, new Vector3(0f, 0f, 1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger0_0_L, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger1_0_L, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger2_0_L, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger3_0_L, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger4_0_L, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger0_0_R, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger1_0_R, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger2_0_R, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger3_0_R, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger4_0_R, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger0_1_L, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger1_1_L, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger2_1_L, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger3_1_L, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger4_1_L, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger0_1_R, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger1_1_R, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger2_1_R, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger3_1_R, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Finger4_1_R, new Vector3(0f, 0f, -1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Toe0_0_L, new Vector3(0f, 0f, 1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Toe0_0_R, new Vector3(0f, 0f, 1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Toe1_0_L, new Vector3(0f, 0f, 1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Toe1_0_R, new Vector3(0f, 0f, 1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Toe2_0_L, new Vector3(0f, 0f, 1f), new Vector2(0f, 170f));
		action2(IKManager.BoneType.Toe2_0_R, new Vector3(0f, 0f, 1f), new Vector2(0f, 170f));
	}

	public static IKDragPoint CreateIKDragPoint(GameObject obj, Maid maid)
	{
		GameObject gameObject = GameObject.Find("IKDragPointParent");
		if (gameObject == null)
		{
			gameObject = new GameObject("IKDragPointParent");
		}
		List<GameObject> list = new List<GameObject>();
		for (int i = 0; i < gameObject.transform.childCount; i++)
		{
			if (gameObject.transform.GetChild(i).childCount == 0 && gameObject.transform.GetChild(i).name != maid.status.guid)
			{
				list.Add(gameObject.transform.GetChild(i).gameObject);
			}
		}
		foreach (GameObject obj2 in list)
		{
			UnityEngine.Object.DestroyImmediate(obj2);
		}
		GameObject gameObject2 = GameObject.Find("IKDragPointParent/" + maid.status.guid);
		if (gameObject2 == null)
		{
			GameObject gameObject3 = new GameObject(maid.status.guid);
			gameObject3.transform.SetParent(gameObject.transform, false);
			gameObject = gameObject3;
		}
		else
		{
			gameObject = gameObject2;
		}
		GameObject gameObject4 = GameObject.Find("IKDragPointParent/" + maid.status.guid + "/IKDragPoint_" + obj.name);
		if (gameObject4 != null)
		{
			return gameObject4.GetComponent<IKDragPoint>();
		}
		GameObject gameObject5 = new GameObject("IKDragPoint_" + obj.name);
		gameObject5.transform.parent = gameObject.transform;
		IKDragPoint ikdragPoint = gameObject5.AddComponent<IKDragPoint>();
		ikdragPoint.SetTargetIKPoint(obj);
		WorldTransformAxis worldTransformAxis = PhotoWindowManager.CreateWorldTransformAxis(gameObject5, true, true);
		ikdragPoint.SetWorldTransformAxis(worldTransformAxis);
		return ikdragPoint;
	}

	private static HashSet<IKManager.BoneType> notFlipTypes = new HashSet<IKManager.BoneType>();

	private static Dictionary<IKManager.BoneType, IKManager.BoneType> swapFlipDic = new Dictionary<IKManager.BoneType, IKManager.BoneType>();

	private Dictionary<IKManager.BoneType, KeyValuePair<IKManager.BoneSetType, GameObject>> bone_dic_ = new Dictionary<IKManager.BoneType, KeyValuePair<IKManager.BoneSetType, GameObject>>();

	private List<KeyValuePair<IKManager.BoneType, GameObject>> sort_bone_list_ = new List<KeyValuePair<IKManager.BoneType, GameObject>>();

	private CacheBoneDataArray cache_bone_data_;

	private List<LimbControl> limb_control_list_;

	private List<GizmoRenderTarget> gizmo_render_list_;

	private Dictionary<IKManager.BoneType, GizmoRenderTarget> gizmo_render_dic_;

	private FingerBlend finger_blend_;

	private IKDragPoint root_drag_point_;

	private List<byte[]> undo_backup_list_ = new List<byte[]>();

	private int history_point;

	public enum BoneType
	{
		TopFixed,
		Root,
		Head,
		Neck,
		Pelvis,
		Spine0,
		Spine1,
		Spine2,
		Spine3,
		Bust_R,
		Clavicle_R,
		UpperArm_R,
		Forearm_R,
		Hand_R,
		Hip_R,
		Thigh_R,
		Calf_R,
		Foot_R,
		Bust_L,
		Clavicle_L,
		UpperArm_L,
		Forearm_L,
		Hand_L,
		Hip_L,
		Thigh_L,
		Calf_L,
		Foot_L,
		Finger0_Root_R,
		Finger0_0_R,
		Finger0_1_R,
		Finger1_Root_R,
		Finger1_0_R,
		Finger1_1_R,
		Finger2_Root_R,
		Finger2_0_R,
		Finger2_1_R,
		Finger3_Root_R,
		Finger3_0_R,
		Finger3_1_R,
		Finger4_Root_R,
		Finger4_0_R,
		Finger4_1_R,
		Finger0_Root_L,
		Finger0_0_L,
		Finger0_1_L,
		Finger1_Root_L,
		Finger1_0_L,
		Finger1_1_L,
		Finger2_Root_L,
		Finger2_0_L,
		Finger2_1_L,
		Finger3_Root_L,
		Finger3_0_L,
		Finger3_1_L,
		Finger4_Root_L,
		Finger4_0_L,
		Finger4_1_L,
		Toe0_Root_R,
		Toe0_0_R,
		Toe1_Root_R,
		Toe1_0_R,
		Toe2_Root_R,
		Toe2_0_R,
		Toe0_Root_L,
		Toe0_0_L,
		Toe1_Root_L,
		Toe1_0_L,
		Toe2_Root_L,
		Toe2_0_L
	}

	public enum BoneSetType
	{
		Body,
		RightArmFinger,
		LeftArmFinger,
		RightLegFinger,
		LeftLegFinger
	}
}