revert: character bone normalization

Author: cubesky

Warudo/Scripts/Warudo/Editor/SetupCharacterWindow.cs

@@ -11,7 +11,6 @@
 using UnityEditor;
 using UnityEngine;
 using VRM;
-using UniVRM10;
 using Warudo.Plugins.Core.Assets.Character;
 
 namespace Warudo.Editor {
@@ -105,9 +104,9 @@ public void SetupCharacter() {
             selectedCharacter.transform.rotation = Quaternion.identity;
 
             var colliderGroups = selectedCharacter.GetComponentsInChildren<VRMSpringBoneColliderGroup>();
-            var colliderGroupCenters = colliderGroups.ToDictionary(it => it, it =>
+            var colliderGroupCenters = colliderGroups.ToDictionary(it => it, it => 
                 it.Colliders.Select(c => it.transform.TransformPoint(c.Offset)).ToArray());
-
+            
             if (!normalizedBones) {
                 var animator = selectedCharacter.GetComponent<Animator>();
                 BoneNormalization.Apply(selectedCharacter.gameObject, animator);

Warudo/Scripts/Warudo/Plugins/Core/Assets/Character/BoneNormalization.cs

@@ -13,119 +13,7 @@
 namespace Warudo.Plugins.Core.Assets.Character {
     // Much of the code here is brought from UniVRM. Thanks!
     public static class BoneNormalization {
-        /// <summary>
-        /// Apply hierarchical bone normalization by storing non-standardized rotations in HumanBones
-        /// and propagating inverse rotations to children to maintain their world positions.
-        /// </summary>
         public static void Apply(GameObject go, Animator animator) {
-            ApplyHierarchicalNormalization(go, animator);
-        }
-
-        /// <summary>
-        /// Normalizes bones hierarchically by:
-        /// 1. Storing the non-identity rotation of each HumanBone
-        /// 2. Setting the HumanBone's local rotation to identity
-        /// 3. Applying the inverse rotation to children to preserve their world positions
-        /// 4. Recursively processing HumanBone children
-        /// </summary>
-        private static void ApplyHierarchicalNormalization(GameObject go, Animator animator) {
-            // Build a HashSet of all HumanBone transforms for quick lookup
-            var humanBoneSet = new HashSet<Transform>();
-            for (var i = 0; i < (int)HumanBodyBones.LastBone; i++) {
-                var bone = animator.GetBoneTransform((HumanBodyBones)i);
-                if (bone != null) {
-                    humanBoneSet.Add(bone);
-                }
-            }
-
-            // Collect all HumanBone transforms in hierarchy order (parent to child)
-            var humanBones = new List<(HumanBodyBones boneType, Transform transform)>();
-            for (var i = 0; i < (int)HumanBodyBones.LastBone; i++) {
-                var bone = animator.GetBoneTransform((HumanBodyBones)i);
-                if (bone != null) {
-                    humanBones.Add(((HumanBodyBones)i, bone));
-                }
-            }
-
-            // Sort by hierarchy depth to process parents before children
-            humanBones.Sort((a, b) => GetHierarchyDepth(a.transform).CompareTo(GetHierarchyDepth(b.transform)));
-
-            Debug.Log($"Normalizing {humanBones.Count} humanoid bones hierarchically...");
-
-            foreach (var (boneType, boneTransform) in humanBones) {
-                if (boneTransform.localRotation == Quaternion.identity) {
-                    continue; // Already normalized
-                }
-
-                var nonStandardRotation = boneTransform.localRotation;
-                Debug.Log($"Normalizing bone {boneTransform.name} ({boneType}): {nonStandardRotation.eulerAngles}");
-
-                // Store the non-standard rotation (we could save this somewhere if needed)
-                // For now, we just apply the normalization
-
-                // Apply inverse rotation to all children to preserve their world positions
-                NormalizeBoneAndChildren(boneTransform, humanBoneSet);
-            }
-
-            Debug.Log("Bone normalization complete.");
-        }
-
-        /// <summary>
-        /// Normalizes a bone and recursively updates its children to preserve world positions.
-        /// </summary>
-        private static void NormalizeBoneAndChildren(Transform boneTransform, HashSet<Transform> humanBoneSet) {
-            var originalRotation = boneTransform.localRotation;
-
-            // If the bone is already normalized, no need to process
-            if (originalRotation == Quaternion.identity) {
-                return;
-            }
-
-            // First, recursively process all HumanBone children first (bottom-up approach)
-            var humanBoneChildren = new List<Transform>();
-            foreach (Transform child in boneTransform) {
-                if (humanBoneSet.Contains(child)) {
-                    humanBoneChildren.Add(child);
-                }
-            }
-
-            // Process HumanBone children first
-            foreach (var child in humanBoneChildren) {
-                NormalizeBoneAndChildren(child, humanBoneSet);
-            }
-
-            // Calculate the inverse rotation that will be applied to children
-            var inverseRotation = Quaternion.Inverse(originalRotation);
-
-            // Now normalize this bone
-            boneTransform.localRotation = Quaternion.identity;
-
-            // Apply inverse rotation to all direct children (both HumanBones and non-HumanBones)
-            // to preserve their world positions
-            foreach (Transform child in boneTransform) {
-                if (!humanBoneChildren.Contains(child)) {
-                    // For non-HumanBone children, apply the inverse rotation
-                    child.localRotation = inverseRotation * child.localRotation;
-                }
-                // HumanBone children were already processed recursively
-            }
-        }
-
-        /// <summary>
-        /// Gets the hierarchy depth of a transform (root = 0).
-        /// </summary>
-        private static int GetHierarchyDepth(Transform transform) {
-            var depth = 0;
-            var current = transform;
-            while (current.parent != null) {
-                depth++;
-                current = current.parent;
-            }
-            return depth;
-        }
-
-        // Legacy method for reference (original implementation)
-        private static void ApplyLegacy(GameObject go, Animator animator) {
             var (normalized, boneMap) = NormalizeHierarchy(go, animator);
 
             foreach (var src in go.transform.Traverse()) {