1083 lines
39 KiB
C#
1083 lines
39 KiB
C#
using UnityEngine;
|
|
using UnityEditor;
|
|
using System.Collections.Generic;
|
|
|
|
public class RenameHumanoidBones : EditorWindow
|
|
{
|
|
private Animator selectedAnimator;
|
|
private Dictionary<HumanBodyBones, Transform> humanoidBones = new Dictionary<HumanBodyBones, Transform>();
|
|
private Dictionary<HumanBodyBones, string> newBoneNames = new Dictionary<HumanBodyBones, string>();
|
|
|
|
[MenuItem("Tools/Humanoid Bone Renamer")]
|
|
public static void ShowWindow()
|
|
{
|
|
GetWindow<RenameHumanoidBones>("Humanoid Bone Renamer");
|
|
}
|
|
|
|
private Vector2 scrollPosition;
|
|
|
|
private void OnGUI()
|
|
{
|
|
GUILayout.Label("Humanoid Bone Renamer", EditorStyles.boldLabel);
|
|
|
|
if (GUILayout.Button("Find Humanoid Bones"))
|
|
{
|
|
FindHumanoidBones();
|
|
}
|
|
|
|
// 믹사모 네이밍으로 일괄 변경 버튼 추가
|
|
if (GUILayout.Button("믹사모 네이밍으로 일괄 변경"))
|
|
{
|
|
RenameToMixamo();
|
|
}
|
|
|
|
if (selectedAnimator == null)
|
|
{
|
|
GUILayout.Label("No valid Humanoid Animator selected.", EditorStyles.helpBox);
|
|
return;
|
|
}
|
|
|
|
GUILayout.Label("Selected GameObject: " + selectedAnimator.gameObject.name, EditorStyles.boldLabel);
|
|
|
|
// T포즈 관련 버튼들 추가
|
|
EditorGUILayout.Space();
|
|
GUILayout.Label("T-Pose Functions", EditorStyles.boldLabel);
|
|
|
|
if (GUILayout.Button("Check T-Pose Conditions"))
|
|
{
|
|
CheckTPoseConditions();
|
|
}
|
|
|
|
if (GUILayout.Button("Apply Perfect T-Pose"))
|
|
{
|
|
ApplyPerfectTPose();
|
|
}
|
|
|
|
if (GUILayout.Button("Reset to Default Pose"))
|
|
{
|
|
ResetToDefaultPose();
|
|
}
|
|
|
|
EditorGUILayout.Space();
|
|
|
|
if (humanoidBones.Count > 0)
|
|
{
|
|
scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition, GUILayout.Height(400));
|
|
|
|
EditorGUILayout.BeginVertical("box");
|
|
GUILayout.Label("Humanoid Bones", EditorStyles.boldLabel);
|
|
|
|
foreach (var bone in humanoidBones)
|
|
{
|
|
EditorGUILayout.BeginHorizontal();
|
|
|
|
// First column: Unity's Humanoid bone name
|
|
GUILayout.Label(bone.Key.ToString(), GUILayout.Width(150));
|
|
|
|
// Second column: Current bone name
|
|
GUILayout.Label(bone.Value != null ? bone.Value.name : "None", GUILayout.Width(150));
|
|
|
|
// Third column: Input field for new name (defaulting to the first column's name)
|
|
if (!newBoneNames.ContainsKey(bone.Key))
|
|
{
|
|
newBoneNames[bone.Key] = bone.Key.ToString();
|
|
}
|
|
newBoneNames[bone.Key] = EditorGUILayout.TextField(newBoneNames[bone.Key], GUILayout.Width(150));
|
|
|
|
EditorGUILayout.EndHorizontal();
|
|
}
|
|
|
|
EditorGUILayout.EndVertical();
|
|
EditorGUILayout.EndScrollView();
|
|
}
|
|
|
|
if (GUILayout.Button("Change Humanoid Bones Name"))
|
|
{
|
|
ChangeHumanoidBoneNames();
|
|
}
|
|
}
|
|
|
|
private void FindHumanoidBones()
|
|
{
|
|
selectedAnimator = null;
|
|
humanoidBones.Clear();
|
|
newBoneNames.Clear();
|
|
|
|
if (Selection.activeGameObject == null)
|
|
{
|
|
Debug.LogError("No GameObject selected. Please select a GameObject with an Animator component.");
|
|
return;
|
|
}
|
|
|
|
selectedAnimator = Selection.activeGameObject.GetComponent<Animator>();
|
|
|
|
if (selectedAnimator == null || selectedAnimator.avatar == null || !selectedAnimator.avatar.isValid || !selectedAnimator.avatar.isHuman)
|
|
{
|
|
Debug.LogError("Selected GameObject does not have a valid Humanoid Avatar.");
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < HumanTrait.BoneCount; i++)
|
|
{
|
|
HumanBodyBones bone = (HumanBodyBones)i;
|
|
Transform boneTransform = selectedAnimator.GetBoneTransform(bone);
|
|
|
|
if (boneTransform != null)
|
|
{
|
|
humanoidBones[bone] = boneTransform;
|
|
}
|
|
}
|
|
|
|
Debug.Log("Humanoid bones found and ready for renaming.");
|
|
}
|
|
|
|
private void ChangeHumanoidBoneNames()
|
|
{
|
|
if (selectedAnimator == null)
|
|
{
|
|
Debug.LogError("No valid Humanoid Animator selected.");
|
|
return;
|
|
}
|
|
|
|
foreach (var bone in humanoidBones)
|
|
{
|
|
if (bone.Value != null && !string.IsNullOrWhiteSpace(newBoneNames[bone.Key]))
|
|
{
|
|
string newName = newBoneNames[bone.Key];
|
|
Debug.Log($"Renaming {bone.Value.name} to {newName}");
|
|
bone.Value.name = newName;
|
|
}
|
|
}
|
|
|
|
Debug.Log("Bone renaming completed.");
|
|
}
|
|
|
|
// T포즈 조건 검증
|
|
private void CheckTPoseConditions()
|
|
{
|
|
if (selectedAnimator == null)
|
|
{
|
|
Debug.LogError("No valid Humanoid Animator selected.");
|
|
return;
|
|
}
|
|
|
|
Debug.Log("=== T-Pose Conditions Check ===");
|
|
|
|
// 1. 몸통 뼈대들의 World X축 좌표가 0인지 확인
|
|
CheckBodyAlignment();
|
|
|
|
// 2. 팔 뼈대들의 World Z축 좌표가 동일한지 확인
|
|
CheckArmAlignment();
|
|
|
|
// 3. 다리 뼈대들의 World X축 좌표가 동일한지 확인
|
|
CheckLegAlignment();
|
|
|
|
Debug.Log("=== T-Pose Conditions Check Complete ===");
|
|
}
|
|
|
|
private void CheckBodyAlignment()
|
|
{
|
|
Debug.Log("--- Body Alignment Check ---");
|
|
|
|
HumanBodyBones[] bodyBones = {
|
|
HumanBodyBones.Hips,
|
|
HumanBodyBones.Spine,
|
|
HumanBodyBones.Chest,
|
|
HumanBodyBones.UpperChest,
|
|
HumanBodyBones.Neck,
|
|
HumanBodyBones.Head
|
|
};
|
|
|
|
float targetX = 0f;
|
|
bool allAligned = true;
|
|
|
|
foreach (var boneType in bodyBones)
|
|
{
|
|
Transform bone = selectedAnimator.GetBoneTransform(boneType);
|
|
if (bone != null)
|
|
{
|
|
float worldX = bone.position.x;
|
|
float difference = Mathf.Abs(worldX - targetX);
|
|
|
|
Debug.Log($"{boneType}: World X = {worldX:F3} (Target: {targetX:F3}, Difference: {difference:F3})");
|
|
|
|
if (difference > 0.01f)
|
|
{
|
|
allAligned = false;
|
|
Debug.LogWarning($" -> {boneType} is not aligned! Difference: {difference:F3}");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (allAligned)
|
|
{
|
|
Debug.Log("✓ Body bones are properly aligned on X-axis");
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning("✗ Body bones are NOT properly aligned on X-axis");
|
|
}
|
|
}
|
|
|
|
private void CheckArmAlignment()
|
|
{
|
|
Debug.Log("--- Arm Alignment Check ---");
|
|
|
|
HumanBodyBones[] leftArmBones = {
|
|
HumanBodyBones.LeftShoulder,
|
|
HumanBodyBones.LeftUpperArm,
|
|
HumanBodyBones.LeftLowerArm,
|
|
HumanBodyBones.LeftHand
|
|
};
|
|
|
|
HumanBodyBones[] rightArmBones = {
|
|
HumanBodyBones.RightShoulder,
|
|
HumanBodyBones.RightUpperArm,
|
|
HumanBodyBones.RightLowerArm,
|
|
HumanBodyBones.RightHand
|
|
};
|
|
|
|
CheckSideArmAlignment("Left Arm", leftArmBones);
|
|
CheckSideArmAlignment("Right Arm", rightArmBones);
|
|
}
|
|
|
|
private void CheckSideArmAlignment(string sideName, HumanBodyBones[] armBones)
|
|
{
|
|
Debug.Log($"--- {sideName} Alignment Check ---");
|
|
|
|
float targetZ = 0f;
|
|
bool firstBone = true;
|
|
bool allAligned = true;
|
|
|
|
foreach (var boneType in armBones)
|
|
{
|
|
Transform bone = selectedAnimator.GetBoneTransform(boneType);
|
|
if (bone != null)
|
|
{
|
|
float worldZ = bone.position.z;
|
|
|
|
if (firstBone)
|
|
{
|
|
targetZ = worldZ;
|
|
firstBone = false;
|
|
}
|
|
|
|
float difference = Mathf.Abs(worldZ - targetZ);
|
|
|
|
Debug.Log($"{boneType}: World Z = {worldZ:F3} (Target: {targetZ:F3}, Difference: {difference:F3})");
|
|
|
|
if (difference > 0.01f)
|
|
{
|
|
allAligned = false;
|
|
Debug.LogWarning($" -> {boneType} is not aligned! Difference: {difference:F3}");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (allAligned)
|
|
{
|
|
Debug.Log($"✓ {sideName} bones are properly aligned on Z-axis");
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning($"✗ {sideName} bones are NOT properly aligned on Z-axis");
|
|
}
|
|
}
|
|
|
|
private void CheckLegAlignment()
|
|
{
|
|
Debug.Log("--- Leg Alignment Check ---");
|
|
|
|
HumanBodyBones[] leftLegBones = {
|
|
HumanBodyBones.LeftUpperLeg,
|
|
HumanBodyBones.LeftLowerLeg,
|
|
HumanBodyBones.LeftFoot,
|
|
HumanBodyBones.LeftToes
|
|
};
|
|
|
|
HumanBodyBones[] rightLegBones = {
|
|
HumanBodyBones.RightUpperLeg,
|
|
HumanBodyBones.RightLowerLeg,
|
|
HumanBodyBones.RightFoot,
|
|
HumanBodyBones.RightToes
|
|
};
|
|
|
|
CheckSideLegAlignment("Left Leg", leftLegBones);
|
|
CheckSideLegAlignment("Right Leg", rightLegBones);
|
|
}
|
|
|
|
private void CheckSideLegAlignment(string sideName, HumanBodyBones[] legBones)
|
|
{
|
|
Debug.Log($"--- {sideName} Alignment Check ---");
|
|
|
|
float targetX = 0f;
|
|
bool firstBone = true;
|
|
bool allAligned = true;
|
|
|
|
foreach (var boneType in legBones)
|
|
{
|
|
Transform bone = selectedAnimator.GetBoneTransform(boneType);
|
|
if (bone != null)
|
|
{
|
|
float worldX = bone.position.x;
|
|
|
|
if (firstBone)
|
|
{
|
|
targetX = worldX;
|
|
firstBone = false;
|
|
}
|
|
|
|
float difference = Mathf.Abs(worldX - targetX);
|
|
|
|
Debug.Log($"{boneType}: World X = {worldX:F3} (Target: {targetX:F3}, Difference: {difference:F3})");
|
|
|
|
if (difference > 0.01f)
|
|
{
|
|
allAligned = false;
|
|
Debug.LogWarning($" -> {boneType} is not aligned! Difference: {difference:F3}");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (allAligned)
|
|
{
|
|
Debug.Log($"✓ {sideName} bones are properly aligned on X-axis");
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning($"✗ {sideName} bones are NOT properly aligned on X-axis");
|
|
}
|
|
}
|
|
|
|
// 완벽한 T포즈 적용
|
|
private void ApplyPerfectTPose()
|
|
{
|
|
if (selectedAnimator == null)
|
|
{
|
|
Debug.LogError("No valid Humanoid Animator selected.");
|
|
return;
|
|
}
|
|
|
|
Debug.Log("=== Applying Perfect T-Pose ===");
|
|
|
|
// Undo 시스템에 등록
|
|
Undo.RecordObject(selectedAnimator.gameObject, "Apply T-Pose");
|
|
|
|
// 단계 1: 팔 부분 조정
|
|
AdjustArmBones();
|
|
|
|
// 단계 2: 다리 부분 조정
|
|
AdjustLegBones();
|
|
|
|
Debug.Log("Perfect T-Pose applied successfully!");
|
|
}
|
|
|
|
// 팔 뼈대 조정 (단계 1)
|
|
private void AdjustArmBones()
|
|
{
|
|
Debug.Log("Adjusting arm bones...");
|
|
|
|
// 왼쪽 팔
|
|
AdjustSingleArm(HumanBodyBones.LeftUpperArm, HumanBodyBones.LeftLowerArm, HumanBodyBones.LeftHand, "Left");
|
|
|
|
// 오른쪽 팔
|
|
AdjustSingleArm(HumanBodyBones.RightUpperArm, HumanBodyBones.RightLowerArm, HumanBodyBones.RightHand, "Right");
|
|
}
|
|
|
|
// 다리 뼈대 조정 (단계 2)
|
|
private void AdjustLegBones()
|
|
{
|
|
Debug.Log("Adjusting leg bones...");
|
|
|
|
// 왼쪽 다리
|
|
AdjustSingleLeg(HumanBodyBones.LeftLowerLeg, HumanBodyBones.LeftFoot, "Left");
|
|
|
|
// 오른쪽 다리
|
|
AdjustSingleLeg(HumanBodyBones.RightLowerLeg, HumanBodyBones.RightFoot, "Right");
|
|
}
|
|
|
|
private void AdjustSingleLeg(HumanBodyBones lowerLeg, HumanBodyBones foot, string side)
|
|
{
|
|
Debug.Log($"Adjusting {side} leg...");
|
|
|
|
// LowerLeg (무릎) 조정
|
|
Transform lowerLegBone = selectedAnimator.GetBoneTransform(lowerLeg);
|
|
if (lowerLegBone != null)
|
|
{
|
|
// 로테이션은 건드리지 않음 (기존 회전값 유지)
|
|
|
|
// 로컬 X, Z 포지션만 0으로 변경
|
|
Vector3 localPos = lowerLegBone.localPosition;
|
|
localPos.x = 0f;
|
|
localPos.z = 0f;
|
|
lowerLegBone.localPosition = localPos;
|
|
|
|
Debug.Log($"{side} LowerLeg - Local Rotation: {lowerLegBone.localRotation.eulerAngles}, Local Position: {lowerLegBone.localPosition}");
|
|
}
|
|
|
|
// Foot (발목) 조정
|
|
Transform footBone = selectedAnimator.GetBoneTransform(foot);
|
|
if (footBone != null)
|
|
{
|
|
// 로테이션은 건드리지 않음 (기존 회전값 유지)
|
|
|
|
// 로컬 X, Z 포지션만 0으로 변경
|
|
Vector3 localPos = footBone.localPosition;
|
|
localPos.x = 0f;
|
|
localPos.z = 0f;
|
|
footBone.localPosition = localPos;
|
|
|
|
Debug.Log($"{side} Foot - Local Rotation: {footBone.localRotation.eulerAngles}, Local Position: {footBone.localPosition}");
|
|
}
|
|
|
|
// 발가락 조정
|
|
AdjustToes(side);
|
|
}
|
|
|
|
private void AdjustToes(string side)
|
|
{
|
|
Debug.Log($"Adjusting {side} toes...");
|
|
|
|
HumanBodyBones toeBone;
|
|
|
|
if (side == "Left")
|
|
{
|
|
toeBone = HumanBodyBones.LeftToes;
|
|
}
|
|
else // Right
|
|
{
|
|
toeBone = HumanBodyBones.RightToes;
|
|
}
|
|
|
|
Transform bone = selectedAnimator.GetBoneTransform(toeBone);
|
|
if (bone != null)
|
|
{
|
|
// 로테이션은 건드리지 않음 (기존 회전값 유지)
|
|
|
|
// 로컬 X, Z 포지션만 0으로 변경
|
|
Vector3 localPos = bone.localPosition;
|
|
localPos.x = 0f;
|
|
localPos.z = 0f;
|
|
bone.localPosition = localPos;
|
|
|
|
Debug.Log($"{side} Toes - Local Rotation: {bone.localRotation.eulerAngles}, Local Position: {bone.localPosition}");
|
|
}
|
|
}
|
|
|
|
private void AdjustSingleArm(HumanBodyBones upperArm, HumanBodyBones lowerArm, HumanBodyBones hand, string side)
|
|
{
|
|
Debug.Log($"Adjusting {side} arm...");
|
|
|
|
// UpperArm 조정
|
|
Transform upperArmBone = selectedAnimator.GetBoneTransform(upperArm);
|
|
if (upperArmBone != null)
|
|
{
|
|
// 로컬 Rotation을 0,0,0으로 초기화
|
|
upperArmBone.localRotation = Quaternion.identity;
|
|
|
|
// 로컬 X, Z 포지션을 0으로 변경
|
|
Vector3 localPos = upperArmBone.localPosition;
|
|
localPos.x = 0f;
|
|
localPos.z = 0f;
|
|
upperArmBone.localPosition = localPos;
|
|
|
|
Debug.Log($"{side} UpperArm - Local Rotation: {upperArmBone.localRotation.eulerAngles}, Local Position: {upperArmBone.localPosition}");
|
|
}
|
|
|
|
// LowerArm 조정
|
|
Transform lowerArmBone = selectedAnimator.GetBoneTransform(lowerArm);
|
|
if (lowerArmBone != null)
|
|
{
|
|
// 로컬 Rotation을 0,0,0으로 초기화
|
|
lowerArmBone.localRotation = Quaternion.identity;
|
|
|
|
// 로컬 X, Z 포지션을 0으로 변경
|
|
Vector3 localPos = lowerArmBone.localPosition;
|
|
localPos.x = 0f;
|
|
localPos.z = 0f;
|
|
lowerArmBone.localPosition = localPos;
|
|
|
|
Debug.Log($"{side} LowerArm - Local Rotation: {lowerArmBone.localRotation.eulerAngles}, Local Position: {lowerArmBone.localPosition}");
|
|
}
|
|
|
|
// Hand 조정
|
|
Transform handBone = selectedAnimator.GetBoneTransform(hand);
|
|
if (handBone != null)
|
|
{
|
|
// 로컬 Rotation을 0,0,0으로 초기화
|
|
handBone.localRotation = Quaternion.identity;
|
|
|
|
// 로컬 X, Z 포지션을 0으로 변경
|
|
Vector3 localPos = handBone.localPosition;
|
|
localPos.x = 0f;
|
|
localPos.z = 0f;
|
|
handBone.localPosition = localPos;
|
|
|
|
Debug.Log($"{side} Hand - Local Rotation: {handBone.localRotation.eulerAngles}, Local Position: {handBone.localPosition}");
|
|
}
|
|
|
|
// 손가락 조정 (엄지손가락 제외)
|
|
AdjustFingers(side);
|
|
}
|
|
|
|
private void AdjustFingers(string side)
|
|
{
|
|
Debug.Log($"Adjusting {side} fingers (excluding thumb)...");
|
|
|
|
// 엄지손가락을 제외한 손가락들
|
|
HumanBodyBones[] fingerBones;
|
|
|
|
if (side == "Left")
|
|
{
|
|
fingerBones = new HumanBodyBones[]
|
|
{
|
|
HumanBodyBones.LeftIndexProximal,
|
|
HumanBodyBones.LeftIndexIntermediate,
|
|
HumanBodyBones.LeftIndexDistal,
|
|
HumanBodyBones.LeftMiddleProximal,
|
|
HumanBodyBones.LeftMiddleIntermediate,
|
|
HumanBodyBones.LeftMiddleDistal,
|
|
HumanBodyBones.LeftRingProximal,
|
|
HumanBodyBones.LeftRingIntermediate,
|
|
HumanBodyBones.LeftRingDistal,
|
|
HumanBodyBones.LeftLittleProximal,
|
|
HumanBodyBones.LeftLittleIntermediate,
|
|
HumanBodyBones.LeftLittleDistal
|
|
};
|
|
}
|
|
else // Right
|
|
{
|
|
fingerBones = new HumanBodyBones[]
|
|
{
|
|
HumanBodyBones.RightIndexProximal,
|
|
HumanBodyBones.RightIndexIntermediate,
|
|
HumanBodyBones.RightIndexDistal,
|
|
HumanBodyBones.RightMiddleProximal,
|
|
HumanBodyBones.RightMiddleIntermediate,
|
|
HumanBodyBones.RightMiddleDistal,
|
|
HumanBodyBones.RightRingProximal,
|
|
HumanBodyBones.RightRingIntermediate,
|
|
HumanBodyBones.RightRingDistal,
|
|
HumanBodyBones.RightLittleProximal,
|
|
HumanBodyBones.RightLittleIntermediate,
|
|
HumanBodyBones.RightLittleDistal
|
|
};
|
|
}
|
|
|
|
foreach (var fingerBone in fingerBones)
|
|
{
|
|
Transform bone = selectedAnimator.GetBoneTransform(fingerBone);
|
|
if (bone != null)
|
|
{
|
|
// 로컬 Rotation을 0,0,0으로 초기화
|
|
bone.localRotation = Quaternion.identity;
|
|
|
|
// 손가락 첫 마디(Proximal)는 X축을 유지, 나머지는 X, Z 포지션을 0으로 변경
|
|
Vector3 localPos = bone.localPosition;
|
|
if (fingerBone.ToString().Contains("Proximal"))
|
|
{
|
|
// 첫 마디는 X축 유지, Z축만 0으로
|
|
localPos.z = 0f;
|
|
}
|
|
else
|
|
{
|
|
// 두번째, 세번째 마디는 X, Z 모두 0으로
|
|
localPos.x = 0f;
|
|
localPos.z = 0f;
|
|
}
|
|
bone.localPosition = localPos;
|
|
|
|
Debug.Log($"{side} {fingerBone} - Local Rotation: {bone.localRotation.eulerAngles}, Local Position: {bone.localPosition}");
|
|
}
|
|
}
|
|
|
|
// 엄지손가락 두번째와 세번째 마디 조정
|
|
AdjustThumbFingers(side);
|
|
}
|
|
|
|
private void AdjustThumbFingers(string side)
|
|
{
|
|
Debug.Log($"Adjusting {side} thumb intermediate and distal...");
|
|
|
|
HumanBodyBones[] thumbBones;
|
|
|
|
if (side == "Left")
|
|
{
|
|
thumbBones = new HumanBodyBones[]
|
|
{
|
|
HumanBodyBones.LeftThumbIntermediate,
|
|
HumanBodyBones.LeftThumbDistal
|
|
};
|
|
}
|
|
else // Right
|
|
{
|
|
thumbBones = new HumanBodyBones[]
|
|
{
|
|
HumanBodyBones.RightThumbIntermediate,
|
|
HumanBodyBones.RightThumbDistal
|
|
};
|
|
}
|
|
|
|
foreach (var thumbBone in thumbBones)
|
|
{
|
|
Transform bone = selectedAnimator.GetBoneTransform(thumbBone);
|
|
if (bone != null)
|
|
{
|
|
// 로컬 Rotation을 0,0,0으로 초기화
|
|
bone.localRotation = Quaternion.identity;
|
|
|
|
// X, Z 포지션을 0으로 변경
|
|
Vector3 localPos = bone.localPosition;
|
|
localPos.x = 0f;
|
|
localPos.z = 0f;
|
|
bone.localPosition = localPos;
|
|
|
|
Debug.Log($"{side} {thumbBone} - Local Rotation: {bone.localRotation.eulerAngles}, Local Position: {bone.localPosition}");
|
|
}
|
|
}
|
|
}
|
|
|
|
// 뼈대들의 부모-자식 관계를 일시적으로 분리
|
|
private Dictionary<Transform, Transform> DetachBonesFromHierarchy()
|
|
{
|
|
Debug.Log("Detaching bones from hierarchy...");
|
|
|
|
Dictionary<Transform, Transform> originalParents = new Dictionary<Transform, Transform>();
|
|
|
|
// 모든 Humanoid 뼈대의 부모-자식 관계를 저장하고 분리
|
|
for (int i = 0; i < HumanTrait.BoneCount; i++)
|
|
{
|
|
HumanBodyBones bone = (HumanBodyBones)i;
|
|
Transform boneTransform = selectedAnimator.GetBoneTransform(bone);
|
|
|
|
if (boneTransform != null)
|
|
{
|
|
// 원래 부모를 저장
|
|
originalParents[boneTransform] = boneTransform.parent;
|
|
|
|
// 뼈대를 최상위 레벨로 이동 (계층구조에서 분리)
|
|
boneTransform.SetParent(null, true);
|
|
|
|
Debug.Log($"Detached {bone} from parent: {originalParents[boneTransform]?.name ?? "None"}");
|
|
}
|
|
}
|
|
|
|
Debug.Log($"Detached {originalParents.Count} bones from hierarchy");
|
|
return originalParents;
|
|
}
|
|
|
|
// 뼈대들을 원래 부모-자식 관계로 복원
|
|
private void RestoreBoneHierarchy(Dictionary<Transform, Transform> originalParents)
|
|
{
|
|
Debug.Log("Restoring bone hierarchy...");
|
|
|
|
foreach (var kvp in originalParents)
|
|
{
|
|
Transform bone = kvp.Key;
|
|
Transform originalParent = kvp.Value;
|
|
|
|
if (bone != null)
|
|
{
|
|
// 원래 부모로 복원
|
|
bone.SetParent(originalParent, true);
|
|
Debug.Log($"Restored {bone.name} to parent: {originalParent?.name ?? "None"}");
|
|
}
|
|
}
|
|
|
|
Debug.Log("Bone hierarchy restored");
|
|
}
|
|
|
|
private void AlignBodyBones()
|
|
{
|
|
Debug.Log("Aligning body bones...");
|
|
|
|
HumanBodyBones[] bodyBones = {
|
|
HumanBodyBones.Hips,
|
|
HumanBodyBones.Spine,
|
|
HumanBodyBones.Chest,
|
|
HumanBodyBones.UpperChest,
|
|
HumanBodyBones.Neck,
|
|
HumanBodyBones.Head
|
|
};
|
|
|
|
foreach (var boneType in bodyBones)
|
|
{
|
|
Transform bone = selectedAnimator.GetBoneTransform(boneType);
|
|
if (bone != null)
|
|
{
|
|
// 현재 위치에서 X축만 0으로 조정
|
|
Vector3 newPosition = bone.position;
|
|
newPosition.x = 0f;
|
|
bone.position = newPosition;
|
|
|
|
// 회전을 0으로 설정 (똑바로 서있음)
|
|
bone.rotation = Quaternion.identity;
|
|
|
|
Debug.Log($"Aligned {boneType} to X=0, rotation=0");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SetArmsToTPose()
|
|
{
|
|
Debug.Log("Setting arms to T-pose...");
|
|
|
|
// 왼쪽 팔
|
|
SetArmToTPose(HumanBodyBones.LeftShoulder, HumanBodyBones.LeftUpperArm,
|
|
HumanBodyBones.LeftLowerArm, HumanBodyBones.LeftHand, true);
|
|
|
|
// 오른쪽 팔
|
|
SetArmToTPose(HumanBodyBones.RightShoulder, HumanBodyBones.RightUpperArm,
|
|
HumanBodyBones.RightLowerArm, HumanBodyBones.RightHand, false);
|
|
}
|
|
|
|
private void SetArmToTPose(HumanBodyBones shoulder, HumanBodyBones upperArm,
|
|
HumanBodyBones lowerArm, HumanBodyBones hand, bool isLeft)
|
|
{
|
|
string side = isLeft ? "Left" : "Right";
|
|
|
|
// 어깨 위치 및 회전 조정
|
|
Transform shoulderBone = selectedAnimator.GetBoneTransform(shoulder);
|
|
if (shoulderBone != null)
|
|
{
|
|
// 어깨를 몸통 중심에서 적절한 거리로 이동
|
|
Vector3 shoulderPos = shoulderBone.position;
|
|
float shoulderOffset = isLeft ? -0.3f : 0.3f;
|
|
shoulderPos.x = shoulderOffset;
|
|
shoulderBone.position = shoulderPos;
|
|
|
|
// 어깨를 Z축 기준으로 회전하여 팔이 수평이 되도록 함
|
|
float shoulderZRotation = isLeft ? 90f : -90f;
|
|
shoulderBone.rotation = Quaternion.Euler(0, 0, shoulderZRotation);
|
|
|
|
Debug.Log($"Positioned {side} shoulder at X={shoulderOffset}, Z rotation={shoulderZRotation}°");
|
|
}
|
|
|
|
// 상완 위치 및 회전 조정
|
|
Transform upperArmBone = selectedAnimator.GetBoneTransform(upperArm);
|
|
if (upperArmBone != null)
|
|
{
|
|
// 상완을 어깨에서 수평으로 뻗도록 위치 조정
|
|
Vector3 upperArmPos = upperArmBone.position;
|
|
float armLength = Vector3.Distance(shoulderBone.position, upperArmBone.position);
|
|
upperArmPos.x = isLeft ? -armLength : armLength;
|
|
upperArmBone.position = upperArmPos;
|
|
|
|
// 상완을 완전히 펴기 위해 회전 조정
|
|
upperArmBone.rotation = Quaternion.identity;
|
|
|
|
Debug.Log($"Positioned {side} upper arm at X={upperArmPos.x}, rotation=0°");
|
|
}
|
|
|
|
// 하완 위치 및 회전 조정
|
|
Transform lowerArmBone = selectedAnimator.GetBoneTransform(lowerArm);
|
|
if (lowerArmBone != null)
|
|
{
|
|
// 하완을 상완에서 수평으로 뻗도록 위치 조정
|
|
Vector3 lowerArmPos = lowerArmBone.position;
|
|
float forearmLength = Vector3.Distance(upperArmBone.position, lowerArmBone.position);
|
|
lowerArmPos.x = isLeft ? -(upperArmBone.position.x + forearmLength) : (upperArmBone.position.x + forearmLength);
|
|
lowerArmBone.position = lowerArmPos;
|
|
|
|
// 하완을 완전히 펴기 위해 회전 조정
|
|
lowerArmBone.rotation = Quaternion.identity;
|
|
|
|
Debug.Log($"Positioned {side} lower arm at X={lowerArmPos.x}, rotation=0°");
|
|
}
|
|
|
|
// 손 위치 및 회전 조정
|
|
Transform handBone = selectedAnimator.GetBoneTransform(hand);
|
|
if (handBone != null)
|
|
{
|
|
// 손을 하완에서 수평으로 뻗도록 위치 조정
|
|
Vector3 handPos = handBone.position;
|
|
float handLength = Vector3.Distance(lowerArmBone.position, handBone.position);
|
|
handPos.x = isLeft ? -(lowerArmBone.position.x + handLength) : (lowerArmBone.position.x + handLength);
|
|
handBone.position = handPos;
|
|
|
|
// 손을 자연스럽게 펴기 위해 회전 조정
|
|
handBone.rotation = Quaternion.identity;
|
|
|
|
Debug.Log($"Positioned {side} hand at X={handPos.x}, rotation=0°");
|
|
}
|
|
}
|
|
|
|
private void AlignLegBones()
|
|
{
|
|
Debug.Log("Aligning leg bones...");
|
|
|
|
HumanBodyBones[] leftLegBones = {
|
|
HumanBodyBones.LeftUpperLeg,
|
|
HumanBodyBones.LeftLowerLeg,
|
|
HumanBodyBones.LeftFoot,
|
|
HumanBodyBones.LeftToes
|
|
};
|
|
|
|
HumanBodyBones[] rightLegBones = {
|
|
HumanBodyBones.RightUpperLeg,
|
|
HumanBodyBones.RightLowerLeg,
|
|
HumanBodyBones.RightFoot,
|
|
HumanBodyBones.RightToes
|
|
};
|
|
|
|
AlignSideLegBones("Left", leftLegBones, -0.2f);
|
|
AlignSideLegBones("Right", rightLegBones, 0.2f);
|
|
}
|
|
|
|
private void AlignSideLegBones(string side, HumanBodyBones[] legBones, float targetX)
|
|
{
|
|
foreach (var boneType in legBones)
|
|
{
|
|
Transform bone = selectedAnimator.GetBoneTransform(boneType);
|
|
if (bone != null)
|
|
{
|
|
// 위치를 목표 X축으로 조정
|
|
Vector3 newPosition = bone.position;
|
|
newPosition.x = targetX;
|
|
bone.position = newPosition;
|
|
|
|
// 다리 뼈대들을 똑바로 세우기 위해 회전 조정
|
|
bone.rotation = Quaternion.identity;
|
|
|
|
Debug.Log($"Aligned {boneType} to X={targetX:F3}, rotation=0°");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SetFingersAndToesToTPose()
|
|
{
|
|
Debug.Log("Setting fingers and toes to T-pose...");
|
|
|
|
// 손가락 설정 (완전히 펴짐)
|
|
SetFingersToTPose(true); // 왼쪽
|
|
SetFingersToTPose(false); // 오른쪽
|
|
|
|
// 발가락 설정 (자연스러운 상태)
|
|
SetToesToTPose(true); // 왼쪽
|
|
SetToesToTPose(false); // 오른쪽
|
|
}
|
|
|
|
private void SetFingersToTPose(bool isLeft)
|
|
{
|
|
string side = isLeft ? "Left" : "Right";
|
|
|
|
// 모든 손가락 관절을 0도로 설정
|
|
for (int finger = 0; finger < 5; finger++)
|
|
{
|
|
for (int joint = 0; joint < 3; joint++)
|
|
{
|
|
HumanBodyBones fingerBone = GetFingerBone(isLeft, finger, joint);
|
|
if (fingerBone != HumanBodyBones.LastBone)
|
|
{
|
|
Transform bone = selectedAnimator.GetBoneTransform(fingerBone);
|
|
if (bone != null)
|
|
{
|
|
bone.localRotation = Quaternion.identity;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Debug.Log($"Set {side} fingers to straight position");
|
|
}
|
|
|
|
private void SetToesToTPose(bool isLeft)
|
|
{
|
|
string side = isLeft ? "Left" : "Right";
|
|
|
|
// 발가락을 자연스러운 상태로 설정
|
|
HumanBodyBones toeBone = isLeft ? HumanBodyBones.LeftToes : HumanBodyBones.RightToes;
|
|
Transform bone = selectedAnimator.GetBoneTransform(toeBone);
|
|
if (bone != null)
|
|
{
|
|
bone.localRotation = Quaternion.identity;
|
|
Debug.Log($"Set {side} toes to natural position");
|
|
}
|
|
}
|
|
|
|
private HumanBodyBones GetFingerBone(bool isLeft, int finger, int joint)
|
|
{
|
|
if (finger == 0) // 엄지
|
|
{
|
|
if (isLeft)
|
|
{
|
|
switch (joint)
|
|
{
|
|
case 0: return HumanBodyBones.LeftThumbProximal;
|
|
case 1: return HumanBodyBones.LeftThumbIntermediate;
|
|
case 2: return HumanBodyBones.LeftThumbDistal;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (joint)
|
|
{
|
|
case 0: return HumanBodyBones.RightThumbProximal;
|
|
case 1: return HumanBodyBones.RightThumbIntermediate;
|
|
case 2: return HumanBodyBones.RightThumbDistal;
|
|
}
|
|
}
|
|
}
|
|
else // 나머지 손가락들
|
|
{
|
|
if (isLeft)
|
|
{
|
|
switch (finger)
|
|
{
|
|
case 1: return joint == 0 ? HumanBodyBones.LeftIndexProximal :
|
|
joint == 1 ? HumanBodyBones.LeftIndexIntermediate :
|
|
HumanBodyBones.LeftIndexDistal;
|
|
case 2: return joint == 0 ? HumanBodyBones.LeftMiddleProximal :
|
|
joint == 1 ? HumanBodyBones.LeftMiddleIntermediate :
|
|
HumanBodyBones.LeftMiddleDistal;
|
|
case 3: return joint == 0 ? HumanBodyBones.LeftRingProximal :
|
|
joint == 1 ? HumanBodyBones.LeftRingIntermediate :
|
|
HumanBodyBones.LeftRingDistal;
|
|
case 4: return joint == 0 ? HumanBodyBones.LeftLittleProximal :
|
|
joint == 1 ? HumanBodyBones.LeftLittleIntermediate :
|
|
HumanBodyBones.LeftLittleDistal;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (finger)
|
|
{
|
|
case 1: return joint == 0 ? HumanBodyBones.RightIndexProximal :
|
|
joint == 1 ? HumanBodyBones.RightIndexIntermediate :
|
|
HumanBodyBones.RightIndexDistal;
|
|
case 2: return joint == 0 ? HumanBodyBones.RightMiddleProximal :
|
|
joint == 1 ? HumanBodyBones.RightMiddleIntermediate :
|
|
HumanBodyBones.RightMiddleDistal;
|
|
case 3: return joint == 0 ? HumanBodyBones.RightRingProximal :
|
|
joint == 1 ? HumanBodyBones.RightRingIntermediate :
|
|
HumanBodyBones.RightRingDistal;
|
|
case 4: return joint == 0 ? HumanBodyBones.RightLittleProximal :
|
|
joint == 1 ? HumanBodyBones.RightLittleIntermediate :
|
|
HumanBodyBones.RightLittleDistal;
|
|
}
|
|
}
|
|
}
|
|
|
|
return HumanBodyBones.LastBone; // 유효하지 않은 경우
|
|
}
|
|
|
|
// 기본 포즈로 리셋
|
|
private void ResetToDefaultPose()
|
|
{
|
|
if (selectedAnimator == null)
|
|
{
|
|
Debug.LogError("No valid Humanoid Animator selected.");
|
|
return;
|
|
}
|
|
|
|
Debug.Log("=== Resetting to Default Pose ===");
|
|
|
|
// Undo 시스템에 등록
|
|
Undo.RecordObject(selectedAnimator.gameObject, "Reset to Default Pose");
|
|
|
|
// 모든 뼈대의 로컬 회전을 0으로 리셋
|
|
for (int i = 0; i < HumanTrait.BoneCount; i++)
|
|
{
|
|
HumanBodyBones bone = (HumanBodyBones)i;
|
|
Transform boneTransform = selectedAnimator.GetBoneTransform(bone);
|
|
|
|
if (boneTransform != null)
|
|
{
|
|
boneTransform.localRotation = Quaternion.identity;
|
|
}
|
|
}
|
|
|
|
Debug.Log("Reset to default pose completed!");
|
|
}
|
|
|
|
// 믹사모 네이밍 매핑 및 일괄 변경 함수 추가
|
|
private void RenameToMixamo()
|
|
{
|
|
if (selectedAnimator == null)
|
|
{
|
|
Debug.LogError("No valid Humanoid Animator selected.");
|
|
return;
|
|
}
|
|
|
|
// HumanBodyBones와 믹사모 네이밍 매핑
|
|
var mixamoMap = new Dictionary<HumanBodyBones, string>
|
|
{
|
|
{ HumanBodyBones.Hips, "mixamorig:Hips" },
|
|
{ HumanBodyBones.LeftUpperLeg, "mixamorig:LeftUpLeg" },
|
|
{ HumanBodyBones.LeftLowerLeg, "mixamorig:LeftLeg" },
|
|
{ HumanBodyBones.LeftFoot, "mixamorig:LeftFoot" },
|
|
{ HumanBodyBones.LeftToes, "mixamorig:LeftToeBase" },
|
|
{ HumanBodyBones.RightUpperLeg, "mixamorig:RightUpLeg" },
|
|
{ HumanBodyBones.RightLowerLeg, "mixamorig:RightLeg" },
|
|
{ HumanBodyBones.RightFoot, "mixamorig:RightFoot" },
|
|
{ HumanBodyBones.RightToes, "mixamorig:RightToeBase" },
|
|
{ HumanBodyBones.Spine, "mixamorig:Spine" },
|
|
{ HumanBodyBones.Chest, "mixamorig:Spine1" },
|
|
{ HumanBodyBones.UpperChest, "mixamorig:Spine2" }, // UpperChest는 있는 경우만
|
|
{ HumanBodyBones.Neck, "mixamorig:Neck" },
|
|
{ HumanBodyBones.Head, "mixamorig:Head" },
|
|
{ HumanBodyBones.LeftShoulder, "mixamorig:LeftShoulder" },
|
|
{ HumanBodyBones.LeftUpperArm, "mixamorig:LeftArm" },
|
|
{ HumanBodyBones.LeftLowerArm, "mixamorig:LeftForeArm" },
|
|
{ HumanBodyBones.LeftHand, "mixamorig:LeftHand" },
|
|
{ HumanBodyBones.RightShoulder, "mixamorig:RightShoulder" },
|
|
{ HumanBodyBones.RightUpperArm, "mixamorig:RightArm" },
|
|
{ HumanBodyBones.RightLowerArm, "mixamorig:RightForeArm" },
|
|
{ HumanBodyBones.RightHand, "mixamorig:RightHand" },
|
|
// 왼손 손가락
|
|
{ HumanBodyBones.LeftThumbProximal, "mixamorig:LeftHandThumb1" },
|
|
{ HumanBodyBones.LeftThumbIntermediate, "mixamorig:LeftHandThumb2" },
|
|
{ HumanBodyBones.LeftThumbDistal, "mixamorig:LeftHandThumb3" },
|
|
// mixamo에는 Thumb4가 있으나, Unity에는 없음
|
|
{ HumanBodyBones.LeftIndexProximal, "mixamorig:LeftHandIndex1" },
|
|
{ HumanBodyBones.LeftIndexIntermediate, "mixamorig:LeftHandIndex2" },
|
|
{ HumanBodyBones.LeftIndexDistal, "mixamorig:LeftHandIndex3" },
|
|
{ HumanBodyBones.LeftMiddleProximal, "mixamorig:LeftHandMiddle1" },
|
|
{ HumanBodyBones.LeftMiddleIntermediate, "mixamorig:LeftHandMiddle2" },
|
|
{ HumanBodyBones.LeftMiddleDistal, "mixamorig:LeftHandMiddle3" },
|
|
{ HumanBodyBones.LeftRingProximal, "mixamorig:LeftHandRing1" },
|
|
{ HumanBodyBones.LeftRingIntermediate, "mixamorig:LeftHandRing2" },
|
|
{ HumanBodyBones.LeftRingDistal, "mixamorig:LeftHandRing3" },
|
|
{ HumanBodyBones.LeftLittleProximal, "mixamorig:LeftHandPinky1" },
|
|
{ HumanBodyBones.LeftLittleIntermediate, "mixamorig:LeftHandPinky2" },
|
|
{ HumanBodyBones.LeftLittleDistal, "mixamorig:LeftHandPinky3" },
|
|
// 오른손 손가락
|
|
{ HumanBodyBones.RightThumbProximal, "mixamorig:RightHandThumb1" },
|
|
{ HumanBodyBones.RightThumbIntermediate, "mixamorig:RightHandThumb2" },
|
|
{ HumanBodyBones.RightThumbDistal, "mixamorig:RightHandThumb3" },
|
|
{ HumanBodyBones.RightIndexProximal, "mixamorig:RightHandIndex1" },
|
|
{ HumanBodyBones.RightIndexIntermediate, "mixamorig:RightHandIndex2" },
|
|
{ HumanBodyBones.RightIndexDistal, "mixamorig:RightHandIndex3" },
|
|
{ HumanBodyBones.RightMiddleProximal, "mixamorig:RightHandMiddle1" },
|
|
{ HumanBodyBones.RightMiddleIntermediate, "mixamorig:RightHandMiddle2" },
|
|
{ HumanBodyBones.RightMiddleDistal, "mixamorig:RightHandMiddle3" },
|
|
{ HumanBodyBones.RightRingProximal, "mixamorig:RightHandRing1" },
|
|
{ HumanBodyBones.RightRingIntermediate, "mixamorig:RightHandRing2" },
|
|
{ HumanBodyBones.RightRingDistal, "mixamorig:RightHandRing3" },
|
|
{ HumanBodyBones.RightLittleProximal, "mixamorig:RightHandPinky1" },
|
|
{ HumanBodyBones.RightLittleIntermediate, "mixamorig:RightHandPinky2" },
|
|
{ HumanBodyBones.RightLittleDistal, "mixamorig:RightHandPinky3" },
|
|
};
|
|
|
|
// UpperChest가 없는 경우 무시
|
|
foreach (var kvp in mixamoMap)
|
|
{
|
|
if (kvp.Key == HumanBodyBones.UpperChest)
|
|
{
|
|
var upperChest = selectedAnimator.GetBoneTransform(HumanBodyBones.UpperChest);
|
|
if (upperChest == null) continue;
|
|
upperChest.name = kvp.Value;
|
|
Debug.Log($"UpperChest 본이 있어 이름을 {kvp.Value}로 변경");
|
|
continue;
|
|
}
|
|
var bone = selectedAnimator.GetBoneTransform(kvp.Key);
|
|
if (bone != null)
|
|
{
|
|
bone.name = kvp.Value;
|
|
Debug.Log($"{kvp.Key} 이름을 {kvp.Value}로 변경");
|
|
}
|
|
}
|
|
Debug.Log("믹사모 네이밍으로 일괄 변경 완료!");
|
|
}
|
|
}
|