public static void Update(string undoName, bool record)
{
List <Ik2D> updatedIKs = new List <Ik2D>();
for (int i = 0; i < s_Ik2Ds.Count; i++)
{
Ik2D ik2D = s_Ik2Ds[i];
if (ik2D && !updatedIKs.Contains(ik2D))
{
List <Ik2D> ikList = IkUtils.UpdateIK(ik2D, undoName, record);
if (ikList != null)
{
updatedIKs.AddRange(ikList);
updatedIKs = updatedIKs.Distinct().ToList();
}
}
}
foreach (Control control in s_Controls)
{
if (control && control.isActiveAndEnabled && control.bone)
{
control.transform.position = control.bone.transform.position;
control.transform.rotation = control.bone.transform.rotation;
}
}
}
static void UpdateIkList(List <Ik2D> ikList, string undoName, bool recordObject)
{
for (int i = 0; i < ikList.Count; i++)
{
Ik2D l_ik2D = ikList[i];
if (l_ik2D && l_ik2D.isActiveAndEnabled)
{
if (!string.IsNullOrEmpty(undoName))
{
for (int j = 0; j < l_ik2D.solver.solverPoses.Count; j++)
{
IkSolver2D.SolverPose pose = l_ik2D.solver.solverPoses [j];
if (pose.bone)
{
if (recordObject)
{
Undo.RecordObject(pose.bone.transform, undoName);
}
else
{
Undo.RegisterCompleteObjectUndo(pose.bone.transform, undoName);
}
}
}
}
if (!string.IsNullOrEmpty(undoName) &&
l_ik2D.orientChild &&
l_ik2D.target &&
l_ik2D.target.child)
{
if (recordObject)
{
Undo.RecordObject(l_ik2D.target.child.transform, undoName);
}
else
{
Undo.RegisterCompleteObjectUndo(l_ik2D.target.child.transform, undoName);
}
}
l_ik2D.UpdateIK();
for (int j = 0; j < l_ik2D.solver.solverPoses.Count; j++)
{
IkSolver2D.SolverPose pose = l_ik2D.solver.solverPoses [j];
if (pose.bone)
{
BoneUtils.FixLocalEulerHint(pose.bone.transform);
}
if (l_ik2D.orientChild && l_ik2D.target.child)
{
BoneUtils.FixLocalEulerHint(l_ik2D.target.child.transform);
}
}
}
}
}
public static void UpdateIK(Bone2D bone, string undoName)
{
List <Bone2D> boneList = new List <Bone2D>(25);
List <Ik2D> ikList = new List <Ik2D>(25);
BuildIkList(bone, boneList, ikList);
for (int i = 0; i < ikList.Count; i++)
{
Ik2D l_ik2D = ikList[i];
if (l_ik2D && l_ik2D.isActiveAndEnabled)
{
for (int j = 0; j < l_ik2D.solver.solverPoses.Count; j++)
{
IkSolver2D.SolverPose pose = l_ik2D.solver.solverPoses [j];
if (pose.bone)
{
Undo.RecordObject(pose.bone.transform, undoName);
}
}
l_ik2D.solver.RestoreDefaultPoses();
l_ik2D.UpdateIK();
}
}
}
static void ForceDeserialize()
{
for (int i = 0; i < s_Ik2Ds.Count; i++)
{
Ik2D ik2D = s_Ik2Ds [i];
if (ik2D)
{
ForceDeserialize(ik2D);
}
}
List <SpriteMeshInstance> spriteMeshInstances = new List <SpriteMeshInstance>(GameObject.FindObjectsOfType <SpriteMeshInstance>());
for (int i = 0; i < spriteMeshInstances.Count; i++)
{
SpriteMeshInstance spriteMeshInstance = spriteMeshInstances [i];
if (spriteMeshInstance)
{
ForceDeserialize(spriteMeshInstance);
}
}
UpdateAttachedIKs();
}
static void BuildIkList(Bone2D bone, List <Bone2D> boneList, List <Ik2D> ikList)
{
if (!bone)
{
return;
}
if (boneList.Contains(bone))
{
return;
}
boneList.Add(bone);
Ik2D ik2D = bone.attachedIK;
List <Bone2D> childBones = new List <Bone2D>(25);
if (ik2D)
{
if (!ikList.Contains(ik2D))
{
ikList.Add(ik2D);
}
for (int i = 0; i < ik2D.solver.solverPoses.Count; i++)
{
IkSolver2D.SolverPose pose = ik2D.solver.solverPoses [i];
if (pose.bone)
{
pose.bone.GetComponentsInChildren <Bone2D>(childBones);
for (int j = 0; j < childBones.Count; j++)
{
Bone2D l_bone = childBones[j];
if (l_bone && !boneList.Contains(l_bone))
{
BuildIkList(l_bone, boneList, ikList);
}
}
}
}
}
else
{
bone.GetComponentsInChildren <Bone2D>(childBones);
for (int j = 0; j < childBones.Count; j++)
{
Bone2D l_bone = childBones[j];
if (l_bone && !boneList.Contains(l_bone))
{
BuildIkList(l_bone, boneList, ikList);
}
}
}
}
public static List <Ik2D> UpdateIK(Ik2D ik2D, string undoName, bool recordObject)
{
if (ik2D && ik2D.target)
{
return(UpdateIK(ik2D.target.chainRoot, undoName, recordObject));
}
return(null);
}
public static List <Ik2D> BuildIkList(Ik2D ik2D)
{
if (ik2D.target)
{
return(BuildIkList(ik2D.target));
}
return(new List <Ik2D>());
}
public static void SavePose(Pose pose, Transform root)
{
List <Bone2D> bones = new List <Bone2D>(50);
root.GetComponentsInChildren <Bone2D>(true, bones);
SerializedObject poseSO = new SerializedObject(pose);
SerializedProperty entriesProp = poseSO.FindProperty("m_BoneEntries");
poseSO.Update();
entriesProp.arraySize = bones.Count;
for (int i = 0; i < bones.Count; i++)
{
Bone2D bone = bones [i];
if (bone)
{
SerializedProperty element = entriesProp.GetArrayElementAtIndex(i);
element.FindPropertyRelative("path").stringValue = BoneUtils.GetBonePath(root, bone);
element.FindPropertyRelative("localPosition").vector3Value = bone.transform.localPosition;
element.FindPropertyRelative("localRotation").quaternionValue = bone.transform.localRotation;
element.FindPropertyRelative("localScale").vector3Value = bone.transform.localScale;
}
}
poseSO.ApplyModifiedProperties();
List <Ik2D> iks = new List <Ik2D>(50);
root.GetComponentsInChildren <Ik2D>(true, iks);
SerializedObject poseS1 = new SerializedObject(pose);
SerializedProperty entriesProp1 = poseS1.FindProperty("m_IkEntries");
poseS1.Update();
entriesProp1.arraySize = iks.Count;
for (int i = 0; i < iks.Count; i++)
{
Ik2D ik = iks[i];
if (ik)
{
SerializedProperty element = entriesProp1.GetArrayElementAtIndex(i);
element.FindPropertyRelative("path").stringValue = IkUtils.GetIkPath(root, ik);
element.FindPropertyRelative("localPosition").vector3Value = ik.transform.localPosition;
element.FindPropertyRelative("localRotation").quaternionValue = ik.transform.localRotation;
element.FindPropertyRelative("localScale").vector3Value = ik.transform.localScale;
}
}
poseS1.ApplyModifiedProperties();
}
protected virtual void OnEnable()
{
m_Ik2D = target as Ik2D;
m_RecordProperty = serializedObject.FindProperty("m_Record");
m_TargetTransformProperty = serializedObject.FindProperty("m_TargetTransform");
m_WeightProperty = serializedObject.FindProperty("m_Weight");
m_RestorePoseProperty = serializedObject.FindProperty("m_RestoreDefaultPose");
m_OrientChildProperty = serializedObject.FindProperty("m_OrientChild");
}
private void AddToIkLateUpdate(Ik2D ik2D)
{
var updater = FindObjectOfType <IkLateUpdater>();
if (updater == null)
{
var newGo = new GameObject("IkLateUpdater", typeof(IkLateUpdater));
updater = newGo.GetComponent <IkLateUpdater>();
}
updater.AddLateUpdate(this);
}
void SetAttachedIK(Ik2D ik2D)
{
for (int i = 0; i < solver.solverPoses.Count; i++)
{
IkSolver2D.SolverPose pose = solver.solverPoses[i];
if (pose.bone)
{
pose.bone.attachedIK = ik2D;
}
}
}
public void UpdateGroup()
{
for (int i = 0; i < m_IkComponents.Count; i++)
{
Ik2D ik = m_IkComponents[i];
if (ik)
{
ik.enabled = false;
ik.UpdateIK();
}
}
}
static void Update()
{
EditorUpdaterProxy.Instance.onLateUpdate -= OnLateUpdate;
EditorUpdaterProxy.Instance.onLateUpdate += OnLateUpdate;
if (s_DraggingATool)
{
s_DraggingATool = false;
string undoName = "Move";
if (Tools.current == Tool.Rotate)
{
undoName = "Rotate";
}
if (Tools.current == Tool.Scale)
{
undoName = "Scale";
}
for (int i = 0; i < Selection.transforms.Length; i++)
{
Transform transform = Selection.transforms [i];
Control control = transform.GetComponent <Control> ();
if (control && control.isActiveAndEnabled && control.bone)
{
Undo.RecordObject(control.bone.transform, undoName);
control.bone.transform.position = control.transform.position;
control.bone.transform.rotation = control.transform.rotation;
BoneUtils.OrientToChild(control.bone.parentBone, false, undoName, true);
}
Ik2D ik2D = transform.GetComponent <Ik2D>();
if (ik2D && ik2D.record)
{
IkUtils.UpdateIK(ik2D, undoName, true);
}
}
SetDirty();
}
AnimationModeCheck();
AnimationWindowTimeCheck();
IkUtils.UpdateAttachedIKs(s_Ik2Ds);
UpdateIKs();
}
public static void LoadPose(Pose pose, Transform root)
{
SerializedObject poseSO = new SerializedObject(pose);
SerializedProperty entriesProp = poseSO.FindProperty("m_PoseEntries");
List <Ik2D> iks = new List <Ik2D>();
for (int i = 0; i < entriesProp.arraySize; i++)
{
SerializedProperty element = entriesProp.GetArrayElementAtIndex(i);
Transform boneTransform = root.Find(element.FindPropertyRelative("path").stringValue);
if (boneTransform)
{
Bone2D boneComponent = boneTransform.GetComponent <Bone2D>();
if (boneComponent && boneComponent.attachedIK && !iks.Contains(boneComponent.attachedIK))
{
iks.Add(boneComponent.attachedIK);
}
Undo.RecordObject(boneTransform, "Load Pose");
boneTransform.localPosition = element.FindPropertyRelative("localPosition").vector3Value;
boneTransform.localRotation = element.FindPropertyRelative("localRotation").quaternionValue;
boneTransform.localScale = element.FindPropertyRelative("localScale").vector3Value;
BoneUtils.FixLocalEulerHint(boneTransform);
}
}
for (int i = 0; i < iks.Count; i++)
{
Ik2D ik = iks[i];
if (ik && ik.target)
{
Undo.RecordObject(ik.transform, "Load Pose");
ik.transform.position = ik.target.endPosition;
if (ik.orientChild && ik.target.child)
{
ik.transform.rotation = ik.target.child.transform.rotation;
BoneUtils.FixLocalEulerHint(ik.transform);
}
}
}
EditorUpdater.SetDirty("Load Pose");
}
public static void UpdateAttachedIKs(List <Ik2D> Ik2Ds)
{
for (int i = 0; i < Ik2Ds.Count; i++)
{
Ik2D ik2D = Ik2Ds[i];
if (ik2D)
{
for (int j = 0; j < ik2D.solver.solverPoses.Count; j++)
{
IkSolver2D.SolverPose pose = ik2D.solver.solverPoses[j];
if (pose.bone)
{
pose.bone.attachedIK = ik2D;
}
}
}
}
}
static void Update()
{
UpdateAttachedIKs();
if (s_DraggingATool)
{
string undoName = "Move";
if (Tools.current == Tool.Rotate)
{
undoName = "Rotate";
}
if (Tools.current == Tool.Scale)
{
undoName = "Scale";
}
for (int i = 0; i < Selection.transforms.Length; i++)
{
Transform transform = Selection.transforms [i];
Ik2D ik2D = transform.GetComponent <Ik2D> ();
if (ik2D)
{
IkUtils.UpdateIK(ik2D, undoName);
}
Bone2D bone = transform.GetComponent <Bone2D>();
if (bone)
{
IkUtils.UpdateIK(bone, undoName);
}
}
s_DraggingATool = false;
}
}
internal void AddLateUpdate(Ik2D ik2D)
{
toUpdate.Add(ik2D);
toUpdate.Sort((x, y) => x.transform.GetSiblingIndex() - y.transform.GetSiblingIndex());
}
protected void DoUpdateIK()
{
Ik2D ik2D = target as Ik2D;
IkUtils.UpdateIK(ik2D, "Update IK");
}
/*사용하지 않는 코드. 차후 필요하면 태그 해제후 사용할것.
* public static string GetIkPath(Ik2D ik)
* {
* return GetBonePath(ik.root.transform, ik);
* }
*/
public static string GetIkPath(Transform root, Ik2D ik)
{
return(GetPath(root, ik.transform));
}
public static void UpdateIK(Ik2D ik2D, string undoName)
{
UpdateIK(ik2D.target, undoName);
}
public static void LoadPose(Pose pose, Transform root)
{
SerializedObject poseSO = new SerializedObject(pose);
SerializedProperty entriesProp = poseSO.FindProperty("m_BoneEntries");
List <Ik2D> iks = new List <Ik2D>();
for (int i = 0; i < entriesProp.arraySize; i++)
{
SerializedProperty element = entriesProp.GetArrayElementAtIndex(i);
Transform boneTransform = root.Find(element.FindPropertyRelative("path").stringValue);
if (boneTransform)
{
Bone2D boneComponent = boneTransform.GetComponent <Bone2D>();
if (boneComponent && boneComponent.attachedIK && !iks.Contains(boneComponent.attachedIK))
{
iks.Add(boneComponent.attachedIK);
}
Undo.RecordObject(boneTransform, "Load Pose");
boneTransform.localPosition = element.FindPropertyRelative("localPosition").vector3Value;
boneTransform.localRotation = element.FindPropertyRelative("localRotation").quaternionValue;
boneTransform.localScale = element.FindPropertyRelative("localScale").vector3Value;
}
}
/* 현재 불필요한 코드
* for (int i = 0; i < iks.Count; i++)
* {
* Ik2D ik = iks[i];
*
* if(ik && ik.target)
* {
* Undo.RecordObject(ik.transform,"Load Pose");
*
* ik.transform.position = ik.target.endPosition;
*
* if(ik.orientChild && ik.target.child)
* {
* ik.transform.rotation = ik.target.child.transform.rotation;
* }
* }
* }
*/
SerializedProperty entriesProp1 = poseSO.FindProperty("m_IkEntries");
for (int i = 0; i < entriesProp1.arraySize; i++)
{
SerializedProperty element = entriesProp1.GetArrayElementAtIndex(i);
Transform ikTransform = root.Find(element.FindPropertyRelative("path").stringValue);
if (ikTransform)
{
Ik2D ikComponent = ikTransform.GetComponent <Ik2D>();
Undo.RecordObject(ikTransform, "Load Pose");
ikTransform.localPosition = element.FindPropertyRelative("localPosition").vector3Value;
/*아래 스케일과 로테이션은 테스트후 제거*/
ikTransform.localRotation = element.FindPropertyRelative("localRotation").quaternionValue;
ikTransform.localScale = element.FindPropertyRelative("localScale").vector3Value;
}
}
EditorUpdater.SetDirty("Load Pose");
}
