Exemple #1
0
        public static void UpdateSpringManagerFromBoneList(SpringManager springManager)
        {
            var rootObject            = springManager.gameObject;
            var designatedSpringBones = GetBonesDesignatedForDynamics(rootObject);
            var currentSpringBones    = rootObject.GetComponentsInChildren <SpringBone>(true);

            var skinBones            = GameObjectExtensions.GameObjectUtil.GetAllBones(rootObject);
            var springBonesToDestroy = currentSpringBones
                                       .Where(bone => !designatedSpringBones.Contains(bone.gameObject));

            foreach (var boneToDestroy in springBonesToDestroy)
            {
                var pivot = boneToDestroy.pivotNode;
                if (pivot != null &&
                    SpringBoneSetup.IsPivotProbablySafeToDestroy(pivot, skinBones))
                {
                    SpringBoneSetup.DestroyUnityObject(pivot.gameObject);
                }
                SpringBoneSetup.DestroyUnityObject(boneToDestroy);
            }

            var objectsToAddBonesTo = designatedSpringBones
                                      .Where(bone => bone.GetComponent <SpringBone>() == null);

            foreach (var newBoneOwner in objectsToAddBonesTo)
            {
                var newSpringBone = newBoneOwner.AddComponent <SpringBone>();
                SpringBoneSetup.CreateSpringPivotNode(newSpringBone);
            }
            SpringBoneSetup.FindAndAssignSpringBones(springManager, true);
        }
Exemple #2
0
        private static void RemoveDuplicateComponents <T>() where T : Component
        {
            // Delete all components of the same type after the first
            var duplicateObjects = GameObjectExtensions.GameObjectUtil.FindComponentsOfType <Transform>()
                                   .Where(item => item.GetComponents <T>().Length > 1);

            if (duplicateObjects.Any())
            {
                Undo.RecordObjects(duplicateObjects.ToArray(), "Remove duplicate components");
                foreach (var transform in duplicateObjects)
                {
                    var components = transform.GetComponents <T>();
                    for (int componentIndex = 1; componentIndex < components.Length; componentIndex++)
                    {
                        SpringBoneSetup.DestroyUnityObject(components[componentIndex]);
                    }
                }
            }
        }
Exemple #3
0
        public static void CleanUpDynamics()
        {
            if (Application.isPlaying)
            {
                Debug.LogError("再生モードを止めてください。");
                return;
            }

            var springManagers = GameObjectExtensions.GameObjectUtil.FindComponentsOfType <SpringManager>();

            if (!springManagers.Any())
            {
                return;
            }

            var queryMessage = "本当にダイナミクスのクリーンナップを行いますか?";

            if (EditorUtility.DisplayDialog("ダイナミクスクリーンナップ", queryMessage, "削除", "キャンセル"))
            {
                RemoveDuplicateComponents <SpringBone>();
                RemoveDuplicateComponents <DynamicsNull>();
                RemoveDuplicateComponents <SpringManager>();

                springManagers = GameObjectExtensions.GameObjectUtil.FindComponentsOfType <SpringManager>();
                foreach (var springManager in springManagers)
                {
                    var springBones = springManager.GetComponentsInChildren <SpringBone>(true);
                    var allBones    = GameObjectExtensions.GameObjectUtil.GetAllBones(springManager.gameObject);

                    var maybeUnusedGameObjects = new HashSet <GameObject>();

                    var unusedSpheres = springManager.GetComponentsInChildren <SpringSphereCollider>(true)
                                        .Where(collider => !springBones.Any(springBone => springBone.sphereColliders.Contains(collider)));
                    foreach (var collider in unusedSpheres)
                    {
                        maybeUnusedGameObjects.Add(collider.gameObject);
                        SpringBoneSetup.DestroyUnityObject(collider);
                    }

                    var unusedCapsules = springManager.GetComponentsInChildren <SpringCapsuleCollider>(true)
                                         .Where(collider => !springBones.Any(springBone => springBone.capsuleColliders.Contains(collider)));
                    foreach (var collider in unusedCapsules)
                    {
                        maybeUnusedGameObjects.Add(collider.gameObject);
                        SpringBoneSetup.DestroyUnityObject(collider);
                    }

                    var unusedPanels = springManager.GetComponentsInChildren <SpringPanelCollider>(true)
                                       .Where(collider => !springBones.Any(springBone => springBone.panelColliders.Contains(collider)));
                    foreach (var collider in unusedPanels)
                    {
                        maybeUnusedGameObjects.Add(collider.gameObject);
                        SpringBoneSetup.DestroyUnityObject(collider);
                    }

                    var gameObjectsToDelete = maybeUnusedGameObjects
                                              .Where(gameObject => !allBones.Contains(gameObject.transform));
                    foreach (var gameObject in gameObjectsToDelete)
                    {
                        if (gameObject.GetComponents <Component>().Length <= 1)
                        {
                            SpringBoneSetup.DestroyUnityObject(gameObject);
                        }
                    }

                    // Next remove all empty entries from SpringBones
                    Undo.RecordObjects(springBones.ToArray(), "SpringBone cleanup");
                    foreach (var springBone in springBones)
                    {
                        springBone.capsuleColliders   = springBone.capsuleColliders.Where(item => item != null).ToArray();
                        springBone.panelColliders     = springBone.panelColliders.Where(item => item != null).ToArray();
                        springBone.sphereColliders    = springBone.sphereColliders.Where(item => item != null).ToArray();
                        springBone.lengthLimitTargets = springBone.lengthLimitTargets.Where(item => item != null).ToArray();
                    }
                }
            }
        }
Exemple #4
0
        public static void DeleteAllChildCollidersFromSelection()
        {
            if (Application.isPlaying)
            {
                Debug.LogError("再生モードを止めてください。");
                return;
            }

            if (Selection.gameObjects.Length == 0)
            {
                return;
            }

            var queryMessage = "本当に選択中のオブジェクトの全子供のコライダーを削除しますか?";

            if (!EditorUtility.DisplayDialog("選択コライダーを削除", queryMessage, "削除", "キャンセル"))
            {
                return;
            }

            var charaBones = Selection.gameObjects
                             .SelectMany(gameObject => GameObjectExtensions.GameObjectUtil.GetAllBones(gameObject.transform.root.gameObject))
                             .Distinct();

            var colliderTypes = SpringColliderSetup.GetColliderTypes();
            var deadColliders = new List <Component>();

            foreach (var gameObject in Selection.gameObjects)
            {
                foreach (var type in colliderTypes)
                {
                    deadColliders.AddRange(gameObject.GetComponentsInChildren(type, true));
                }
            }
            deadColliders = deadColliders.Distinct().ToList();

            var probablyDeadGameObjects = deadColliders.Select(collider => collider.gameObject)
                                          .Distinct()
                                          .Where(gameObject => !charaBones.Contains(gameObject.transform) &&
                                                 gameObject.GetComponents <Component>().Count() <= 1 &&
                                                 gameObject.transform.childCount == 0)
                                          .ToArray();

            var springBones = GameObjectExtensions.GameObjectUtil.FindComponentsOfType <SpringBone>();
            var undoObjects = new List <Object>(springBones.Select(item => (Object)item));

            undoObjects.AddRange(deadColliders.Select(item => (Object)item));
            undoObjects.AddRange(probablyDeadGameObjects.Select(item => (Object)item));
            Undo.RecordObjects(undoObjects.ToArray(), "Remove all selected child colliders");

            foreach (var springBone in springBones)
            {
                springBone.sphereColliders  = springBone.sphereColliders.Where(collider => !deadColliders.Contains(collider)).ToArray();
                springBone.capsuleColliders = springBone.capsuleColliders.Where(collider => !deadColliders.Contains(collider)).ToArray();
                springBone.panelColliders   = springBone.panelColliders.Where(collider => !deadColliders.Contains(collider)).ToArray();
            }

            foreach (var deadCollider in deadColliders)
            {
                SpringBoneSetup.DestroyUnityObject(deadCollider);
            }

            foreach (var gameObject in probablyDeadGameObjects)
            {
                SpringBoneSetup.DestroyUnityObject(gameObject);
            }
        }