//-----------------------------------------------------------------------------------------
// FFD Start
public bool StartFFDTransform__MeshTRS()
{
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(false);
}
apMesh mesh = Editor.Select.Mesh;
List <apVertex> vertices = mesh._vertexData;
List <apVertex> selectedVertices = Editor.VertController.Vertices;
if (vertices.Count == 0 || selectedVertices.Count == 0)
{
return(false);
}
List <object> srcObjectList = new List <object>();
List <Vector2> worldPosList = new List <Vector2>();
apVertex vert = null;
for (int i = 0; i < selectedVertices.Count; i++)
{
vert = selectedVertices[i];
srcObjectList.Add(vert);
worldPosList.Add(vert._pos - mesh._offsetPos);
}
Editor.Gizmos.RegistTransformedObjectList(srcObjectList, worldPosList); //<<True로 리턴할거면 이 함수를 호출해주자
return(true);
}
public void Move__MeshAutoGen(Vector2 curMouseGL, Vector2 curMousePosW, Vector2 deltaMoveW, int btnIndex, bool isFirstMove)
{
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;
}
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;
apMeshGenMapper.ControlPoint curPoint = null;
for (int i = 0; i < selectedControlPoints.Count; i++)
{
curPoint = selectedControlPoints[i];
curPoint._pos_Cur += deltaMoveW;
}
Editor.SetRepaint();
}
// 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));
}
// Init
//------------------------------------
public apRenderVertex(apRenderUnit parentRenderUnit, apMeshGroup parentMeshGroup, apMesh parentMesh, apVertex vertex)
{
_parentRenderUnit = parentRenderUnit;
_parentMeshGroup = parentMeshGroup;
_parentMesh = parentMesh;
_vertex = vertex;
//_isStaticRefreshed = false;
_isCalculated = false;
//_matrixStack.Clear();
//
_matrix_Static_Vert2Mesh = apMatrix3x3.identity;
_matrix_Cal_VertLocal = apMatrix3x3.identity;
_matrix_MeshTransform = apMatrix3x3.identity;
_matrix_Cal_VertWorld = apMatrix3x3.identity;
_matrix_ToWorld = apMatrix3x3.identity;
_pos_World = Vector2.zero;
//_cal_VertWorld = Vector2.zero;
//_matrixHashCode_Static_Vert2Mesh = -1;
//_matrixHashCode_Calculate = -1;
//_isMatrixChanged = true;
//_isUpdateMatrixForce = true;
_pos_Rigging = Vector2.zero;
_weight_Rigging = 0.0f;
_matrix_Rigging = apMatrix3x3.identity;
}
//---------------------------------------------------------------------------------------
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));
}
// 단축키 : 버텍스 전체 선택
private void OnHotKeyEvent__MeshTRS__Ctrl_A(object paramObject)
{
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;
}
apMesh mesh = Editor.Select.Mesh;
List <apVertex> vertices = mesh._vertexData;
if (vertices.Count == 0)
{
return;
}
//전체 선택
Editor.VertController.SelectVertices(vertices, apGizmos.SELECT_TYPE.Add);
Editor.SetRepaint();
Editor.Gizmos.SetSelectResultForce_Multiple <apVertex>(Editor.VertController.Vertices);
}
public override void ExecuteNext2Prev(apEditor editor)
{
try
{
switch (_actionType)
{
case apUndoManager.ACTION_TYPE.Add:
{
apMesh mesh = _keyObj as apMesh;
if (mesh == null)
{
return;
}
//Next에서 Prev로 Vertex List를 비교하여 [제거]해준다.
//Add의 반대는 Remove
Debug.Log("Undo : Add -> Remove");
}
break;
case apUndoManager.ACTION_TYPE.Remove:
break;
case apUndoManager.ACTION_TYPE.Changed:
break;
}
}
catch (Exception ex)
{
Debug.LogError("Undo Exception : " + ex);
}
}
// Functions
//----------------------------------------------
/// <summary>
/// 현재 변수값을 저장한다.
/// 오브젝트의 현재 값을 그대로 저장한다.
/// </summary>
public override void SavePrevStatus()
{
Debug.Log("Record Prev Status : Mesh Vertex : " + _actionType + " / " + _label);
// 액션 타입에 따라 keyObj와 저장된 데이터가 다르다.
switch (_actionType)
{
case apUndoManager.ACTION_TYPE.Add:
{
apMesh mesh = _keyObj as apMesh;
if (mesh == null)
{
return;
}
//현재의 VertexData를 기록한다.
_copiedVertices_Prev.Clear();
for (int i = 0; i < mesh._vertexData.Count; i++)
{
_copiedVertices_Prev.Add(new CopiedVertexData(mesh._vertexData[i]));
}
}
break;
case apUndoManager.ACTION_TYPE.Remove:
break;
case apUndoManager.ACTION_TYPE.Changed:
break;
}
}
// Scale
public void Scale__MeshTRS(Vector2 deltaScaleW, bool isFirstScale)
{
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;
}
apMesh mesh = Editor.Select.Mesh;
//Vector2 imageHalfOffset = new Vector2(mesh.LinkedTextureData._width * 0.5f, mesh.LinkedTextureData._height * 0.5f);
List <apVertex> vertices = mesh._vertexData;
List <apVertex> selectedVertices = Editor.VertController.Vertices;
if (vertices.Count == 0 || selectedVertices.Count == 0)
{
return;
}
if (isFirstScale)
{
apEditorUtil.SetRecord_Mesh(apUndoGroupData.ACTION.MeshEdit_EditVertex, Editor, mesh, mesh, true);
}
apVertex curVert = null;
Vector2 centerPos = Vector2.zero;
for (int i = 0; i < selectedVertices.Count; i++)
{
curVert = selectedVertices[i];
centerPos += curVert._pos - mesh._offsetPos;
}
centerPos /= selectedVertices.Count;
Vector2 scale = new Vector2(1.0f + deltaScaleW.x, 1.0f + deltaScaleW.y);
apMatrix3x3 matrix_Rotate = apMatrix3x3.TRS(centerPos, 0, Vector2.one)
* apMatrix3x3.TRS(Vector2.zero, 0.0f, scale)
* apMatrix3x3.TRS(-centerPos, 0, Vector2.one);
Vector2 posW = Vector2.zero;
for (int i = 0; i < selectedVertices.Count; i++)
{
curVert = selectedVertices[i];
posW = curVert._pos - (mesh._offsetPos);
posW = matrix_Rotate.MultiplyPoint(posW);
curVert._pos = posW + (mesh._offsetPos);
}
for (int i = 0; i < selectedVertices.Count; i++)
{
mesh.RefreshVertexAutoUV(selectedVertices[i]);
}
Editor.SetRepaint();
}
/// <summary>
/// 변경된(갱신, 추가, 삭제)된 valueObj를 반영하자
/// </summary>
public override void Refresh()
{
switch (_actionType)
{
case apUndoManager.ACTION_TYPE.Add:
{
apMesh mesh = _keyObj as apMesh;
if (mesh == null)
{
return;
}
//변경된 VertexData를 기록한다.
_copiedVertices_Next.Clear();
for (int i = 0; i < mesh._vertexData.Count; i++)
{
_copiedVertices_Next.Add(new CopiedVertexData(mesh._vertexData[i]));
}
}
break;
case apUndoManager.ACTION_TYPE.Remove:
break;
case apUndoManager.ACTION_TYPE.Changed:
break;
}
}
// Show Window
//------------------------------------------------------------------
public static object ShowDialog(apEditor editor, apMesh targetMesh, FUNC_SELECT_TEXTUREDATA_RESULT funcResult)
{
CloseDialog();
if (editor == null || editor._portrait == null || editor._portrait._controller == null)
{
return(null);
}
EditorWindow curWindow = EditorWindow.GetWindow(typeof(apDialog_SelectTextureData), true, "Select Texture", true);
apDialog_SelectTextureData curTool = curWindow as apDialog_SelectTextureData;
object loadKey = new object();
if (curTool != null && curTool != s_window)
{
int width = 500;
int height = 600;
s_window = curTool;
s_window.position = new Rect((editor.position.xMin + editor.position.xMax) / 2 - (width / 2),
(editor.position.yMin + editor.position.yMax) / 2 - (height / 2),
width, height);
s_window.Init(editor, targetMesh, loadKey, funcResult);
return(loadKey);
}
else
{
return(null);
}
}
public void Link(apModifiedMesh modifiedMesh, apMesh mesh, apVertex vertex)
{
_modifiedMesh = modifiedMesh;
_mesh = mesh;
_vertex = vertex;
if (_vertex != null)
{
_vertIndex = _vertex._index;
}
else
{
_vertIndex = -1;
}
_renderVertex = null;
if (modifiedMesh._renderUnit != null && _vertex != null)
{
_renderVertex = modifiedMesh._renderUnit._renderVerts.Find(delegate(apRenderVertex a)
{
return(a._vertex == _vertex);
});
}
if (_physicParam == null)
{
_physicParam = new apPhysicsVertParam();
}
_physicParam.Link(modifiedMesh, this);
RefreshModMeshAndWeights(_modifiedMesh);
}
public void Clear()
{
//if (_isCleared)
//{
// return;
//}
_cloneVerts.Clear();
_crossVerts.Clear();
_cloneEdges.Clear();
_mesh = null;
_nSelectedVert = 0;
_nTotalVert = 0;
_nTotalEdge = 0;
_offset = 0.0f;
_isAddOnRuler = false;
_isMirrorX = true;
_mirrorPos = 0.0f;
_srcEdges.Clear();
_srcVerts.Clear();
_vert2Verts.Clear();
_vert2Clone.Clear();
_clone2Vert.Clear();
CloneVertex.ClearIndex();
//_isCleared = true;
}
public apVertex FindNearestVertex(Vector2 pos, apMesh mesh, float offset, apVertex exceptVert = null)
{
apVertex curVert = null;
apVertex minVert = null;
float curDist = 0.0f;
float minDist = 0.0f;
for (int iVert = 0; iVert < mesh._vertexData.Count; iVert++)
{
curVert = mesh._vertexData[iVert];
if (exceptVert == curVert)
{
continue;
}
if (Mathf.Abs(curVert._pos.x - pos.x) < offset &&
Mathf.Abs(curVert._pos.y - pos.y) < offset)
{
curDist = Mathf.Abs(curVert._pos.x - pos.x) + Mathf.Abs(curVert._pos.y - pos.y); //MHT Dist
//선택할 수 있다.
if (minVert == null || curDist < minDist)
{
minVert = curVert;
minDist = curDist;
}
}
}
return(minVert);
}
public apGizmos.TransformParam PivotReturn__MeshAutoGen()
{
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("Pivot Failed");
return(null);
}
List <apMeshGenMapper.ControlPoint> selectedControlPoints = Editor.MeshGenerator._selectedControlPoints;
if (selectedControlPoints.Count == 0)
{
//Debug.LogError("Pivot Failed : Count 0");
return(null);
}
apMesh mesh = Editor.Select.Mesh;
Vector2 imageHalfOffset = new Vector2(mesh.LinkedTextureData._width * 0.5f, mesh.LinkedTextureData._height * 0.5f);
apMeshGenMapper.ControlPoint curPoint = null;
Vector2 posW = Vector2.zero;
if (selectedControlPoints.Count == 1)
{
curPoint = selectedControlPoints[0];
posW = curPoint._pos_Cur - (mesh._offsetPos + imageHalfOffset);
return(apGizmos.TransformParam.Make(posW, 0.0f, Vector2.one,
0, Color.black,
true,
apMatrix3x3.identity,
false,
apGizmos.TRANSFORM_UI.TRS_NoDepth,
Vector2.zero, 0.0f, Vector2.one));
}
else
{
Vector2 centerPos = Vector2.zero;
for (int i = 0; i < selectedControlPoints.Count; i++)
{
curPoint = selectedControlPoints[i];
posW = curPoint._pos_Cur - (mesh._offsetPos + imageHalfOffset);
centerPos += posW;
}
centerPos /= selectedControlPoints.Count;
//Debug.Log("Pivot : Multiple " + centerPos + " (" + selectedControlPoints.Count + ")");
return(apGizmos.TransformParam.Make(centerPos, 0.0f, Vector2.one,
0, Color.black, true,
apMatrix3x3.identity, true, apGizmos.TRANSFORM_UI.TRS_NoDepth,
Vector2.zero, 0.0f, Vector2.one));
}
}
private apMeshEdge GetMeshNearestEdge(Vector2 posGL, apMesh mesh, float offsetGL)
{
apMeshEdge curEdge = null;
//Vector2 posW = apGL.GL2World(posGL) + mesh._offsetPos;
Vector2 vPos1GL = Vector2.zero;
Vector2 vPos2GL = Vector2.zero;
float minX = 0.0f;
float maxX = 0.0f;
float minY = 0.0f;
float maxY = 0.0f;
float curDist = 0.0f;
float minDist = 0.0f;
apMeshEdge minEdge = null;
for (int i = 0; i < mesh._edges.Count; i++)
{
curEdge = mesh._edges[i];
if (curEdge._vert1 == null || curEdge._vert2 == null)
{
continue;
}
//기본 사각 범위안에 있는지 확인
vPos1GL = apGL.World2GL(curEdge._vert1._pos - mesh._offsetPos);
vPos2GL = apGL.World2GL(curEdge._vert2._pos - mesh._offsetPos);
minX = Mathf.Min(vPos1GL.x, vPos2GL.x);
maxX = Mathf.Max(vPos1GL.x, vPos2GL.x);
minY = Mathf.Min(vPos1GL.y, vPos2GL.y);
maxY = Mathf.Max(vPos1GL.y, vPos2GL.y);
if (posGL.x < minX || maxX < posGL.x ||
posGL.y < minY || maxY < posGL.y)
{
continue;
}
curDist = apEditorUtil.DistanceFromLine(
vPos1GL,
vPos2GL,
posGL);
if (curDist < offsetGL)
{
if (minEdge == null || curDist < minDist)
{
minDist = curDist;
minEdge = curEdge;
}
}
}
return(minEdge);
}
//------------------------------------------------------------------------------------
// Transform Changed (Pos)
public void TransformChanged_Position__MeshTRS(Vector2 pos)
{
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;
}
if (Editor.Gizmos.IsFFDMode)
{
//FFD 모드에서는 처리가 안된다.
return;
}
apMesh mesh = Editor.Select.Mesh;
List <apVertex> vertices = mesh._vertexData;
List <apVertex> selectedVertices = Editor.VertController.Vertices;
if (vertices.Count == 0 || selectedVertices.Count == 0)
{
return;
}
apEditorUtil.SetRecord_Mesh(apUndoGroupData.ACTION.MeshEdit_EditVertex, Editor, mesh, mesh, true);
apVertex curVert = null;
Vector2 centerPos = Vector2.zero;
for (int i = 0; i < selectedVertices.Count; i++)
{
curVert = selectedVertices[i];
centerPos += curVert._pos - mesh._offsetPos;
}
centerPos /= selectedVertices.Count;
pos -= mesh._offsetPos;
Vector2 deltaMoveW = pos - centerPos;
//Debug.Log("Input : " + pos + " / Cur Center : " + centerPos + " >> Delta : " + deltaMoveW);
for (int i = 0; i < selectedVertices.Count; i++)
{
curVert = selectedVertices[i];
curVert._pos += deltaMoveW;
}
for (int i = 0; i < selectedVertices.Count; i++)
{
mesh.RefreshVertexAutoUV(selectedVertices[i]);
}
Editor.SetRepaint();
}
// Init
//------------------------------------------------------------------
public void Init(apEditor editor, apMesh targetMesh, object loadKey, FUNC_SELECT_TEXTUREDATA_RESULT funcResult)
{
_editor = editor;
_loadKey = loadKey;
_targetMesh = targetMesh;
_funcResult = funcResult;
_textureData = _editor._portrait._textureData;
}
public void Init()
{
_mesh = null;
_curVertex = null;
_curPolygon = null;
_nextVertex = null;
_isTmpEdgeWire = false;
_tmpEdgeWire_MousePos = Vector2.zero;
}
// Init
//--------------------------------------
public apCalculatedMesh(apMesh mesh)
{
_mesh = mesh;
_localMatrixPerVertex.Clear();
for (int i = 0; i < _mesh._vertexData.Count; i++)
{
_localMatrixPerVertex.Add(_mesh._vertexData[i], apMatrix3x3.identity);
_worldMatrixPerVertex.Add(_mesh._vertexData[i], apMatrix3x3.identity);
}
}
//-----------------------------------------------------------------------------------------
// Pivot
public apGizmos.TransformParam PivotReturn__MeshTRS()
{
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);
}
if (Editor.VertController.Vertex == null)
{
return(null);
}
apMesh mesh = Editor.Select.Mesh;
//Vector2 imageHalfOffset = new Vector2(mesh.LinkedTextureData._width * 0.5f, mesh.LinkedTextureData._height * 0.5f);
if (Editor.VertController.Vertices.Count == 1)
{
//1개 선택되었다.
apVertex vert = Editor.VertController.Vertices[0];
return(apGizmos.TransformParam.Make(vert._pos - (mesh._offsetPos),
0.0f, Vector2.one, 0, Color.black,
true,
apMatrix3x3.identity,
false,
apGizmos.TRANSFORM_UI.Position2D, vert._pos, 0.0f, Vector2.one));
}
else if (Editor.VertController.Vertices.Count > 1)
{
apVertex vert = null;
Vector2 centerPos = Vector2.zero;
int nVert = Editor.VertController.Vertices.Count;
for (int i = 0; i < Editor.VertController.Vertices.Count; i++)
{
vert = Editor.VertController.Vertices[i];
centerPos += vert._pos;
}
centerPos /= nVert;
return(apGizmos.TransformParam.Make(centerPos - mesh._offsetPos,
0.0f, Vector2.one, 0, Color.black,
true,
apMatrix3x3.identity,
true,
apGizmos.TRANSFORM_UI.Position2D | apGizmos.TRANSFORM_UI.Vertex_Transform, centerPos, 0.0f, Vector2.one));
}
return(null);
}
//----------------------------------------------------------------
public bool IsOnAxisByMesh(Vector2 pos, apMesh mesh)
{
if (mesh._isMirrorX)
{
return(Mathf.Abs(pos.x - mesh._mirrorAxis.x) < _editor._meshTRSOption_MirrorOffset);
}
else
{
return(Mathf.Abs(pos.y - mesh._mirrorAxis.y) < _editor._meshTRSOption_MirrorOffset);
}
}
public void Scale__MeshAutoGen(Vector2 deltaScaleW, bool isFirstScale)
{
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;
}
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 (selectedControlPoints.Count <= 1)
{
return;
}
apMeshGenMapper.ControlPoint curPoint = null;
Vector2 posW = Vector2.zero;
Vector2 centerPos = Vector2.zero;
for (int i = 0; i < selectedControlPoints.Count; i++)
{
curPoint = selectedControlPoints[i];
posW = curPoint._pos_Cur - (mesh._offsetPos + imageHalfOffset);
centerPos += posW;
}
centerPos /= selectedControlPoints.Count;
Vector2 scale = new Vector2(1.0f + deltaScaleW.x, 1.0f + deltaScaleW.y);
apMatrix3x3 matrix_Scale = apMatrix3x3.TRS(centerPos, 0, Vector2.one)
* apMatrix3x3.TRS(Vector2.zero, 0, scale)
* apMatrix3x3.TRS(-centerPos, 0, Vector2.one);
for (int i = 0; i < selectedControlPoints.Count; i++)
{
curPoint = selectedControlPoints[i];
posW = curPoint._pos_Cur - (mesh._offsetPos + imageHalfOffset);
posW = matrix_Scale.MultiplyPoint(posW);
curPoint._pos_Cur = posW + (mesh._offsetPos + imageHalfOffset);
}
Editor.SetRepaint();
}
public void DrawMeshEdgeOnly(apMesh mesh, apMatrix3x3 matrix)
{
try
{
//0. 메시, 텍스쳐가 없을 때
//if (mesh == null || mesh._textureData == null || mesh._textureData._image == null)//이전 코드
if (mesh == null || mesh.LinkedTextureData == null || mesh.LinkedTextureData._image == null) //변경 코드
{
return;
}
//1. 모든 메시를 보여줄때 (또는 클리핑된 메시가 없을 때) =>
Color meshEdgeColor = new Color(1.0f, 0.5f, 0.0f, 0.9f);
Color meshHiddenEdgeColor = new Color(1.0f, 1.0f, 0.0f, 0.7f);
matrix *= mesh.Matrix_VertToLocal;
Vector2 pos0 = Vector2.zero, pos1 = Vector2.zero;
if (mesh._edges.Count > 0)
{
_matBatch.SetPass_Color();
_matBatch.SetClippingSize(_glScreenClippingSize);
GL.Begin(GL.LINES);
for (int i = 0; i < mesh._edges.Count; i++)
{
pos0 = matrix.MultiplyPoint(mesh._edges[i]._vert1._pos);
pos1 = matrix.MultiplyPoint(mesh._edges[i]._vert2._pos);
DrawLine(pos0, pos1, meshEdgeColor, false);
}
for (int iPoly = 0; iPoly < mesh._polygons.Count; iPoly++)
{
for (int iHE = 0; iHE < mesh._polygons[iPoly]._hidddenEdges.Count; iHE++)
{
apMeshEdge hiddenEdge = mesh._polygons[iPoly]._hidddenEdges[iHE];
pos0 = matrix.MultiplyPoint(hiddenEdge._vert1._pos);
pos1 = matrix.MultiplyPoint(hiddenEdge._vert2._pos);
DrawLine(pos0, pos1, meshHiddenEdgeColor, false);
}
}
GL.End();
}
}
catch (Exception ex)
{
Debug.LogException(ex);
}
}
public Vector2 GetMirrorPosByMesh(Vector2 pos, apMesh mesh)
{
if (mesh._isMirrorX)
{
pos.x = mesh._mirrorAxis.x - (pos.x - mesh._mirrorAxis.x);
}
else
{
pos.y = mesh._mirrorAxis.y - (pos.y - mesh._mirrorAxis.y);
}
return(pos);
}
public Vector2 GetAxisPosToSnap(Vector2 pos, apMesh mesh)
{
if (mesh._isMirrorX)
{
pos.x = mesh._mirrorAxis.x;
}
else
{
pos.y = mesh._mirrorAxis.y;
}
return(pos);
}
private void OnTextureDataSelected(bool isSuccess, apMesh targetMesh, object loadKey, apTextureData resultTextureData)
{
if (!isSuccess)
{
_loadKey_TextureSelect = null;
return;
}
if (_loadKey_TextureSelect != loadKey)
{
_loadKey_TextureSelect = null;
return;
}
_loadKey_TextureSelect = null;
apEditorUtil.SetRecord_Modifier(apUndoGroupData.ACTION.Modifier_SettingChanged, _editor, _modifier, _modMesh._extraValue, false);
//일단 초기화
_modMesh._extraValue._textureDataID = -1;
_modMesh._extraValue._linkedTextureData = null;
_dstTexureData = null;
if (_modMesh != null && _modMesh._isMeshTransform && _modMesh._transform_Mesh != null)
{
if (resultTextureData != null)
{
_modMesh._extraValue._textureDataID = resultTextureData._uniqueID;
}
}
if (_modMesh._extraValue._textureDataID >= 0)
{
_dstTexureData = _portrait.GetTexture(_modMesh._extraValue._textureDataID);
_modMesh._extraValue._linkedTextureData = _dstTexureData;
if (_dstTexureData == null)
{
_modMesh._extraValue._textureDataID = -1;
}
}
RefreshImagePreview();
Repaint();
_meshGroup.RefreshModifierLink(); //<<Modifier Link를 다시 해야한다.
_editor.SetRepaint();
}
public void Clear()
{
_action = ACTION.None;
_saveTarget = SAVE_TARGET.None;
_portrait = null;
_mesh = null;
_meshGroup = null;
_modifier = null;
_keyObject = null;
_isCallContinuous = false; //여러 항목을 동시에 처리하는 Batch 액션 중인가
_lastUndoTime = DateTime.Now;
}
public void RemoveMirrorVertex(apVertex removedVertex, apMesh mesh, bool isShift)
{
ClearMovedVertex();
if (removedVertex == null)
{
return;
}
Vector2 mirrorPos = GetMirrorPosByMesh(removedVertex._pos, mesh);
apVertex removableMirrorVert = FindNearestVertex(mirrorPos, mesh, 2.0f, removedVertex); //<<아주 좁은 범위
if (removableMirrorVert != null)
{
mesh.RemoveVertex(removableMirrorVert, isShift);
}
}
// Functions
//-----------------------------------------------
public void SetMesh(apMesh mesh)
{
if (_mesh != mesh)
{
_mesh = mesh;
_curVertex = null;
_curPolygon = null;
UnselectNextVertex();
_isTmpEdgeWire = false;
_isTmpEdgeWireCrossEdge = false;
_isTmpEdgeWireCrossEdge_Multiple = false;
_tmpEdgeWire_MousePos = Vector2.zero;
_tmpEdgeWireMultipleCrossPoints.Clear();
}
}
