public void SelectVertices(List <apVertex> vertices, apGizmos.SELECT_TYPE selectType)
{
if (selectType == apGizmos.SELECT_TYPE.New)
{
_curVertex = null;
_curVertices.Clear();
}
switch (selectType)
{
case apGizmos.SELECT_TYPE.Add:
case apGizmos.SELECT_TYPE.New:
for (int i = 0; i < vertices.Count; i++)
{
if (!_curVertices.Contains(vertices[i]))
{
_curVertices.Add(vertices[i]);
}
}
break;
case apGizmos.SELECT_TYPE.Subtract:
for (int i = 0; i < vertices.Count; i++)
{
if (_curVertices.Contains(vertices[i]))
{
_curVertices.Remove(vertices[i]);
}
}
break;
}
if (_curVertices.Count > 0)
{
if (_curVertex == null || !_curVertices.Contains(_curVertex))
{
_curVertex = _curVertices[0];
}
}
else
{
_curVertex = null;
}
UnselectNextVertex();
_isTmpEdgeWire = false;
_isTmpEdgeWireCrossEdge = false;
//_tmpEdgeWire_MousePos = Vector2.zero;
_isTmpEdgeWireCrossEdge_Multiple = false;
_tmpEdgeWireMultipleCrossPoints.Clear();
//_isTmpEdgeWire_SnapToEdge = false;
//_tmpEdgeWire_SnapToEdge = Vector2.zero;
_curPolygon = null;
}
//---------------------------------------------------------------------------------------
public apGizmos.SelectResult MultipleSelect__MeshTRS(Vector2 mousePosGL_Min, Vector2 mousePosGL_Max, Vector2 mousePosW_Min, Vector2 mousePosW_Max, apGizmos.SELECT_TYPE areaSelectType)
{
if (Editor.Select.SelectionType != apSelection.SELECTION_TYPE.Mesh ||
Editor.Select.Mesh == null ||
Editor.Select.Mesh.LinkedTextureData == null ||
Editor.Select.Mesh.LinkedTextureData._image == null ||
Editor._meshEditMode != apEditor.MESH_EDIT_MODE.MakeMesh ||
Editor._meshEditeMode_MakeMesh != apEditor.MESH_EDIT_MODE_MAKEMESH.TRS)
{
return(null);
}
apMesh mesh = Editor.Select.Mesh;
//Vector2 imageHalfOffset = new Vector2(mesh.LinkedTextureData._width * 0.5f, mesh.LinkedTextureData._height * 0.5f);
List <apVertex> vertices = mesh._vertexData;
if (vertices.Count == 0)
{
return(null);
}
List <apVertex> tmpVertex = null;
apVertex curVert = null;
Vector2 vertPos = Vector2.zero;
for (int iVert = 0; iVert < vertices.Count; iVert++)
{
curVert = vertices[iVert];
//클릭할 수 있는가
//vertPos = curVert._pos - (mesh._offsetPos + imageHalfOffset);
vertPos = curVert._pos - (mesh._offsetPos);
bool isSelectable = (mousePosW_Min.x < vertPos.x && vertPos.x < mousePosW_Max.x) &&
(mousePosW_Min.y < vertPos.y && vertPos.y < mousePosW_Max.y);
if (isSelectable)
{
//일단 리스트에 추가
if (tmpVertex == null)
{
tmpVertex = new List <apVertex>();
}
tmpVertex.Add(curVert);
}
}
if (tmpVertex != null)
{
Editor.VertController.SelectVertices(tmpVertex, areaSelectType);
Editor.SetRepaint();
}
else if (areaSelectType == apGizmos.SELECT_TYPE.New)
{
Editor.VertController.UnselectVertex();
Editor.SetRepaint();
}
return(apGizmos.SelectResult.Main.SetMultiple <apVertex>(Editor.VertController.Vertices));
}
// Select
public apGizmos.SelectResult Select__MeshTRS(Vector2 mousePosGL, Vector2 mousePosW, int btnIndex, apGizmos.SELECT_TYPE selectType)
{
if (Editor.Select.SelectionType != apSelection.SELECTION_TYPE.Mesh ||
Editor.Select.Mesh == null ||
Editor.Select.Mesh.LinkedTextureData == null ||
Editor.Select.Mesh.LinkedTextureData._image == null ||
Editor._meshEditMode != apEditor.MESH_EDIT_MODE.MakeMesh ||
Editor._meshEditeMode_MakeMesh != apEditor.MESH_EDIT_MODE_MAKEMESH.TRS)
{
return(null);
}
apMesh mesh = Editor.Select.Mesh;
//Vector2 imageHalfOffset = new Vector2(mesh.LinkedTextureData._width * 0.5f, mesh.LinkedTextureData._height * 0.5f);
List <apVertex> vertices = mesh._vertexData;
if (vertices.Count == 0)
{
return(null);
}
List <apVertex> tmpVertex = null;
apVertex curVert = null;
for (int iVert = 0; iVert < vertices.Count; iVert++)
{
curVert = vertices[iVert];
//클릭할 수 있는가
//if (Editor.Controller.IsVertexClickable(apGL.World2GL(curVert._pos - (mesh._offsetPos + imageHalfOffset)), mousePosGL))
if (Editor.Controller.IsVertexClickable(apGL.World2GL(curVert._pos - (mesh._offsetPos)), mousePosGL))
{
//일단 리스트에 추가
if (tmpVertex == null)
{
tmpVertex = new List <apVertex>();
}
tmpVertex.Add(curVert);
if (selectType == apGizmos.SELECT_TYPE.New)
{
//New인 경우에는 1개만 체크한다.
break;
}
}
}
if (tmpVertex != null)
{
Editor.VertController.SelectVertices(tmpVertex, selectType);
Editor.SetRepaint();
}
else if (selectType == apGizmos.SELECT_TYPE.New)
{
Editor.VertController.UnselectVertex();
Editor.SetRepaint();
}
return(apGizmos.SelectResult.Main.SetMultiple <apVertex>(Editor.VertController.Vertices));
}
public apGizmos.SelectResult Select__MeshGroup_Setting(Vector2 mousePosGL, Vector2 mousePosW, int btnIndex, apGizmos.SELECT_TYPE selectType)
{
if (Editor.Select.MeshGroup == null)
{
return(null);
}
apTransform_MeshGroup prevSelectedMeshGroupTransform = Editor.Select.SubMeshGroupInGroup;
//apTransform_Mesh prevSelectedMeshTransform = Editor.Select.SubMeshInGroup;
//apGizmos.SELECT_RESULT result = apGizmos.SELECT_RESULT.None;
//int result = 0;
object resultObj = null;
if (Editor.Controller.IsMouseInGUI(mousePosGL))
{
apTransform_Mesh selectedMeshTransform = null;
//정렬된 Render Unit
//List<apRenderUnit> renderUnits = Editor.Select.MeshGroup._renderUnits_All;//<<이전 : RenderUnits_All 이용
List <apRenderUnit> renderUnits = Editor.Select.MeshGroup.SortedRenderUnits; //<<변경 : Sorted 리스트 이용
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)
{
//Debug.LogError("TODO : Mouse Picking 바꿀것");
//bool isPick = apEditorUtil.IsMouseInMesh(
// mousePosGL,
// renderUnit._meshTransform._mesh,
// renderUnit.WorldMatrixOfNode.inverse
// );
bool isPick = apEditorUtil.IsMouseInRenderUnitMesh(
mousePosGL, renderUnit);
if (isPick)
{
selectedMeshTransform = renderUnit._meshTransform;
//찾았어도 계속 찾는다.
//뒤의 아이템이 "앞쪽"에 있는 것이기 때문
}
}
}
}
if (selectedMeshTransform != null)
{
//이전 버전
//>> 만약 ChildMeshGroup에 속한 거라면, Mesh Group 자체를 선택해야 한다.
//apMeshGroup parentMeshGroup = Editor.Select.MeshGroup.FindParentMeshGroupOfMeshTransform(selectedMeshTransform);
//if (parentMeshGroup == null || parentMeshGroup == Editor.Select.MeshGroup)
//{
// 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);
// }
//}
//수정된 버전
//>> 그냥 MeshGroup Transform은 마우스로 선택 못하는 걸로 하자
Editor.Select.SetSubMeshInGroup(selectedMeshTransform);
//result = 1;
resultObj = selectedMeshTransform;
//if(prevSelectedMeshGroupTransform == Editor.Select.SubMeshGroupInGroup
// //&& prevSelectedMeshGroupTransform == Editor.Select.SubMeshGroupInGroup//<<이거 뭐야?
// )
//{
// //isSameObject = true;
// //result = apGizmos.SELECT_RESULT.SameSelected;
// result = 1;
// resultObj = Editor.Select.SubMeshGroupInGroup;
//}
//else
//{
// //isSameObject = false;
// //result = apGizmos.SELECT_RESULT.NewSelected;
// result = 1;
//}
}
else
{
Editor.Select.SetSubMeshInGroup(null);
}
Editor.RefreshControllerAndHierarchy();
//Editor.Repaint();
Editor.SetRepaint();
}
if (resultObj == null)
{
resultObj = prevSelectedMeshGroupTransform;
}
//return result;
return(apGizmos.SelectResult.Main.SetSingle(resultObj));
}
/// <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);
}
/// <summary>
/// Physics Modifier내에서의 Gizmo 이벤트 : Vertex 계열 선택시 [복수 선택]
/// </summary>
/// <param name="mousePosGL_Min"></param>
/// <param name="mousePosGL_Max"></param>
/// <param name="mousePosW_Min"></param>
/// <param name="mousePosW_Max"></param>
/// <param name="areaSelectType"></param>
/// <returns></returns>
public apGizmos.SelectResult MultipleSelect__Modifier_Physics(Vector2 mousePosGL_Min, Vector2 mousePosGL_Max, Vector2 mousePosW_Min, Vector2 mousePosW_Max, apGizmos.SELECT_TYPE areaSelectType)
{
if (Editor.Select.MeshGroup == null || Editor.Select.Modifier == null)
{
return(null);
}
if (Editor.Select.ModRenderVertListOfMod == null)
{
return(null);
}
// 이건 다중 버텍스 선택밖에 없다.
//Transform 선택은 없음
bool isAnyChanged = false;
if (Editor.Select.ExEditingMode != apSelection.EX_EDIT.None && Editor.Select.ExKey_ModMesh != null && Editor.Select.MeshGroup != 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 isSelectable = (mousePosW_Min.x < renderVert._pos_World.x && renderVert._pos_World.x < mousePosW_Max.x) &&
(mousePosW_Min.y < renderVert._pos_World.y && renderVert._pos_World.y < mousePosW_Max.y);
if (isSelectable)
{
apModifiedVertexWeight selectedModVertWeight = Editor.Select.ExKey_ModMesh._vertWeights.Find(delegate(apModifiedVertexWeight a)
{
return(renderVert._vertex._uniqueID == a._vertexUniqueID);
});
if (selectedModVertWeight != null)
{
if (areaSelectType == apGizmos.SELECT_TYPE.Add ||
areaSelectType == apGizmos.SELECT_TYPE.New)
{
Editor.Select.AddModVertexOfModifier(null, null, selectedModVertWeight, renderVert);
}
else
{
Editor.Select.RemoveModVertexOfModifier(null, null, selectedModVertWeight, renderVert);
}
isAnyChanged = true;
}
}
}
Editor.RefreshControllerAndHierarchy();
//Editor.Repaint();
Editor.SetRepaint();
}
}
if (isAnyChanged)
{
Editor.Select.AutoSelectModMeshOrModBone();
}
//return Editor.Select.ModRenderVertListOfMod.Count;
return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
}
/// <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);
}
public apGizmos.SelectResult MultipleSelect__MeshAutoGen(Vector2 mousePosGL_Min, Vector2 mousePosGL_Max, Vector2 mousePosW_Min, Vector2 mousePosW_Max, apGizmos.SELECT_TYPE areaSelectType)
{
if (Editor.Select.SelectionType != apSelection.SELECTION_TYPE.Mesh ||
Editor.Select.Mesh == null ||
Editor.Select.Mesh.LinkedTextureData == null ||
Editor.Select.Mesh.LinkedTextureData._image == null ||
Editor._meshEditMode != apEditor.MESH_EDIT_MODE.MakeMesh ||
Editor._meshEditeMode_MakeMesh != apEditor.MESH_EDIT_MODE_MAKEMESH.AutoGenerate ||
!Editor.MeshGenerator.IsScanned)
{
return(null);
}
apMesh mesh = Editor.Select.Mesh;
Vector2 imageHalfOffset = new Vector2(mesh.LinkedTextureData._width * 0.5f, mesh.LinkedTextureData._height * 0.5f);
List <apMeshGenMapper.ControlPoint> controlPoints = Editor.MeshGenerator.Mapper.ControlPoints;
List <apMeshGenMapper.ControlPoint> selectedControlPoints = Editor.MeshGenerator._selectedControlPoints;
//if (!Editor.Controller.IsMouseInGUI(mousePosGL))
//{
// return apGizmos.SelectResult.Main.SetMultiple<apMeshGenMapper.ControlPoint>(selectedControlPoints);
//}
if (areaSelectType == apGizmos.SELECT_TYPE.New)
{
selectedControlPoints.Clear();
}
apMeshGenMapper.ControlPoint curPoint = null;
Vector2 posW = Vector2.zero;
bool isAnyChanged = false;
for (int iPoint = 0; iPoint < controlPoints.Count; iPoint++)
{
curPoint = controlPoints[iPoint];
posW = curPoint._pos_Cur - (mesh._offsetPos + imageHalfOffset);
bool isSelectable = (mousePosW_Min.x < posW.x && posW.x < mousePosW_Max.x) &&
(mousePosW_Min.y < posW.y && posW.y < mousePosW_Max.y);
if (isSelectable)
{
switch (areaSelectType)
{
case apGizmos.SELECT_TYPE.New:
case apGizmos.SELECT_TYPE.Add:
if (!selectedControlPoints.Contains(curPoint))
{
selectedControlPoints.Add(curPoint);
}
break;
case apGizmos.SELECT_TYPE.Subtract:
if (selectedControlPoints.Contains(curPoint))
{
selectedControlPoints.Remove(curPoint);
}
break;
}
isAnyChanged = true;
}
}
if (isAnyChanged)
{
Editor.SetRepaint();
}
else
{
if (areaSelectType == apGizmos.SELECT_TYPE.New)
{
selectedControlPoints.Clear();
Editor.SetRepaint();
}
}
return(apGizmos.SelectResult.Main.SetMultiple <apMeshGenMapper.ControlPoint>(selectedControlPoints));
}
// Select
public apGizmos.SelectResult Select__MeshAutoGen(Vector2 mousePosGL, Vector2 mousePosW, int btnIndex, apGizmos.SELECT_TYPE selectType)
{
//Debug.Log("Select__MeshAutoGen : " + mousePosGL);
if (Editor.Select.SelectionType != apSelection.SELECTION_TYPE.Mesh ||
Editor.Select.Mesh == null ||
Editor.Select.Mesh.LinkedTextureData == null ||
Editor.Select.Mesh.LinkedTextureData._image == null ||
Editor._meshEditMode != apEditor.MESH_EDIT_MODE.MakeMesh ||
Editor._meshEditeMode_MakeMesh != apEditor.MESH_EDIT_MODE_MAKEMESH.AutoGenerate ||
!Editor.MeshGenerator.IsScanned)
{
//Debug.LogError("Select__MeshAutoGen : Failed");
return(null);
}
apMesh mesh = Editor.Select.Mesh;
Vector2 imageHalfOffset = new Vector2(mesh.LinkedTextureData._width * 0.5f, mesh.LinkedTextureData._height * 0.5f);
List <apMeshGenMapper.ControlPoint> controlPoints = Editor.MeshGenerator.Mapper.ControlPoints;
List <apMeshGenMapper.ControlPoint> selectedControlPoints = Editor.MeshGenerator._selectedControlPoints;
if (!Editor.Controller.IsMouseInGUI(mousePosGL))
{
//Debug.LogError("Select__MeshAutoGen : Mouse Over");
return(apGizmos.SelectResult.Main.SetMultiple <apMeshGenMapper.ControlPoint>(selectedControlPoints));
}
apMeshGenMapper.ControlPoint curPoint = null;
Vector2 posGL = Vector2.zero;
bool isAnySelect_ControlPoint = false;
for (int iPoint = 0; iPoint < controlPoints.Count; iPoint++)
{
curPoint = controlPoints[iPoint];
posGL = apGL.World2GL(curPoint._pos_Cur - (mesh._offsetPos + imageHalfOffset));
if (IsAutoGenMeshControlPointClickable(posGL, mousePosGL, 13))
{
if (selectType == apGizmos.SELECT_TYPE.New)
{
selectedControlPoints.Clear();
selectedControlPoints.Add(curPoint);
}
else if (selectType == apGizmos.SELECT_TYPE.Add)
{
if (!selectedControlPoints.Contains(curPoint))
{
selectedControlPoints.Add(curPoint);
}
}
else //if (selectType == apGizmos.SELECT_TYPE.Subtract)
{
if (selectedControlPoints.Contains(curPoint))
{
selectedControlPoints.Remove(curPoint);
}
}
isAnySelect_ControlPoint = true;
break;
}
}
if (isAnySelect_ControlPoint)
{
//Debug.Log(">>> Select__MeshAutoGen : Is Any Selected");
Editor.SetRepaint();
}
else
{
if (selectType == apGizmos.SELECT_TYPE.New)
{
selectedControlPoints.Clear();
//Debug.Log(">>> Select__MeshAutoGen : Unselected");
Editor.SetRepaint();
}
}
return(apGizmos.SelectResult.Main.SetMultiple <apMeshGenMapper.ControlPoint>(selectedControlPoints));
}
public apGizmos.SelectResult Select__Bone_MeshGroupMenu(Vector2 mousePosGL, Vector2 mousePosW, int btnIndex, apGizmos.SELECT_TYPE selectType)
{
//Default에서는 MeshGroup 선택 상태에서 제어한다.
//Default Matrix 편집 가능한 상태가 아니더라도 일단 선택은 가능하다.
//다만 MeshGroup이 없으면 실패
//Debug.Log("Select__Bone_MeshGroupMenu : MousePosW : " + mousePosW + " [ " + btnIndex + " ]");
if (Editor.Select.MeshGroup == null || Editor._boneGUIRenderMode != apEditor.BONE_RENDER_MODE.Render)
{
return(null);
}
bool isAnyClick = false;
apBone prevBone = Editor.Select.Bone;
apMeshGroup meshGroup = Editor.Select.MeshGroup;
//TODO : 마우스 클릭 체크
//Debug.Log("Select__Bone_MeshGroupMenu : MousePosW : " + mousePosW);
List <apBone> boneList = meshGroup._boneList_Root;
apBone bone = null;
apBone resultBone = null;
//수정 -> 렌더링 순서에 맞게 처리하자.
//for (int i = 0; i < boneList.Count; i++)
//{
// bone = boneList[i];
// if(IsBoneClick(bone, mousePosW))
// {
// //Debug.Log("Selected : " + bone._name);
// Editor.Select.SetBone(bone);
// isAnyClick = true;
// break;
// }
//}
for (int i = 0; i < boneList.Count; i++)
{
bone = CheckBoneClick(boneList[i], mousePosW, mousePosGL, Editor._boneGUIRenderMode, -1);
if (bone != null)
{
resultBone = bone;
}
}
if (resultBone != null)
{
Editor.Select.SetBone(resultBone);
isAnyClick = true;
}
if (!isAnyClick)
{
Editor.Select.SetBone(null);
}
if (prevBone != Editor.Select.Bone)
{
_isBoneSelect_MovePosReset = true;
Editor.RefreshControllerAndHierarchy();
}
if (Editor.Select.Bone != null)
{
_boneSelectPosW = Editor.Select.Bone._worldMatrix._pos;
//return 1;
return(apGizmos.SelectResult.Main.SetSingle(Editor.Select.Bone));
}
//return 0;
return(null);
}
public apGizmos.SelectResult Select__MeshEdit_Modify(Vector2 mousePosGL, Vector2 mousePosW, int btnIndex, apGizmos.SELECT_TYPE selectType)
{
if (Editor.Select.Mesh == null || Editor._meshEditMode != apEditor.MESH_EDIT_MODE.Modify)
{
return(null);
}
Vector2 meshOffset = Editor.Select.Mesh._offsetPos;
if (Editor.Controller.IsMouseInGUI(mousePosGL))
{
List <apVertex> vertices = Editor.Select.Mesh._vertexData;
List <apVertex> selectedVertices = new List <apVertex>();
apVertex vert = null;
Vector2 vPosW = Vector2.zero;
for (int i = 0; i < vertices.Count; i++)
{
vert = vertices[i];
vPosW = vert._pos - meshOffset;
Vector2 vertPosGL = apGL.World2GL(vPosW);
if (Editor.Controller.IsVertexClickable(vertPosGL, mousePosGL))
{
selectedVertices.Add(vert);
}
}
Editor.VertController.SelectVertices(selectedVertices, selectType);
Editor.SetRepaint();
}
if (Editor.VertController.Vertices.Count == 0)
{
return(null);
}
if (Editor.VertController.Vertices.Count == 1)
{
return(apGizmos.SelectResult.Main.SetSingle(Editor.VertController.Vertex));
}
else
{
return(apGizmos.SelectResult.Main.SetMultiple <apVertex>(Editor.VertController.Vertices));
}
}
//--------------------------------------------------------------------------
public apGizmos.SelectResult MultipleSelect__MeshEdit_Modify(Vector2 mousePosGL_Min, Vector2 mousePosGL_Max, Vector2 mousePosW_Min, Vector2 mousePosW_Max, apGizmos.SELECT_TYPE areaSelectType)
{
if (Editor.Select.Mesh == null || Editor._meshEditMode != apEditor.MESH_EDIT_MODE.Modify)
{
return(null);
}
Vector2 meshOffset = Editor.Select.Mesh._offsetPos;
List <apVertex> vertices = Editor.Select.Mesh._vertexData;
List <apVertex> selectedVertices = new List <apVertex>();
apVertex vert = null;
Vector2 vPosW = Vector2.zero;
for (int i = 0; i < vertices.Count; i++)
{
vert = vertices[i];
vPosW = vert._pos - meshOffset;
Vector2 vertPosGL = apGL.World2GL(vPosW);
bool isSelectable = (mousePosGL_Min.x < vertPosGL.x && vertPosGL.x < mousePosGL_Max.x) &&
(mousePosGL_Min.y < vertPosGL.y && vertPosGL.y < mousePosGL_Max.y);
if (isSelectable)
{
selectedVertices.Add(vert);
}
}
Editor.VertController.SelectVertices(selectedVertices, areaSelectType);
Editor.SetRepaint();
if (Editor.VertController.Vertices.Count == 0)
{
return(null);
}
if (Editor.VertController.Vertices.Count == 1)
{
return(apGizmos.SelectResult.Main.SetSingle(Editor.VertController.Vertex));
}
else
{
return(apGizmos.SelectResult.Main.SetMultiple <apVertex>(Editor.VertController.Vertices));
}
}
