public bool Paste_MultipleVertRig(apMeshGroup keyMeshGroup, List <apSelection.ModRenderVert> modRenderVerts)
        {
            bool isPastable = IsRiggingPosPastable(keyMeshGroup, modRenderVerts);

            if (!isPastable)
            {
                return(false);
            }

            List <apModifiedVertexRig> vertRigs = new List <apModifiedVertexRig>();

            apSelection.ModRenderVert curModRenderVert = null;
            for (int i = 0; i < modRenderVerts.Count; i++)
            {
                curModRenderVert = modRenderVerts[i];
                if (curModRenderVert != null && curModRenderVert._modVertRig != null)
                {
                    vertRigs.Add(curModRenderVert._modVertRig);
                }
            }
            if (vertRigs.Count == 0)
            {
                return(false);
            }

            return(_clipboard_MultipleVertRig.Paste(keyMeshGroup, vertRigs));
        }
        public void Copy_MultipleVertRig(apMeshGroup keyMeshGroup, List <apSelection.ModRenderVert> modRenderVerts)
        {
            if (_clipboard_MultipleVertRig == null)
            {
                _clipboard_MultipleVertRig = new apSnapShot_MultipleVertRig();
            }

            List <apModifiedVertexRig> vertRigs = new List <apModifiedVertexRig>();

            apSelection.ModRenderVert curModRenderVert = null;
            for (int i = 0; i < modRenderVerts.Count; i++)
            {
                curModRenderVert = modRenderVerts[i];
                if (curModRenderVert != null && curModRenderVert._modVertRig != null)
                {
                    vertRigs.Add(curModRenderVert._modVertRig);
                }
            }

            _clipboard_MultipleVertRig.Copy(keyMeshGroup, vertRigs);
        }
        /// <summary>
        /// Physic Modifier내에서의 Gizmo 이벤트 : Vertex 계열 선택시 [단일 선택]
        /// </summary>
        /// <param name="mousePosGL"></param>
        /// <param name="mousePosW"></param>
        /// <param name="btnIndex"></param>
        /// <param name="selectType"></param>
        /// <returns></returns>
        public apGizmos.SelectResult Select__Modifier_Physics(Vector2 mousePosGL, Vector2 mousePosW, int btnIndex, apGizmos.SELECT_TYPE selectType)
        {
            if (Editor.Select.MeshGroup == null || Editor.Select.Modifier == null)
            {
                return(null);
            }

            //(Editing 상태일 때)
            //1. Vertex 선택
            //2. (Lock 걸리지 않았다면) 다른 Transform을 선택

            //(Editing 상태가 아닐 때)
            //(Lock 걸리지 않았다면) Transform을 선택한다.
            // Child 선택이 가능하면 MeshTransform을 선택. 그렇지 않아면 MeshGroupTransform을 선택해준다.

            if (Editor.Select.ModRenderVertListOfMod == null)
            {
                return(null);
            }

            int prevSelectedCount = Editor.Select.ModRenderVertListOfMod.Count;

            if (!Editor.Controller.IsMouseInGUI(mousePosGL))
            {
                return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
            }

            bool isChildMeshTransformSelectable = Editor.Select.Modifier.IsTarget_ChildMeshTransform;

            //apGizmos.SELECT_RESULT result = apGizmos.SELECT_RESULT.None;

            bool isTransformSelectable = false;

            if (Editor.Select.ExEditingMode != apSelection.EX_EDIT.None)
            {
                //(Editing 상태일 때)
                //1. Vertex 선택
                //2. (Lock 걸리지 않았다면) 다른 Transform을 선택
                bool selectVertex = false;
                if (Editor.Select.ExKey_ModMesh != null && Editor.Select.MeshGroup != null)
                {
                    //일단 선택한 Vertex가 클릭 가능한지 체크
                    if (Editor.Select.ModRenderVertOfMod != null)
                    {
                        if (Editor.Select.ModRenderVertListOfMod.Count == 1)
                        {
                            if (Editor.Controller.IsVertexClickable(apGL.World2GL(Editor.Select.ModRenderVertOfMod._renderVert._pos_World), mousePosGL))
                            {
                                if (selectType == apGizmos.SELECT_TYPE.Subtract)
                                {
                                    //삭제인 경우 : ModVertWeight를 선택한다.
                                    Editor.Select.RemoveModVertexOfModifier(null, null, Editor.Select.ModRenderVertOfMod._modVertWeight, Editor.Select.ModRenderVertOfMod._renderVert);
                                }
                                else
                                {
                                    //그 외에는 => 그대로 갑시다.
                                    selectVertex = true;
                                    //return apGizmos.SELECT_RESULT.SameSelected;
                                }
                                //return Editor.Select.ModRenderVertListOfMod.Count;
                                return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
                            }
                        }
                        else
                        {
                            //여러개라고 하네요.
                            List <apSelection.ModRenderVert> modRenderVerts = Editor.Select.ModRenderVertListOfMod;
                            for (int iModRenderVert = 0; iModRenderVert < modRenderVerts.Count; iModRenderVert++)
                            {
                                apSelection.ModRenderVert modRenderVert = modRenderVerts[iModRenderVert];

                                if (Editor.Controller.IsVertexClickable(apGL.World2GL(modRenderVert._renderVert._pos_World), mousePosGL))
                                {
                                    if (selectType == apGizmos.SELECT_TYPE.Subtract)
                                    {
                                        //삭제인 경우
                                        //하나 지우고 끝
                                        //결과는 List의 개수
                                        Editor.Select.RemoveModVertexOfModifier(null, null, modRenderVert._modVertWeight, modRenderVert._renderVert);
                                    }
                                    else if (selectType == apGizmos.SELECT_TYPE.Add)
                                    {
                                        //Add 상태에서 원래 선택된걸 누른다면
                                        //추가인 경우 => 그대로
                                        selectVertex = true;
                                    }
                                    else
                                    {
                                        //만약... new 라면?
                                        //다른건 초기화하고
                                        //얘만 선택해야함
                                        apRenderVertex         selectedRenderVert    = modRenderVert._renderVert;
                                        apModifiedVertexWeight selectedModVertWeight = modRenderVert._modVertWeight;
                                        Editor.Select.SetModVertexOfModifier(null, null, null, null);
                                        Editor.Select.SetModVertexOfModifier(null, null, selectedModVertWeight, selectedRenderVert);
                                    }

                                    //return Editor.Select.ModRenderVertListOfMod.Count;
                                    return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
                                }
                            }
                        }
                    }

                    if (selectType == apGizmos.SELECT_TYPE.New)
                    {
                        //Add나 Subtract가 아닐땐, 잘못 클릭하면 선택을 해제하자 (전부)
                        Editor.Select.SetModVertexOfModifier(null, null, null, null);
                    }

                    if (selectType != apGizmos.SELECT_TYPE.Subtract)
                    {
                        if (Editor.Select.ExKey_ModMesh._transform_Mesh != null &&
                            Editor.Select.ExKey_ModMesh._vertices != null)
                        {
                            //선택된 RenderUnit을 고르자
                            apRenderUnit targetRenderUnit = Editor.Select.MeshGroup.GetRenderUnit(Editor.Select.ExKey_ModMesh._transform_Mesh);

                            if (targetRenderUnit != null)
                            {
                                for (int iVert = 0; iVert < targetRenderUnit._renderVerts.Count; iVert++)
                                {
                                    apRenderVertex renderVert = targetRenderUnit._renderVerts[iVert];
                                    bool           isClick    = Editor.Controller.IsVertexClickable(apGL.World2GL(renderVert._pos_World), mousePosGL);
                                    if (isClick)
                                    {
                                        apModifiedVertexWeight selectedModVertWeight = Editor.Select.ExKey_ModMesh._vertWeights.Find(delegate(apModifiedVertexWeight a)
                                        {
                                            return(renderVert._vertex._uniqueID == a._vertexUniqueID);
                                        });

                                        if (selectedModVertWeight != null)
                                        {
                                            if (selectType == apGizmos.SELECT_TYPE.New)
                                            {
                                                Editor.Select.SetModVertexOfModifier(null, null, selectedModVertWeight, renderVert);
                                            }
                                            else if (selectType == apGizmos.SELECT_TYPE.Add)
                                            {
                                                Editor.Select.AddModVertexOfModifier(null, null, selectedModVertWeight, renderVert);
                                            }

                                            selectVertex = true;
                                            //result = apGizmos.SELECT_RESULT.NewSelected;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                //Vertex를 선택한게 없다면
                //+ Lock 상태가 아니라면
                if (!selectVertex && !Editor.Select.IsLockExEditKey)
                {
                    //Transform을 선택
                    isTransformSelectable = true;
                }
            }
            else
            {
                //(Editing 상태가 아닐때)
                isTransformSelectable = true;

                if (Editor.Select.ExKey_ModMesh != null && Editor.Select.IsLockExEditKey)
                {
                    //뭔가 선택된 상태에서 Lock이 걸리면 다른건 선택 불가
                    isTransformSelectable = false;
                }
            }

            if (isTransformSelectable && selectType == apGizmos.SELECT_TYPE.New)
            {
                //(Editing 상태가 아닐 때)
                //Transform을 선택한다.

                apTransform_Mesh selectedMeshTransform = null;

                List <apRenderUnit> renderUnits = Editor.Select.MeshGroup._renderUnits_All;               //<<정렬된 Render Unit
                for (int iUnit = 0; iUnit < renderUnits.Count; iUnit++)
                {
                    apRenderUnit renderUnit = renderUnits[iUnit];
                    if (renderUnit._meshTransform != null && renderUnit._meshTransform._mesh != null)
                    {
                        if (renderUnit._meshTransform._isVisible_Default && renderUnit._meshColor2X.a > 0.1f)                        //Alpha 옵션 추가
                        {
                            //Debug.LogError("TODO : Mouse Picking 바꿀것");
                            bool isPick = apEditorUtil.IsMouseInRenderUnitMesh(
                                mousePosGL, renderUnit);

                            if (isPick)
                            {
                                selectedMeshTransform = renderUnit._meshTransform;
                                //찾았어도 계속 찾는다.
                                //뒤의 아이템이 "앞쪽"에 있는 것이기 때문
                            }
                        }
                    }
                }

                if (selectedMeshTransform != null)
                {
                    //만약 ChildMeshGroup에 속한 거라면,
                    //Mesh Group 자체를 선택해야 한다. <- 추가 : Child Mesh Transform이 허용되는 경우 그럴 필요가 없다.
                    apMeshGroup parentMeshGroup = Editor.Select.MeshGroup.FindParentMeshGroupOfMeshTransform(selectedMeshTransform);
                    if (parentMeshGroup == null || parentMeshGroup == Editor.Select.MeshGroup || isChildMeshTransformSelectable)
                    {
                        Editor.Select.SetSubMeshInGroup(selectedMeshTransform);
                    }
                    else
                    {
                        apTransform_MeshGroup childMeshGroupTransform = Editor.Select.MeshGroup.FindChildMeshGroupTransform(parentMeshGroup);
                        if (childMeshGroupTransform != null)
                        {
                            Editor.Select.SetSubMeshGroupInGroup(childMeshGroupTransform);
                        }
                        else
                        {
                            Editor.Select.SetSubMeshInGroup(selectedMeshTransform);
                        }
                    }
                }
                else
                {
                    Editor.Select.SetSubMeshInGroup(null);
                }

                Editor.RefreshControllerAndHierarchy();
                //Editor.Repaint();
                Editor.SetRepaint();
            }

            //개수에 따라 한번더 결과 보정
            if (Editor.Select.ModRenderVertListOfMod != null)
            {
                //return Editor.Select.ModRenderVertListOfMod.Count;
                return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
            }
            return(null);
        }
Esempio n. 4
0
        /// <summary>
        /// Rigging Modifier 내에서의 Gizmo 이벤트 : Vertex 선택 또는 Bone 선택 [단일 선택]
        /// </summary>
        /// <param name="mousePosGL"></param>
        /// <param name="mousePosW"></param>
        /// <param name="btnIndex"></param>
        /// <param name="selectType"></param>
        /// <returns></returns>
        public apGizmos.SelectResult Select__Modifier_Rigging(Vector2 mousePosGL, Vector2 mousePosW, int btnIndex, apGizmos.SELECT_TYPE selectType)
        {
            if (Editor.Select.MeshGroup == null || Editor.Select.Modifier == null)
            {
                return(null);
            }

            // 선택은 Test Posing 상관없이 수행한다.
            // - Vertex > (선택 못했어도 일단 이전에 선택한 Vertex를 해제하지 않는다.)
            // - Bone > (선택 못했으면 이전에 선택한 Bone 해제)
            // Vertex나 Bone 선택이 되지 않았다면, 이전에 선택했던 Vertex, Bone을 모두 해제한다.

            // - Mesh Transform 선택 (Lock이 안걸린 경우. 이건 리턴하지 않는다)
            // (아무것도 선택하지 않은 경우) -> Vertex, Bone, Mesh Transform 해제

            bool isAnySelected = false;


            if (Editor.Select.ModRenderVertListOfMod == null)
            {
                return(null);
            }



            if (!Editor.Controller.IsMouseInGUI(mousePosGL))
            {
                if (Editor.Select.ModRenderVertListOfMod.Count > 0)
                {
                    return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
                }
                if (Editor.Select.Bone != null)
                {
                    return(apGizmos.SelectResult.Main.SetSingle(Editor.Select.Bone));
                }
                return(null);
            }
            int  prevSelectedVertex  = Editor.Select.ModRenderVertListOfMod.Count;
            bool isAnyVertexSelected = false;
            bool isAnyBoneSelected   = false;
            List <apSelection.ModRenderVert> prevSelectedVertices = new List <apSelection.ModRenderVert>();

            for (int i = 0; i < Editor.Select.ModRenderVertListOfMod.Count; i++)
            {
                prevSelectedVertices.Add(Editor.Select.ModRenderVertListOfMod[i]);
            }

            //1. 버텍스 선택을 먼저
            bool isChildMeshTransformSelectable = Editor.Select.Modifier.IsTarget_ChildMeshTransform;


            if (Editor.Select.ExKey_ModMesh != null && Editor.Select.MeshGroup != null)
            {
                //bool selectVertex = false;
                //일단 선택한 Vertex가 클릭 가능한지 체크
                if (Editor.Select.ModRenderVertOfMod != null)
                {
                    if (Editor.Select.ModRenderVertListOfMod.Count == 1)
                    {
                        if (Editor.Controller.IsVertexClickable(apGL.World2GL(Editor.Select.ModRenderVertOfMod._renderVert._pos_World), mousePosGL))
                        {
                            if (selectType == apGizmos.SELECT_TYPE.Subtract)
                            {
                                //삭제인 경우
                                //ModVert가 아니라 ModVertRig인 점 주의
                                Editor.Select.RemoveModVertexOfModifier(null, Editor.Select.ModRenderVertOfMod._modVertRig, null, Editor.Select.ModRenderVertOfMod._renderVert);
                                //return apGizmos.SELECT_RESULT.None;
                            }
                            else
                            {
                                //그 외에는 => 그대로 갑시다.
                                isAnySelected = true;
                                //return apGizmos.SELECT_RESULT.SameSelected;
                            }
                            //return Editor.Select.ModRenderVertListOfMod.Count;
                            return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
                        }
                    }
                    else
                    {
                        //여러개라고 하네요.
                        List <apSelection.ModRenderVert> modRenderVerts = Editor.Select.ModRenderVertListOfMod;
                        for (int iModRenderVert = 0; iModRenderVert < modRenderVerts.Count; iModRenderVert++)
                        {
                            apSelection.ModRenderVert modRenderVert = modRenderVerts[iModRenderVert];

                            if (Editor.Controller.IsVertexClickable(apGL.World2GL(modRenderVert._renderVert._pos_World), mousePosGL))
                            {
                                if (selectType == apGizmos.SELECT_TYPE.Subtract)
                                {
                                    //삭제인 경우
                                    //하나 지우고 끝
                                    //결과는 List의 개수
                                    Editor.Select.RemoveModVertexOfModifier(null, modRenderVert._modVertRig, null, modRenderVert._renderVert);
                                }
                                else if (selectType == apGizmos.SELECT_TYPE.Add)
                                {
                                    //Add 상태에서 원래 선택된걸 누른다면
                                    //추가인 경우 => 그대로
                                    isAnySelected = true;
                                }
                                else
                                {
                                    //만약... new 라면?
                                    //다른건 초기화하고
                                    //얘만 선택해야함
                                    apRenderVertex      selectedRenderVert = modRenderVert._renderVert;
                                    apModifiedVertexRig selectedModVertRig = modRenderVert._modVertRig;
                                    Editor.Select.SetModVertexOfModifier(null, null, null, null);
                                    Editor.Select.SetModVertexOfModifier(null, selectedModVertRig, null, selectedRenderVert);
                                    //return apGizmos.SELECT_RESULT.NewSelected;
                                    //return Editor.Select.ModRenderVertOfModList.Count;
                                }

                                //return Editor.Select.ModRenderVertListOfMod.Count;
                                return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
                            }
                        }
                    }
                }

                //이부분 주의
                //일단 날리되, "Bone을 선택했다면 이전에 선택한 vertex를 유지한다"를 지켜야한다.
                if (selectType == apGizmos.SELECT_TYPE.New)
                {
                    //Add나 Subtract가 아닐땐, 잘못 클릭하면 선택을 해제하자 (전부)
                    Editor.Select.SetModVertexOfModifier(null, null, null, null);
                }

                if (selectType != apGizmos.SELECT_TYPE.Subtract)
                {
                    if (Editor.Select.ExKey_ModMesh._transform_Mesh != null &&
                        Editor.Select.ExKey_ModMesh._vertRigs != null)
                    {
                        //선택된 RenderUnit을 고르자
                        apRenderUnit targetRenderUnit = Editor.Select.MeshGroup.GetRenderUnit(Editor.Select.ExKey_ModMesh._transform_Mesh);

                        if (targetRenderUnit != null)
                        {
                            for (int iVert = 0; iVert < targetRenderUnit._renderVerts.Count; iVert++)
                            {
                                apRenderVertex renderVert = targetRenderUnit._renderVerts[iVert];
                                bool           isClick    = Editor.Controller.IsVertexClickable(apGL.World2GL(renderVert._pos_World), mousePosGL);
                                if (isClick)
                                {
                                    apModifiedVertexRig selectedModVertRig = Editor.Select.ExKey_ModMesh._vertRigs.Find(delegate(apModifiedVertexRig a)
                                    {
                                        return(renderVert._vertex._uniqueID == a._vertexUniqueID);
                                    });

                                    if (selectedModVertRig != null)
                                    {
                                        if (selectType == apGizmos.SELECT_TYPE.New)
                                        {
                                            Editor.Select.SetModVertexOfModifier(null, selectedModVertRig, null, renderVert);
                                        }
                                        else if (selectType == apGizmos.SELECT_TYPE.Add)
                                        {
                                            Editor.Select.AddModVertexOfModifier(null, selectedModVertRig, null, renderVert);
                                        }

                                        isAnySelected       = true;
                                        isAnyVertexSelected = true;

                                        //result = apGizmos.SELECT_RESULT.NewSelected;
                                        break;
                                    }
                                }
                            }

                            Editor.RefreshControllerAndHierarchy();
                            //Editor.Repaint();
                            Editor.SetRepaint();
                        }
                    }
                }

                if (isAnySelected)
                {
                    Editor.Select.AutoSelectModMeshOrModBone();
                }
            }

            if (!Editor.Select.IsLockExEditKey)
            {
                if (!isAnySelected)
                {
                    //2. Bone을 선택하자
                    //Bone은 Select Mode가 Subtract가 아닌 이상 무조건 작동을 한다.
                    //만약, 잠금 버튼이 눌렸다면 -> Bone 선택하지 않았어도 해제를 하지 않는다.
                    apMeshGroup meshGroup = Editor.Select.MeshGroup;
                    apBone      prevBone  = Editor.Select.Bone;

                    List <apBone> boneList = meshGroup._boneList_All;
                    apBone        bone     = null;
                    for (int i = 0; i < boneList.Count; i++)
                    {
                        bone = boneList[i];
                        if (IsBoneClick(bone, mousePosW, mousePosGL, Editor._boneGUIRenderMode == apEditor.BONE_RENDER_MODE.RenderOutline))
                        {
                            //Debug.Log("Selected : " + bone._name);
                            if (selectType != apGizmos.SELECT_TYPE.Subtract)
                            {
                                Editor.Select.SetBone(bone);
                                isAnySelected = true;
                            }
                            else
                            {
                                Editor.Select.SetBone(null);
                            }

                            isAnyBoneSelected = true;

                            break;
                        }
                    }

                    if (!isAnySelected)
                    {
                        Editor.Select.SetBone(null);
                        if (Editor.Select.IsLockExEditKey)
                        {
                            Editor.Select.SetBone(prevBone);                            //복구
                        }
                    }
                    else
                    {
                        //Bone을 선택했다면
                        //Vertex를 복구해주자
                        for (int i = 0; i < prevSelectedVertices.Count; i++)
                        {
                            apSelection.ModRenderVert modRenderVert = prevSelectedVertices[i];
                            Editor.Select.AddModVertexOfModifier(modRenderVert._modVert, modRenderVert._modVertRig, null, modRenderVert._renderVert);
                        }
                    }

                    if (prevBone != Editor.Select.Bone)
                    {
                        _isBoneSelect_MovePosReset = true;
                        Editor.RefreshControllerAndHierarchy();
                    }
                }
            }


            if (!Editor.Select.IsLockExEditKey)
            {
                if (!isAnySelected && selectType == apGizmos.SELECT_TYPE.New)
                {
                    //3. Mesh Transform을 선택하자
                    //이건 선택 영역에 포함되지 않는다.
                    apTransform_Mesh selectedMeshTransform = null;

                    List <apRenderUnit> renderUnits = Editor.Select.MeshGroup._renderUnits_All;                   //<<정렬된 Render Unit
                    for (int iUnit = 0; iUnit < renderUnits.Count; iUnit++)
                    {
                        apRenderUnit renderUnit = renderUnits[iUnit];
                        if (renderUnit._meshTransform != null && renderUnit._meshTransform._mesh != null)
                        {
                            if (renderUnit._meshTransform._isVisible_Default && renderUnit._meshColor2X.a > 0.1f)                            //Alpha 옵션 추가
                            {
                                //Debug.LogError("TODO : Mouse Picking 바꿀것");
                                bool isPick = apEditorUtil.IsMouseInRenderUnitMesh(
                                    mousePosGL, renderUnit);

                                if (isPick)
                                {
                                    selectedMeshTransform = renderUnit._meshTransform;
                                    //찾았어도 계속 찾는다.
                                    //뒤의 아이템이 "앞쪽"에 있는 것이기 때문
                                }
                            }
                        }
                    }

                    if (selectedMeshTransform != null)
                    {
                        //만약 ChildMeshGroup에 속한 거라면,
                        //Mesh Group 자체를 선택해야 한다. <- 추가 : Child Mesh Transform이 허용되는 경우 그럴 필요가 없다.
                        apMeshGroup parentMeshGroup = Editor.Select.MeshGroup.FindParentMeshGroupOfMeshTransform(selectedMeshTransform);
                        if (parentMeshGroup == null || parentMeshGroup == Editor.Select.MeshGroup || isChildMeshTransformSelectable)
                        {
                            Editor.Select.SetSubMeshInGroup(selectedMeshTransform);
                        }
                        else
                        {
                            apTransform_MeshGroup childMeshGroupTransform = Editor.Select.MeshGroup.FindChildMeshGroupTransform(parentMeshGroup);
                            if (childMeshGroupTransform != null)
                            {
                                Editor.Select.SetSubMeshGroupInGroup(childMeshGroupTransform);
                            }
                            else
                            {
                                Editor.Select.SetSubMeshInGroup(selectedMeshTransform);
                            }
                        }
                    }
                    else
                    {
                        Editor.Select.SetSubMeshInGroup(null);
                    }

                    Editor.RefreshControllerAndHierarchy();
                    //Editor.Repaint();
                    Editor.SetRepaint();
                }
            }

            if (isAnySelected)
            {
                if (Editor.Select.ModRenderVertListOfMod != null && Editor.Select.ModRenderVertListOfMod.Count > 0)
                {
                    //return Editor.Select.ModRenderVertListOfMod.Count;
                    return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
                }

                if (Editor.Select.Bone != null)
                {
                    return(apGizmos.SelectResult.Main.SetSingle(Editor.Select.Bone));
                }
            }

            return(null);
        }