ClientServer/Client/Assets/Scripts/Util/Mesh/MeshColliderDuplicator.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using NaughtyAttributes;
using UnityEditor;
using UnityEngine;
#if UNITY_EDITROR
using System.Collections;
using Unity.EditorCoroutines.Editor;
using UnityEditor;
using UnityEngine.Rendering;
#endif
namespace Util.Mesh
{

    public class MeshColliderDuplicator : MonoBehaviour
    {
#if UNITY_EDITROR
        [SerializeField] private BoxCollider[] allBoxed;
        [SerializeField] private SphereCollider[] allSphere;
        [SerializeField] private CapsuleCollider[] allCapsule;
        [SerializeField] private MeshCollider[] allMesh;
        [SerializeField] private List<UnityEngine.Mesh> allType = new List<UnityEngine.Mesh>();
        [SerializeField] private SerializedDictionary<UnityEngine.Mesh,GameObject> allTypeObjects =
            new SerializedDictionary<UnityEngine.Mesh,GameObject>();

        [Button("Duplicate All  Collider")]
        public void StartAsync()
        {
            EditorCoroutineUtility.StartCoroutine(GetCollider(),this);
            EditorCoroutineUtility.StartCoroutine(GetMesh(),this);
            EditorCoroutineUtility.StartCoroutine(DuplicateAll(),this);

        }

        public IEnumerator GetMesh()
        {

            foreach (var boxes in allBoxed)
            {
                var filter = boxes.GetComponent<MeshFilter>();
                int val = allBoxed.ToList().Count;
                int valObj = 0;
                if (!allType.Contains(filter.sharedMesh))
                {
                    allType.Add(filter.sharedMesh);
                    var sharedMesh = filter.sharedMesh;
                    GameObject objectParentDuplicate = new GameObject(sharedMesh.name);
                    allTypeObjects.Add(sharedMesh,objectParentDuplicate);

                    valObj++;
                    yield return EditorApplication.update;
                    Debugger.Logger($"allBoxed GetMesh {valObj}/{val}",Process.Create);
                }
            }
            foreach (var boxes in allSphere)
            {
                var filter = boxes.GetComponent<MeshFilter>();
                int val = allBoxed.ToList().Count;
                int valObj = 0;
                if (!allType.Contains(filter.sharedMesh))
                {
                    allType.Add(filter.sharedMesh);
                    var sharedMesh = filter.sharedMesh;
                    GameObject objectParentDuplicate = new GameObject(sharedMesh.name);
                    allTypeObjects.Add(sharedMesh,objectParentDuplicate);

                    valObj++;
                    yield return EditorApplication.update;
                    Debugger.Logger($"allSphere GetMesh {valObj}/{val}",Process.Create);
                }
            }
            foreach (var boxes in allCapsule)
            {
                var filter = boxes.GetComponent<MeshFilter>();
                int val = allBoxed.ToList().Count;
                int valObj = 0;
                if (!allType.Contains(filter.sharedMesh))
                {
                    allType.Add(filter.sharedMesh);
                    var sharedMesh = filter.sharedMesh;
                    GameObject objectParentDuplicate = new GameObject(sharedMesh.name);
                    allTypeObjects.Add(sharedMesh,objectParentDuplicate);

                    valObj++;
                    yield return EditorApplication.update;
                    Debugger.Logger($"allCapsule GetMesh {valObj}/{val}",Process.Create);
                }
            }
            foreach (var boxes in allMesh)
            {
                var filter = boxes.GetComponent<MeshFilter>();
                int val = allBoxed.ToList().Count;
                int valObj = 0;
                if (!allType.Contains(filter.sharedMesh))
                {
                    allType.Add(filter.sharedMesh);
                    var sharedMesh = filter.sharedMesh;
                    GameObject objectParentDuplicate = new GameObject(sharedMesh.name);
                    allTypeObjects.Add(sharedMesh,objectParentDuplicate);

                    valObj++;
                    yield return EditorApplication.update;
                    Debugger.Logger($"allMesh GetMesh {valObj}/{val}",Process.Create);
                }
            }
        }
        public IEnumerator GetCollider()
        {
            allBoxed = GetComponentsInChildren<BoxCollider>();
            allCapsule = GetComponentsInChildren<CapsuleCollider>();
            allSphere = GetComponentsInChildren<SphereCollider>();
            allMesh = GetComponentsInChildren<MeshCollider>();
            
            Debugger.Logger($"GetCollider end",Process.Action);
            yield break;
        }
        public  IEnumerator  DuplicateAll()
        {
            GameObject objectParentDuplicate = new GameObject("");
            int val = allBoxed.ToList().Count;
            int valObj = 0;
            foreach (var boxes in allBoxed)
            {
                var filter = boxes.GetComponent<MeshFilter>();
                var objectName = filter.gameObject.name;
                var parent = allTypeObjects[filter.sharedMesh];
                var boxTransform = boxes.transform;
                var bo = Instantiate(objectParentDuplicate, 
                    boxTransform.position, boxTransform.rotation,parent.transform);
                var box = bo.AddComponent<BoxCollider>();
                bo.name = objectName;
                box.center = boxes.center;
                box.size = boxes.size;
                valObj++;
                yield return EditorApplication.update;

                Console.Clear();
                Debugger.Logger($"Duplicate allBoxed  {valObj}/{val}",Process.Create);
            }
            foreach (var boxes in allCapsule)
            {
                var filter = boxes.GetComponent<MeshFilter>();
                var objectName = filter.gameObject.name;
                var parent = allTypeObjects[filter.sharedMesh];
                var boxTransform = boxes.transform;
                var bo = Instantiate(objectParentDuplicate, 
                    boxTransform.position, boxTransform.rotation,parent.transform);
                var box = bo.AddComponent<CapsuleCollider>();
                bo.name = objectName;
                box.center = boxes.center;
                box.direction = boxes.direction;
                box.height = boxes.height;
                box.radius = boxes.radius;
                valObj++;
                yield return EditorApplication.update;
                
                Console.Clear();
                Debugger.Logger($"Duplicate allCapsule {valObj}/{val}",Process.Create);

            }
            foreach (var boxes in allSphere)
            {
                var filter = boxes.GetComponent<MeshFilter>();
                var objectName = filter.gameObject.name;
                var parent = allTypeObjects[filter.sharedMesh];
                var boxTransform = boxes.transform;
                var bo = Instantiate(objectParentDuplicate, 
                    boxTransform.position, boxTransform.rotation,parent.transform);
                var box = bo.AddComponent<SphereCollider>();
                bo.name = objectName;
                box.center = boxes.center;
                box.radius = boxes.radius;
                valObj++;
                yield return EditorApplication.update;
                
                Console.Clear();
                Debugger.Logger($"Duplicate allSphere {valObj}/{val}",Process.Create);

            }
            foreach (var boxes in allMesh)
            {
                var filter = boxes.GetComponent<MeshFilter>();
                var objectName = filter.gameObject.name;
                var parent = allTypeObjects[filter.sharedMesh];
                var boxTransform = boxes.transform;
                var bo = Instantiate(objectParentDuplicate, 
                    boxTransform.position, boxTransform.rotation,parent.transform);
                var box = bo.AddComponent<MeshCollider>();
                bo.name = objectName;
                box.convex = boxes.convex;
                box.sharedMesh = boxes.sharedMesh;
                valObj++;
                yield return EditorApplication.update;
                
                Console.Clear();
                Debugger.Logger($"Duplicate allMesh {valObj}/{val}",Process.Create);

            }
            DestroyImmediate(objectParentDuplicate);
//          StartCoroutine(SortByBoxCollider(allBoxed.ToList()));
            //var allSphere  = GetComponentsInChildren<SphereCollider>();
            //await SortBySphereCollider(allSphere.ToList());
            //var allCapsule  = GetComponentsInChildren<CapsuleCollider>();
            //await SortByCapsuleCollider(allCapsule.ToList());
            //var allMeshes  = GetComponentsInChildren<MeshCollider>();
            //await SortByMeshCollider(allMeshes.ToList());
        }
#endif

    }
}