Unity Tool Bone Hierarchy

2024-06-02 11:02 UTC gpt-4

You

Turn this into a Unity Editor Tool that accepts a root bone, and a list of omitted bones contained in a scriptable object, and generates a new Scriptable object with the bone transform list, the bone name list and the parent indices list. then this scriptable object is stored and can be used for ever, without losing serialization

using System; using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.Events; using UnityEngine.Serialization; using NeuronBones = Neuron.NeuronBones;

public enum BoneSorting { BasedOnNeuron, BasedOnHierarchy }

public class LimbIdentifier : MonoBehaviour { [Header(“Referenced Elements”)] public Transform root; public bool add_root; public BoneSorting boneSorting; public List omitted_bones = new();

[Header("Identified Elements")]
public List<string> IdentifiedBones;
public List<Transform> BoneTransforms;
public List<int> ParentBoneIndex;

[HideInInspector] public UnityEvent<List<Transform>> OnLimbsIdentified;
[HideInInspector] public UnityEvent<List<string>> OnLimbNamesIdentified;
[HideInInspector] public UnityEvent<List<int>> OnLimbHierarchyIdentified;
[HideInInspector] public UnityEvent OnLimbInfoBroadcasted;

[HideInInspector] public string[] Bones;


public void PublishData()
{
    PublishData(out var trans, out var names, out var inds);

    OnLimbsIdentified.Invoke(trans);
    OnLimbNamesIdentified?.Invoke(names);
    OnLimbHierarchyIdentified?.Invoke(inds);
    OnLimbInfoBroadcasted?.Invoke();
}

public void PublishData(out List<Transform> boneTransforms, out List<string> boneNames,
    out List<int> parentBoneIndex)
{
    var emptyLists =
        (BoneTransforms?.Count ?? 0) == 0 ||
        (IdentifiedBones?.Count ?? 0) == 0 ||
        (ParentBoneIndex?.Count ?? 0) == 0;

    if (emptyLists)
    {
        IdentifySkeletonBones();
    }

    boneTransforms = BoneTransforms;
    boneNames = IdentifiedBones;
    parentBoneIndex = ParentBoneIndex;
}

private void IdentifySkeletonBones()
{
    IdentifiedBones = new List<string>();
    BoneTransforms = new List<Transform>();
    ParentBoneIndex = new List<int>();

    // add root to bone transforms
    if (add_root)
    {
        IdentifiedBones.Add(root.name);
        BoneTransforms.Add(root);
    }

    //Bones = Enum.GetNames(typeof(NeuronBones));
    CreateBoneHierarchy();

    var bone_count = Bones.Length;

    for (var i = 0; i < bone_count; i++)
    {
        SearchForBoneTransform(Bones[i],root);
    }

    DetectBoneHierarchy(root,ParentBoneIndex);
}

private void CreateBoneHierarchy()
{
    switch (boneSorting)
    {
        case BoneSorting.BasedOnNeuron:
            Bones = Enum.GetNames(typeof(NeuronBones));
            break;
        case BoneSorting.BasedOnHierarchy:
            List<string> boneNames = new List<string>();
            ExtractBoneName(root,boneNames);
            Bones = boneNames.ToArray();
            break;
        default:
            throw new ArgumentOutOfRangeException();
    }
}

private void ExtractBoneName(Transform tr, List<string> names)
{
    //bool omit_name = false;
    var n = tr.gameObject.name;
    /*for (int i = 0; i < omitted_bones.Count; i++)
    {
        if (n.Contains(omitted_bones[i]))
        {
            omit_name = true;
            break;
        }
    }*/
    bool omit_name = OmitBone(n);

    // only add name if it is not in the omit list
    if(!omit_name) names.Add(tr.gameObject.name);
    if (tr.childCount > 0)
    {
        for (int i = 0; i < tr.childCount; i++)
        {
            ExtractBoneName(tr.GetChild(i),names);
        }
    }
}

private bool OmitBone(string n)
{
    bool omit_name = false;
    for (int i = 0; i < omitted_bones.Count; i++)
    {
        if (n.Contains(omitted_bones[i]))
        {
            omit_name = true;
            break;
        }
    }

    return omit_name;
}

private void SearchForBoneTransform(string bone, Transform tr)
{
    for (int i = 0; i < tr.childCount; i++)
    {
        var ch = tr.GetChild(i);

        if (ch.gameObject.name.Contains(bone))
        {
            IdentifiedBones.Add(bone);
            BoneTransforms.Add(ch);
            break;
        }
        SearchForBoneTransform(bone,ch);
    }
}

private void DetectBoneHierarchy(Transform tr, List<int> h_index)
{
    int p_index;
    // we are at root --  not looking for parent
    if (tr.gameObject.name.Contains(Bones[0]))
    {
        p_index = -1;
        h_index.Add(p_index);
    }
    else
    {
        bool omit_name = OmitBone(tr.gameObject.name);
        if (!omit_name)
        {
            var p_name = tr.parent.gameObject.name;
            for (int i = 0; i < Bones.Length; i++)
            {
                if (p_name.Contains(Bones[i]))
                {
                    p_index = i;
                    h_index.Add(p_index);
                    //Debug.Log($"Adding parent {i} for transform {tr.gameObject.name}");
                    break;
                }
            }
        }
    }

    if (tr.childCount > 0)
    {
        for (int i = 0; i < tr.childCount; i++)
        {
            DetectBoneHierarchy(tr.GetChild(i),h_index);
        }
    }

}

}

ChatGPT

To create a Unity Editor Tool that accepts a root bone, and a list of omitted bones contained in a scriptable object, and generates a new ScriptableObject with the bone transform list, the bone name list, and the parent indices list, you can follow the structure below. This script will include creating a custom editor window to manage the tool and the scriptable objects.

Here’s how you can implement this:

1. Create the ScriptableObject classes:

using System.Collections.Generic;
using UnityEngine;

[CreateAssetMenu(fileName = "BoneOmissionList", menuName = "ScriptableObjects/BoneOmissionList", order = 1)]
public class BoneOmissionList : ScriptableObject
{
    public List<string> omittedBones;
}

[CreateAssetMenu(fileName = "BoneHierarchyData", menuName = "ScriptableObjects/BoneHierarchyData", order = 2)]
public class BoneHierarchyData : ScriptableObject
{
    public List<Transform> boneTransforms;
    public List<string> boneNames;
    public List<int> parentIndices;
}

2. Modify the LimbIdentifier class to work with the new ScriptableObject:

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;

public class LimbIdentifier : MonoBehaviour
{
    [Header("Referenced Elements")]
    public Transform root;
    public bool addRoot;
    public BoneSorting boneSorting;
    public BoneOmissionList omittedBonesList;

    [Header("Identified Elements")]
    public List<string> IdentifiedBones;
    public List<Transform> BoneTransforms;
    public List<int> ParentBoneIndex;

    [HideInInspector] public UnityEvent<List<Transform>> OnLimbsIdentified;
    [HideInInspector] public UnityEvent<List<string>> OnLimbNamesIdentified;
    [HideInInspector] public UnityEvent<List<int>> OnLimbHierarchyIdentified;
    [HideInInspector] public UnityEvent OnLimbInfoBroadcasted;

    [HideInInspector] public string[] Bones;

    public void PublishData()
    {
        PublishData(out var trans, out var names, out var inds);

        OnLimbsIdentified.Invoke(trans);
        OnLimbNamesIdentified?.Invoke(names);
        OnLimbHierarchyIdentified?.Invoke(inds);
        OnLimbInfoBroadcasted?.Invoke();
    }

    public void PublishData(out List<Transform> boneTransforms, out List<string> boneNames, out List<int> parentBoneIndex)
    {
        var emptyLists = (BoneTransforms?.Count ?? 0) == 0 || (IdentifiedBones?.Count ?? 0) == 0 || (ParentBoneIndex?.Count ?? 0) == 0;

        if (emptyLists)
        {
            IdentifySkeletonBones();
        }

        boneTransforms = BoneTransforms;
        boneNames = IdentifiedBones;
        parentBoneIndex = ParentBoneIndex;
    }

    private void IdentifySkeletonBones()
    {
        IdentifiedBones = new List<string>();
        BoneTransforms = new List<Transform>();
        ParentBoneIndex = new List<int>();

        if (addRoot)
        {
            IdentifiedBones.Add(root.name);
            BoneTransforms.Add(root);
        }

        CreateBoneHierarchy();

        var boneCount = Bones.Length;

        for (var i = 0; i < boneCount; i++)
        {
            SearchForBoneTransform(Bones[i], root);
        }

        DetectBoneHierarchy(root, ParentBoneIndex);
    }

    private void CreateBoneHierarchy()
    {
        switch (boneSorting)
        {
            case BoneSorting.BasedOnNeuron:
                Bones = System.Enum.GetNames(typeof(NeuronBones));
                break;
            case BoneSorting.BasedOnHierarchy:
                List<string> boneNames = new List<string>();
                ExtractBoneName(root, boneNames);
                Bones = boneNames.ToArray();
                break;
            default:
                throw new System.ArgumentOutOfRangeException();
        }
    }

    private void ExtractBoneName(Transform tr, List<string> names)
    {
        var n = tr.gameObject.name;
        bool omitName = OmitBone(n);

        if (!omitName) names.Add(tr.gameObject.name);
        if (tr.childCount > 0)
        {
            for (int i = 0; i < tr.childCount; i++)
            {
                ExtractBoneName(tr.GetChild(i), names);
            }
        }
    }

    private bool OmitBone(string n)
    {
        bool omitName = false;
        for (int i = 0; i < omittedBonesList.omittedBones.Count; i++)
        {
            if (n.Contains(omittedBonesList.omittedBones[i]))
            {
                omitName = true;
                break;
            }
        }

        return omitName;
    }

    private void SearchForBoneTransform(string bone, Transform tr)
    {
        for (int i = 0; i < tr.childCount; i++)
        {
            var ch = tr.GetChild(i);

            if (ch.gameObject.name.Contains(bone))
            {
                IdentifiedBones.Add(bone);
                BoneTransforms.Add(ch);
                break;
            }
            SearchForBoneTransform(bone, ch);
        }
    }

    private void DetectBoneHierarchy(Transform tr, List<int> hIndex)
    {
        int pIndex;
        if (tr.gameObject.name.Contains(Bones[0]))
        {
            pIndex = -1;
            hIndex.Add(pIndex);
        }
        else
        {
            bool omitName = OmitBone(tr.gameObject.name);
            if (!omitName)
            {
                var pName = tr.parent.gameObject.name;
                for (int i = 0; i < Bones.Length; i++)
                {
                    if (pName.Contains(Bones[i]))
                    {
                        pIndex = i;
                        hIndex.Add(pIndex);
                        break;
                    }
                }
            }
        }

        if (tr.childCount > 0)
        {
            for (int i = 0; i < tr.childCount; i++)
            {
                DetectBoneHierarchy(tr.GetChild(i), hIndex);
            }
        }
    }
}

3. Create the custom editor window:

using UnityEditor;
using UnityEngine;

public class BoneHierarchyTool : EditorWindow
{
    private Transform rootBone;
    private BoneOmissionList omissionList;
    private BoneHierarchyData hierarchyData;

    [MenuItem("Tools/Bone Hierarchy Tool")]
    public static void ShowWindow()
    {
        GetWindow<BoneHierarchyTool>("Bone Hierarchy Tool");
    }

    private void OnGUI()
    {
        GUILayout.Label("Bone Hierarchy Tool", EditorStyles.boldLabel);

        rootBone = (Transform)EditorGUILayout.ObjectField("Root Bone", rootBone, typeof(Transform), true);
        omissionList = (BoneOmissionList)EditorGUILayout.ObjectField("Omission List", omissionList, typeof(BoneOmissionList), false);
        hierarchyData = (BoneHierarchyData)EditorGUILayout.ObjectField("Hierarchy Data", hierarchyData, typeof(BoneHierarchyData), false);

        if (GUILayout.Button("Generate Hierarchy Data"))
        {
            GenerateHierarchyData();
        }
    }

    private void GenerateHierarchyData()
    {
        if (rootBone == null || omissionList == null || hierarchyData == null)
        {
            Debug.LogError("Please assign all required fields.");
            return;
        }

        var limbIdentifier = new GameObject("LimbIdentifier").AddComponent<LimbIdentifier>();
        limbIdentifier.root = rootBone;
        limbIdentifier.omittedBonesList = omissionList;
        limbIdentifier.addRoot = true;
        limbIdentifier.boneSorting = BoneSorting.BasedOnHierarchy;

        limbIdentifier.IdentifySkeletonBones();

        hierarchyData.boneTransforms = new List<Transform>(limbIdentifier.BoneTransforms);
        hierarchyData.boneNames = new List<string>(limbIdentifier.IdentifiedBones);
        hierarchyData.parentIndices = new List<int>(limbIdentifier.ParentBoneIndex);

        EditorUtility.SetDirty(hierarchyData);
        DestroyImmediate(limbIdentifier.gameObject);

        Debug.Log("Hierarchy data generated and saved successfully.");
    }
}

This code accomplishes the following:

• ScriptableObjects: Defines BoneOmissionList for omitted bones and BoneHierarchyData for storing the hierarchy data.
• LimbIdentifier: Modified to use the BoneOmissionList ScriptableObject and includes functionality to identify and serialize bone data.
• Custom Editor Window: Provides a user interface to input the root bone, omission list, and target scriptable object, and generates the bone hierarchy data, storing it in the specified ScriptableObject.

With this tool, you can easily create, manage, and save bone hierarchy data without losing serialization.

You

my transform list shows type mismatch

ChatGPT

It seems the error might be due to type mismatch issues when serializing Transform objects within ScriptableObjects. Unity serialization doesn’t directly support Transform objects. To resolve this, you can store the necessary data of Transforms (e.g., their names and positions) instead of the Transform objects themselves.

Here’s an approach to modify the BoneHierarchyData ScriptableObject to store bone data in a way that Unity can serialize it:

1. Modify the ScriptableObject to store bone data:

using System;
using System.Collections.Generic;
using UnityEngine;

[CreateAssetMenu(fileName = "BoneHierarchyData", menuName = "ScriptableObjects/BoneHierarchyData", order = 2)]
public class BoneHierarchyData : ScriptableObject
{
    [Serializable]
    public struct BoneData
    {
        public string boneName;
        public Vector3 position;
        public Quaternion rotation;
        public Vector3 scale;
    }

    public List<BoneData> bones = new List<BoneData>();
    public List<int> parentIndices = new List<int>();
}

2. Modify the LimbIdentifier class to work with the new ScriptableObject:

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;

public class LimbIdentifier : MonoBehaviour
{
    [Header("Referenced Elements")]
    public Transform root;
    public bool addRoot;
    public BoneSorting boneSorting;
    public BoneOmissionList omittedBonesList;

    [Header("Identified Elements")]
    public List<string> IdentifiedBones;
    public List<Transform> BoneTransforms;
    public List<int> ParentBoneIndex;

    [HideInInspector] public UnityEvent<List<Transform>> OnLimbsIdentified;
    [HideInInspector] public UnityEvent<List<string>> OnLimbNamesIdentified;
    [HideInInspector] public UnityEvent<List<int>> OnLimbHierarchyIdentified;
    [HideInInspector] public UnityEvent OnLimbInfoBroadcasted;

    [HideInInspector] public string[] Bones;

    public void PublishData()
    {
        PublishData(out var trans, out var names, out var inds);

        OnLimbsIdentified.Invoke(trans);
        OnLimbNamesIdentified?.Invoke(names);
        OnLimbHierarchyIdentified?.Invoke(inds);
        OnLimbInfoBroadcasted?.Invoke();
    }

    public void PublishData(out List<Transform> boneTransforms, out List<string> boneNames, out List<int> parentBoneIndex)
    {
        var emptyLists = (BoneTransforms?.Count ?? 0) == 0 || (IdentifiedBones?.Count ?? 0) == 0 || (ParentBoneIndex?.Count ?? 0) == 0;

        if (emptyLists)
        {
            IdentifySkeletonBones();
        }

        boneTransforms = BoneTransforms;
        boneNames = IdentifiedBones;
        parentBoneIndex = ParentBoneIndex;
    }

    private void IdentifySkeletonBones()
    {
        IdentifiedBones = new List<string>();
        BoneTransforms = new List<Transform>();
        ParentBoneIndex = new List<int>();

        if (addRoot)
        {
            IdentifiedBones.Add(root.name);
            BoneTransforms.Add(root);
        }

        CreateBoneHierarchy();

        var boneCount = Bones.Length;

        for (var i = 0; i < boneCount; i++)
        {
            SearchForBoneTransform(Bones[i], root);
        }

        DetectBoneHierarchy(root, ParentBoneIndex);
    }

    private void CreateBoneHierarchy()
    {
        switch (boneSorting)
        {
            case BoneSorting.BasedOnNeuron:
                Bones = System.Enum.GetNames(typeof(NeuronBones));
                break;
            case BoneSorting.BasedOnHierarchy:
                List<string> boneNames = new List<string>();
                ExtractBoneName(root, boneNames);
                Bones = boneNames.ToArray();
                break;
            default:
                throw new System.ArgumentOutOfRangeException();
        }
    }

    private void ExtractBoneName(Transform tr, List<string> names)
    {
        var n = tr.gameObject.name;
        bool omitName = OmitBone(n);

        if (!omitName) names.Add(tr.gameObject.name);
        if (tr.childCount > 0)
        {
            for (int i = 0; i < tr.childCount; i++)
            {
                ExtractBoneName(tr.GetChild(i), names);
            }
        }
    }

    private bool OmitBone(string n)
    {
        bool omitName = false;
        for (int i = 0; i < omittedBonesList.omittedBones.Count; i++)
        {
            if (n.Contains(omittedBonesList.omittedBones[i]))
            {
                omitName = true;
                break;
            }
        }

        return omitName;
    }

    private void SearchForBoneTransform(string bone, Transform tr)
    {
        for (int i = 0; i < tr.childCount; i++)
        {
            var ch = tr.GetChild(i);

            if (ch.gameObject.name.Contains(bone))
            {
                IdentifiedBones.Add(bone);
                BoneTransforms.Add(ch);
                break;
            }
            SearchForBoneTransform(bone, ch);
        }
    }

    private void DetectBoneHierarchy(Transform tr, List<int> hIndex)
    {
        int pIndex;
        if (tr.gameObject.name.Contains(Bones[0]))
        {
            pIndex = -1;
            hIndex.Add(pIndex);
        }
        else
        {
            bool omitName = OmitBone(tr.gameObject.name);
            if (!omitName)
            {
                var pName = tr.parent.gameObject.name;
                for (int i = 0; i < Bones.Length; i++)
                {
                    if (pName.Contains(Bones[i]))
                    {
                        pIndex = i;
                        hIndex.Add(pIndex);
                        break;
                    }
                }
            }
        }

        if (tr.childCount > 0)
        {
            for (int i = 0; i < tr.childCount; i++)
            {
                DetectBoneHierarchy(tr.GetChild(i), hIndex);
            }
        }
    }
}

3. Update the editor window to store the correct data in the ScriptableObject:

using UnityEditor;
using UnityEngine;

public class BoneHierarchyTool : EditorWindow
{
    private Transform rootBone;
    private BoneOmissionList omissionList;
    private BoneHierarchyData hierarchyData;

    [MenuItem("Tools/Bone Hierarchy Tool")]
    public static void ShowWindow()
    {
        GetWindow<BoneHierarchyTool>("Bone Hierarchy Tool");
    }

    private void OnGUI()
    {
        GUILayout.Label("Bone Hierarchy Tool", EditorStyles.boldLabel);

        rootBone = (Transform)EditorGUILayout.ObjectField("Root Bone", rootBone, typeof(Transform), true);
        omissionList = (BoneOmissionList)EditorGUILayout.ObjectField("Omission List", omissionList, typeof(BoneOmissionList), false);
        hierarchyData = (BoneHierarchyData)EditorGUILayout.ObjectField("Hierarchy Data", hierarchyData, typeof(BoneHierarchyData), false);

        if (GUILayout.Button("Generate Hierarchy Data"))
        {
            GenerateHierarchyData();
        }
    }

    private void GenerateHierarchyData()
    {
        if (rootBone == null || omissionList == null || hierarchyData == null)
        {
            Debug.LogError("Please assign all required fields.");
            return;
        }

        var limbIdentifier = new GameObject("LimbIdentifier").AddComponent<LimbIdentifier>();
        limbIdentifier.root = rootBone;
        limbIdentifier.omittedBonesList = omissionList;
        limbIdentifier.addRoot = true;
        limbIdentifier.boneSorting = BoneSorting.BasedOnHierarchy;

        limbIdentifier.IdentifySkeletonBones();

        hierarchyData.bones.Clear();
        foreach (var bone in limbIdentifier.BoneTransforms)
        {
            hierarchyData.bones.Add(new BoneHierarchyData.BoneData
            {
                boneName = bone.name,
                position = bone.localPosition,
                rotation = bone.localRotation,
                scale = bone.localScale
            });
        }

        hierarchyData.parentIndices = new List<int>(limbIdentifier.ParentBoneIndex);

        EditorUtility.SetDirty(hierarchyData);
        DestroyImmediate(limbIdentifier.gameObject);

        Debug.Log("Hierarchy data generated and saved successfully.");
    }
}

In this updated script:

• The BoneHierarchyData class stores the bone data (name, position, rotation, scale) in a serializable format.
• The LimbIdentifier class remains mostly unchanged, but it now works with the BoneOmissionList ScriptableObject.
• The custom editor window creates and fills the BoneHierarchyData ScriptableObject with the necessary data, ensuring that Unity can serialize and store it correctly.

This approach ensures that the transform data is stored in a way that Unity can serialize, avoiding the type mismatch issue.

You

also make the window ” remember” the last selected scriptable objects, so i dont have to drag them again all the time

ChatGPT

To make the editor window “remember” the last selected scriptable objects, you can use Unity’s EditorPrefs to store the references as GUIDs and then retrieve them when the window is opened again. Here’s how you can modify the script to achieve this:

1. Store and retrieve GUIDs using EditorPrefs:

using UnityEditor;
using UnityEngine;

public class BoneHierarchyTool : EditorWindow
{
    private const string RootBoneKey = "BoneHierarchyTool_RootBone";
    private const string OmissionListKey = "BoneHierarchyTool_OmissionList";
    private const string HierarchyDataKey = "BoneHierarchyTool_HierarchyData";

    private Transform rootBone;
    private BoneOmissionList omissionList;
    private BoneHierarchyData hierarchyData;

    [MenuItem("Tools/Bone Hierarchy Tool")]
    public static void ShowWindow()
    {
        GetWindow<BoneHierarchyTool>("Bone Hierarchy Tool");
    }

    private void OnEnable()
    {
        string rootBoneGuid = EditorPrefs.GetString(RootBoneKey, string.Empty);
        string omissionListGuid = EditorPrefs.GetString(OmissionListKey, string.Empty);
        string hierarchyDataGuid = EditorPrefs.GetString(HierarchyDataKey, string.Empty);

        rootBone = AssetDatabase.LoadAssetAtPath<Transform>(AssetDatabase.GUIDToAssetPath(rootBoneGuid));
        omissionList = AssetDatabase.LoadAssetAtPath<BoneOmissionList>(AssetDatabase.GUIDToAssetPath(omissionListGuid));
        hierarchyData = AssetDatabase.LoadAssetAtPath<BoneHierarchyData>(AssetDatabase.GUIDToAssetPath(hierarchyDataGuid));
    }

    private void OnDisable()
    {
        if (rootBone != null)
        {
            string rootBonePath = AssetDatabase.GetAssetPath(rootBone);
            string rootBoneGuid = AssetDatabase.AssetPathToGUID(rootBonePath);
            EditorPrefs.SetString(RootBoneKey, rootBoneGuid);
        }

        if (omissionList != null)
        {
            string omissionListPath = AssetDatabase.GetAssetPath(omissionList);
            string omissionListGuid = AssetDatabase.AssetPathToGUID(omissionListPath);
            EditorPrefs.SetString(OmissionListKey, omissionListGuid);
        }

        if (hierarchyData != null)
        {
            string hierarchyDataPath = AssetDatabase.GetAssetPath(hierarchyData);
            string hierarchyDataGuid = AssetDatabase.AssetPathToGUID(hierarchyDataPath);
            EditorPrefs.SetString(HierarchyDataKey, hierarchyDataGuid);
        }
    }

    private void OnGUI()
    {
        GUILayout.Label("Bone Hierarchy Tool", EditorStyles.boldLabel);

        rootBone = (Transform)EditorGUILayout.ObjectField("Root Bone", rootBone, typeof(Transform), true);
        omissionList = (BoneOmissionList)EditorGUILayout.ObjectField("Omission List", omissionList, typeof(BoneOmissionList), false);
        hierarchyData = (BoneHierarchyData)EditorGUILayout.ObjectField("Hierarchy Data", hierarchyData, typeof(BoneHierarchyData), false);

        if (GUILayout.Button("Generate Hierarchy Data"))
        {
            GenerateHierarchyData();
        }
    }

    private void GenerateHierarchyData()
    {
        if (rootBone == null || omissionList == null || hierarchyData == null)
        {
            Debug.LogError("Please assign all required fields.");
            return;
        }

        var limbIdentifier = new GameObject("LimbIdentifier").AddComponent<LimbIdentifier>();
        limbIdentifier.root = rootBone;
        limbIdentifier.omittedBonesList = omissionList;
        limbIdentifier.addRoot = true;
        limbIdentifier.boneSorting = BoneSorting.BasedOnHierarchy;

        limbIdentifier.IdentifySkeletonBones();

        hierarchyData.bones.Clear();
        foreach (var bone in limbIdentifier.BoneTransforms)
        {
            hierarchyData.bones.Add(new BoneHierarchyData.BoneData
            {
                boneName = bone.name,
                position = bone.localPosition,
                rotation = bone.localRotation,
                scale = bone.localScale
            });
        }

        hierarchyData.parentIndices = new List<int>(limbIdentifier.ParentBoneIndex);

        EditorUtility.SetDirty(hierarchyData);
        DestroyImmediate(limbIdentifier.gameObject);

        Debug.Log("Hierarchy data generated and saved successfully.");
    }
}

Key Changes

1. OnEnable Method:

   • Retrieves GUIDs stored in EditorPrefs and converts them back to asset paths to load the references.

2. OnDisable Method:

   • Converts asset paths of the selected objects to GUIDs and stores them in EditorPrefs.

Explanation

• EditorPrefs: Unity’s way of storing and retrieving editor-specific settings between sessions.
• GUIDs: Unique identifiers for assets in Unity, which are stable across sessions, unlike direct references.

This will ensure that the last selected scriptable objects are remembered and reloaded whenever the tool window is reopened.

You

the root bone doesnt come from assets. it comes from the scene

ChatGPT

Given that the root bone is a scene object and not an asset, you can’t directly use EditorPrefs to store it, as EditorPrefs is for simple types and can’t store Unity object references. Instead, you can use the EditorSceneManager to store and retrieve the InstanceID of the rootBone. Here’s how you can modify the script to remember the scene object:

1. Using EditorSceneManager to handle scene objects:

using UnityEditor;
using UnityEngine;
using UnityEditor.SceneManagement;

public class BoneHierarchyTool : EditorWindow
{
    private const string RootBoneKey = "BoneHierarchyTool_RootBone";
    private const string OmissionListKey = "BoneHierarchyTool_OmissionList";
    private const string HierarchyDataKey = "BoneHierarchyTool_HierarchyData";

    private Transform rootBone;
    private BoneOmissionList omissionList;
    private BoneHierarchyData hierarchyData;

    [MenuItem("Tools/Bone Hierarchy Tool")]
    public static void ShowWindow()
    {
        GetWindow<BoneHierarchyTool>("Bone Hierarchy Tool");
    }

    private void OnEnable()
    {
        // Retrieve the instance ID of the root bone and convert it to a Transform
        int rootBoneInstanceID = EditorPrefs.GetInt(RootBoneKey, 0);
        rootBone = EditorUtility.InstanceIDToObject(rootBoneInstanceID) as Transform;

        // Retrieve the GUIDs for the omission list and hierarchy data
        string omissionListGuid = EditorPrefs.GetString(OmissionListKey, string.Empty);
        string hierarchyDataGuid = EditorPrefs.GetString(HierarchyDataKey, string.Empty);

        // Load the ScriptableObjects from the AssetDatabase using the GUIDs
        omissionList = AssetDatabase.LoadAssetAtPath<BoneOmissionList>(AssetDatabase.GUIDToAssetPath(omissionListGuid));
        hierarchyData = AssetDatabase.LoadAssetAtPath<BoneHierarchyData>(AssetDatabase.GUIDToAssetPath(hierarchyDataGuid));
    }

    private void OnDisable()
    {
        // Store the instance ID of the root bone
        if (rootBone != null)
        {
            int rootBoneInstanceID = rootBone.GetInstanceID();
            EditorPrefs.SetInt(RootBoneKey, rootBoneInstanceID);
        }

        // Store the GUIDs for the omission list and hierarchy data
        if (omissionList != null)
        {
            string omissionListPath = AssetDatabase.GetAssetPath(omissionList);
            string omissionListGuid = AssetDatabase.AssetPathToGUID(omissionListPath);
            EditorPrefs.SetString(OmissionListKey, omissionListGuid);
        }

        if (hierarchyData != null)
        {
            string hierarchyDataPath = AssetDatabase.GetAssetPath(hierarchyData);
            string hierarchyDataGuid = AssetDatabase.AssetPathToGUID(hierarchyDataPath);
            EditorPrefs.SetString(HierarchyDataKey, hierarchyDataGuid);
        }
    }

    private void OnGUI()
    {
        GUILayout.Label("Bone Hierarchy Tool", EditorStyles.boldLabel);

        rootBone = (Transform)EditorGUILayout.ObjectField("Root Bone", rootBone, typeof(Transform), true);
        omissionList = (BoneOmissionList)EditorGUILayout.ObjectField("Omission List", omissionList, typeof(BoneOmissionList), false);
        hierarchyData = (BoneHierarchyData)EditorGUILayout.ObjectField("Hierarchy Data", hierarchyData, typeof(BoneHierarchyData), false);

        if (GUILayout.Button("Generate Hierarchy Data"))
        {
            GenerateHierarchyData();
        }
    }

    private void GenerateHierarchyData()
    {
        if (rootBone == null || omissionList == null || hierarchyData == null)
        {
            Debug.LogError("Please assign all required fields.");
            return;
        }

        var limbIdentifier = new GameObject("LimbIdentifier").AddComponent<LimbIdentifier>();
        limbIdentifier.root = rootBone;
        limbIdentifier.omittedBonesList = omissionList;
        limbIdentifier.addRoot = true;
        limbIdentifier.boneSorting = BoneSorting.BasedOnHierarchy;

        limbIdentifier.IdentifySkeletonBones();

        hierarchyData.bones.Clear();
        foreach (var bone in limbIdentifier.BoneTransforms)
        {
            hierarchyData.bones.Add(new BoneHierarchyData.BoneData
            {
                boneName = bone.name,
                position = bone.localPosition,
                rotation = bone.localRotation,
                scale = bone.localScale
            });
        }

        hierarchyData.parentIndices = new List<int>(limbIdentifier.ParentBoneIndex);

        EditorUtility.SetDirty(hierarchyData);
        DestroyImmediate(limbIdentifier.gameObject);

        Debug.Log("Hierarchy data generated and saved successfully.");
    }
}

Key Changes

1. OnEnable Method:

   • Retrieves the instance ID of the rootBone from EditorPrefs and converts it back to a Transform using EditorUtility.InstanceIDToObject.

2. OnDisable Method:

   • Stores the instance ID of the rootBone using EditorPrefs.SetInt.

Explanation

• InstanceID: A unique identifier for objects within the scene in Unity, which can be used to store and retrieve references to scene objects.
• EditorPrefs: Used to store simple types like integers, which are then converted back to object references using InstanceIDToObject.

This approach allows the editor window to remember the scene object references and scriptable objects between sessions.

You

when the data is generated, select the hierarchy scriptable object to show its contents on the inspector

ChatGPT

To select and display the generated hierarchy scriptable object in the Inspector after data generation, you can use Selection.activeObject in Unity. This will automatically highlight and show the object in the Inspector.

Here’s how you can update the BoneHierarchyTool script to include this functionality:

using UnityEditor;
using UnityEngine;
using UnityEditor.SceneManagement;

public class BoneHierarchyTool : EditorWindow
{
    private const string RootBoneKey = "BoneHierarchyTool_RootBone";
    private const string OmissionListKey = "BoneHierarchyTool_OmissionList";
    private const string HierarchyDataKey = "BoneHierarchyTool_HierarchyData";

    private Transform rootBone;
    private BoneOmissionList omissionList;
    private BoneHierarchyData hierarchyData;

    [MenuItem("Tools/Bone Hierarchy Tool")]
    public static void ShowWindow()
    {
        GetWindow<BoneHierarchyTool>("Bone Hierarchy Tool");
    }

    private void OnEnable()
    {
        // Retrieve the instance ID of the root bone and convert it to a Transform
        int rootBoneInstanceID = EditorPrefs.GetInt(RootBoneKey, 0);
        rootBone = EditorUtility.InstanceIDToObject(rootBoneInstanceID) as Transform;

        // Retrieve the GUIDs for the omission list and hierarchy data
        string omissionListGuid = EditorPrefs.GetString(OmissionListKey, string.Empty);
        string hierarchyDataGuid = EditorPrefs.GetString(HierarchyDataKey, string.Empty);

        // Load the ScriptableObjects from the AssetDatabase using the GUIDs
        omissionList = AssetDatabase.LoadAssetAtPath<BoneOmissionList>(AssetDatabase.GUIDToAssetPath(omissionListGuid));
        hierarchyData = AssetDatabase.LoadAssetAtPath<BoneHierarchyData>(AssetDatabase.GUIDToAssetPath(hierarchyDataGuid));
    }

    private void OnDisable()
    {
        // Store the instance ID of the root bone
        if (rootBone != null)
        {
            int rootBoneInstanceID = rootBone.GetInstanceID();
            EditorPrefs.SetInt(RootBoneKey, rootBoneInstanceID);
        }

        // Store the GUIDs for the omission list and hierarchy data
        if (omissionList != null)
        {
            string omissionListPath = AssetDatabase.GetAssetPath(omissionList);
            string omissionListGuid = AssetDatabase.AssetPathToGUID(omissionListPath);
            EditorPrefs.SetString(OmissionListKey, omissionListGuid);
        }

        if (hierarchyData != null)
        {
            string hierarchyDataPath = AssetDatabase.GetAssetPath(hierarchyData);
            string hierarchyDataGuid = AssetDatabase.AssetPathToGUID(hierarchyDataPath);
            EditorPrefs.SetString(HierarchyDataKey, hierarchyDataGuid);
        }
    }

    private void OnGUI()
    {
        GUILayout.Label("Bone Hierarchy Tool", EditorStyles.boldLabel);

        rootBone = (Transform)EditorGUILayout.ObjectField("Root Bone", rootBone, typeof(Transform), true);
        omissionList = (BoneOmissionList)EditorGUILayout.ObjectField("Omission List", omissionList, typeof(BoneOmissionList), false);
        hierarchyData = (BoneHierarchyData)EditorGUILayout.ObjectField("Hierarchy Data", hierarchyData, typeof(BoneHierarchyData), false);

        if (GUILayout.Button("Generate Hierarchy Data"))
        {
            GenerateHierarchyData();
        }
    }

    private void GenerateHierarchyData()
    {
        if (rootBone == null || omissionList == null || hierarchyData == null)
        {
            Debug.LogError("Please assign all required fields.");
            return;
        }

        var limbIdentifier = new GameObject("LimbIdentifier").AddComponent<LimbIdentifier>();
        limbIdentifier.root = rootBone;
        limbIdentifier.omittedBonesList = omissionList;
        limbIdentifier.addRoot = true;
        limbIdentifier.boneSorting = BoneSorting.BasedOnHierarchy;

        limbIdentifier.IdentifySkeletonBones();

        hierarchyData.bones.Clear();
        foreach (var bone in limbIdentifier.BoneTransforms)
        {
            hierarchyData.bones.Add(new BoneHierarchyData.BoneData
            {
                boneName = bone.name,
                position = bone.localPosition,
                rotation = bone.localRotation,
                scale = bone.localScale
            });
        }

        hierarchyData.parentIndices = new List<int>(limbIdentifier.ParentBoneIndex);

        EditorUtility.SetDirty(hierarchyData);
        DestroyImmediate(limbIdentifier.gameObject);

        Debug.Log("Hierarchy data generated and saved successfully.");

        // Select the hierarchyData object to show its contents in the Inspector
        Selection.activeObject = hierarchyData;
    }
}

Key Changes

1. GenerateHierarchyData Method:
   • After the data is generated and saved, Selection.activeObject = hierarchyData; is used to select the hierarchyData object, making it show up in the Inspector.

Explanation

• Selection.activeObject: This property sets the currently active object in the Unity Editor. Setting this to hierarchyData will highlight it in the Project window and display its properties in the Inspector.

By adding this line, the script ensures that after generating the bone hierarchy data, the hierarchyData ScriptableObject is selected and shown in the Inspector, improving the workflow by allowing immediate inspection and verification of the generated data.

You

why don’t we store the parent indices in the same struct?

ChatGPT

Storing the parent indices in the same struct makes sense and can simplify the data structure. This approach encapsulates all related data within a single entity, making it more cohesive and easier to manage.

Here’s how you can modify the BoneHierarchyData scriptable object and update the editor tool accordingly:

1. Modify the ScriptableObject to store parent indices within the BoneData struct:

using System;
using System.Collections.Generic;
using UnityEngine;

[CreateAssetMenu(fileName = "BoneHierarchyData", menuName = "ScriptableObjects/BoneHierarchyData", order = 2)]
public class BoneHierarchyData : ScriptableObject
{
    [Serializable]
    public struct BoneData
    {
        public string boneName;
        public Vector3 position;
        public Quaternion rotation;
        public Vector3 scale;
        public int parentIndex;
    }

    public List<BoneData> bones = new List<BoneData>();
}

2. Modify the LimbIdentifier class to populate the parent index within the BoneData struct:

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;

public class LimbIdentifier : MonoBehaviour
{
    [Header("Referenced Elements")]
    public Transform root;
    public bool addRoot;
    public BoneSorting boneSorting;
    public BoneOmissionList omittedBonesList;

    [Header("Identified Elements")]
    public List<string> IdentifiedBones;
    public List<Transform> BoneTransforms;
    public List<int> ParentBoneIndex;

    [HideInInspector] public UnityEvent<List<Transform>> OnLimbsIdentified;
    [HideInInspector] public UnityEvent<List<string>> OnLimbNamesIdentified;
    [HideInInspector] public UnityEvent<List<int>> OnLimbHierarchyIdentified;
    [HideInInspector] public UnityEvent OnLimbInfoBroadcasted;

    [HideInInspector] public string[] Bones;

    public void PublishData()
    {
        PublishData(out var trans, out var names, out var inds);

        OnLimbsIdentified.Invoke(trans);
        OnLimbNamesIdentified?.Invoke(names);
        OnLimbHierarchyIdentified?.Invoke(inds);
        OnLimbInfoBroadcasted?.Invoke();
    }

    public void PublishData(out List<Transform> boneTransforms, out List<string> boneNames, out List<int> parentBoneIndex)
    {
        var emptyLists = (BoneTransforms?.Count ?? 0) == 0 || (IdentifiedBones?.Count ?? 0) == 0 || (ParentBoneIndex?.Count ?? 0) == 0;

        if (emptyLists)
        {
            IdentifySkeletonBones();
        }

        boneTransforms = BoneTransforms;
        boneNames = IdentifiedBones;
        parentBoneIndex = ParentBoneIndex;
    }

    private void IdentifySkeletonBones()
    {
        IdentifiedBones = new List<string>();
        BoneTransforms = new List<Transform>();
        ParentBoneIndex = new List<int>();

        if (addRoot)
        {
            IdentifiedBones.Add(root.name);
            BoneTransforms.Add(root);
        }

        CreateBoneHierarchy();

        var boneCount = Bones.Length;

        for (var i = 0; i < boneCount; i++)
        {
            SearchForBoneTransform(Bones[i], root);
        }

        DetectBoneHierarchy(root, ParentBoneIndex);
    }

    private void CreateBoneHierarchy()
    {
        switch (boneSorting)
        {
            case BoneSorting.BasedOnNeuron:
                Bones = System.Enum.GetNames(typeof(NeuronBones));
                break;
            case BoneSorting.BasedOnHierarchy:
                List<string> boneNames = new List<string>();
                ExtractBoneName(root, boneNames);
                Bones = boneNames.ToArray();
                break;
            default:
                throw new System.ArgumentOutOfRangeException();
        }
    }

    private void ExtractBoneName(Transform tr, List<string> names)
    {
        var n = tr.gameObject.name;
        bool omitName = OmitBone(n);

        if (!omitName) names.Add(tr.gameObject.name);
        if (tr.childCount > 0)
        {
            for (int i = 0; i < tr.childCount; i++)
            {
                ExtractBoneName(tr.GetChild(i), names);
            }
        }
    }

    private bool OmitBone(string n)
    {
        bool omitName = false;
        for (int i = 0; i < omittedBonesList.omittedBones.Count; i++)
        {
            if (n.Contains(omittedBonesList.omittedBones[i]))
            {
                omitName = true;
                break;
            }
        }

        return omitName;
    }

    private void SearchForBoneTransform(string bone, Transform tr)
    {
        for (int i = 0; i < tr.childCount; i++)
        {
            var ch = tr.GetChild(i);

            if (ch.gameObject.name.Contains(bone))
            {
                IdentifiedBones.Add(bone);
                BoneTransforms.Add(ch);
                break;
            }
            SearchForBoneTransform(bone, ch);
        }
    }

    private void DetectBoneHierarchy(Transform tr, List<int> hIndex)
    {
        int pIndex;
        if (tr.gameObject.name.Contains(Bones[0]))
        {
            pIndex = -1;
            hIndex.Add(pIndex);
        }
        else
        {
            bool omitName = OmitBone(tr.gameObject.name);
            if (!omitName)
            {
                var pName = tr.parent.gameObject.name;
                for (int i = 0; i < Bones.Length; i++)
                {
                    if (pName.Contains(Bones[i]))
                    {
                        pIndex = i;
                        hIndex.Add(pIndex);
                        break;
                    }
                }
            }
        }

        if (tr.childCount > 0)
        {
            for (int i = 0; i < tr.childCount; i++)
            {
                DetectBoneHierarchy(tr.GetChild(i), hIndex);
            }
        }
    }
}

3. Update the editor window to populate and display the new structure:

using UnityEditor;
using UnityEngine;
using UnityEditor.SceneManagement;

public class BoneHierarchyTool : EditorWindow
{
    private const string RootBoneKey = "BoneHierarchyTool_RootBone";
    private const string OmissionListKey = "BoneHierarchyTool_OmissionList";
    private const string HierarchyDataKey = "BoneHierarchyTool_HierarchyData";

    private Transform rootBone;
    private BoneOmissionList omissionList;
    private BoneHierarchyData hierarchyData;

    [MenuItem("Tools/Bone Hierarchy Tool")]
    public static void ShowWindow()
    {
        GetWindow<BoneHierarchyTool>("Bone Hierarchy Tool");
    }

    private void OnEnable()
    {
        int rootBoneInstanceID = EditorPrefs.GetInt(RootBoneKey, 0);
        rootBone = EditorUtility.InstanceIDToObject(rootBoneInstanceID) as Transform;

        string omissionListGuid = EditorPrefs.GetString(OmissionListKey, string.Empty);
        string hierarchyDataGuid = EditorPrefs.GetString(HierarchyDataKey, string.Empty);

        omissionList = AssetDatabase.LoadAssetAtPath<BoneOmissionList>(AssetDatabase.GUIDToAssetPath(omissionListGuid));
        hierarchyData = AssetDatabase.LoadAssetAtPath<BoneHierarchyData>(AssetDatabase.GUIDToAssetPath(hierarchyDataGuid));
    }

    private void OnDisable()
    {
        if (rootBone != null)
        {
            int rootBoneInstanceID = rootBone.GetInstanceID();
            EditorPrefs.SetInt(RootBoneKey, rootBoneInstanceID);
        }

        if (omissionList != null)
        {
            string omissionListPath = AssetDatabase.GetAssetPath(omissionList);
            string omissionListGuid = AssetDatabase.AssetPathToGUID(omissionListPath);
            EditorPrefs.SetString(OmissionListKey, omissionListGuid);
        }

        if (hierarchyData != null)
        {
            string hierarchyDataPath = AssetDatabase.GetAssetPath(hierarchyData);
            string hierarchyDataGuid = AssetDatabase.AssetPathToGUID(hierarchyDataPath);
            EditorPrefs.SetString(HierarchyDataKey, hierarchyDataGuid);
        }
    }

    private void OnGUI()
    {
        GUILayout.Label("Bone Hierarchy Tool", EditorStyles.boldLabel);

        rootBone = (Transform)EditorGUILayout.ObjectField("Root Bone", rootBone, typeof(Transform), true);
        omissionList = (BoneOmissionList)EditorGUILayout.ObjectField("Omission List", omissionList, typeof(BoneOmissionList), false);
        hierarchyData = (BoneHierarchyData)EditorGUILayout.ObjectField("Hierarchy Data", hierarchyData, typeof(BoneHierarchyData), false);

        if (GUILayout.Button("Generate Hierarchy Data"))
        {
            GenerateHierarchyData();
        }
    }

    private void GenerateHierarchyData()
    {
        if (rootBone == null || omissionList == null || hierarchyData == null)
        {
            Debug.LogError("Please assign all required fields.");
            return;
        }

        var limbIdentifier = new GameObject("LimbIdentifier").AddComponent<LimbIdentifier>();
        limbIdentifier.root = rootBone;
        limbIdentifier.omittedBonesList = omissionList;
        limbIdentifier.addRoot = true;
        limbIdentifier.boneSorting = BoneSorting.BasedOnHierarchy;

        limbIdentifier.IdentifySkeletonBones();

        hierarchyData.bones.Clear();
        for (int i = 0; i < limbIdentifier.BoneTransforms.Count; i++)
        {
            var bone = limbIdentifier.BoneTransforms[i];
            hierarchyData.bones.Add(new BoneHierarchyData.BoneData
            {
                boneName = bone.name,
                position = bone.localPosition,
                rotation = bone.localRotation,
                scale = bone.localScale,
                parentIndex = limbIdentifier.ParentBoneIndex[i]
            });
        }

        EditorUtility.SetDirty(hierarchyData);
        DestroyImmediate(limbIdentifier.gameObject);

        Debug.Log("Hierarchy data generated and saved successfully.");

        // Select the hierarchyData object to show its contents in the Inspector
        Selection.activeObject = hierarchyData;
    }
}

Key Changes

1. BoneHierarchyData ScriptableObject:

   • The BoneData struct now includes a parentIndex field.

2. LimbIdentifier Class:

   • The DetectBoneHierarchy method now assigns parent indices within the struct.

3. BoneHierarchyTool Editor Window:

   • The GenerateHierarchyData method now populates BoneData instances with parentIndex.

By integrating the parent index into the BoneData struct, the data structure becomes more cohesive, encapsulating all relevant information within a single entity. The editor tool has been updated to accommodate these changes, ensuring the generated data is correctly populated and displayed in the Inspector.

You

can i turn the bone data into transforms?

ChatGPT

Yes, you can convert the BoneData back into Transform objects at runtime. To do this, you will need to store the information required to recreate the hierarchy of Transform objects in the scene.

Here’s how you can implement this:

1. Modify the BoneHierarchyData ScriptableObject to store bone data and include a method to convert this data back into a hierarchy of Transform objects:

using System;
using System.Collections.Generic;
using UnityEngine;

[CreateAssetMenu(fileName = "BoneHierarchyData", menuName = "ScriptableObjects/BoneHierarchyData", order = 2)]
public class BoneHierarchyData : ScriptableObject
{
    [Serializable]
    public struct BoneData
    {
        public string boneName;
        public Vector3 position;
        public Quaternion rotation;
        public Vector3 scale;
        public int parentIndex;
    }

    public List<BoneData> bones = new List<BoneData>();

    public List<Transform> CreateTransformHierarchy()
    {
        List<Transform> createdTransforms = new List<Transform>();

        for (int i = 0; i < bones.Count; i++)
        {
            BoneData boneData = bones[i];
            GameObject boneGO = new GameObject(boneData.boneName);
            Transform boneTransform = boneGO.transform;
            boneTransform.localPosition = boneData.position;
            boneTransform.localRotation = boneData.rotation;
            boneTransform.localScale = boneData.scale;

            if (boneData.parentIndex != -1)
            {
                boneTransform.parent = createdTransforms[boneData.parentIndex];
            }

            createdTransforms.Add(boneTransform);
        }

        return createdTransforms;
    }
}

2. Update the BoneHierarchyTool editor window to include an option to recreate the hierarchy from the stored bone data:

using UnityEditor;
using UnityEngine;
using UnityEditor.SceneManagement;

public class BoneHierarchyTool : EditorWindow
{
    private const string RootBoneKey = "BoneHierarchyTool_RootBone";
    private const string OmissionListKey = "BoneHierarchyTool_OmissionList";
    private const string HierarchyDataKey = "BoneHierarchyTool_HierarchyData";

    private Transform rootBone;
    private BoneOmissionList omissionList;
    private BoneHierarchyData hierarchyData;

    [MenuItem("Tools/Bone Hierarchy Tool")]
    public static void ShowWindow()
    {
        GetWindow<BoneHierarchyTool>("Bone Hierarchy Tool");
    }

    private void OnEnable()
    {
        int rootBoneInstanceID = EditorPrefs.GetInt(RootBoneKey, 0);
        rootBone = EditorUtility.InstanceIDToObject(rootBoneInstanceID) as Transform;

        string omissionListGuid = EditorPrefs.GetString(OmissionListKey, string.Empty);
        string hierarchyDataGuid = EditorPrefs.GetString(HierarchyDataKey, string.Empty);

        omissionList = AssetDatabase.LoadAssetAtPath<BoneOmissionList>(AssetDatabase.GUIDToAssetPath(omissionListGuid));
        hierarchyData = AssetDatabase.LoadAssetAtPath<BoneHierarchyData>(AssetDatabase.GUIDToAssetPath(hierarchyDataGuid));
    }

    private void OnDisable()
    {
        if (rootBone != null)
        {
            int rootBoneInstanceID = rootBone.GetInstanceID();
            EditorPrefs.SetInt(RootBoneKey, rootBoneInstanceID);
        }

        if (omissionList != null)
        {
            string omissionListPath = AssetDatabase.GetAssetPath(omissionList);
            string omissionListGuid = AssetDatabase.AssetPathToGUID(omissionListPath);
            EditorPrefs.SetString(OmissionListKey, omissionListGuid);
        }

        if (hierarchyData != null)
        {
            string hierarchyDataPath = AssetDatabase.GetAssetPath(hierarchyData);
            string hierarchyDataGuid = AssetDatabase.AssetPathToGUID(hierarchyDataPath);
            EditorPrefs.SetString(HierarchyDataKey, hierarchyDataGuid);
        }
    }

    private void OnGUI()
    {
        GUILayout.Label("Bone Hierarchy Tool", EditorStyles.boldLabel);

        rootBone = (Transform)EditorGUILayout.ObjectField("Root Bone", rootBone, typeof(Transform), true);
        omissionList = (BoneOmissionList)EditorGUILayout.ObjectField("Omission List", omissionList, typeof(BoneOmissionList), false);
        hierarchyData = (BoneHierarchyData)EditorGUILayout.ObjectField("Hierarchy Data", hierarchyData, typeof(BoneHierarchyData), false);

        if (GUILayout.Button("Generate Hierarchy Data"))
        {
            GenerateHierarchyData();
        }

        if (GUILayout.Button("Create Transform Hierarchy"))
        {
            CreateTransformHierarchy();
        }
    }

    private void GenerateHierarchyData()
    {
        if (rootBone == null || omissionList == null || hierarchyData == null)
        {
            Debug.LogError("Please assign all required fields.");
            return;
        }

        var limbIdentifier = new GameObject("LimbIdentifier").AddComponent<LimbIdentifier>();
        limbIdentifier.root = rootBone;
        limbIdentifier.omittedBonesList = omissionList;
        limbIdentifier.addRoot = true;
        limbIdentifier.boneSorting = BoneSorting.BasedOnHierarchy;

        limbIdentifier.IdentifySkeletonBones();

        hierarchyData.bones.Clear();
        for (int i = 0; i < limbIdentifier.B

You

can I store the Gameobject reference in the struct, so that I can access it in runtime?

ChatGPT

Unity’s serialization system does not support storing direct references to scene objects, such as GameObjects or Transforms, in ScriptableObjects because ScriptableObjects are meant to be assets that can persist across different scenes and project reloads. Storing direct references to scene objects would break this principle and lead to issues when the scene is unloaded or the project is reloaded.

However, you can store identifiers or paths to GameObjects in the struct, and then resolve these identifiers or paths to actual GameObject references at runtime. Here’s how you can approach this:

1. Modify the BoneHierarchyData ScriptableObject to store identifiers instead of direct references:

using System;
using System.Collections.Generic;
using UnityEngine;

[CreateAssetMenu(fileName = "BoneHierarchyData", menuName = "ScriptableObjects/BoneHierarchyData", order = 2)]
public class BoneHierarchyData : ScriptableObject
{
    [Serializable]
    public struct BoneData
    {
        public string boneName;
        public Vector3 position;
        public Quaternion rotation;
        public Vector3 scale;
        public int parentIndex;
        public string path;
    }

    public List<BoneData> bones = new List<BoneData>();

    public List<Transform> CreateTransformHierarchy()
    {
        List<Transform> createdTransforms = new List<Transform>();

        foreach (var boneData in bones)
        {
            GameObject boneGO = new GameObject(boneData.boneName);
            Transform boneTransform = boneGO.transform;
            boneTransform.localPosition = boneData.position;
            boneTransform.localRotation = boneData.rotation;
            boneTransform.localScale = boneData.scale;

            if (boneData.parentIndex != -1)
            {
                boneTransform.parent = createdTransforms[boneData.parentIndex];
            }

            createdTransforms.Add(boneTransform);
        }

        return createdTransforms;
    }

    public void ResolveBoneReferences()
    {
        foreach (var boneData in bones)
        {
            GameObject boneGO = GameObject.Find(boneData.path);
            if (boneGO != null)
            {
                // Do something with the resolved GameObject
                Debug.Log("Resolved bone: " + boneGO.name);
            }
            else
            {
                Debug.LogWarning("Could not find GameObject at path: " + boneData.path);
            }
        }
    }
}

2. Update the LimbIdentifier class to store the path of each GameObject:

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;

public class LimbIdentifier : MonoBehaviour
{
    [Header("Referenced Elements")]
    public Transform root;
    public bool addRoot;
    public BoneSorting boneSorting;
    public BoneOmissionList omittedBonesList;

    [Header("Identified Elements")]
    public List<string> IdentifiedBones;
    public List<Transform> BoneTransforms;
    public List<int> ParentBoneIndex;
    public List<string> BonePaths;

    [HideInInspector] public UnityEvent<List<Transform>> OnLimbsIdentified;
    [HideInInspector] public UnityEvent<List<string>> OnLimbNamesIdentified;
    [HideInInspector] public UnityEvent<List<int>> OnLimbHierarchyIdentified;
    [HideInInspector] public UnityEvent OnLimbInfoBroadcasted;

    [HideInInspector] public string[] Bones;

    public void PublishData()
    {
        PublishData(out var trans, out var names, out var inds, out var paths);

        OnLimbsIdentified.Invoke(trans);
        OnLimbNamesIdentified?.Invoke(names);
        OnLimbHierarchyIdentified?.Invoke(inds);
        OnLimbInfoBroadcasted?.Invoke();
    }

    public void PublishData(out List<Transform> boneTransforms, out List<string> boneNames, out List<int> parentBoneIndex, out List<string> bonePaths)
    {
        var emptyLists = (BoneTransforms?.Count ?? 0) == 0 || (IdentifiedBones?.Count ?? 0) == 0 || (ParentBoneIndex?.Count ?? 0) == 0;

        if (emptyLists)
        {
            IdentifySkeletonBones();
        }

        boneTransforms = BoneTransforms;
        boneNames = IdentifiedBones;
        parentBoneIndex = ParentBoneIndex;
        bonePaths = BonePaths;
    }

    private void IdentifySkeletonBones()
    {
        IdentifiedBones = new List<string>();
        BoneTransforms = new List<Transform>();
        ParentBoneIndex = new List<int>();
        BonePaths = new List<string>();

        if (addRoot)
        {
            IdentifiedBones.Add(root.name);
            BoneTransforms.Add(root);
            BonePaths.Add(GetGameObjectPath(root.gameObject));
        }

        CreateBoneHierarchy();

        var boneCount = Bones.Length;

        for (var i = 0; i < boneCount; i++)
        {
            SearchForBoneTransform(Bones[i], root);
        }

        DetectBoneHierarchy(root, ParentBoneIndex);
    }

    private void CreateBoneHierarchy()
    {
        switch (boneSorting)
        {
            case BoneSorting.BasedOnNeuron:
                Bones = System.Enum.GetNames(typeof(NeuronBones));
                break;
            case BoneSorting.BasedOnHierarchy:
                List<string> boneNames = new List<string>();
                ExtractBoneName(root, boneNames);
                Bones = boneNames.ToArray();
                break;
            default:
                throw new System.ArgumentOutOfRangeException();
        }
    }

    private void ExtractBoneName(Transform tr, List<string> names)
    {
        var n = tr.gameObject.name;
        bool omitName = OmitBone(n);

        if (!omitName) names.Add(tr.gameObject.name);
        if (tr.childCount > 0)
        {
            for (int i = 0; i < tr.childCount; i++)
            {
                ExtractBoneName(tr.GetChild(i), names);
            }
        }
    }

    private bool OmitBone(string n)
    {
        bool omitName = false;
        for (int i = 0; i < omittedBonesList.omittedBones.Count; i++)
        {
            if (n.Contains(omittedBonesList.omittedBones[i]))
            {
                omitName = true;
                break;
            }
        }

        return omitName;
    }

    private void SearchForBoneTransform(string bone, Transform tr)
    {
        for (int i = 0; i < tr.childCount; i++)
        {
            var ch = tr.GetChild(i);

            if (ch.gameObject.name.Contains(bone))
            {
                IdentifiedBones.Add(bone);
                BoneTransforms.Add(ch);
                BonePaths.Add(GetGameObjectPath(ch.gameObject));
                break;
            }
            SearchForBoneTransform(bone, ch);
        }
    }

    private void DetectBoneHierarchy(Transform tr, List<int> hIndex)
    {
        int pIndex;
        if (tr.gameObject.name.Contains(Bones[0]))
        {
            pIndex = -1;
            hIndex.Add(pIndex);
        }
        else
        {
            bool omitName = OmitBone(tr.gameObject.name);
            if (!omitName)
            {
                var pName = tr.parent.gameObject.name;
                for (int i = 0; i < Bones.Length; i++)
                {
                    if (pName.Contains(Bones[i]))
                    {
                        pIndex = i;
                        hIndex.Add(pIndex);
                        break;
                    }
                }
            }
        }

        if (tr.childCount > 0)
        {
            for (int i = 0; i < tr.childCount; i++)
            {
                DetectBoneHierarchy(tr.GetChild(i), hIndex);
            }
        }
    }

    private string GetGameObjectPath(GameObject obj)
    {
        string path = obj.name;
        Transform parent = obj.transform.parent;
        while (parent != null)
        {
            path = parent.name + "/" + path;
            parent = parent.parent;
        }
        return path;
    }
}

3. Update the editor window to include the path information and resolve it at runtime:

using UnityEditor;
using UnityEngine;
using UnityEditor.SceneManagement;

public class BoneHierarchyTool : EditorWindow
{
    private const string RootBoneKey = "BoneHierarchyTool_RootBone";
    private const string OmissionListKey = "BoneHierarchyTool_OmissionList";
    private const string HierarchyDataKey = "BoneHierarchyTool_HierarchyData";

    private Transform rootBone;
    private BoneOmissionList omissionList;
    private BoneHierarchyData hierarchyData;

    [MenuItem("Tools/Bone Hierarchy Tool")]
    public static void ShowWindow()
    {
        GetWindow<BoneHierarchyTool>("Bone Hierarchy Tool");
    }

    private void OnEnable()
    {
        int rootBoneInstanceID = EditorPrefs.GetInt(RootBoneKey, 0);
        rootBone = EditorUtility.InstanceIDToObject(rootBoneInstanceID) as Transform;

        string omissionListGuid = EditorPrefs.GetString(OmissionListKey, string.Empty);
        string hierarchyDataGuid = EditorPrefs.GetString(HierarchyDataKey, string.Empty);

        omissionList = AssetDatabase.LoadAssetAtPath<BoneOmissionList>(AssetDatabase.GUIDToAssetPath(omissionListGuid));
        hierarchyData = AssetDatabase.LoadAssetAtPath<BoneHierarchyData>(AssetDatabase.GUIDToAssetPath(hierarchyDataGuid));
    }

    private void OnDisable()
    {
        if (rootBone != null)
        {
            int rootBoneInstanceID = rootBone.GetInstanceID();
            EditorPrefs.SetInt(RootBoneKey, rootBoneInstanceID);
        }

        if (omissionList != null)
        {
            string omissionListPath = AssetDatabase.GetAssetPath(omissionList);
            string omissionListGuid = AssetDatabase.AssetPathToGUID(omissionListPath);
            EditorPrefs.SetString(OmissionListKey, omissionListGuid);
        }

        if (hierarchyData != null)
        {
            string hierarchyDataPath = AssetDatabase.GetAssetPath(hierarchyData);
            string hierarchyDataGuid = AssetDatabase.AssetPathToGUID(hierarchyDataPath);
            EditorPrefs.SetString(HierarchyDataKey, hierarchyDataGuid);
        }
    }

    private void OnGUI()
    {
        GUILayout.Label("Bone Hierarchy Tool", EditorStyles.boldLabel);

        rootBone = (Transform)EditorGUILayout.ObjectField("Root Bone", rootBone, typeof(Transform), true);
        omissionList = (BoneOmissionList)EditorGUILayout.ObjectField("Omission List", omissionList, typeof(BoneOmissionList), false);
        hierarchyData = (BoneHierarchyData)EditorGUILayout.ObjectField("Hierarchy Data", hierarchyData, typeof(BoneHierarchyData), false);

        if (GUILayout.Button("Generate Hierarchy Data"))
        {
            GenerateHierarchyData();
        }

        if (GUILayout.Button("Create Transform Hierarchy"))
        {
            CreateTransformHierarchy();
        }

        if (GUILayout.Button("Resolve Bone References"))
        {
            ResolveBoneReferences();
        }
    }

    private void GenerateHierarchyData()
    {
        if (rootBone == null || omissionList == null || hierarchyData == null)
        {
            Debug.LogError("Please assign all required fields.");
            return;
        }

        var limbIdentifier = new GameObject("LimbIdentifier").AddComponent<LimbIdentifier>();
        limbIdentifier.root = rootBone;
        limbIdentifier.omittedBonesList = omissionList;
        limbIdentifier.addRoot = true;
        limbIdentifier.boneSorting = BoneSorting.BasedOnHierarchy;

        limbIdentifier.IdentifySkeletonBones();

        hierarchyData.bones.Clear();
        for (int i = 0; i < limbIdentifier.BoneTransforms.Count; i++)
        {
            var bone = limbIdentifier.BoneTransforms[i];
            hierarchyData.bones.Add(new BoneHierarchyData.BoneData
            {
                boneName = bone.name,
                position = bone.localPosition,
                rotation = bone.localRotation,
                scale = bone.localScale,
                parentIndex = limbIdentifier.ParentBoneIndex[i],
                path = limbIdentifier.BonePaths[i]
            });
        }

        EditorUtility.SetDirty(hierarchyData);
        DestroyImmediate(limbIdentifier.gameObject);

        Debug.Log("Hierarchy data generated and saved successfully.");

        // Select the hierarchyData object to show its contents in the Inspector
        Selection.activeObject = hierarchyData;
    }

    private void CreateTransformHierarchy()
    {
        if (hierarchyData == null)
        {
            Debug.LogError("Please assign a hierarchy data ScriptableObject.");
            return;
        }

        hierarchyData.CreateTransformHierarchy();
    }

    private void ResolveBoneReferences()
    {
        if (hierarchyData == null)
        {
            Debug.LogError("Please assign a hierarchy data ScriptableObject.");
            return;
        }

        hierarchyData.ResolveBoneReferences();
    }
}

Key Changes

1. BoneHierarchyData ScriptableObject:

   • The BoneData struct now includes a path field to store the hierarchy path of each bone.

2. LimbIdentifier Class:

   • The IdentifySkeletonBones method now records the path of each bone using the GetGameObjectPath method.

3. BoneHierarchyTool Editor Window:

   • Added a new button “Resolve Bone References” to resolve the paths stored in the BoneHierarchyData back to GameObjects.

Explanation

• GetGameObjectPath Method: Generates a unique path for each GameObject in the hierarchy, which can be used later to find the GameObject.
• ResolveBoneReferences Method: Finds and logs the GameObjects using the stored paths in the BoneHierarchyData.

This approach ensures that you can store references to GameObjects in a way that is compatible with Unity’s serialization system and retrieve these references at runtime.

You

remove the creathierarchy, and replace its functionality with the resolvebonereferences. only show these modifications not everything

ChatGPT

Certainly! Here are the specific modifications:

1. BoneHierarchyData ScriptableObject:

Remove the CreateTransformHierarchy method and ensure the ResolveBoneReferences method can handle the functionality of recreating the hierarchy.

using System;
using System.Collections.Generic;
using UnityEngine;

[CreateAssetMenu(fileName = "BoneHierarchyData", menuName = "ScriptableObjects/BoneHierarchyData", order = 2)]
public class BoneHierarchyData : ScriptableObject
{
    [Serializable]
    public struct BoneData
    {
        public string boneName;
        public Vector3 position;
        public Quaternion rotation;
        public Vector3 scale;
        public int parentIndex;
        public string path;
    }

    public List<BoneData> bones = new List<BoneData>();

    public void ResolveBoneReferences()
    {
        List<Transform> createdTransforms = new List<Transform>();

        foreach (var boneData in bones)
        {
            GameObject boneGO = new GameObject(boneData.boneName);
            Transform boneTransform = boneGO.transform;
            boneTransform.localPosition = boneData.position;
            boneTransform.localRotation = boneData.rotation;
            boneTransform.localScale = boneData.scale;

            if (boneData.parentIndex != -1)
            {
                boneTransform.parent = createdTransforms[boneData.parentIndex];
            }

            createdTransforms.Add(boneTransform);

            // Log resolved GameObject paths
            GameObject resolvedGO = GameObject.Find(boneData.path);
            if (resolvedGO != null)
            {
                Debug.Log("Resolved bone: " + resolvedGO.name);
            }
            else
            {
                Debug.LogWarning("Could not find GameObject at path: " + boneData.path);
            }
        }
    }
}

2. BoneHierarchyTool Editor Window:

Replace the “Create Transform Hierarchy” button and its corresponding method call with “Resolve Bone References”.

using UnityEditor;
using UnityEngine;
using UnityEditor.SceneManagement;

public class BoneHierarchyTool : EditorWindow
{
    private const string RootBoneKey = "BoneHierarchyTool_RootBone";
    private const string OmissionListKey = "BoneHierarchyTool_OmissionList";
    private const string HierarchyDataKey = "BoneHierarchyTool_HierarchyData";

    private Transform rootBone;
    private BoneOmissionList omissionList;
    private BoneHierarchyData hierarchyData;

    [MenuItem("Tools/Bone Hierarchy Tool")]
    public static void ShowWindow()
    {
        GetWindow<BoneHierarchyTool>("Bone Hierarchy Tool");
    }

    private void OnEnable()
    {
        int rootBoneInstanceID = EditorPrefs.GetInt(RootBoneKey, 0);
        rootBone = EditorUtility.InstanceIDToObject(rootBoneInstanceID) as Transform;

        string omissionListGuid = EditorPrefs.GetString(OmissionListKey, string.Empty);
        string hierarchyDataGuid = EditorPrefs.GetString(HierarchyDataKey, string.Empty);

        omissionList = AssetDatabase.LoadAssetAtPath<BoneOmissionList>(AssetDatabase.GUIDToAssetPath(omissionListGuid));
        hierarchyData = AssetDatabase.LoadAssetAtPath<BoneHierarchyData>(AssetDatabase.GUIDToAssetPath(hierarchyDataGuid));
    }

    private void OnDisable()
    {
        if (rootBone != null)
        {
            int rootBoneInstanceID = rootBone.GetInstanceID();
            EditorPrefs.SetInt(RootBoneKey, rootBoneInstanceID);
        }

        if (omissionList != null)
        {
            string omissionListPath = AssetDatabase.GetAssetPath(omissionList);
            string omissionListGuid = AssetDatabase.AssetPathToGUID(omissionListPath);
            EditorPrefs.SetString(OmissionListKey, omissionListGuid);
        }

        if (hierarchyData != null)
        {
            string hierarchyDataPath = AssetDatabase.GetAssetPath(hierarchyData);
            string hierarchyDataGuid = AssetDatabase.AssetPathToGUID(hierarchyDataPath);
            EditorPrefs.SetString(HierarchyDataKey, hierarchyDataGuid);
        }
    }

    private void OnGUI()
    {
        GUILayout.Label("Bone Hierarchy Tool", EditorStyles.boldLabel);

        rootBone = (Transform)EditorGUILayout.ObjectField("Root Bone", rootBone, typeof(Transform), true);
        omissionList = (BoneOmissionList)EditorGUILayout.ObjectField("Omission List", omissionList, typeof(BoneOmissionList), false);
        hierarchyData = (BoneHierarchyData)EditorGUILayout.ObjectField("Hierarchy Data", hierarchyData, typeof(BoneHierarchyData), false);

        if (GUILayout.Button("Generate Hierarchy Data"))
        {
            GenerateHierarchyData();
        }

        if (GUILayout.Button("Resolve Bone References"))
        {
            ResolveBoneReferences();
        }
    }

    private void GenerateHierarchyData()
    {
        if (rootBone == null || omissionList == null || hierarchyData == null)
        {
            Debug.LogError("Please assign all required fields.");
            return;
        }

        var limbIdentifier =

You

No ! don’t make new gameobjects, find the existing and collect their transforms

ChatGPT

Got it! Here’s how you can modify the BoneHierarchyData to find existing GameObjects in the scene based on the stored paths and then collect their Transforms:

1. Modify the BoneHierarchyData ScriptableObject:

Update the ResolveBoneReferences method to find the existing GameObjects and collect their Transforms instead of creating new GameObjects.

using System;
using System.Collections.Generic;
using UnityEngine;

[CreateAssetMenu(fileName = "BoneHierarchyData", menuName = "ScriptableObjects/BoneHierarchyData", order = 2)]
public class BoneHierarchyData : ScriptableObject
{
    [Serializable]
    public struct BoneData
    {
        public string boneName;
        public Vector3 position;
        public Quaternion rotation;
        public Vector3 scale;
        public int parentIndex;
        public string path;
    }

    public List<BoneData> bones = new List<BoneData>();

    public void ResolveBoneReferences(out List<Transform> resolvedTransforms)
    {
        resolvedTransforms = new List<Transform>();

        foreach (var boneData in bones)
        {
            GameObject boneGO = GameObject.Find(boneData.path);
            if (boneGO != null)
            {
                Transform boneTransform = boneGO.transform;
                resolvedTransforms.Add(boneTransform);

                // Log the resolved GameObject path
                Debug.Log("Resolved bone: " + boneGO.name);
            }
            else
            {
                Debug.LogWarning("Could not find GameObject at path: " + boneData.path);
            }
        }
    }
}

2. Update the LimbIdentifier class:

Ensure it stores the paths of the GameObjects.

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;

public class LimbIdentifier : MonoBehaviour
{
    [Header("Referenced Elements")]
    public Transform root;
    public bool addRoot;
    public BoneSorting boneSorting;
    public BoneOmissionList omittedBonesList;

    [Header("Identified Elements")]
    public List<string> IdentifiedBones;
    public List<Transform> BoneTransforms;
    public List<int> ParentBoneIndex;
    public List<string> BonePaths;

    [HideInInspector] public UnityEvent<List<Transform>> OnLimbsIdentified;
    [HideInInspector] public UnityEvent<List<string>> OnLimbNamesIdentified;
    [HideInInspector] public UnityEvent<List<int>> OnLimbHierarchyIdentified;
    [HideInInspector] public UnityEvent OnLimbInfoBroadcasted;

    [HideInInspector] public string[] Bones;

    public void PublishData()
    {
        PublishData(out var trans, out var names, out var inds, out var paths);

        OnLimbsIdentified.Invoke(trans);
        OnLimbNamesIdentified?.Invoke(names);
        OnLimbHierarchyIdentified?.Invoke(inds);
        OnLimbInfoBroadcasted?.Invoke();
    }

    public void PublishData(out List<Transform> boneTransforms, out List<string> boneNames, out List<int> parentBoneIndex, out List<string> bonePaths)
    {
        var emptyLists = (BoneTransforms?.Count ?? 0) == 0 || (IdentifiedBones?.Count ?? 0) == 0 || (ParentBoneIndex?.Count ?? 0) == 0;

        if (emptyLists)
        {
            IdentifySkeletonBones();
        }

        boneTransforms = BoneTransforms;
        boneNames = IdentifiedBones;
        parentBoneIndex = ParentBoneIndex;
        bonePaths = BonePaths;
    }

    private void IdentifySkeletonBones()
    {
        IdentifiedBones = new List<string>();
        BoneTransforms = new List<Transform>();
        ParentBoneIndex = new List<int>();
        BonePaths = new List<string>();

        if (addRoot)
        {
            IdentifiedBones.Add(root.name);
            BoneTransforms.Add(root);
            BonePaths.Add(GetGameObjectPath(root.gameObject));
        }

        CreateBoneHierarchy();

        var boneCount = Bones.Length;

        for (var i = 0; i < boneCount; i++)
        {
            SearchForBoneTransform(Bones[i], root);
        }

        DetectBoneHierarchy(root, ParentBoneIndex);
    }

    private void CreateBoneHierarchy()
    {
        switch (boneSorting)
        {
            case BoneSorting.BasedOnNeuron:
                Bones = System.Enum.GetNames(typeof(NeuronBones));
                break;
            case BoneSorting.BasedOnHierarchy:
                List<string> boneNames = new List<string>();
                ExtractBoneName(root, boneNames);
                Bones = boneNames.ToArray();
                break;
            default:
                throw new System.ArgumentOutOfRangeException();
        }
    }

    private void ExtractBoneName(Transform tr, List<string> names)
    {
        var n = tr.gameObject.name;
        bool omitName = OmitBone(n);

        if (!omitName) names.Add(tr.gameObject.name);
        if (tr.childCount > 0)
        {
            for (int i = 0; i < tr.childCount; i++)
            {
                ExtractBoneName(tr.GetChild(i), names);
            }
        }
    }

    private bool OmitBone(string n)
    {
        bool omitName = false;
        for (int i = 0; i < omittedBonesList.omittedBones.Count; i++)
        {
            if (n.Contains(omittedBonesList.omittedBones[i]))
            {
                omitName = true;
                break;
            }
        }

        return omitName;
    }

    private void SearchForBoneTransform(string bone, Transform tr)
    {
        for (int i = 0; i < tr.childCount; i++)
        {
            var ch = tr.GetChild(i);

            if (ch.gameObject.name.Contains(bone))
            {
                IdentifiedBones.Add(bone);
                BoneTransforms.Add(ch);
                BonePaths.Add(GetGameObjectPath(ch.gameObject));
                break;
            }
            SearchForBoneTransform(bone, ch);
        }
    }

    private void DetectBoneHierarchy(Transform tr, List<int> hIndex)
    {
        int pIndex;
        if (tr.gameObject.name.Contains(Bones[0]))
        {
            pIndex = -1;
            hIndex.Add(pIndex);
        }
        else
        {
            bool omitName = OmitBone(tr.gameObject.name);
            if (!omitName)
            {
                var pName = tr.parent.gameObject.name;
                for (int i = 0; i < Bones.Length; i++)
                {
                    if (pName.Contains(Bones[i]))
                    {
                        pIndex = i;
                        hIndex.Add(pIndex);
                        break;
                    }
                }
            }
        }

        if (tr.childCount > 0)
        {
            for (int i = 0; i < tr.childCount; i++)
            {
                DetectBoneHierarchy(tr.GetChild(i), hIndex);
            }
        }
    }

    private string GetGameObjectPath(GameObject obj)
    {
        string path = obj.name;
        Transform parent = obj.transform.parent;
        while (parent != null)
        {
            path = parent.name + "/" + path;
            parent = parent.parent;
        }
        return path;
    }
}

3. Update the BoneHierarchyTool Editor Window:

Replace the “Create Transform Hierarchy” button and its corresponding method call with “Resolve Bone References”.

using UnityEditor;
using UnityEngine;
using UnityEditor.SceneManagement;

public class BoneHierarchyTool : EditorWindow
{
    private const string RootBoneKey = "BoneHierarchyTool_RootBone";
    private const string OmissionListKey = "BoneHierarchyTool_OmissionList";
    private const string HierarchyDataKey = "BoneHierarchyTool_HierarchyData";

    private Transform rootBone;
    private BoneOmissionList omissionList;
    private BoneHierarchyData hierarchyData;

    [MenuItem("Tools/Bone Hierarchy Tool")]
    public static void ShowWindow()
    {
        GetWindow<BoneHierarchyTool>("Bone Hierarchy Tool");
    }

    private void OnEnable()
    {
        int rootBoneInstanceID = EditorPrefs.GetInt(RootBoneKey, 0);
        rootBone = EditorUtility.InstanceIDToObject(rootBoneInstanceID) as Transform;

        string omissionListGuid = EditorPrefs.GetString(OmissionListKey, string.Empty);
        string hierarchyDataGuid = EditorPrefs.GetString(HierarchyDataKey, string.Empty);

        omissionList = AssetDatabase.LoadAssetAtPath<BoneOmissionList>(AssetDatabase.GUIDToAssetPath(omissionListGuid));
        hierarchyData = AssetDatabase.LoadAssetAtPath<BoneHierarchyData>(AssetDatabase.GUIDToAssetPath(hierarchyDataGuid));
    }

    private void OnDisable()
    {
        if (rootBone != null)
        {
            int rootBoneInstanceID = rootBone.GetInstanceID();
            EditorPrefs.SetInt(RootBoneKey, rootBoneInstanceID);
        }

        if (omissionList != null)
        {
            string omissionListPath = AssetDatabase.GetAssetPath(omissionList);
            string omissionListGuid = AssetDatabase.AssetPathToGUID(omissionListPath);
            EditorPrefs.SetString(OmissionListKey, omissionListGuid);
        }

        if (hierarchyData != null)
        {
            string hierarchyDataPath = AssetDatabase.GetAssetPath(hierarchyData);
            string hierarchyDataGuid = AssetDatabase.AssetPathToGUID(hierarchyDataPath);
            EditorPrefs.SetString(HierarchyDataKey, hierarchyDataGuid);
        }
    }

    private void OnGUI()
    {
        GUILayout.Label("Bone Hierarchy Tool", EditorStyles.boldLabel);

        rootBone = (Transform)EditorGUILayout.ObjectField("Root Bone",

You

Ok, now add all the properties of the LimbIdentifier to the Tool window, and pass them. also remember the last settings

ChatGPT

Sure! Here’s how you can update the BoneHierarchyTool editor window to include all properties of the LimbIdentifier class, pass them appropriately, and remember the last settings using EditorPrefs.

1. Update the LimbIdentifier class to handle all properties:

Make sure that the LimbIdentifier class has all the necessary properties exposed as public so they can be accessed and modified by the editor window.

2. Update the BoneHierarchyTool Editor Window:

Add fields for all the properties from LimbIdentifier and save/load their values using EditorPrefs.

using UnityEditor;
using UnityEngine;
using UnityEditor.SceneManagement;

public class BoneHierarchyTool : EditorWindow
{
    private const string RootBoneKey = "BoneHierarchyTool_RootBone";
    private const string OmissionListKey = "BoneHierarchyTool_OmissionList";
    private const string HierarchyDataKey = "BoneHierarchyTool_HierarchyData";
    private const string AddRootKey = "BoneHierarchyTool_AddRoot";
    private const string BoneSortingKey = "BoneHierarchyTool_BoneSorting";

    private Transform rootBone;
    private BoneOmissionList omissionList;
    private BoneHierarchyData hierarchyData;
    private bool addRoot;
    private BoneSorting boneSorting;

    [MenuItem("Tools/Bone Hierarchy Tool")]
    public static void ShowWindow()
    {
        GetWindow<BoneHierarchyTool>("Bone Hierarchy Tool");
    }

    private void OnEnable()
    {
        int rootBoneInstanceID = EditorPrefs.GetInt(RootBoneKey, 0);
        rootBone = EditorUtility.InstanceIDToObject(rootBoneInstanceID) as Transform;

        string omissionListGuid = EditorPrefs.GetString(OmissionListKey, string.Empty);
        string hierarchyDataGuid = EditorPrefs.GetString(HierarchyDataKey, string.Empty);

        omissionList = AssetDatabase.LoadAssetAtPath<BoneOmissionList>(AssetDatabase.GUIDToAssetPath(omissionListGuid));
        hierarchyData = AssetDatabase.LoadAssetAtPath<BoneHierarchyData>(AssetDatabase.GUIDToAssetPath(hierarchyDataGuid));

        addRoot = EditorPrefs.GetBool(AddRootKey, true);
        boneSorting = (BoneSorting)EditorPrefs.GetInt(BoneSortingKey, (int)BoneSorting.BasedOnHierarchy);
    }

    private void OnDisable()
    {
        if (rootBone != null)
        {
            int rootBoneInstanceID = rootBone.GetInstanceID();
            EditorPrefs.SetInt(RootBoneKey, rootBoneInstanceID);
        }

        if (omissionList != null)
        {
            string omissionListPath = AssetDatabase.GetAssetPath(omissionList);
            string omissionListGuid = AssetDatabase.AssetPathToGUID(omissionListPath);
            EditorPrefs.SetString(OmissionListKey, omissionListGuid);
        }

        if (hierarchyData != null)
        {
            string hierarchyDataPath = AssetDatabase.GetAssetPath(hierarchyData);
            string hierarchyDataGuid = AssetDatabase.AssetPathToGUID(hierarchyDataPath);
            EditorPrefs.SetString(HierarchyDataKey, hierarchyDataGuid);
        }

        EditorPrefs.SetBool(AddRootKey, addRoot);
        EditorPrefs.SetInt(BoneSortingKey, (int)boneSorting);
    }

    private void OnGUI()
    {
        GUILayout.Label("Bone Hierarchy Tool", EditorStyles.boldLabel);

        rootBone = (Transform)EditorGUILayout.ObjectField("Root Bone", rootBone, typeof(Transform), true);
        omissionList = (BoneOmissionList)EditorGUILayout.ObjectField("Omission List", omissionList, typeof(BoneOmissionList), false);
        hierarchyData = (BoneHierarchyData)EditorGUILayout.ObjectField("Hierarchy Data", hierarchyData, typeof(BoneHierarchyData), false);

        addRoot = EditorGUILayout.Toggle("Add Root", addRoot);
        boneSorting = (BoneSorting)EditorGUILayout.EnumPopup("Bone Sorting", boneSorting);

        if (GUILayout.Button("Generate Hierarchy Data"))
        {
            GenerateHierarchyData();
        }

        if (GUILayout.Button("Resolve Bone References"))
        {
            ResolveBoneReferences();
        }
    }

    private void GenerateHierarchyData()
    {
        if (rootBone == null || omissionList == null || hierarchyData == null)
        {
            Debug.LogError("Please assign all required fields.");
            return;
        }

        var limbIdentifier = new GameObject("LimbIdentifier").AddComponent<LimbIdentifier>();
        limbIdentifier.root = rootBone;
        limbIdentifier.omittedBonesList = omissionList;
        limbIdentifier.addRoot = addRoot;
        limbIdentifier.boneSorting = boneSorting;

        limbIdentifier.IdentifySkeletonBones();

        hierarchyData.bones.Clear();
        for (int i = 0; i < limbIdentifier.BoneTransforms.Count; i++)
        {
            var bone = limbIdentifier.BoneTransforms[i];
            hierarchyData.bones.Add(new BoneHierarchyData.BoneData
            {
                boneName = bone.name,
                position = bone.localPosition,
                rotation = bone.localRotation,
                scale = bone.localScale,
                parentIndex = limbIdentifier.ParentBoneIndex[i],
                path = limbIdentifier.BonePaths[i]
            });
        }

        EditorUtility.SetDirty(hierarchyData);
        DestroyImmediate(limbIdentifier.gameObject);

        Debug.Log("Hierarchy data generated and saved successfully.");

        // Select the hierarchyData object to show its contents in the Inspector
        Selection.activeObject = hierarchyData;
    }

    private void ResolveBoneReferences()
    {
        if (hierarchyData == null)
        {
            Debug.LogError("Please assign a hierarchy data ScriptableObject.");
            return;
        }

        hierarchyData.ResolveBoneReferences(out List<Transform> resolvedTransforms);
        Debug.Log("Resolved " + resolvedTransforms.Count + " bones.");
    }
}

Explanation

1. Store and Retrieve Settings:

   • OnEnable: Load the last used settings from EditorPrefs.
   • OnDisable: Save the current settings to EditorPrefs.

2. GUI Elements:

   • Added fields for addRoot and boneSorting which match the properties in LimbIdentifier.
   • These fields are stored and retrieved from EditorPrefs.

3. GenerateHierarchyData:

   • Pass the values from the editor window to the LimbIdentifier component.

4. ResolveBoneReferences:

   • Find and log the resolved transforms.

This ensures that all properties from the LimbIdentifier are included in the tool window and their settings are remembered between sessions.

You

when storing the paths, make them relative to the root object, so that i can swap objects if i want

ChatGPT

To make the paths relative to the root object, you need to calculate the path from the root object to each bone. This ensures that the paths are consistent even if the root object is swapped.

Here’s how you can modify the code to store relative paths and ensure the paths are correctly resolved:

1. Update the LimbIdentifier class:

Modify the GetGameObjectPath method to calculate the path relative to the root object.

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;

public class LimbIdentifier : MonoBehaviour
{
    [Header("Referenced Elements")]
    public Transform root;
    public bool addRoot;
    public BoneSorting boneSorting;
    public BoneOmissionList omittedBonesList;

    [Header("Identified Elements")]
    public List<string> IdentifiedBones;
    public List<Transform> BoneTransforms;
    public List<int> ParentBoneIndex;
    public List<string> BonePaths;

    [HideInInspector] public UnityEvent<List<Transform>> OnLimbsIdentified;
    [HideInInspector] public UnityEvent<List<string>> OnLimbNamesIdentified;
    [HideInInspector] public UnityEvent<List<int>> OnLimbHierarchyIdentified;
    [HideInInspector] public UnityEvent OnLimbInfoBroadcasted;

    [HideInInspector] public string[] Bones;

    public void PublishData()
    {
        PublishData(out var trans, out var names, out var inds, out var paths);

        OnLimbsIdentified.Invoke(trans);
        OnLimbNamesIdentified?.Invoke(names);
        OnLimbHierarchyIdentified?.Invoke(inds);
        OnLimbInfoBroadcasted?.Invoke();
    }

    public void PublishData(out List<Transform> boneTransforms, out List<string> boneNames, out List<int> parentBoneIndex, out List<string> bonePaths)
    {
        var emptyLists = (BoneTransforms?.Count ?? 0) == 0 || (IdentifiedBones?.Count ?? 0) == 0 || (ParentBoneIndex?.Count ?? 0) == 0;

        if (emptyLists)
        {
            IdentifySkeletonBones();
        }

        boneTransforms = BoneTransforms;
        boneNames = IdentifiedBones;
        parentBoneIndex = ParentBoneIndex;
        bonePaths = BonePaths;
    }

    private void IdentifySkeletonBones()
    {
        IdentifiedBones = new List<string>();
        BoneTransforms = new List<Transform>();
        ParentBoneIndex = new List<int>();
        BonePaths = new List<string>();

        if (addRoot)
        {
            IdentifiedBones.Add(root.name);
            BoneTransforms.Add(root);
            BonePaths.Add(GetRelativePath(root, root));
        }

        CreateBoneHierarchy();

        var boneCount = Bones.Length;

        for (var i = 0; i < boneCount; i++)
        {
            SearchForBoneTransform(Bones[i], root);
        }

        DetectBoneHierarchy(root, ParentBoneIndex);
    }

    private void CreateBoneHierarchy()
    {
        switch (boneSorting)
        {
            case BoneSorting.BasedOnNeuron:
                Bones = System.Enum.GetNames(typeof(NeuronBones));
                break;
            case BoneSorting.BasedOnHierarchy:
                List<string> boneNames = new List<string>();
                ExtractBoneName(root, boneNames);
                Bones = boneNames.ToArray();
                break;
            default:
                throw new System.ArgumentOutOfRangeException();
        }
    }

    private void ExtractBoneName(Transform tr, List<string> names)
    {
        var n = tr.gameObject.name;
        bool omitName = OmitBone(n);

        if (!omitName) names.Add(tr.gameObject.name);
        if (tr.childCount > 0)
        {
            for (int i = 0; i < tr.childCount; i++)
            {
                ExtractBoneName(tr.GetChild(i), names);
            }
        }
    }

    private bool OmitBone(string n)
    {
        bool omitName = false;
        for (int i = 0; i < omittedBonesList.omittedBones.Count; i++)
        {
            if (n.Contains(omittedBonesList.omittedBones[i]))
            {
                omitName = true;
                break;
            }
        }

        return omitName;
    }

    private void SearchForBoneTransform(string bone, Transform tr)
    {
        for (int i = 0; i < tr.childCount; i++)
        {
            var ch = tr.GetChild(i);

            if (ch.gameObject.name.Contains(bone))
            {
                IdentifiedBones.Add(bone);
                BoneTransforms.Add(ch);
                BonePaths.Add(GetRelativePath(root, ch));
                break;
            }
            SearchForBoneTransform(bone, ch);
        }
    }

    private void DetectBoneHierarchy(Transform tr, List<int> hIndex)
    {
        int pIndex;
        if (tr.gameObject.name.Contains(Bones[0]))
        {
            pIndex = -1;
            hIndex.Add(pIndex);
        }
        else
        {
            bool omitName = OmitBone(tr.gameObject.name);
            if (!omitName)
            {
                var pName = tr.parent.gameObject.name;
                for (int i = 0; i < Bones.Length; i++)
                {
                    if (pName.Contains(Bones[i]))
                    {
                        pIndex = i;
                        hIndex.Add(pIndex);
                        break;
                    }
                }
            }
        }

        if (tr.childCount > 0)
        {
            for (int i = 0; i < tr.childCount; i++)
            {
                DetectBoneHierarchy(tr.GetChild(i), hIndex);
            }
        }
    }

    private string GetRelativePath(Transform root, Transform target)
    {
        string path = target.name;
        Transform current = target.parent;
        while (current != null && current != root)
        {
            path = current.name + "/" + path;
            current = current.parent;
        }
        return path;
    }
}

2. Update the BoneHierarchyTool Editor Window:

Ensure the tool saves and uses the settings for the additional properties.

using UnityEditor;
using UnityEngine;
using UnityEditor.SceneManagement;

public class BoneHierarchyTool : EditorWindow
{
    private const string RootBoneKey = "BoneHierarchyTool_RootBone";
    private const string OmissionListKey = "BoneHierarchyTool_OmissionList";
    private const string HierarchyDataKey = "BoneHierarchyTool_HierarchyData";
    private const string AddRootKey = "BoneHierarchyTool_AddRoot";
    private const string BoneSortingKey = "BoneHierarchyTool_BoneSorting";

    private Transform rootBone;
    private BoneOmissionList omissionList;
    private BoneHierarchyData hierarchyData;
    private bool addRoot;
    private BoneSorting boneSorting;

    [MenuItem("Tools/Bone Hierarchy Tool")]
    public static void ShowWindow()
    {
        GetWindow<BoneHierarchyTool>("Bone Hierarchy Tool");
    }

    private void OnEnable()
    {
        int rootBoneInstanceID = EditorPrefs.GetInt(RootBoneKey, 0);
        rootBone = EditorUtility.InstanceIDToObject(rootBoneInstanceID) as Transform;

        string omissionListGuid = EditorPrefs.GetString(OmissionListKey, string.Empty);
        string hierarchyDataGuid = EditorPrefs.GetString(HierarchyDataKey, string.Empty);

        omissionList = AssetDatabase.LoadAssetAtPath<BoneOmissionList>(AssetDatabase.GUIDToAssetPath(omissionListGuid));
        hierarchyData = AssetDatabase.LoadAssetAtPath<BoneHierarchyData>(AssetDatabase.GUIDToAssetPath(hierarchyDataGuid));

        addRoot = EditorPrefs.GetBool(AddRootKey, true);
        boneSorting = (BoneSorting)EditorPrefs.GetInt(BoneSortingKey, (int)BoneSorting.BasedOnHierarchy);
    }

    private void OnDisable()
    {
        if (rootBone != null)
        {
            int rootBoneInstanceID = rootBone.GetInstanceID();
            EditorPrefs.SetInt(RootBoneKey, rootBoneInstanceID);
        }

        if (omissionList != null)
        {
            string omissionListPath = AssetDatabase.GetAssetPath(omissionList);
            string omissionListGuid = AssetDatabase.AssetPathToGUID(omissionListPath);
            EditorPrefs.SetString(OmissionListKey, omissionListGuid);
        }

        if (hierarchyData != null)
        {
            string hierarchyDataPath = AssetDatabase.GetAssetPath(hierarchyData);
            string hierarchyDataGuid = AssetDatabase.AssetPathToGUID(hierarchyDataPath);
            EditorPrefs.SetString(HierarchyDataKey, hierarchyDataGuid);
        }

        EditorPrefs.SetBool(AddRootKey, addRoot);
        EditorPrefs.SetInt(BoneSortingKey, (int)boneSorting);
    }

    private void OnGUI()
    {
        GUILayout.Label("Bone Hierarchy Tool", EditorStyles.boldLabel);

        rootBone = (Transform)EditorGUILayout.ObjectField("Root Bone", rootBone, typeof(Transform), true);
        omissionList = (BoneOmissionList)EditorGUILayout.ObjectField("Omission List", omissionList, typeof(BoneOmissionList), false);
        hierarchyData = (BoneHierarchyData)EditorGUILayout.ObjectField("Hierarchy Data", hierarchyData, typeof(BoneHierarchyData), false);

        addRoot = EditorGUILayout.Toggle("Add Root", addRoot);
        boneSorting = (BoneSorting)EditorGUILayout.EnumPopup("Bone Sorting", boneSorting);

        if (GUILayout.Button("Generate Hierarchy Data"))
        {
            GenerateHierarchyData();
        }

        if (GUILayout.Button("Resolve Bone References"))
        {
            ResolveBoneReferences();
        }
    }

    private void GenerateHierarchyData()
    {
        if (rootBone == null || omissionList == null || hierarchyData == null)
        {
            Debug.LogError("Please assign all required fields.");
            return;
        }

        var limbIdentifier = new GameObject("LimbIdentifier").AddComponent<LimbIdentifier>();
        limbIdentifier.root = rootBone;
        limbIdentifier.omittedBonesList = omissionList;
        limbIdentifier.addRoot = addRoot;
        limbIdentifier.boneSorting = boneSorting;

        limbIdentifier.IdentifySkeletonBones();

        hierarchyData.bones.Clear();
        for (int i = 0; i < limbIdentifier.BoneTransforms.Count; i++)
        {
            var bone = limbIdentifier.BoneTransforms[i];
            hierarchyData.bones.Add(new BoneHierarchyData.BoneData
            {
                boneName = bone.name,
                position = bone.localPosition,
                rotation = bone.localRotation,
                scale = bone.localScale,
                parentIndex = limbIdentifier.ParentBoneIndex[i],
                path = limbIdentifier.BonePaths[i]
            });
        }

        EditorUtility.SetDirty(hierarchyData);
        DestroyImmediate(limbIdentifier.gameObject);

        Debug.Log("Hierarchy data generated and saved successfully.");

        // Select the hierarchyData object to show its contents in the Inspector
        Selection.activeObject = hierarchyData;
    }

    private void ResolveBoneReferences()
    {
        if (hierarchyData == null)
        {
            Debug.LogError("Please assign a hierarchy data ScriptableObject.");
            return;
        }

        hierarchyData.ResolveBoneReferences(out List<Transform> resolvedTransforms);
        Debug.Log("Resolved " + resolvedTransforms.Count + " bones.");
    }
}

Explanation

1. GetRelativePath Method:

   • Computes the path from the root object to each target object, ensuring the paths are relative.

2. EditorPrefs:

   • Stores and retrieves settings for addRoot and boneSorting using EditorPrefs.

3. GenerateHierarchyData:

   • Uses GetRelativePath to store paths relative to the root object.

4. ResolveBoneReferences:

   • Finds and logs the resolved transforms based on the relative paths stored.

This approach ensures that paths are relative to the root object, allowing you to swap root objects while maintaining the correct hierarchy and references.

You

Only omit the top top level gameobject, not the root of the bone hierarchy

ChatGPT

Understood! To ensure that only the top-level GameObject (which is not part of the root bone hierarchy) is omitted, we need to modify the GetRelativePath method to handle this distinction. This involves ensuring that the root object is included in the path calculation but not the actual top-level GameObject.

Here’s how you can modify the code to achieve this:

1. Modify the LimbIdentifier class:

Ensure the root of the bone hierarchy is always included, but omit the top-level GameObject.

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;

public class LimbIdentifier : MonoBehaviour
{
    [Header("Referenced Elements")]
    public Transform root;
    public bool addRoot;
    public BoneSorting boneSorting;
    public BoneOmissionList omittedBonesList;

    [Header("Identified Elements")]
    public List<string> IdentifiedBones;
    public List<Transform> BoneTransforms;
    public List<int> ParentBoneIndex;
    public List<string> BonePaths;

    [HideInInspector] public UnityEvent<List<Transform>> OnLimbsIdentified;
    [HideInInspector] public UnityEvent<List<string>> OnLimbNamesIdentified;
    [HideInInspector] public UnityEvent<List<int>> OnLimbHierarchyIdentified;
    [HideInInspector] public UnityEvent OnLimbInfoBroadcasted;

    [HideInInspector] public string[] Bones;

    public void PublishData()
    {
        PublishData(out var trans, out var names, out var inds, out var paths);

        OnLimbsIdentified.Invoke(trans);
        OnLimbNamesIdentified?.Invoke(names);
        OnLimbHierarchyIdentified?.Invoke(inds);
        OnLimbInfoBroadcasted?.Invoke();
    }

    public void PublishData(out List<Transform> boneTransforms, out List<string> boneNames, out List<int> parentBoneIndex, out List<string> bonePaths)
    {
        var emptyLists = (BoneTransforms?.Count ?? 0) == 0 || (IdentifiedBones?.Count ?? 0) == 0 || (ParentBoneIndex?.Count ?? 0) == 0;

        if (emptyLists)
        {
            IdentifySkeletonBones();
        }

        boneTransforms = BoneTransforms;
        boneNames = IdentifiedBones;
        parentBoneIndex = ParentBoneIndex;
        bonePaths = BonePaths;
    }

    private void IdentifySkeletonBones()
    {
        IdentifiedBones = new List<string>();
        BoneTransforms = new List<Transform>();
        ParentBoneIndex = new List<int>();
        BonePaths = new List<string>();

        if (addRoot)
        {
            IdentifiedBones.Add(root.name);
            BoneTransforms.Add(root);
            BonePaths.Add(GetRelativePath(root, root));
        }

        CreateBoneHierarchy();

        var boneCount = Bones.Length;

        for (var i = 0; i < boneCount; i++)
        {
            SearchForBoneTransform(Bones[i], root);
        }

        DetectBoneHierarchy(root, ParentBoneIndex);
    }

    private void CreateBoneHierarchy()
    {
        switch (boneSorting)
        {
            case BoneSorting.BasedOnNeuron:
                Bones = System.Enum.GetNames(typeof(NeuronBones));
                break;
            case BoneSorting.BasedOnHierarchy:
                List<string> boneNames = new List<string>();
                ExtractBoneName(root, boneNames);
                Bones = boneNames.ToArray();
                break;
            default:
                throw new System.ArgumentOutOfRangeException();
        }
    }

    private void ExtractBoneName(Transform tr, List<string> names)
    {
        var n = tr.gameObject.name;
        bool omitName = OmitBone(n);

        if (!omitName) names.Add(tr.gameObject.name);
        if (tr.childCount > 0)
        {
            for (int i = 0; i < tr.childCount; i++)
            {
                ExtractBoneName(tr.GetChild(i), names);
            }
        }
    }

    private bool OmitBone(string n)
    {
        bool omitName = false;
        for (int i = 0; i < omittedBonesList.omittedBones.Count; i++)
        {
            if (n.Contains(omittedBonesList.omittedBones[i]))
            {
                omitName = true;
                break;
            }
        }

        return omitName;
    }

    private void SearchForBoneTransform(string bone, Transform tr)
    {
        for (int i = 0; i < tr.childCount; i++)
        {
            var ch = tr.GetChild(i);

            if (ch.gameObject.name.Contains(bone))
            {
                IdentifiedBones.Add(bone);
                BoneTransforms.Add(ch);
                BonePaths.Add(GetRelativePath(root, ch));
                break;
            }
            SearchForBoneTransform(bone, ch);
        }
    }

    private void DetectBoneHierarchy(Transform tr, List<int> hIndex)
    {
        int pIndex;
        if (tr.gameObject.name.Contains(Bones[0]))
        {
            pIndex = -1;
            hIndex.Add(pIndex);
        }
        else
        {
            bool omitName = OmitBone(tr.gameObject.name);
            if (!omitName)
            {
                var pName = tr.parent.gameObject.name;
                for (int i = 0; i < Bones.Length; i++)
                {
                    if (pName.Contains(Bones[i]))
                    {
                        pIndex = i;
                        hIndex.Add(pIndex);
                        break;
                    }
                }
            }
        }

        if (tr.childCount > 0)
        {
            for (int i = 0; i < tr.childCount; i++)
            {
                DetectBoneHierarchy(tr.GetChild(i), hIndex);
            }
        }
    }

    private string GetRelativePath(Transform root, Transform target)
    {
        string path = target.name;
        Transform current = target.parent;
        while (current != null && current != root.parent)
        {
            path = current.name + "/" + path;
            current = current.parent;
        }
        return path;
    }
}

2. Update the BoneHierarchyTool Editor Window:

Ensure the tool saves and uses the settings for the additional properties and handles the relative paths correctly.

using UnityEditor;
using UnityEngine;
using UnityEditor.SceneManagement;

public class BoneHierarchyTool : EditorWindow
{
    private const string RootBoneKey = "BoneHierarchyTool_RootBone";
    private const string OmissionListKey = "BoneHierarchyTool_OmissionList";
    private const string HierarchyDataKey = "BoneHierarchyTool_HierarchyData";
    private const string AddRootKey = "BoneHierarchyTool_AddRoot";
    private const string BoneSortingKey = "BoneHierarchyTool_BoneSorting";

    private Transform rootBone;
    private BoneOmissionList omissionList;
    private BoneHierarchyData hierarchyData;
    private bool addRoot;
    private BoneSorting boneSorting;

    [MenuItem("Tools/Bone Hierarchy Tool")]
    public static void ShowWindow()
    {
        GetWindow<BoneHierarchyTool>("Bone Hierarchy Tool");
    }

    private void OnEnable()
    {
        int rootBoneInstanceID = EditorPrefs.GetInt(RootBoneKey, 0);
        rootBone = EditorUtility.InstanceIDToObject(rootBoneInstanceID) as Transform;

        string omissionListGuid = EditorPrefs.GetString(OmissionListKey, string.Empty);
        string hierarchyDataGuid = EditorPrefs.GetString(HierarchyDataKey, string.Empty);

        omissionList = AssetDatabase.LoadAssetAtPath<BoneOmissionList>(AssetDatabase.GUIDToAssetPath(omissionListGuid));
        hierarchyData = AssetDatabase.LoadAssetAtPath<BoneHierarchyData>(AssetDatabase.GUIDToAssetPath(hierarchyDataGuid));

        addRoot = EditorPrefs.GetBool(AddRootKey, true);
        boneSorting = (BoneSorting)EditorPrefs.GetInt(BoneSortingKey, (int)BoneSorting.BasedOnHierarchy);
    }

    private void OnDisable()
    {
        if (rootBone != null)
        {
            int rootBoneInstanceID = rootBone.GetInstanceID();
            EditorPrefs.SetInt(RootBoneKey, rootBoneInstanceID);
        }

        if (omissionList != null)
        {
            string omissionListPath = AssetDatabase.GetAssetPath(omissionList);
            string omissionListGuid = AssetDatabase.AssetPathToGUID(omissionListPath);
            EditorPrefs.SetString(OmissionListKey, omissionListGuid);
        }

        if (hierarchyData != null)
        {
            string hierarchyDataPath = AssetDatabase.GetAssetPath(hierarchyData);
            string hierarchyDataGuid = AssetDatabase.AssetPathToGUID(hierarchyDataPath);
            EditorPrefs.SetString(HierarchyDataKey, hierarchyDataGuid);
        }

        EditorPrefs.SetBool(AddRootKey, addRoot);
        EditorPrefs.SetInt(BoneSortingKey, (int)boneSorting);
    }

    private void OnGUI()
    {
        GUILayout.Label("Bone Hierarchy Tool", EditorStyles.boldLabel);

        rootBone = (Transform)EditorGUILayout.ObjectField("Root Bone", rootBone, typeof(Transform), true);
        omissionList = (BoneOmissionList)EditorGUILayout.ObjectField("Omission List", omissionList, typeof(BoneOmissionList), false);
        hierarchyData = (BoneHierarchyData)EditorGUILayout.ObjectField("Hierarchy Data", hierarchyData, typeof(BoneHierarchyData), false);

        addRoot = EditorGUILayout.Toggle("Add Root", addRoot);
        boneSorting = (BoneSorting)EditorGUILayout.EnumPopup("Bone Sorting", boneSorting);

        if (GUILayout.Button("Generate Hierarchy Data"))
        {
            GenerateHierarchyData();
        }

        if (GUILayout.Button("Resolve Bone References"))
        {
            ResolveBoneReferences();
        }
    }

    private void GenerateHierarchyData()
    {
        if (rootBone == null || omissionList == null || hierarchyData == null)
        {
            Debug.LogError("Please assign all required fields.");
            return;
        }

        var limbIdentifier = new GameObject("LimbIdentifier").AddComponent<LimbIdentifier>();
        limbIdentifier.root = rootBone;
        limbIdentifier.omittedBonesList = omissionList;
        limbIdentifier.addRoot = addRoot;
        limbIdentifier.boneSorting = boneSorting;

        limbIdentifier.IdentifySkeletonBones();

        hierarchyData.bones.Clear();
        for (int i = 0; i < limbIdentifier.BoneTransforms.Count; i++)
        {
            var bone = limbIdentifier.BoneTransforms[i];
            hierarchyData.bones.Add(new BoneHierarchyData.BoneData
            {
                boneName = bone.name,
                position = bone.localPosition,
                rotation = bone.localRotation,
                scale = bone.localScale,
                parentIndex = limbIdentifier.ParentBoneIndex[i],
                path = limbIdentifier.BonePaths[i]
            });
        }

        EditorUtility.SetDirty(hierarchyData);
        DestroyImmediate(limbIdentifier.gameObject);

        Debug.Log("Hierarchy data generated and saved successfully.");

        // Select the hierarchyData object to show its contents in the Inspector
        Selection.activeObject = hierarchyData;
    }

    private void ResolveBoneReferences()
    {
        if (hierarchyData == null)
        {
            Debug.LogError("Please assign a hierarchy data ScriptableObject.");
            return;
        }

        hierarchyData.ResolveBoneReferences(out List<Transform> resolvedTransforms);
        Debug.Log("Resolved " + resolvedTransforms.Count + " bones.");
    }
}

Explanation

1. GetRelativePath Method:

   • Computes the path from the root object to each target object, but ensures that the top-level GameObject is not included.

2. LimbIdentifier Class:

   • Uses the GetRelativePath method to store paths relative to the root object.

3. BoneHierarchyTool Editor Window:

   • Stores and retrieves settings for addRoot and boneSorting using EditorPrefs.
   • Uses GetRelativePath to store paths relative to the root object.

By making these changes, you ensure that only the top-level GameObject is omitted from the paths, and paths are correctly computed relative to the root of the bone hierarchy.