public static void AssignSpringBonesRecursively()
        {
            if (Application.isPlaying)
            {
                Debug.LogError("再生モードを止めてください。");
                return;
            }

            if (Selection.gameObjects.Length < 1)
            {
                Debug.LogError("一つ以上のオブジェクトを選択してください。");
                return;
            }

            var springManagers = new HashSet <SpringManager>();

            foreach (var gameObject in Selection.gameObjects)
            {
                SpringBoneSetup.AssignSpringBonesRecursively(gameObject.transform);
                var manager = gameObject.GetComponentInParent <SpringManager>();
                if (manager != null)
                {
                    springManagers.Add(manager);
                }
            }

            foreach (var manager in springManagers)
            {
                SpringBoneSetup.FindAndAssignSpringBones(manager, true);
            }

            AssetDatabase.Refresh();
        }
            public void BuildObjects(GameObject springBoneRoot, GameObject colliderRoot, IEnumerable <string> requiredBones)
            {
                var managerProperties = PersistentSpringManagerProperties.Create(
                    springBoneRoot.GetComponentInChildren <SpringManager>());

                SpringBoneSetup.DestroySpringManagersAndBones(springBoneRoot);

                if (requiredBones != null)
                {
                    FilterBoneRecordsByRequiredBonesAndCreateUnrecordedBones(springBoneRoot, requiredBones);
                }

                var initialTransforms = GameObjectUtil.BuildNameToComponentMap <Transform>(springBoneRoot, true);

                foreach (var record in pivotRecords)
                {
                    BuildPivotFromSerializer(initialTransforms, record);
                }

                var setupMaps = SpringBoneSetupMaps.Build(springBoneRoot, colliderRoot);

                foreach (var record in springBoneRecords)
                {
                    BuildSpringBoneFromSerializer(setupMaps, record);
                }

                var springManager = springBoneRoot.AddComponent <SpringManager>();

                if (managerProperties != null)
                {
                    managerProperties.ApplyTo(springManager);
                }
                SpringBoneSetup.FindAndAssignSpringBones(springManager);
            }
Exemple #3
0
        public static SpringManager PerformSetup
        (
            GameObject rootObject,
            IEnumerable <GameObject> newSpringBones,
            AutoSetupParameters parameters
        )
        {
            SpringBoneSetup.DestroySpringManagersAndBones(rootObject);
            SpringColliderSetup.DestroySpringColliders(rootObject);

            var springBones = new List <SpringBone>();

            foreach (var boneParent in newSpringBones.Where(boneParent => boneParent.transform.childCount > 0))
            {
                springBones.Add(boneParent.AddComponent <SpringBone>());
            }

            var manager = rootObject.AddComponent <SpringManager>();

            SpringBoneSetup.FindAndAssignSpringBones(manager, true);

            if (parameters.createPivots)
            {
                foreach (var springBone in springBones)
                {
                    SpringBoneSetup.CreateSpringPivotNode(springBone);
                }
            }

            return(manager);
        }
Exemple #4
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);
        }
        public static void AddToOrUpdateSpringManagerInSelection()
        {
            if (Application.isPlaying)
            {
                Debug.LogError("再生モードを止めてください。");
                return;
            }

            if (Selection.gameObjects.Length <= 0)
            {
                Debug.LogError("一つ以上のオブジェクトを選択してください。");
                return;
            }

            foreach (var gameObject in Selection.gameObjects)
            {
                var manager = gameObject.GetComponent <SpringManager>();
                if (manager == null)
                {
                    manager = gameObject.AddComponent <SpringManager>();
                }
                SpringBoneSetup.FindAndAssignSpringBones(manager, true);
            }
        }
Exemple #6
0
 private static void UpdateBoneList(SpringManager manager)
 {
     SpringBoneSetup.FindAndAssignSpringBones(manager, true);
 }
 private static void UpdateBoneList(SpringManager manager)
 {
     Undo.RecordObject(manager, "SpringBoneリストを更新");
     SpringBoneSetup.FindAndAssignSpringBones(manager, true);
 }