Beispiel #1
0
        public override void OnInspectorGUI()
        {
            //return;

            //base.OnInspectorGUI();
            apPortrait targetPortrait = target as apPortrait;

            if (targetPortrait != _targetPortrait)
            {
                _targetPortrait = targetPortrait;
                Init();
            }
            if (_targetPortrait == null)
            {
                //Profiler.EndSample();
                return;
            }

            //Profiler.BeginSample("anyPortrait Inspector GUI");


            //return;
            if (apEditor.IsOpen())
            {
                //에디터가 작동중에는 안보이도록 하자
                EditorGUILayout.LabelField("Editor is opened");

                //Profiler.EndSample();

                return;
            }

            try
            {
                bool          request_OpenEditor    = false;
                bool          request_QuickBake     = false;
                bool          request_RefreshMeshes = false;
                bool          prevImportant         = _targetPortrait._isImportant;
                MonoBehaviour prevAnimEventListener = _targetPortrait._optAnimEventListener;
                int           prevSortingLayerID    = _targetPortrait._sortingLayerID;
                int           prevSortingOrder      = _targetPortrait._sortingOrder;

                if (!EditorApplication.isPlaying)
                {
                    if (!_targetPortrait._isOptimizedPortrait)
                    {
                        GUILayout.Space(10);
                        if (GUILayout.Button("Open Editor and Select", GUILayout.Height(30)))
                        {
                            request_OpenEditor = true;
                        }
                        if (GUILayout.Button("Quick Bake", GUILayout.Height(25)))
                        {
                            request_QuickBake = true;
                        }
                    }
                    else
                    {
                        GUILayout.Space(10);
                        if (GUILayout.Button("Open Editor (Not Selectable)", GUILayout.Height(30)))
                        {
                            //열기만 하고 선택은 못함
                            request_OpenEditor = true;
                        }
                    }
                    //추가 12.18 : Mesh를 리프레시 하자
                    if (GUILayout.Button("Refresh Meshes", GUILayout.Height(25)))
                    {
                        request_RefreshMeshes = true;
                    }
                }

                GUILayout.Space(10);

                _targetPortrait._isImportant          = EditorGUILayout.Toggle("Is Important", _targetPortrait._isImportant);
                _targetPortrait._optAnimEventListener = (MonoBehaviour)EditorGUILayout.ObjectField("Event Listener", _targetPortrait._optAnimEventListener, typeof(MonoBehaviour), true);


                GUILayout.Space(5);
                //추가3.22
                //Sorting Layer
                string[] sortingLayerName = new string[SortingLayer.layers.Length];
                int      layerIndex       = -1;
                for (int i = 0; i < SortingLayer.layers.Length; i++)
                {
                    sortingLayerName[i] = SortingLayer.layers[i].name;
                    if (SortingLayer.layers[i].id == _targetPortrait._sortingLayerID)
                    {
                        layerIndex = i;
                    }
                }
                int nextLayerIndex = EditorGUILayout.Popup("Sorting Layer", layerIndex, sortingLayerName);
                int nextLayerOrder = EditorGUILayout.IntField("Sorting Order", _targetPortrait._sortingOrder);

                if (nextLayerIndex != layerIndex)
                {
                    //Sorting Layer를 바꾸자
                    if (nextLayerIndex >= 0 && nextLayerIndex < SortingLayer.layers.Length)
                    {
                        string nextLayerName = SortingLayer.layers[nextLayerIndex].name;
                        _targetPortrait.SetSortingLayer(nextLayerName);
                    }
                }
                if (nextLayerOrder != _targetPortrait._sortingOrder)
                {
                    _targetPortrait.SetSortingOrder(nextLayerOrder);
                }


                if (prevImportant != _targetPortrait._isImportant ||
                    prevAnimEventListener != _targetPortrait._optAnimEventListener ||
                    prevSortingLayerID != _targetPortrait._sortingLayerID ||
                    prevSortingOrder != _targetPortrait._sortingOrder)
                {
                    apEditorUtil.SetEditorDirty();
                }


                GUILayout.Space(5);

                //빌보드
                apPortrait.BILLBOARD_TYPE nextBillboard = (apPortrait.BILLBOARD_TYPE)EditorGUILayout.EnumPopup("Billboard Type", _targetPortrait._billboardType);
                if (nextBillboard != _targetPortrait._billboardType)
                {
                    _targetPortrait._billboardType = nextBillboard;
                    apEditorUtil.SetEditorDirty();
                }

                GUILayout.Space(5);

                _isFold_RootPortraits = EditorGUILayout.Foldout(_isFold_RootPortraits, "Root Portraits");
                if (_isFold_RootPortraits)
                {
                    string strRootPortrait = "";
                    if (_targetPortrait._optRootUnitList.Count == 0)
                    {
                        strRootPortrait = "No Baked Portrait";
                    }
                    else if (_targetPortrait._optRootUnitList.Count == 1)
                    {
                        strRootPortrait = "1 Baked Portrait";
                    }
                    else
                    {
                        strRootPortrait = _targetPortrait._optRootUnitList.Count + " Baked Portraits";
                    }
                    EditorGUILayout.LabelField(strRootPortrait);
                    GUILayout.Space(5);
                    for (int i = 0; i < _targetPortrait._optRootUnitList.Count; i++)
                    {
                        apOptRootUnit rootUnit = _targetPortrait._optRootUnitList[i];
                        EditorGUILayout.ObjectField("[" + i + "]", rootUnit, typeof(apOptRootUnit), true);
                    }

                    GUILayout.Space(20);
                }



                _isFold_AnimationClips = EditorGUILayout.Foldout(_isFold_AnimationClips, "Animation Settings");
                if (_isFold_AnimationClips)
                {
                    EditorGUILayout.LabelField("Animation Clips");
                    string strAnimClips = "";
                    if (_targetPortrait._animClips.Count == 0)
                    {
                        strAnimClips = "No Animation Clip";
                    }
                    else if (_targetPortrait._animClips.Count == 1)
                    {
                        strAnimClips = "1 Animation Clip";
                    }
                    else
                    {
                        strAnimClips = _targetPortrait._animClips.Count + " Animation Clips";
                    }
                    EditorGUILayout.LabelField(strAnimClips);
                    GUILayout.Space(5);


                    for (int i = 0; i < _targetPortrait._animClips.Count; i++)
                    {
                        EditorGUILayout.BeginHorizontal();
                        GUILayout.Space(5);
                        apAnimClip animClip = _targetPortrait._animClips[i];
                        if (animClip._uniqueID == _targetPortrait._autoPlayAnimClipID)
                        {
                            EditorGUILayout.LabelField("[" + i + "] (Auto)", GUILayout.Width(80));
                        }
                        else
                        {
                            EditorGUILayout.LabelField("[" + i + "]", GUILayout.Width(80));
                        }
                        EditorGUILayout.TextField(animClip._name);
                        try
                        {
                            AnimationClip nextAnimationClip = EditorGUILayout.ObjectField(animClip._animationClipForMecanim, typeof(AnimationClip), false) as AnimationClip;
                            if (nextAnimationClip != animClip._animationClipForMecanim)
                            {
                                UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
                                Undo.IncrementCurrentGroup();
                                Undo.RegisterCompleteObjectUndo(_targetPortrait, "Animation Changed");

                                animClip._animationClipForMecanim = nextAnimationClip;
                            }
                        }
                        catch (Exception)
                        { }

                        EditorGUILayout.EndHorizontal();
                    }
                    GUILayout.Space(10);
                    AnimationClip nextEmptyAnimClip = EditorGUILayout.ObjectField("Empty Animation Clip", _targetPortrait._emptyAnimClipForMecanim, typeof(AnimationClip), false) as AnimationClip;
                    if (nextEmptyAnimClip != _targetPortrait._emptyAnimClipForMecanim)
                    {
                        UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
                        Undo.IncrementCurrentGroup();
                        Undo.RegisterCompleteObjectUndo(_targetPortrait, "Animation Changed");

                        _targetPortrait._emptyAnimClipForMecanim = nextEmptyAnimClip;
                    }

                    GUILayout.Space(10);
                    EditorGUILayout.LabelField("Mecanim Settings");
                    bool isNextUsingMecanim = EditorGUILayout.Toggle("Use Mecanim", _targetPortrait._isUsingMecanim);
                    if (_targetPortrait._isUsingMecanim != isNextUsingMecanim)
                    {
                        UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
                        Undo.IncrementCurrentGroup();
                        Undo.RegisterCompleteObjectUndo(_targetPortrait, "Mecanim Setting Changed");

                        _targetPortrait._isUsingMecanim = isNextUsingMecanim;
                    }


                    if (_targetPortrait._isUsingMecanim)
                    {
                        GUILayout.Space(10);
                        try
                        {
                            Animator nextAnimator = EditorGUILayout.ObjectField("Animator", _targetPortrait._animator, typeof(Animator), true) as Animator;
                            if (nextAnimator != _targetPortrait._animator)
                            {
                                //하위에 있는 Component일 때에만 변동 가능
                                if (nextAnimator == null)
                                {
                                    _targetPortrait._animator = null;
                                }
                                else
                                {
                                    if (nextAnimator == _targetPortrait.GetComponent <Animator>())
                                    {
                                        _targetPortrait._animator = nextAnimator;
                                    }
                                    else
                                    {
                                        EditorUtility.DisplayDialog("Invalid Animator", "Invalid Animator. Only the Animator, which is its own component, is valid.", "Okay");
                                    }
                                }
                            }
                        }
                        catch (Exception)
                        {
                        }
                        if (_targetPortrait._animator == null)
                        {
                            //1. Animator가 없다면
                            // > 생성하기
                            // > 생성되어 있다면 다시 링크
                            GUIStyle guiStyle_WarningText = new GUIStyle(GUI.skin.label);
                            guiStyle_WarningText.normal.textColor = Color.red;
                            EditorGUILayout.LabelField("Warning : No Animator!", guiStyle_WarningText);
                            GUILayout.Space(5);

                            if (GUILayout.Button("Add / Check Animator", GUILayout.Height(25)))
                            {
                                UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
                                Undo.IncrementCurrentGroup();
                                Undo.RegisterCompleteObjectUndo(_targetPortrait, "Mecanim Setting Changed");

                                Animator animator = _targetPortrait.gameObject.GetComponent <Animator>();
                                if (animator == null)
                                {
                                    animator = _targetPortrait.gameObject.AddComponent <Animator>();
                                }
                                _targetPortrait._animator = animator;
                            }
                        }
                        else
                        {
                            //2. Animator가 있다면
                            if (GUILayout.Button("Refresh Layers", GUILayout.Height(25)))
                            {
                                UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
                                Undo.IncrementCurrentGroup();
                                Undo.RegisterCompleteObjectUndo(_targetPortrait, "Mecanim Setting Changed");

                                //Animator의 Controller가 있는지 체크해야한다.

                                if (_targetPortrait._animator.runtimeAnimatorController == null)
                                {
                                    //AnimatorController가 없다면 Layer는 초기화
                                    _targetPortrait._animatorLayerBakedData.Clear();
                                }
                                else
                                {
                                    //AnimatorController가 있다면 레이어에 맞게 설정
                                    _targetPortrait._animatorLayerBakedData.Clear();
                                    UnityEditor.Animations.AnimatorController animatorController = _targetPortrait._animator.runtimeAnimatorController as UnityEditor.Animations.AnimatorController;

                                    if (animatorController != null && animatorController.layers.Length > 0)
                                    {
                                        for (int iLayer = 0; iLayer < animatorController.layers.Length; iLayer++)
                                        {
                                            apAnimMecanimData_Layer newLayerData = new apAnimMecanimData_Layer();
                                            newLayerData._layerIndex = iLayer;
                                            newLayerData._layerName  = animatorController.layers[iLayer].name;
                                            newLayerData._blendType  = apAnimMecanimData_Layer.MecanimLayerBlendType.Unknown;
                                            switch (animatorController.layers[iLayer].blendingMode)
                                            {
                                            case UnityEditor.Animations.AnimatorLayerBlendingMode.Override:
                                                newLayerData._blendType = apAnimMecanimData_Layer.MecanimLayerBlendType.Override;
                                                break;

                                            case UnityEditor.Animations.AnimatorLayerBlendingMode.Additive:
                                                newLayerData._blendType = apAnimMecanimData_Layer.MecanimLayerBlendType.Additive;
                                                break;
                                            }

                                            _targetPortrait._animatorLayerBakedData.Add(newLayerData);
                                        }
                                    }
                                }
                            }
                            GUILayout.Space(5);
                            EditorGUILayout.LabelField("Animator Controller Layers");
                            for (int i = 0; i < _targetPortrait._animatorLayerBakedData.Count; i++)
                            {
                                apAnimMecanimData_Layer layer = _targetPortrait._animatorLayerBakedData[i];
                                EditorGUILayout.BeginHorizontal();
                                GUILayout.Space(5);
                                EditorGUILayout.LabelField("[" + layer._layerIndex + "]", GUILayout.Width(50));
                                EditorGUILayout.TextField(layer._layerName);
                                apAnimMecanimData_Layer.MecanimLayerBlendType nextBlendType = (apAnimMecanimData_Layer.MecanimLayerBlendType)EditorGUILayout.EnumPopup(layer._blendType);
                                EditorGUILayout.EndHorizontal();

                                if (nextBlendType != layer._blendType)
                                {
                                    UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
                                    Undo.IncrementCurrentGroup();
                                    Undo.RegisterCompleteObjectUndo(_targetPortrait, "Mecanim Setting Changed");

                                    _targetPortrait._animatorLayerBakedData[i]._blendType = nextBlendType;
                                }
                            }
                        }
                    }


                    GUILayout.Space(20);
                }


                bool isChanged = false;

                _isFold_ConrolParameters = EditorGUILayout.Foldout(_isFold_ConrolParameters, "Control Parameters");
                if (_isFold_ConrolParameters)
                {
#if UNITY_2017_3_OR_NEWER
                    _curControlCategory = (apControlParam.CATEGORY)EditorGUILayout.EnumFlagsField(new GUIContent("Category"), _curControlCategory);
#else
                    _curControlCategory = (apControlParam.CATEGORY)EditorGUILayout.EnumMaskPopup(new GUIContent("Category"), _curControlCategory);
#endif

                    EditorGUILayout.Space();
                    //1. 컨르롤러를 제어할 수 있도록 하자

                    if (_controlParams != null)
                    {
                        for (int i = 0; i < _controlParams.Count; i++)
                        {
                            if ((int)(_controlParams[i]._category & _curControlCategory) != 0)
                            {
                                if (GUI_ControlParam(_controlParams[i]))
                                {
                                    isChanged = true;
                                }
                            }
                        }
                    }

                    GUILayout.Space(20);
                }


                GUILayout.Space(10);

                //2. 토글 버튼을 두어서 기본 Inspector 출력 여부를 결정하자.
                string strBaseButton = "Show All Properties";
                if (_showBaseInspector)
                {
                    strBaseButton = "Hide Properties";
                }

                if (GUILayout.Button(strBaseButton, GUILayout.Height(20)))
                {
                    _showBaseInspector = !_showBaseInspector;
                }

                if (_showBaseInspector)
                {
                    base.OnInspectorGUI();
                }


                if (!Application.isPlaying && isChanged)
                {
                    //플레이 중이라면 자동으로 업데이트 될 것이다.
                    _targetPortrait.UpdateForce();
                }

                if (_targetPortrait != null)
                {
                    if (request_OpenEditor)
                    {
                        if (_targetPortrait._isOptimizedPortrait)
                        {
                            RequestDelayedOpenEditor(_targetPortrait, REQUEST_TYPE.Open);
                        }
                        else
                        {
                            RequestDelayedOpenEditor(_targetPortrait, REQUEST_TYPE.OpenAndSet);
                        }
                        //apEditor anyPortraitEditor = apEditor.ShowWindow();
                        //if (anyPortraitEditor != null && !_targetPortrait._isOptimizedPortrait)
                        //{
                        //	anyPortraitEditor.SetPortraitByInspector(_targetPortrait, false);
                        //}
                    }
                    else if (request_QuickBake)
                    {
                        RequestDelayedOpenEditor(_targetPortrait, REQUEST_TYPE.QuickBake);
                        //apEditor anyPortraitEditor = apEditor.ShowWindow();
                        //if (anyPortraitEditor != null)
                        //{
                        //	anyPortraitEditor.SetPortraitByInspector(_targetPortrait, true);

                        //	Selection.activeObject = _targetPortrait.gameObject;
                        //}
                    }
                    else if (request_RefreshMeshes)
                    {
                        _targetPortrait.OnMeshResetInEditor();
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.LogError("apInspector_Portrait Exception : " + ex);
            }

            //Profiler.EndSample();
        }
Beispiel #2
0
        public override void OnInspectorGUI()
        {
            //return;
            LoadImages();


            //base.OnInspectorGUI();
            apPortrait targetPortrait = target as apPortrait;

            if (targetPortrait != _targetPortrait)
            {
                _targetPortrait = targetPortrait;
                Init();
            }
            if (_targetPortrait == null)
            {
                //Profiler.EndSample();
                return;
            }

            //Profiler.BeginSample("anyPortrait Inspector GUI");


            //return;
            if (apEditor.IsOpen())
            {
                //에디터가 작동중에는 안보이도록 하자
                //EditorGUILayout.LabelField("Editor is opened");
                GUILayout.Space(10);

                EditorGUILayout.LabelField(_guiContent_EditorIsOpen, GUILayout.Height(36));

                //Profiler.EndSample();

                return;
            }

            try
            {
                bool          request_OpenEditor    = false;
                bool          request_QuickBake     = false;
                bool          request_RefreshMeshes = false;
                bool          prevImportant         = _targetPortrait._isImportant;
                MonoBehaviour prevAnimEventListener = _targetPortrait._optAnimEventListener;
                int           prevSortingLayerID    = _targetPortrait._sortingLayerID;
                apPortrait.SORTING_ORDER_OPTION prevSortingOrderOption = _targetPortrait._sortingOrderOption;
                int prevSortingOrder = _targetPortrait._sortingOrder;

                if (!EditorApplication.isPlaying)
                {
                    int iconWidth    = 32;
                    int iconHeight   = 34;
                    int buttonHeight = 34;

                    //추가 19.5.26 : 용량 최적화 기능이 추가되었는가
                    if (!_targetPortrait._isSizeOptimizedV117)
                    {
                        GUILayout.Space(10);

                        Color prevBackColor = GUI.backgroundColor;
                        GUI.backgroundColor = new Color(1.0f, 0.7f, 0.7f, 1.0f);
                        GUILayout.Box("[File size reduction] has not been applied.\nExecute the [Bake] again.",
                                      _guiStyle_subTitle,
                                      GUILayout.Width((int)EditorGUIUtility.currentViewWidth - 36), GUILayout.Height(40));
                        GUI.backgroundColor = prevBackColor;
                    }

                    if (!_targetPortrait._isOptimizedPortrait)
                    {
                        GUILayout.Space(10);

                        EditorGUILayout.BeginHorizontal(GUILayout.Height(iconHeight));
                        GUILayout.Space(5);
                        EditorGUILayout.LabelField(_guiContent_OpenEditor, _guiStyle_buttonIcon, GUILayout.Width(iconWidth), GUILayout.Height(iconHeight));
                        GUILayout.Space(5);
                        if (GUILayout.Button("Open Editor and Select", GUILayout.Height(buttonHeight)))
                        {
                            request_OpenEditor = true;
                        }
                        EditorGUILayout.EndHorizontal();

                        EditorGUILayout.BeginHorizontal(GUILayout.Height(iconHeight));
                        GUILayout.Space(5);
                        EditorGUILayout.LabelField(_guiContent_QuickBake, _guiStyle_buttonIcon, GUILayout.Width(iconWidth), GUILayout.Height(iconHeight));
                        GUILayout.Space(5);
                        if (GUILayout.Button("Quick Bake", GUILayout.Height(buttonHeight)))
                        {
                            request_QuickBake = true;
                        }
                        EditorGUILayout.EndHorizontal();
                    }
                    else
                    {
                        GUILayout.Space(10);

                        EditorGUILayout.BeginHorizontal(GUILayout.Height(iconHeight));
                        GUILayout.Space(5);
                        EditorGUILayout.LabelField(_guiContent_OpenEditor, _guiStyle_buttonIcon, GUILayout.Width(iconWidth), GUILayout.Height(iconHeight));
                        GUILayout.Space(5);
                        if (GUILayout.Button("Open Editor (Not Selectable)", GUILayout.Height(buttonHeight)))
                        {
                            //열기만 하고 선택은 못함
                            request_OpenEditor = true;
                        }
                        EditorGUILayout.EndHorizontal();
                    }
                    //추가 12.18 : Mesh를 리프레시 하자

                    EditorGUILayout.BeginHorizontal(GUILayout.Height(iconHeight));
                    GUILayout.Space(5);
                    EditorGUILayout.LabelField(_guiContent_RefreshMeshes, _guiStyle_buttonIcon, GUILayout.Width(iconWidth), GUILayout.Height(iconHeight));
                    GUILayout.Space(5);
                    if (GUILayout.Button("Refresh Meshes", GUILayout.Height(buttonHeight)))
                    {
                        request_RefreshMeshes = true;
                    }
                    EditorGUILayout.EndHorizontal();
                }

                GUILayout.Space(10);


                //BasicSettings
                //-----------------------------------------------------------------------------
                //"Basic Settings"

                int width          = (int)EditorGUIUtility.currentViewWidth;
                int subTitleWidth  = width - 44;
                int subTitleHeight = 26;

                GUILayout.Box(_guiContent_BasicSettings, _guiStyle_subTitle, GUILayout.Width(subTitleWidth), GUILayout.Height(subTitleHeight));


                _targetPortrait._isImportant          = EditorGUILayout.Toggle("Is Important", _targetPortrait._isImportant);
                _targetPortrait._optAnimEventListener = (MonoBehaviour)EditorGUILayout.ObjectField("Event Listener", _targetPortrait._optAnimEventListener, typeof(MonoBehaviour), true);


                GUILayout.Space(5);
                //추가3.22
                //Sorting Layer
                string[] sortingLayerName = new string[SortingLayer.layers.Length];
                int      layerIndex       = -1;
                for (int i = 0; i < SortingLayer.layers.Length; i++)
                {
                    sortingLayerName[i] = SortingLayer.layers[i].name;
                    if (SortingLayer.layers[i].id == _targetPortrait._sortingLayerID)
                    {
                        layerIndex = i;
                    }
                }
                int nextLayerIndex = EditorGUILayout.Popup("Sorting Layer", layerIndex, sortingLayerName);
                apPortrait.SORTING_ORDER_OPTION nextSortingOption = (apPortrait.SORTING_ORDER_OPTION)EditorGUILayout.EnumPopup("Sorting Order Option", _targetPortrait._sortingOrderOption);

                int nextLayerOrder = _targetPortrait._sortingOrder;
                if (_targetPortrait._sortingOrderOption == apPortrait.SORTING_ORDER_OPTION.SetOrder)
                {
                    nextLayerOrder = EditorGUILayout.IntField("Sorting Order", _targetPortrait._sortingOrder);

                    if (nextLayerOrder != _targetPortrait._sortingOrder)
                    {
                        _targetPortrait.SetSortingOrder(nextLayerOrder);
                    }
                }


                if (nextLayerIndex != layerIndex)
                {
                    //Sorting Layer를 바꾸자
                    if (nextLayerIndex >= 0 && nextLayerIndex < SortingLayer.layers.Length)
                    {
                        string nextLayerName = SortingLayer.layers[nextLayerIndex].name;
                        _targetPortrait.SetSortingLayer(nextLayerName);
                    }
                }
                if (nextSortingOption != _targetPortrait._sortingOrderOption)
                {
                    _targetPortrait._sortingOrderOption = nextSortingOption;
                    //변경된 Sorting Order Option에 따라서 바로 Sorting을 해야한다.
                    _targetPortrait.ApplySortingOptionToOptRootUnits();
                    switch (_targetPortrait._sortingOrderOption)
                    {
                    case apPortrait.SORTING_ORDER_OPTION.SetOrder:
                        _targetPortrait.SetSortingOrder(_targetPortrait._sortingOrder);
                        break;

                    case apPortrait.SORTING_ORDER_OPTION.DepthToOrder:
                    case apPortrait.SORTING_ORDER_OPTION.ReverseDepthToOrder:
                        _targetPortrait.SetSortingOrderChangedAutomatically(true);
                        _targetPortrait.RefreshSortingOrderByDepth();
                        break;
                    }
                }



                if (prevImportant != _targetPortrait._isImportant ||
                    prevAnimEventListener != _targetPortrait._optAnimEventListener ||
                    prevSortingLayerID != _targetPortrait._sortingLayerID ||
                    prevSortingOrderOption != _targetPortrait._sortingOrderOption ||
                    prevSortingOrder != _targetPortrait._sortingOrder)
                {
                    apEditorUtil.SetEditorDirty();
                }


                GUILayout.Space(5);

                //빌보드
                apPortrait.BILLBOARD_TYPE nextBillboard = (apPortrait.BILLBOARD_TYPE)EditorGUILayout.EnumPopup("Billboard Type", _targetPortrait._billboardType);
                if (nextBillboard != _targetPortrait._billboardType)
                {
                    _targetPortrait._billboardType = nextBillboard;
                    apEditorUtil.SetEditorDirty();
                }

                GUILayout.Space(20);

                // Root Portraits
                //-----------------------------------------------------------------------------
                GUILayout.Box(_guiContent_RootPortraits, _guiStyle_subTitle, GUILayout.Width(subTitleWidth), GUILayout.Height(subTitleHeight));

                _isFold_RootPortraits = EditorGUILayout.Foldout(_isFold_RootPortraits, "Portraits");
                if (_isFold_RootPortraits)
                {
                    for (int i = 0; i < _targetPortrait._optRootUnitList.Count; i++)
                    {
                        apOptRootUnit rootUnit = _targetPortrait._optRootUnitList[i];
                        EditorGUILayout.ObjectField("[" + i + "]", rootUnit, typeof(apOptRootUnit), true);
                    }
                }

                GUILayout.Space(20);


                // Animation Settings
                //-----------------------------------------------------------------------------

                GUILayout.Box(_guiContent_AnimationSettings, _guiStyle_subTitle, GUILayout.Width(subTitleWidth), GUILayout.Height(subTitleHeight));

                _isFold_AnimationClips = EditorGUILayout.Foldout(_isFold_AnimationClips, "Animation Clips");
                if (_isFold_AnimationClips)
                {
                    for (int i = 0; i < _targetPortrait._animClips.Count; i++)
                    {
                        EditorGUILayout.BeginHorizontal();
                        GUILayout.Space(5);
                        apAnimClip animClip = _targetPortrait._animClips[i];
                        if (animClip._uniqueID == _targetPortrait._autoPlayAnimClipID)
                        {
                            EditorGUILayout.LabelField("[" + i + "] (Auto)", GUILayout.Width(80));
                        }
                        else
                        {
                            EditorGUILayout.LabelField("[" + i + "]", GUILayout.Width(80));
                        }
                        EditorGUILayout.TextField(animClip._name);
                        try
                        {
                            AnimationClip nextAnimationClip = EditorGUILayout.ObjectField(animClip._animationClipForMecanim, typeof(AnimationClip), false) as AnimationClip;
                            if (nextAnimationClip != animClip._animationClipForMecanim)
                            {
                                UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
                                Undo.IncrementCurrentGroup();
                                Undo.RegisterCompleteObjectUndo(_targetPortrait, "Animation Changed");

                                animClip._animationClipForMecanim = nextAnimationClip;
                            }
                        }
                        catch (Exception)
                        { }

                        EditorGUILayout.EndHorizontal();
                    }
                }

                GUILayout.Space(10);

                AnimationClip nextEmptyAnimClip = EditorGUILayout.ObjectField("Empty Anim Clip", _targetPortrait._emptyAnimClipForMecanim, typeof(AnimationClip), false) as AnimationClip;
                if (nextEmptyAnimClip != _targetPortrait._emptyAnimClipForMecanim)
                {
                    UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
                    Undo.IncrementCurrentGroup();
                    Undo.RegisterCompleteObjectUndo(_targetPortrait, "Animation Changed");

                    _targetPortrait._emptyAnimClipForMecanim = nextEmptyAnimClip;
                }

                GUILayout.Space(10);

                //EditorGUILayout.LabelField("Mecanim Settings");
                EditorGUILayout.LabelField(_guiContent_Mecanim, GUILayout.Height(24));

                bool isNextUsingMecanim = EditorGUILayout.Toggle("Use Mecanim", _targetPortrait._isUsingMecanim);
                if (_targetPortrait._isUsingMecanim != isNextUsingMecanim)
                {
                    UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
                    Undo.IncrementCurrentGroup();
                    Undo.RegisterCompleteObjectUndo(_targetPortrait, "Mecanim Setting Changed");

                    _targetPortrait._isUsingMecanim = isNextUsingMecanim;
                }


                if (_targetPortrait._isUsingMecanim)
                {
                    //GUILayout.Space(10);
                    try
                    {
                        Animator nextAnimator = EditorGUILayout.ObjectField("Animator", _targetPortrait._animator, typeof(Animator), true) as Animator;
                        if (nextAnimator != _targetPortrait._animator)
                        {
                            //하위에 있는 Component일 때에만 변동 가능
                            if (nextAnimator == null)
                            {
                                _targetPortrait._animator = null;
                            }
                            else
                            {
                                if (nextAnimator == _targetPortrait.GetComponent <Animator>())
                                {
                                    _targetPortrait._animator = nextAnimator;
                                }
                                else
                                {
                                    EditorUtility.DisplayDialog("Invalid Animator", "Invalid Animator. Only the Animator, which is its own component, is valid.", "Okay");
                                }
                            }
                        }
                    }
                    catch (Exception)
                    {
                    }
                    if (_targetPortrait._animator == null)
                    {
                        //1. Animator가 없다면
                        // > 생성하기
                        // > 생성되어 있다면 다시 링크
                        GUIStyle guiStyle_WarningText = new GUIStyle(GUI.skin.label);
                        guiStyle_WarningText.normal.textColor = Color.red;
                        EditorGUILayout.LabelField("Warning : No Animator!", guiStyle_WarningText);
                        GUILayout.Space(5);

                        if (GUILayout.Button("Add / Check Animator", GUILayout.Height(25)))
                        {
                            UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
                            Undo.IncrementCurrentGroup();
                            Undo.RegisterCompleteObjectUndo(_targetPortrait, "Mecanim Setting Changed");

                            Animator animator = _targetPortrait.gameObject.GetComponent <Animator>();
                            if (animator == null)
                            {
                                animator = _targetPortrait.gameObject.AddComponent <Animator>();
                            }
                            _targetPortrait._animator = animator;
                        }
                    }
                    else
                    {
                        //2. Animator가 있다면
                        if (GUILayout.Button("Refresh Layers", GUILayout.Height(25)))
                        {
                            UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
                            Undo.IncrementCurrentGroup();
                            Undo.RegisterCompleteObjectUndo(_targetPortrait, "Mecanim Setting Changed");

                            //Animator의 Controller가 있는지 체크해야한다.

                            if (_targetPortrait._animator.runtimeAnimatorController == null)
                            {
                                //AnimatorController가 없다면 Layer는 초기화
                                _targetPortrait._animatorLayerBakedData.Clear();
                            }
                            else
                            {
                                //AnimatorController가 있다면 레이어에 맞게 설정
                                _targetPortrait._animatorLayerBakedData.Clear();
                                UnityEditor.Animations.AnimatorController animatorController = _targetPortrait._animator.runtimeAnimatorController as UnityEditor.Animations.AnimatorController;

                                if (animatorController != null && animatorController.layers.Length > 0)
                                {
                                    for (int iLayer = 0; iLayer < animatorController.layers.Length; iLayer++)
                                    {
                                        apAnimMecanimData_Layer newLayerData = new apAnimMecanimData_Layer();
                                        newLayerData._layerIndex = iLayer;
                                        newLayerData._layerName  = animatorController.layers[iLayer].name;
                                        newLayerData._blendType  = apAnimMecanimData_Layer.MecanimLayerBlendType.Unknown;
                                        switch (animatorController.layers[iLayer].blendingMode)
                                        {
                                        case UnityEditor.Animations.AnimatorLayerBlendingMode.Override:
                                            newLayerData._blendType = apAnimMecanimData_Layer.MecanimLayerBlendType.Override;
                                            break;

                                        case UnityEditor.Animations.AnimatorLayerBlendingMode.Additive:
                                            newLayerData._blendType = apAnimMecanimData_Layer.MecanimLayerBlendType.Additive;
                                            break;
                                        }

                                        _targetPortrait._animatorLayerBakedData.Add(newLayerData);
                                    }
                                }
                            }
                        }
                        GUILayout.Space(5);
                        EditorGUILayout.LabelField("Animator Controller Layers");
                        for (int i = 0; i < _targetPortrait._animatorLayerBakedData.Count; i++)
                        {
                            apAnimMecanimData_Layer layer = _targetPortrait._animatorLayerBakedData[i];
                            EditorGUILayout.BeginHorizontal();
                            GUILayout.Space(5);
                            EditorGUILayout.LabelField("[" + layer._layerIndex + "]", GUILayout.Width(50));
                            EditorGUILayout.TextField(layer._layerName);
                            apAnimMecanimData_Layer.MecanimLayerBlendType nextBlendType = (apAnimMecanimData_Layer.MecanimLayerBlendType)EditorGUILayout.EnumPopup(layer._blendType);
                            EditorGUILayout.EndHorizontal();

                            if (nextBlendType != layer._blendType)
                            {
                                UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
                                Undo.IncrementCurrentGroup();
                                Undo.RegisterCompleteObjectUndo(_targetPortrait, "Mecanim Setting Changed");

                                _targetPortrait._animatorLayerBakedData[i]._blendType = nextBlendType;
                            }
                        }
                    }
                }


                GUILayout.Space(20);


                //추가 3.4 : 타임라인 설정
#if UNITY_2017_1_OR_NEWER
                EditorGUILayout.LabelField(_guiContent_Timeline, GUILayout.Height(24));

                _isFold_Timeline = EditorGUILayout.Foldout(_isFold_Timeline, "Track Data");
                if (_isFold_Timeline)
                {
                    int nextTimelineTracks = EditorGUILayout.DelayedIntField("Size", _nTimelineTrackSet);
                    if (nextTimelineTracks != _nTimelineTrackSet)
                    {
                        //TimelineTrackSet의 개수가 바뀌었다.
                        UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
                        Undo.IncrementCurrentGroup();
                        Undo.RegisterCompleteObjectUndo(_targetPortrait, "Track Setting Changed");
                        _nTimelineTrackSet = nextTimelineTracks;
                        if (_nTimelineTrackSet < 0)
                        {
                            _nTimelineTrackSet = 0;
                        }

                        //일단 이전 개수만큼 복사를 한다.
                        int nPrev = 0;
                        List <apPortrait.TimelineTrackPreset> prevSets = new List <apPortrait.TimelineTrackPreset>();
                        if (targetPortrait._timelineTrackSets != null && targetPortrait._timelineTrackSets.Length > 0)
                        {
                            for (int i = 0; i < targetPortrait._timelineTrackSets.Length; i++)
                            {
                                prevSets.Add(targetPortrait._timelineTrackSets[i]);
                            }
                            nPrev = targetPortrait._timelineTrackSets.Length;
                        }

                        //배열을 새로 만들자
                        targetPortrait._timelineTrackSets = new apPortrait.TimelineTrackPreset[_nTimelineTrackSet];

                        //가능한 이전 소스를 복사한다.
                        for (int i = 0; i < _nTimelineTrackSet; i++)
                        {
                            if (i < nPrev)
                            {
                                targetPortrait._timelineTrackSets[i] = new apPortrait.TimelineTrackPreset();
                                targetPortrait._timelineTrackSets[i]._playableDirector = prevSets[i]._playableDirector;
                                targetPortrait._timelineTrackSets[i]._trackName        = prevSets[i]._trackName;
                                targetPortrait._timelineTrackSets[i]._layer            = prevSets[i]._layer;
                                targetPortrait._timelineTrackSets[i]._blendMethod      = prevSets[i]._blendMethod;
                            }
                            else
                            {
                                targetPortrait._timelineTrackSets[i] = new apPortrait.TimelineTrackPreset();
                            }
                        }


                        apEditorUtil.ReleaseGUIFocus();
                    }

                    GUILayout.Space(5);

                    if (targetPortrait._timelineTrackSets != null)
                    {
                        apPortrait.TimelineTrackPreset curTrackSet = null;
                        for (int i = 0; i < targetPortrait._timelineTrackSets.Length; i++)
                        {
                            //트랙을 하나씩 적용
                            curTrackSet = targetPortrait._timelineTrackSets[i];

                            EditorGUILayout.LabelField("[" + i + "] : " + (curTrackSet._playableDirector == null ? "<None>" : curTrackSet._playableDirector.name));
                            PlayableDirector nextDirector  = EditorGUILayout.ObjectField("Director", curTrackSet._playableDirector, typeof(PlayableDirector), true) as PlayableDirector;
                            string           nextTrackName = EditorGUILayout.DelayedTextField("Track Name", curTrackSet._trackName);
                            int nextLayer = EditorGUILayout.DelayedIntField("Layer", curTrackSet._layer);
                            apAnimPlayUnit.BLEND_METHOD nextBlendMethod = (apAnimPlayUnit.BLEND_METHOD)EditorGUILayout.EnumPopup("Blend", curTrackSet._blendMethod);

                            if (nextDirector != curTrackSet._playableDirector ||
                                nextTrackName != curTrackSet._trackName ||
                                nextLayer != curTrackSet._layer ||
                                nextBlendMethod != curTrackSet._blendMethod
                                )
                            {
                                UnityEditor.SceneManagement.EditorSceneManager.MarkAllScenesDirty();
                                Undo.IncrementCurrentGroup();
                                Undo.RegisterCompleteObjectUndo(_targetPortrait, "Track Setting Changed");

                                curTrackSet._playableDirector = nextDirector;
                                curTrackSet._trackName        = nextTrackName;
                                curTrackSet._layer            = nextLayer;
                                curTrackSet._blendMethod      = nextBlendMethod;

                                apEditorUtil.ReleaseGUIFocus();
                            }

                            GUILayout.Space(5);
                        }
                    }
                }

                GUILayout.Space(20);
#endif

                bool isChanged = false;

                // Control Parameters
                //-----------------------------------------------------------------------------

                if (_guiContent_Category == null)
                {
                    _guiContent_Category = apGUIContentWrapper.Make("Category", false);
                }


                GUILayout.Box(_guiContent_ControlParams, _guiStyle_subTitle, GUILayout.Width(subTitleWidth), GUILayout.Height(subTitleHeight));

#if UNITY_2017_3_OR_NEWER
                _curControlCategory = (apControlParam.CATEGORY)EditorGUILayout.EnumFlagsField(_guiContent_Category.Content, _curControlCategory);
#else
                _curControlCategory = (apControlParam.CATEGORY)EditorGUILayout.EnumMaskPopup(_guiContent_Category.Content, _curControlCategory);
#endif

                EditorGUILayout.Space();
                //1. 컨르롤러를 제어할 수 있도록 하자

                if (_controlParams != null)
                {
                    for (int i = 0; i < _controlParams.Count; i++)
                    {
                        if ((int)(_controlParams[i]._category & _curControlCategory) != 0)
                        {
                            if (GUI_ControlParam(_controlParams[i]))
                            {
                                isChanged = true;
                            }
                        }
                    }
                }

                GUILayout.Space(30);

                //2. 토글 버튼을 두어서 기본 Inspector 출력 여부를 결정하자.
                string strBaseButton = "Show All Properties";
                if (_showBaseInspector)
                {
                    strBaseButton = "Hide Properties";
                }

                if (GUILayout.Button(strBaseButton, GUILayout.Height(20)))
                {
                    _showBaseInspector = !_showBaseInspector;
                }

                if (_showBaseInspector)
                {
                    base.OnInspectorGUI();
                }


                if (!Application.isPlaying && isChanged)
                {
                    //플레이 중이라면 자동으로 업데이트 될 것이다.
                    _targetPortrait.UpdateForce();
                }

                if (_targetPortrait != null)
                {
                    if (request_OpenEditor)
                    {
                        if (_targetPortrait._isOptimizedPortrait)
                        {
                            RequestDelayedOpenEditor(_targetPortrait, REQUEST_TYPE.Open);
                        }
                        else
                        {
                            RequestDelayedOpenEditor(_targetPortrait, REQUEST_TYPE.OpenAndSet);
                        }
                        //apEditor anyPortraitEditor = apEditor.ShowWindow();
                        //if (anyPortraitEditor != null && !_targetPortrait._isOptimizedPortrait)
                        //{
                        //	anyPortraitEditor.SetPortraitByInspector(_targetPortrait, false);
                        //}
                    }
                    else if (request_QuickBake)
                    {
                        RequestDelayedOpenEditor(_targetPortrait, REQUEST_TYPE.QuickBake);
                        //apEditor anyPortraitEditor = apEditor.ShowWindow();
                        //if (anyPortraitEditor != null)
                        //{
                        //	anyPortraitEditor.SetPortraitByInspector(_targetPortrait, true);

                        //	Selection.activeObject = _targetPortrait.gameObject;
                        //}
                    }
                    else if (request_RefreshMeshes)
                    {
                        _targetPortrait.OnMeshResetInEditor();
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.LogError("apInspector_Portrait Exception : " + ex);
            }

            //Profiler.EndSample();
        }