public SynchronizeAnimation()
        {
            synchronizeObjects = new List <SynchronizeObject>();

            Action <GameObject> AddGameObject = (go) =>
            {
                Func <Transform, bool> CheckHideFlags = null;
                CheckHideFlags = (t) =>
                {
                    if ((t.gameObject.hideFlags & (HideFlags.HideAndDontSave | HideFlags.NotEditable)) != 0)
                    {
                        return(false);
                    }

                    if (t.parent != null)
                    {
                        return(CheckHideFlags(t.parent));
                    }
                    else
                    {
                        return(true);
                    }
                };

                foreach (var animator in go.GetComponentsInChildren <Animator>(true))
                {
                    if (animator == null || animator == vaw.animator)
                    {
                        continue;
                    }
                    if (!animator.gameObject.activeInHierarchy || !animator.enabled)
                    {
                        continue;
                    }
                    if (!CheckHideFlags(animator.transform))
                    {
                        continue;
                    }
                    #region Clip
                    AnimationClip clip = null;
                    {
                        var saveSettings = animator.GetComponent <VeryAnimationSaveSettings>();
                        if (saveSettings != null && saveSettings.lastSelectAnimationClip != null)
                        {
                            if (ArrayUtility.Contains(AnimationUtility.GetAnimationClips(animator.gameObject), saveSettings.lastSelectAnimationClip))
                            {
                                clip = saveSettings.lastSelectAnimationClip;
                            }
                        }
                        if (clip == null)
                        {
                            var ac = EditorCommon.GetAnimatorController(animator);
                            if (ac != null && ac.layers.Length > 0)
                            {
                                var state = ac.layers[0].stateMachine.defaultState;
                                if (state != null)
                                {
                                    if (state.motion is UnityEditor.Animations.BlendTree)
                                    {
                                        Action <UnityEditor.Animations.BlendTree> FindBlendTree = null;
                                        FindBlendTree = (blendTree) =>
                                        {
                                            if (blendTree.children == null)
                                            {
                                                return;
                                            }
                                            var children = blendTree.children;
                                            for (int i = 0; i < children.Length; i++)
                                            {
                                                if (children[i].motion is UnityEditor.Animations.BlendTree)
                                                {
                                                    FindBlendTree(children[i].motion as UnityEditor.Animations.BlendTree);
                                                }
                                                else
                                                {
                                                    clip = children[i].motion as AnimationClip;
                                                }
                                                if (clip != null)
                                                {
                                                    break;
                                                }
                                            }
                                            blendTree.children = children;
                                        };
                                        FindBlendTree(state.motion as UnityEditor.Animations.BlendTree);
                                    }
                                    else
                                    {
                                        clip = state.motion as AnimationClip;
                                    }
                                }
                            }
                            if (clip != null)
                            {
                                var owc = animator.runtimeAnimatorController as AnimatorOverrideController;
                                if (owc != null)
                                {
                                    clip = owc[clip];
                                }
                            }
                        }
                    }
                    if (clip == null)
                    {
                        continue;
                    }
                    #endregion

                    synchronizeObjects.Add(new SynchronizeObject(animator, clip));
                }
                foreach (var animation in go.GetComponentsInChildren <Animation>(true))
                {
                    if (animation == null || animation == vaw.animation)
                    {
                        continue;
                    }
                    if (!animation.gameObject.activeInHierarchy || !animation.enabled)
                    {
                        continue;
                    }
                    if (!CheckHideFlags(animation.transform))
                    {
                        continue;
                    }
                    #region Clip
                    AnimationClip clip = null;
                    {
                        var saveSettings = animation.GetComponent <VeryAnimationSaveSettings>();
                        if (saveSettings != null && saveSettings.lastSelectAnimationClip != null)
                        {
                            if (ArrayUtility.Contains(AnimationUtility.GetAnimationClips(animation.gameObject), saveSettings.lastSelectAnimationClip))
                            {
                                clip = saveSettings.lastSelectAnimationClip;
                            }
                        }
                        if (clip == null)
                        {
                            clip = animation.clip;
                        }
                    }
                    if (clip == null)
                    {
                        continue;
                    }
                    #endregion

                    synchronizeObjects.Add(new SynchronizeObject(animation, clip));
                }
            };

#if UNITY_2018_3_OR_NEWER
            if (PrefabStageUtility.GetCurrentPrefabStage() != null)
            {
                var scene = PrefabStageUtility.GetCurrentPrefabStage().scene;
                foreach (var go in scene.GetRootGameObjects())
                {
                    AddGameObject(go);
                }
            }
            else
#endif
            {
                for (int i = 0; i < SceneManager.sceneCount; i++)
                {
                    var scene = SceneManager.GetSceneAt(i);
                    foreach (var go in scene.GetRootGameObjects())
                    {
                        AddGameObject(go);
                    }
                }
            }
        }
Beispiel #2
0
        private void UpdateBlendShapeSetIcon()
        {
            if (!blendShapeSetIconUpdate)
            {
                return;
            }
            blendShapeSetIconUpdate = false;

            if (va.blendShapeSetList == null || va.blendShapeSetList.Count <= 0)
            {
                return;
            }

            TransformPoseSave    beforePose       = new TransformPoseSave(va.editGameObject);
            BlendShapeWeightSave beforeBlendShape = new BlendShapeWeightSave(va.editGameObject);

            va.transformPoseSave.ResetDefaultTransform();
            va.blendShapeWeightSave.ResetDefaultWeight();

            var gameObject = GameObject.Instantiate <GameObject>(va.editGameObject);

            gameObject.hideFlags         |= HideFlags.HideAndDontSave;
            gameObject.transform.rotation = Quaternion.identity;
            EditorCommon.DisableOtherBehaviors(gameObject);

            Action ForceObjectUpdate = () =>
            {
                gameObject.SetActive(false);
                gameObject.SetActive(true);
            };

            int blankLayer;

            {
                for (blankLayer = 31; blankLayer > 0; blankLayer--)
                {
                    if (string.IsNullOrEmpty(LayerMask.LayerToName(blankLayer)))
                    {
                        break;
                    }
                }
                if (blankLayer < 0)
                {
                    blankLayer = 31;
                }
            }
            foreach (var renderer in gameObject.GetComponentsInChildren <Renderer>(true))
            {
                if (renderer == null)
                {
                    continue;
                }
                renderer.gameObject.layer = blankLayer;
            }
            var renderers = gameObject.GetComponentsInChildren <SkinnedMeshRenderer>(true).Where(renderer => renderer != null && renderer.sharedMesh != null && renderer.sharedMesh.blendShapeCount > 0).ToArray();

            foreach (var renderer in renderers)
            {
                renderer.updateWhenOffscreen = true;
            }

            {
                RenderTexture iconTexture = new RenderTexture(IconTextureSize, IconTextureSize, 16, RenderTextureFormat.ARGB32);
                iconTexture.hideFlags |= HideFlags.HideAndDontSave;
                iconTexture.Create();
                var cameraObject = new GameObject();
                cameraObject.hideFlags |= HideFlags.HideAndDontSave;
                var camera = cameraObject.AddComponent <Camera>();
                camera.targetTexture   = iconTexture;
                camera.clearFlags      = CameraClearFlags.Color;
                camera.backgroundColor = Color.clear;
                camera.cullingMask     = 1 << blankLayer;
                {
                    Bounds bounds = new Bounds();
                    foreach (var renderer in renderers)
                    {
                        if (Mathf.Approximately(bounds.size.sqrMagnitude, 0f))
                        {
                            bounds = renderer.bounds;
                        }
                        else
                        {
                            bounds.Encapsulate(renderer.bounds);
                        }
                    }
                    var transform = camera.transform;
                    var sizeMax   = Mathf.Max(bounds.size.x, Mathf.Max(bounds.size.y, bounds.size.z));
                    switch (blendShapeSetIconCameraMode)
                    {
                    case IconCameraMode.forward:
                    {
                        var rot = Quaternion.AngleAxis(180f, Vector3.up);
                        transform.localRotation = rot;
                        sizeMax = Mathf.Max(bounds.size.x, bounds.size.y);
                        transform.localPosition = new Vector3(bounds.center.x, bounds.center.y, bounds.max.z) - transform.forward;
                    }
                    break;

                    case IconCameraMode.back:
                    {
                        transform.localRotation = Quaternion.identity;
                        sizeMax = Mathf.Max(bounds.size.x, bounds.size.y);
                        transform.localPosition = new Vector3(bounds.center.x, bounds.center.y, bounds.min.z) - transform.forward;
                    }
                    break;

                    case IconCameraMode.up:
                    {
                        var rot = Quaternion.AngleAxis(90f, Vector3.right);
                        transform.localRotation = rot;
                        sizeMax = Mathf.Max(bounds.size.x, bounds.size.z);
                        transform.localPosition = new Vector3(bounds.center.x, bounds.max.y, bounds.center.z) - transform.forward;
                    }
                    break;

                    case IconCameraMode.down:
                    {
                        var rot = Quaternion.AngleAxis(-90f, Vector3.right);
                        transform.localRotation = rot;
                        sizeMax = Mathf.Max(bounds.size.x, bounds.size.z);
                        transform.localPosition = new Vector3(bounds.center.x, bounds.min.y, bounds.center.z) - transform.forward;
                    }
                    break;

                    case IconCameraMode.right:
                    {
                        var rot = Quaternion.AngleAxis(-90f, Vector3.up);
                        transform.localRotation = rot;
                        sizeMax = Mathf.Max(bounds.size.y, bounds.size.z);
                        transform.localPosition = new Vector3(bounds.max.x, bounds.center.y, bounds.center.z) - transform.forward;
                    }
                    break;

                    case IconCameraMode.left:
                    {
                        var rot = Quaternion.AngleAxis(90f, Vector3.up);
                        transform.localRotation = rot;
                        sizeMax = Mathf.Max(bounds.size.y, bounds.size.z);
                        transform.localPosition = new Vector3(bounds.min.x, bounds.center.y, bounds.center.z) - transform.forward;
                    }
                    break;
                    }
                    camera.orthographic     = true;
                    camera.orthographicSize = sizeMax * 0.6f;
                    camera.farClipPlane     = 1f + sizeMax * 5f;
                }
                cameraObject.transform.SetParent(gameObject.transform);
                gameObject.transform.rotation = va.editGameObject.transform.rotation;

                foreach (var set in va.blendShapeSetList)
                {
                    va.blendShapeWeightSave.ResetDefaultWeight();
                    if (set.poseTemplate.blendShapePaths != null && set.poseTemplate.blendShapeValues != null)
                    {
                        foreach (var renderer in renderers)
                        {
                            var path  = AnimationUtility.CalculateTransformPath(renderer.transform, gameObject.transform);
                            var index = EditorCommon.ArrayIndexOf(set.poseTemplate.blendShapePaths, path);
                            if (index < 0)
                            {
                                continue;
                            }
                            for (int i = 0; i < set.poseTemplate.blendShapeValues[index].names.Length; i++)
                            {
                                var sindex = renderer.sharedMesh.GetBlendShapeIndex(set.poseTemplate.blendShapeValues[index].names[i]);
                                if (sindex < 0 || sindex >= renderer.sharedMesh.blendShapeCount)
                                {
                                    continue;
                                }
                                renderer.SetBlendShapeWeight(sindex, set.poseTemplate.blendShapeValues[index].weights[i]);
                            }
                        }
                    }
                    ForceObjectUpdate();
                    camera.Render();
                    {
                        RenderTexture save = RenderTexture.active;
                        RenderTexture.active = iconTexture;
                        if (set.icon == null)
                        {
                            set.icon            = new Texture2D(iconTexture.width, iconTexture.height, TextureFormat.ARGB32, iconTexture.useMipMap);
                            set.icon.hideFlags |= HideFlags.HideAndDontSave;
                        }
                        set.icon.ReadPixels(new Rect(0, 0, iconTexture.width, iconTexture.height), 0, 0);
                        set.icon.Apply();
                        RenderTexture.active = save;
                    }
                }

                GameObject.DestroyImmediate(cameraObject);
                iconTexture.Release();
                RenderTexture.DestroyImmediate(iconTexture);
            }

            GameObject.DestroyImmediate(gameObject);

            beforePose.ResetDefaultTransform();
            beforeBlendShape.ResetDefaultWeight();
            {
                va.editGameObject.SetActive(false);
                va.editGameObject.SetActive(true);
            }
            va.SetUpdateResampleAnimation();
        }
Beispiel #3
0
        private void ToolsTemplatePose()
        {
            var transforms = EditorCommon.GetHierarchyTransform(activeRootObject.transform);

            Undo.RecordObjects(transforms.ToArray(), "Template Pose");
            var animator = activeRootObject.GetComponent <Animator>();

            if (animator != null && !animator.isInitialized)
            {
                animator.Rebind();
            }
            var save = new TransformPoseSave.SaveData(activeRootObject.transform);

            string[] paths = new string[transforms.Count];
            for (int i = 0; i < transforms.Count; i++)
            {
                paths[i] = AnimationUtility.CalculateTransformPath(transforms[i], activeRootObject.transform);
            }
            #region Human
            if (animator != null && animator.isHuman)
            {
                var uAnimator        = new UAnimator();
                var humanPoseHandler = new HumanPoseHandler(animator.avatar, uAnimator.GetAvatarRoot(animator));
                var humanPose        = new HumanPose();
                humanPoseHandler.GetHumanPose(ref humanPose);
                {
                    var musclePropertyName = new MusclePropertyName();
                    if (toolPoseTemplate.haveRootT)
                    {
                        humanPose.bodyPosition = toolPoseTemplate.rootT;
                    }
                    if (toolPoseTemplate.haveRootQ)
                    {
                        humanPose.bodyRotation = toolPoseTemplate.rootQ;
                    }
                    if (toolPoseTemplate.musclePropertyNames != null && toolPoseTemplate.muscleValues != null)
                    {
                        Assert.IsTrue(toolPoseTemplate.musclePropertyNames.Length == toolPoseTemplate.muscleValues.Length);
                        for (int i = 0; i < toolPoseTemplate.musclePropertyNames.Length; i++)
                        {
                            var muscleIndex = EditorCommon.ArrayIndexOf(musclePropertyName.PropertyNames, toolPoseTemplate.musclePropertyNames[i]);
                            if (muscleIndex < 0)
                            {
                                continue;
                            }
                            humanPose.muscles[muscleIndex] = toolPoseTemplate.muscleValues[i];
                        }
                    }
                    if (toolPoseTemplate.tdofIndices != null && toolPoseTemplate.tdofValues != null)
                    {
                        //not support
                    }
                }
                humanPoseHandler.SetHumanPose(ref humanPose);
            }
            #endregion
            #region Generic
            if (toolPoseTemplate.transformPaths != null && toolPoseTemplate.transformPaths != null)
            {
                Assert.IsTrue(toolPoseTemplate.transformPaths.Length == toolPoseTemplate.transformValues.Length);
                for (int i = 0; i < toolPoseTemplate.transformPaths.Length; i++)
                {
                    var index = EditorCommon.ArrayIndexOf(paths, toolPoseTemplate.transformPaths[i]);
                    if (index < 0)
                    {
                        continue;
                    }
                    transforms[index].localPosition = toolPoseTemplate.transformValues[i].position;
                    transforms[index].localRotation = toolPoseTemplate.transformValues[i].rotation;
                    transforms[index].localScale    = toolPoseTemplate.transformValues[i].scale;
                }
            }
            #endregion
            save.LoadLocal(activeRootObject.transform);
        }
Beispiel #4
0
        public void BlendShapeTreeGUI()
        {
            var e = Event.current;

            GUIStyleReady();

            EditorGUILayout.BeginVertical(vaw.guiStyleSkinBox);
            if (blendShapeMode == BlendShapeMode.Slider)
            {
                #region Slider
                const int IndentWidth = 15;

                #region SetBlendShapeFoldout
                Action <BlendShapeNode, bool> SetBlendShapeFoldout = null;
                SetBlendShapeFoldout = (mg, foldout) =>
                {
                    mg.foldout = foldout;
                };
                #endregion

                var mgRoot = blendShapeNodes;

                #region Top
                {
                    EditorGUILayout.BeginHorizontal();
                    if (GUILayout.Button("Select All", GUILayout.Width(100)))
                    {
                        if (Shortcuts.IsKeyControl(e) || e.shift)
                        {
                            var combineGoList      = new HashSet <GameObject>(va.selectionGameObjects);
                            var combineVirtualList = new HashSet <HumanBodyBones>();
                            if (va.selectionHumanVirtualBones != null)
                            {
                                combineVirtualList.UnionWith(va.selectionHumanVirtualBones);
                            }
                            var combineBindings = new HashSet <EditorCurveBinding>(va.uAw.GetCurveSelection());
                            foreach (var root in mgRoot)
                            {
                                if (root.renderer != null && root.renderer.gameObject != null)
                                {
                                    combineGoList.Add(root.renderer.gameObject);
                                }
                                if (root.infoList != null && root.infoList.Length > 0)
                                {
                                    foreach (var info in root.infoList)
                                    {
                                        combineBindings.Add(va.AnimationCurveBindingBlendShape(root.renderer, info.blendShapeName));
                                    }
                                }
                            }
                            va.SelectGameObjects(combineGoList.ToArray(), combineVirtualList.ToArray());
                            va.SetAnimationWindowSynchroSelection(combineBindings.ToArray());
                        }
                        else
                        {
                            var combineGoList   = new List <GameObject>();
                            var combineBindings = new List <EditorCurveBinding>();
                            foreach (var root in mgRoot)
                            {
                                if (root.renderer != null && root.renderer.gameObject != null)
                                {
                                    combineGoList.Add(root.renderer.gameObject);
                                }
                                if (root.infoList != null && root.infoList.Length > 0)
                                {
                                    foreach (var info in root.infoList)
                                    {
                                        combineBindings.Add(va.AnimationCurveBindingBlendShape(root.renderer, info.blendShapeName));
                                    }
                                }
                            }
                            va.SelectGameObjects(combineGoList.ToArray());
                            va.SetAnimationWindowSynchroSelection(combineBindings.ToArray());
                        }
                    }
                    EditorGUILayout.Space();
                    if (GUILayout.Button("Reset All", GUILayout.Width(100)))
                    {
                        Undo.RecordObject(vae, "Reset All BlendShape Group");
                        for (int i = 0; i < blendShapeGroupValues.Length; i++)
                        {
                            blendShapeGroupValues[i] = 0f;
                        }
                        foreach (var root in mgRoot)
                        {
                            if (root.infoList != null && root.infoList.Length > 0)
                            {
                                foreach (var info in root.infoList)
                                {
                                    va.SetAnimationValueBlendShapeIfNotOriginal(root.renderer, info.blendShapeName, va.blendShapeWeightSave.GetDefaultWeight(root.renderer, info.blendShapeName));
                                }
                            }
                        }
                    }
                    EditorGUILayout.EndHorizontal();
                }
                #endregion

                EditorGUILayout.Space();

                #region BlendShape
                BlendShapeRootNode rootNode = null;
                int RowCount = 0;
                Action <BlendShapeNode, int, int> BlendShapeTreeNodeGUI = null;
                BlendShapeTreeNodeGUI = (mg, level, brotherMaxLevel) =>
                {
                    const int FoldoutWidth    = 22;
                    const int FoldoutSpace    = 17;
                    const int FloatFieldWidth = 44;
                    var       indentSpace     = IndentWidth * level;
                    EditorGUILayout.BeginHorizontal(RowCount++ % 2 == 0 ? vaw.guiStyleAnimationRowEvenStyle : vaw.guiStyleAnimationRowOddStyle);
                    {
                        {
                            var rect = EditorGUILayout.GetControlRect(false, GUILayout.Width(FoldoutWidth));
                            EditorGUI.BeginChangeCheck();
                            mg.foldout = EditorGUI.Foldout(rect, mg.foldout, "", true);
                            if (EditorGUI.EndChangeCheck())
                            {
                                if (e.alt)
                                {
                                    SetBlendShapeFoldout(mg, mg.foldout);
                                }
                            }
                        }
                        if (GUILayout.Button(new GUIContent(mg.name, mg.name), GUILayout.Width(vaw.editorSettings.settingEditorNameFieldWidth)))
                        {
                            if (Shortcuts.IsKeyControl(e) || e.shift)
                            {
                                var combineGoList      = new HashSet <GameObject>(va.selectionGameObjects);
                                var combineVirtualList = new HashSet <HumanBodyBones>();
                                if (va.selectionHumanVirtualBones != null)
                                {
                                    combineVirtualList.UnionWith(va.selectionHumanVirtualBones);
                                }
                                var combineBindings = new HashSet <EditorCurveBinding>(va.uAw.GetCurveSelection());
                                if (rootNode.renderer != null && rootNode.renderer.gameObject != null)
                                {
                                    combineGoList.Add(rootNode.renderer.gameObject);
                                }
                                if (rootNode.infoList != null && rootNode.infoList.Length > 0)
                                {
                                    foreach (var info in rootNode.infoList)
                                    {
                                        combineBindings.Add(va.AnimationCurveBindingBlendShape(rootNode.renderer, info.blendShapeName));
                                    }
                                }
                                va.SelectGameObjects(combineGoList.ToArray(), combineVirtualList.ToArray());
                                va.SetAnimationWindowSynchroSelection(combineBindings.ToArray());
                            }
                            else
                            {
                                var combineGoList   = new List <GameObject>();
                                var combineBindings = new List <EditorCurveBinding>();
                                if (rootNode.renderer != null && rootNode.renderer.gameObject != null)
                                {
                                    combineGoList.Add(rootNode.renderer.gameObject);
                                }
                                if (rootNode.infoList != null && rootNode.infoList.Length > 0)
                                {
                                    foreach (var info in rootNode.infoList)
                                    {
                                        combineBindings.Add(va.AnimationCurveBindingBlendShape(rootNode.renderer, info.blendShapeName));
                                    }
                                }
                                va.SelectGameObjects(combineGoList.ToArray());
                                va.SetAnimationWindowSynchroSelection(combineBindings.ToArray());
                            }
                        }
                        {
                            GUILayout.Space(FoldoutSpace);
                        }
                        {
                            EditorGUI.BeginChangeCheck();
                            var value = GUILayout.HorizontalSlider(blendShapeGroupValues[blendShapeGroupTreeTable[mg]], 0f, 100f);
                            if (EditorGUI.EndChangeCheck())
                            {
                                Undo.RecordObject(vae, "Change BlendShape Group");
                                blendShapeGroupValues[blendShapeGroupTreeTable[mg]] = value;
                                if (mg.infoList != null && mg.infoList.Length > 0)
                                {
                                    foreach (var info in mg.infoList)
                                    {
                                        va.SetAnimationValueBlendShape(rootNode.renderer, info.blendShapeName, value);
                                    }
                                }
                            }
                        }
                        {
                            var width = FloatFieldWidth + IndentWidth * Math.Max(0, brotherMaxLevel);
                            EditorGUI.BeginChangeCheck();
                            var value = EditorGUILayout.FloatField(blendShapeGroupValues[blendShapeGroupTreeTable[mg]], GUILayout.Width(width));
                            if (EditorGUI.EndChangeCheck())
                            {
                                Undo.RecordObject(vae, "Change BlendShape Group");
                                blendShapeGroupValues[blendShapeGroupTreeTable[mg]] = value;
                                if (mg.infoList != null && mg.infoList.Length > 0)
                                {
                                    foreach (var info in mg.infoList)
                                    {
                                        va.SetAnimationValueBlendShape(rootNode.renderer, info.blendShapeName, value);
                                    }
                                }
                            }
                        }
                    }
                    EditorGUILayout.EndHorizontal();
                    if (mg.foldout)
                    {
                        if (mg.infoList != null && mg.infoList.Length > 0)
                        {
                            #region BlendShape
                            foreach (var info in mg.infoList)
                            {
                                var blendShapeValue = va.GetAnimationValueBlendShape(rootNode.renderer, info.blendShapeName);
                                EditorGUILayout.BeginHorizontal(RowCount++ % 2 == 0 ? vaw.guiStyleAnimationRowEvenStyle : vaw.guiStyleAnimationRowOddStyle);
                                {
                                    EditorGUILayout.GetControlRect(false, GUILayout.Width(indentSpace + FoldoutWidth));
                                    if (GUILayout.Button(new GUIContent(info.blendShapeName, info.blendShapeName), GUILayout.Width(vaw.editorSettings.settingEditorNameFieldWidth)))
                                    {
                                        if (Shortcuts.IsKeyControl(e) || e.shift)
                                        {
                                            var combineGoList      = new HashSet <GameObject>(va.selectionGameObjects);
                                            var combineVirtualList = new HashSet <HumanBodyBones>();
                                            if (va.selectionHumanVirtualBones != null)
                                            {
                                                combineVirtualList.UnionWith(va.selectionHumanVirtualBones);
                                            }
                                            var combineBindings = new HashSet <EditorCurveBinding>(va.uAw.GetCurveSelection());
                                            if (rootNode.renderer != null && rootNode.renderer.gameObject != null)
                                            {
                                                combineGoList.Add(rootNode.renderer.gameObject);
                                            }
                                            combineBindings.Add(va.AnimationCurveBindingBlendShape(rootNode.renderer, info.blendShapeName));
                                            va.SelectGameObjects(combineGoList.ToArray(), combineVirtualList.ToArray());
                                            va.SetAnimationWindowSynchroSelection(combineBindings.ToArray());
                                        }
                                        else
                                        {
                                            if (rootNode.renderer != null && rootNode.renderer.gameObject != null)
                                            {
                                                va.SelectGameObject(rootNode.renderer.gameObject);
                                            }
                                            va.SetAnimationWindowSynchroSelection(new EditorCurveBinding[] { va.AnimationCurveBindingBlendShape(rootNode.renderer, info.blendShapeName) });
                                        }
                                    }
                                }
                                {
                                    var mirrorName = va.GetMirrorBlendShape(rootNode.renderer, info.blendShapeName);
                                    if (!string.IsNullOrEmpty(mirrorName))
                                    {
                                        if (GUILayout.Button(new GUIContent("", string.Format("Mirror: '{0}'", mirrorName)), vaw.guiStyleMirrorButton, GUILayout.Width(vaw.mirrorTex.width), GUILayout.Height(vaw.mirrorTex.height)))
                                        {
                                            if (rootNode.renderer != null && rootNode.renderer.gameObject != null)
                                            {
                                                va.SelectGameObject(rootNode.renderer.gameObject);
                                            }
                                            va.SetAnimationWindowSynchroSelection(new EditorCurveBinding[] { va.AnimationCurveBindingBlendShape(rootNode.renderer, mirrorName) });
                                        }
                                    }
                                    else
                                    {
                                        GUILayout.Space(FoldoutSpace);
                                    }
                                    if (blendShapeMirrorName)
                                    {
                                        var mirrorIndex = EditorCommon.ArrayIndexOf(rootNode.blendShapeNames, mirrorName);
                                        EditorGUI.BeginChangeCheck();
                                        mirrorIndex = EditorGUILayout.Popup(mirrorIndex, rootNode.blendShapeNames);
                                        if (EditorGUI.EndChangeCheck())
                                        {
                                            string newMirrorName = mirrorIndex > 0 ? rootNode.blendShapeNames[mirrorIndex] : null;
                                            if (info.blendShapeName == newMirrorName)
                                            {
                                                newMirrorName = null;
                                            }
                                            va.ChangeBlendShapeMirror(rootNode.renderer, info.blendShapeName, newMirrorName);
                                            if (!string.IsNullOrEmpty(newMirrorName))
                                            {
                                                va.ChangeBlendShapeMirror(rootNode.renderer, newMirrorName, info.blendShapeName);
                                            }
                                        }
                                    }
                                }
                                {
                                    EditorGUI.BeginChangeCheck();
                                    var value2 = GUILayout.HorizontalSlider(blendShapeValue, 0f, 100f);
                                    if (EditorGUI.EndChangeCheck())
                                    {
                                        va.SetAnimationValueBlendShape(rootNode.renderer, info.blendShapeName, value2);
                                    }
                                }
                                {
                                    EditorGUI.BeginChangeCheck();
                                    var value2 = EditorGUILayout.FloatField(blendShapeValue, GUILayout.Width(FloatFieldWidth));
                                    if (EditorGUI.EndChangeCheck())
                                    {
                                        va.SetAnimationValueBlendShape(rootNode.renderer, info.blendShapeName, value2);
                                    }
                                }
                                EditorGUILayout.EndHorizontal();
                            }
                            #endregion
                        }
                    }
                };
                {
                    int maxLevel = 0;
                    foreach (var root in mgRoot)
                    {
                        if (root.renderer != null && root.mesh != null && root.renderer.sharedMesh == root.mesh)
                        {
                            if (root.foldout)
                            {
                                maxLevel = Math.Max(maxLevel, 1);
                            }
                        }
                    }
                    foreach (var root in mgRoot)
                    {
                        if (root.renderer != null && root.mesh != null && root.renderer.sharedMesh == root.mesh)
                        {
                            rootNode = root;
                            BlendShapeTreeNodeGUI(root, 1, maxLevel);
                        }
                    }
                }
                #endregion
                #endregion
            }
            else if (blendShapeMode == BlendShapeMode.List)
            {
                #region List
                if (e.type == EventType.Layout)
                {
                    UpdateBlendShapeSetListReorderableList();
                }
                if (blendShapeSetListReorderableList != null)
                {
                    blendShapeSetListReorderableList.DoLayoutList();
                }
                #endregion
            }
            else if (blendShapeMode == BlendShapeMode.Icon)
            {
                #region Icon
                if (e.type == EventType.Layout)
                {
                    UpdateBlendShapeSetIcon();
                }
                {
                    EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
                    {
                        EditorGUI.BeginChangeCheck();
                        blendShapeSetIconCameraMode = (IconCameraMode)EditorGUILayout.EnumPopup(blendShapeSetIconCameraMode, EditorStyles.toolbarDropDown, GUILayout.Width(80f));
                        if (EditorGUI.EndChangeCheck())
                        {
                            blendShapeSetIconUpdate = true;
                        }
                    }
                    EditorGUILayout.Space();
                    blendShapeSetIconShowName = GUILayout.Toggle(blendShapeSetIconShowName, "Show Name", EditorStyles.toolbarButton);
                    EditorGUILayout.Space();
                    blendShapeSetIconSize = EditorGUILayout.Slider(blendShapeSetIconSize, 32f, IconTextureSize);
                    EditorGUILayout.EndHorizontal();
                }
                EditorGUILayout.Space();
                if (va.blendShapeSetList.Count > 0)
                {
                    float areaWidth = vae.position.width - 16f;
                    int   countX    = Math.Max(1, Mathf.FloorToInt(areaWidth / blendShapeSetIconSize));
                    int   countY    = Mathf.CeilToInt(va.blendShapeSetList.Count / (float)countX);
                    for (int i = 0; i < countY; i++)
                    {
                        EditorGUILayout.BeginHorizontal();
                        for (int j = 0; j < countX; j++)
                        {
                            var index = i * countX + j;
                            if (index >= va.blendShapeSetList.Count)
                            {
                                break;
                            }
                            var rect = EditorGUILayout.GetControlRect(false, blendShapeSetIconSize, guiStyleIconButton, GUILayout.Width(blendShapeSetIconSize), GUILayout.Height(blendShapeSetIconSize));
                            if (GUI.Button(rect, va.blendShapeSetList[index].icon, guiStyleIconButton))
                            {
                                var poseTemplate = va.blendShapeSetList[index].poseTemplate;
                                va.LoadPoseTemplate(poseTemplate, false, false, VeryAnimation.PoseTemplateFlags.BlendShape);
                            }
                            if (blendShapeSetIconShowName)
                            {
                                GUI.Label(rect, va.blendShapeSetList[index].poseTemplate.name, guiStyleNameLabel);
                            }
                        }
                        EditorGUILayout.EndHorizontal();
                    }
                }
                else
                {
                    EditorGUILayout.LabelField("List is Empty", EditorStyles.centeredGreyMiniLabel);
                }
                #endregion
            }
            EditorGUILayout.EndVertical();
        }
Beispiel #5
0
 public SynchronizeObject(Animator animator)
 {
     this.animator         = animator;
     gameObject            = animator.gameObject;
     propertyModifications = PrefabUtility.GetPropertyModifications(gameObject);
     transformPoseSave     = new TransformPoseSave(gameObject);
     blendShapeWeightSave  = new BlendShapeWeightSave(gameObject);
     #region Clip
     {
         var saveSettings = gameObject.GetComponent <VeryAnimationSaveSettings>();
         if (saveSettings != null && saveSettings.lastSelectAnimationClip != null)
         {
             if (ArrayUtility.Contains(AnimationUtility.GetAnimationClips(gameObject), saveSettings.lastSelectAnimationClip))
             {
                 clip = saveSettings.lastSelectAnimationClip;
             }
         }
         if (clip == null)
         {
             var ac = EditorCommon.GetAnimatorController(animator);
             if (ac != null && ac.layers.Length > 0)
             {
                 var state = ac.layers[0].stateMachine.defaultState;
                 if (state != null)
                 {
                     if (state.motion is UnityEditor.Animations.BlendTree)
                     {
                         Action <UnityEditor.Animations.BlendTree> FindBlendTree = null;
                         FindBlendTree = (blendTree) =>
                         {
                             if (blendTree.children == null)
                             {
                                 return;
                             }
                             var children = blendTree.children;
                             for (int i = 0; i < children.Length; i++)
                             {
                                 if (children[i].motion is UnityEditor.Animations.BlendTree)
                                 {
                                     FindBlendTree(children[i].motion as UnityEditor.Animations.BlendTree);
                                 }
                                 else
                                 {
                                     clip = children[i].motion as AnimationClip;
                                 }
                                 if (clip != null)
                                 {
                                     break;
                                 }
                             }
                             blendTree.children = children;
                         };
                         FindBlendTree(state.motion as UnityEditor.Animations.BlendTree);
                     }
                     else
                     {
                         clip = state.motion as AnimationClip;
                     }
                 }
             }
             if (clip != null)
             {
                 var owc = animator.runtimeAnimatorController as AnimatorOverrideController;
                 if (owc != null)
                 {
                     clip = owc[clip];
                 }
             }
         }
     }
     #endregion
     animator.enabled = false;   //In order to avoid the mysterious behavior where an event is called from "UnityEditor.Handles: DrawCameraImpl", it is invalid except when updating
 }