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);
}
}
// Calculate
//---------------------------------------------------------
public void Calculate()
{
//역순으로 World Matrix를 계산하자
_matrix_ToWorld = _matrix_Cal_VertWorld
//* _matrix_TF_Cal_Parent
//* _matrix_Cal_Mesh
//* _matrix_TF_Mesh
* _matrix_MeshTransform
* _matrix_Cal_VertLocal
* _matrix_Static_Vert2Mesh;
//_matrix_ToVert = _matrix_ToWorld.inverse;
//이전 식
//_vertPos3_World = _matrix_ToWorld.MultiplyPoint3x4(_pos3_Local);
//리깅 포함한 식으로 변경
//_weight_Rigging = Mathf.Clamp(_weight_Rigging, 0.0f, 0.5f);
_vertPos_World = _matrix_ToWorld.MultiplyPoint(_pos_Local * (1.0f - _weight_Rigging) + _pos_Rigging * _weight_Rigging);
//_vertPos_World.x = _vertPos3_World.x;
//_vertPos_World.y = _vertPos3_World.y;
Vector2 posLocalUpdated = (_matrix_Static_Vert2Mesh_Inverse).MultiplyPoint(_vertPos_World);
_vertPos3_LocalUpdated.x = posLocalUpdated.x;
_vertPos3_LocalUpdated.y = posLocalUpdated.y;
_vertPos3_LocalUpdated.z = 0;
_isCalculated = true;
}
// 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>
/// Modifier가 적용되지 않은 World Position을 직접 계산한다.
/// _pos_World_NoMod로 저장된다.
/// </summary>
/// <param name="matrix_Vert2Local"></param>
/// <param name="matrix_meshTransformNoMod"></param>
public void CalculateNotModified(apMatrix3x3 matrix_Vert2Local, apMatrix3x3 matrix_meshTransformNoMod)
{
apMatrix3x3 matrix_ToWorld = matrix_meshTransformNoMod * matrix_Vert2Local;
Vector2 posW = matrix_ToWorld.MultiplyPoint(_vertex._pos);
_pos_World_NoMod = posW;
//_pos_World_NoMod.x = posW.x;
//_pos_World_NoMod.y = posW.y;
}
public void Calculate(float tDelta) //<<tDelta가 추가되었다.
{
#region [미사용 코드] 해시코드 체크 부분을 없앴다. 퍼포먼스 잘나온다 =3=b
//if (_isMatrixChanged)
//{
// //테스트
// //상대값이 아니라 절대값을 World로 사용하자
// //_matrix_ToWorld = _matrix_MeshTransform * _matrix_Cal_VertLocal * _matrix_Static_Vert2Mesh;
// //_pos_World3 = _matrix_ToWorld.MultiplyPoint3x4(Vector3.zero);
// //_pos_World3 = _matrix_ToWorld.MultiplyPoint3x4(_vertex._pos);
// //역순으로 World Matrix를 계산하자
// _matrix_ToWorld = _matrix_Cal_VertWorld
// //* _matrix_TF_Cal_Parent
// //* _matrix_Cal_Mesh
// //* _matrix_TF_Mesh
// * _matrix_MeshTransform
// * _matrix_Cal_VertLocal
// * _matrix_Static_Vert2Mesh;
// //_matrix_ToVert = _matrix_ToWorld.inverse;
//}
#endregion
//역순으로 World Matrix를 계산하자
//1. 기존 식
//(Vert -> Rigging : ITP) -> (V2Mesh -> Local Morph -> Mesh TF -> World Morph : WorldMTX) 방식
//_matrix_ToWorld = _matrix_Cal_VertWorld
// * _matrix_MeshTransform
// * _matrix_Cal_VertLocal
// * _matrix_Static_Vert2Mesh;
//_pos_World = _matrix_ToWorld.MultiplyPoint(_vertex._pos * (1.0f - _weight_Rigging) + _pos_Rigging * _weight_Rigging);
//2. 변경된 식
//Vert -> (V2Mesh -> Local Morph -> RiggingMTX -> MeshTF -> World Morph : WorldMTX) 방식
_matrix_ToWorld = _matrix_Cal_VertWorld
* _matrix_MeshTransform
* _matrix_Rigging //<<이게 추가
* _matrix_Cal_VertLocal
* _matrix_Static_Vert2Mesh;
_pos_World = _matrix_ToWorld.MultiplyPoint(_vertex._pos);
//World -> Local
_pos_LocalOnMesh = (_matrix_MeshTransform.inverse).MultiplyPoint(_pos_World);
_isCalculated = true;
}
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 Calculate(float tDelta) //<<tDelta가 추가되었다.
{
#region [미사용 코드] 해시코드 체크 부분을 없앴다. 퍼포먼스 잘나온다 =3=b
//if (_isMatrixChanged)
//{
// //테스트
// //상대값이 아니라 절대값을 World로 사용하자
// //_matrix_ToWorld = _matrix_MeshTransform * _matrix_Cal_VertLocal * _matrix_Static_Vert2Mesh;
// //_pos_World3 = _matrix_ToWorld.MultiplyPoint3x4(Vector3.zero);
// //_pos_World3 = _matrix_ToWorld.MultiplyPoint3x4(_vertex._pos);
// //역순으로 World Matrix를 계산하자
// _matrix_ToWorld = _matrix_Cal_VertWorld
// //* _matrix_TF_Cal_Parent
// //* _matrix_Cal_Mesh
// //* _matrix_TF_Mesh
// * _matrix_MeshTransform
// * _matrix_Cal_VertLocal
// * _matrix_Static_Vert2Mesh;
// //_matrix_ToVert = _matrix_ToWorld.inverse;
//}
#endregion
//역순으로 World Matrix를 계산하자
_matrix_ToWorld = _matrix_Cal_VertWorld
* _matrix_MeshTransform
* _matrix_Cal_VertLocal
* _matrix_Static_Vert2Mesh;
//_pos_World3 = _matrix_ToWorld.MultiplyPoint3x4(_vertex._pos * (1.0f - _weight_Rigging) + _pos_Rigging * _weight_Rigging);
//_pos_World.x = _pos_World3.x;
//_pos_World.y = _pos_World3.y;
_pos_World = _matrix_ToWorld.MultiplyPoint(_vertex._pos * (1.0f - _weight_Rigging) + _pos_Rigging * _weight_Rigging);
_pos_LocalOnMesh = (_matrix_MeshTransform.inverse).MultiplyPoint(_pos_World);
//_pos_LocalOnMesh.z = 0;
_isCalculated = true;
//_isUpdateMatrixForce = false;
//_isMatrixChanged = false;
}
public static bool IsMouseInMesh(Vector2 mousePos, apMesh targetMesh, apMatrix3x3 matrixWorldToMeshLocal)
{
Vector2 mousePosW = apGL.GL2World(mousePos);
Vector2 mousePosL = matrixWorldToMeshLocal.MultiplyPoint(mousePosW);
//Vector2 mousePosL = mousePosW + targetMesh._offsetPos;//<<이걸 추가해줘야 Local Pos가 된다.
List <apMeshPolygon> polygons = targetMesh._polygons;
for (int iPoly = 0; iPoly < polygons.Count; iPoly++)
{
List <apMeshTri> tris = polygons[iPoly]._tris;
for (int iTri = 0; iTri < tris.Count; iTri++)
{
apMeshTri tri = tris[iTri];
if (tri.IsPointInTri(mousePosL))
{
return(true);
}
}
}
return(false);
}
// Calculate
//---------------------------------------------------------
public void Calculate()
{
//역순으로 World Matrix를 계산하자
#region [미사용 코드 : 리깅을 Vertex Pos로 받던 방식]
//기본 코드
//_matrix_ToWorld = _matrix_Cal_VertWorld
// //* _matrix_TF_Cal_Parent
// //* _matrix_Cal_Mesh
// //* _matrix_TF_Mesh
// * _matrix_MeshTransform
// * _matrix_Cal_VertLocal
// * _matrix_Static_Vert2Mesh;
//마개조 코드/.... 예전 코드
//_matrix_ToWorld._m00 = _matrix_MeshTransform._m00;
//_matrix_ToWorld._m01 = _matrix_MeshTransform._m01;
//_matrix_ToWorld._m02 = _matrix_MeshTransform._m00 * (_matrix_Cal_VertLocal._m02 + _matrix_Static_Vert2Mesh._m02)
// + _matrix_MeshTransform._m01 * (_matrix_Cal_VertLocal._m12 + _matrix_Static_Vert2Mesh._m12)
// + _matrix_MeshTransform._m02
// + _matrix_Cal_VertWorld._m02;
//_matrix_ToWorld._m10 = _matrix_MeshTransform._m10;
//_matrix_ToWorld._m11 = _matrix_MeshTransform._m11;
//_matrix_ToWorld._m12 = _matrix_MeshTransform._m10 * (_matrix_Cal_VertLocal._m02 + _matrix_Static_Vert2Mesh._m02)
// + _matrix_MeshTransform._m11 * (_matrix_Cal_VertLocal._m12 + _matrix_Static_Vert2Mesh._m12)
// + _matrix_MeshTransform._m12
// + _matrix_Cal_VertWorld._m12;
//_matrix_ToWorld._m20 = 0;
//_matrix_ToWorld._m21 = 0;
//_matrix_ToWorld._m22 = 1;
#endregion
//Rigging이 포함된 코드
//_matrix_ToWorld = _matrix_Cal_VertWorld // T
// * _matrix_MeshTransform // TRS
// * _matrix_Rigging//<<추가 // TRS
// * _matrix_Cal_VertLocal // T
// * _matrix_Static_Vert2Mesh; // T
//단축식을 만들자
//1. MR 00, 01, 10, 11
_matrix_ToWorld._m00 = (_matrix_MeshTransform._m00 * _matrix_Rigging._m00) + (_matrix_MeshTransform._m01 * _matrix_Rigging._m10);
_matrix_ToWorld._m01 = (_matrix_MeshTransform._m00 * _matrix_Rigging._m01) + (_matrix_MeshTransform._m01 * _matrix_Rigging._m11);
_matrix_ToWorld._m10 = (_matrix_MeshTransform._m10 * _matrix_Rigging._m00) + (_matrix_MeshTransform._m11 * _matrix_Rigging._m10);
_matrix_ToWorld._m11 = (_matrix_MeshTransform._m10 * _matrix_Rigging._m01) + (_matrix_MeshTransform._m11 * _matrix_Rigging._m11);
//2.
//x=02, y=12
// X : MR00(Lx+Px) + MR01(Ly+Py) + M00Rx + M01Ry + Wx + Mx
// Y : MR10(Lx+Px) + MR11(Ly+Py) + M10Rx + M11Ry + Wy + My
_matrix_ToWorld._m02 = _matrix_ToWorld._m00 * (_matrix_Cal_VertLocal._m02 + _matrix_Static_Vert2Mesh._m02)
+ _matrix_ToWorld._m01 * (_matrix_Cal_VertLocal._m12 + _matrix_Static_Vert2Mesh._m12)
+ _matrix_MeshTransform._m00 * _matrix_Rigging._m02
+ _matrix_MeshTransform._m01 * _matrix_Rigging._m12
+ _matrix_Cal_VertWorld._m02
+ _matrix_MeshTransform._m02;
_matrix_ToWorld._m12 = _matrix_ToWorld._m10 * (_matrix_Cal_VertLocal._m02 + _matrix_Static_Vert2Mesh._m02)
+ _matrix_ToWorld._m11 * (_matrix_Cal_VertLocal._m12 + _matrix_Static_Vert2Mesh._m12)
+ _matrix_MeshTransform._m10 * _matrix_Rigging._m02
+ _matrix_MeshTransform._m11 * _matrix_Rigging._m12
+ _matrix_Cal_VertWorld._m12
+ _matrix_MeshTransform._m12;
_matrix_ToWorld._m20 = 0;
_matrix_ToWorld._m21 = 0;
_matrix_ToWorld._m22 = 1;
//_matrix_ToVert = _matrix_ToWorld.inverse;
//이전 식
//_vertPos3_World = _matrix_ToWorld.MultiplyPoint3x4(_pos3_Local);
//리깅 포함한 식으로 변경
//리깅 변경 이전 코드
//_vertPos_World = _matrix_ToWorld.MultiplyPoint(_pos_Local * (1.0f - _weight_Rigging) + _pos_Rigging * _weight_Rigging);
//리깅 변경 후 코드
_vertPos_World = _matrix_ToWorld.MultiplyPoint(_pos_Local);
//_vertPos_World.x = _vertPos3_World.x;
//_vertPos_World.y = _vertPos3_World.y;
if (_isMeshOrthoCorrection)
{
//추가 : Pers -> Ortho Correction을 적용한다.
_cal_posLocalUpdated2 = (_matrix_MeshOrthoCorrection * _matrix_Static_Vert2Mesh_Inverse).MultiplyPoint(_vertPos_World);
}
else
{
_cal_posLocalUpdated2 = (_matrix_Static_Vert2Mesh_Inverse).MultiplyPoint(_vertPos_World);
}
_vertPos3_LocalUpdated.x = _cal_posLocalUpdated2.x;
_vertPos3_LocalUpdated.y = _cal_posLocalUpdated2.y;
_vertPos3_LocalUpdated.z = _zDepth * 0.01f;
_isCalculated = true;
}
public void DrawTexture(Texture2D image, apMatrix3x3 matrix, float width, float height, Color color2X, float depth, bool isDrawToneOutline = false)
{
if (_matBatch.IsNotReady())
{
return;
}
float width_Half = width * 0.5f;
float height_Half = height * 0.5f;
//Zero 대신 mesh Pivot 위치로 삼자
Vector2 pos_0 = World2GL(matrix.MultiplyPoint(new Vector2(-width_Half, +height_Half)));
Vector2 pos_1 = World2GL(matrix.MultiplyPoint(new Vector2(+width_Half, +height_Half)));
Vector2 pos_2 = World2GL(matrix.MultiplyPoint(new Vector2(+width_Half, -height_Half)));
Vector2 pos_3 = World2GL(matrix.MultiplyPoint(new Vector2(-width_Half, -height_Half)));
//CW
// -------->
// | 0(--) 1
// |
// | 3 2 (++)
float u_left = 0.0f;
float u_right = 1.0f;
float v_top = 0.0f;
float v_bottom = 1.0f;
Vector3 uv_0 = new Vector3(u_left, v_bottom, 0.0f);
Vector3 uv_1 = new Vector3(u_right, v_bottom, 0.0f);
Vector3 uv_2 = new Vector3(u_right, v_top, 0.0f);
Vector3 uv_3 = new Vector3(u_left, v_top, 0.0f);
//CW
// -------->
// | 0 1
// |
// | 3 2
if (!isDrawToneOutline)
{
_matBatch.SetPass_Texture_Normal(color2X, image, apPortrait.SHADER_TYPE.AlphaBlend);
}
else
{
_matBatch.SetPass_ToneColor_Custom(color2X, image, 0.0f, 0.0f);
}
_matBatch.SetClippingSize(_glScreenClippingSize);
GL.Begin(GL.TRIANGLES);
GL.TexCoord(uv_0); GL.Vertex(new Vector3(pos_0.x, pos_0.y, depth)); // 0
GL.TexCoord(uv_1); GL.Vertex(new Vector3(pos_1.x, pos_1.y, depth)); // 1
GL.TexCoord(uv_2); GL.Vertex(new Vector3(pos_2.x, pos_2.y, depth)); // 2
GL.TexCoord(uv_2); GL.Vertex(new Vector3(pos_2.x, pos_2.y, depth)); // 2
GL.TexCoord(uv_3); GL.Vertex(new Vector3(pos_3.x, pos_3.y, depth)); // 3
GL.TexCoord(uv_0); GL.Vertex(new Vector3(pos_0.x, pos_0.y, depth)); // 0
GL.End();
}
public void DrawMesh(apMesh mesh, apMatrix3x3 matrix, Color color2X, bool isShowAllTexture, bool isDrawOutline, bool isDrawEdge, bool isDrawToneOutline = false)
{
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 textureColor = new Color(0.5f, 0.5f, 0.5f, 1.0f);
//Color shadedTextureColor = new Color(0.3f, 0.3f, 0.3f, 1.0f);
Color atlasBorderColor = new Color(0.0f, 1.0f, 1.0f, 0.5f);
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;
if (isShowAllTexture)
{
//DrawTexture(mesh._textureData._image, matrix, mesh._textureData._width, mesh._textureData._height, textureColor, -10);
DrawTexture(mesh.LinkedTextureData._image, matrix, mesh.LinkedTextureData._width, mesh.LinkedTextureData._height, textureColor, -10);
}
Vector2 pos2_0 = Vector2.zero;
Vector2 pos2_1 = Vector2.zero;
Vector2 pos2_2 = Vector2.zero;
Vector3 pos_0 = Vector3.zero;
Vector3 pos_1 = Vector3.zero;
Vector3 pos_2 = Vector3.zero;
Vector2 uv_0 = Vector2.zero;
Vector2 uv_1 = Vector2.zero;
Vector2 uv_2 = Vector2.zero;
//2. 메시를 렌더링하자
if (mesh._indexBuffer.Count >= 3)
{
if (!isDrawToneOutline)
{
_matBatch.SetPass_Texture_Normal(color2X, mesh.LinkedTextureData._image, apPortrait.SHADER_TYPE.AlphaBlend);
}
else
{
_matBatch.SetPass_ToneColor_Custom(color2X, mesh.LinkedTextureData._image, 0.0f, 0.0f);
}
_matBatch.SetClippingSize(_glScreenClippingSize);
GL.Begin(GL.TRIANGLES);
//------------------------------------------
apVertex vert0, vert1, vert2;
//Color color0 = Color.black, color1 = Color.black, color2 = Color.black;
Color color0 = Color.white, color1 = Color.white, color2 = Color.white;
for (int i = 0; i < mesh._indexBuffer.Count; i += 3)
{
if (i + 2 >= mesh._indexBuffer.Count)
{
break;
}
if (mesh._indexBuffer[i + 0] >= mesh._vertexData.Count ||
mesh._indexBuffer[i + 1] >= mesh._vertexData.Count ||
mesh._indexBuffer[i + 2] >= mesh._vertexData.Count)
{
break;
}
vert0 = mesh._vertexData[mesh._indexBuffer[i + 0]];
vert1 = mesh._vertexData[mesh._indexBuffer[i + 1]];
vert2 = mesh._vertexData[mesh._indexBuffer[i + 2]];
pos2_0 = World2GL(matrix.MultiplyPoint(vert0._pos));
pos2_1 = World2GL(matrix.MultiplyPoint(vert1._pos));
pos2_2 = World2GL(matrix.MultiplyPoint(vert2._pos));
pos_0 = new Vector3(pos2_0.x, pos2_0.y, vert0._zDepth * 0.1f);
pos_1 = new Vector3(pos2_1.x, pos2_1.y, vert1._zDepth * 0.5f);
pos_2 = new Vector3(pos2_2.x, pos2_2.y, vert2._zDepth * 0.5f); //<<Z값이 반영되었다.
uv_0 = mesh._vertexData[mesh._indexBuffer[i + 0]]._uv;
uv_1 = mesh._vertexData[mesh._indexBuffer[i + 1]]._uv;
uv_2 = mesh._vertexData[mesh._indexBuffer[i + 2]]._uv;
GL.Color(color0); GL.TexCoord(uv_0); GL.Vertex(pos_0); // 0
GL.Color(color1); GL.TexCoord(uv_1); GL.Vertex(pos_1); // 1
GL.Color(color2); GL.TexCoord(uv_2); GL.Vertex(pos_2); // 2
//Back Side
GL.Color(color2); GL.TexCoord(uv_2); GL.Vertex(pos_2); // 2
GL.Color(color1); GL.TexCoord(uv_1); GL.Vertex(pos_1); // 1
GL.Color(color0); GL.TexCoord(uv_0); GL.Vertex(pos_0); // 0
////------------------------------------------
}
GL.End();
}
if (mesh._isPSDParsed && isDrawOutline)
{
Vector2 pos_LT = matrix.MultiplyPoint(new Vector2(mesh._atlasFromPSD_LT.x, mesh._atlasFromPSD_LT.y));
Vector2 pos_RT = matrix.MultiplyPoint(new Vector2(mesh._atlasFromPSD_RB.x, mesh._atlasFromPSD_LT.y));
Vector2 pos_LB = matrix.MultiplyPoint(new Vector2(mesh._atlasFromPSD_LT.x, mesh._atlasFromPSD_RB.y));
Vector2 pos_RB = matrix.MultiplyPoint(new Vector2(mesh._atlasFromPSD_RB.x, mesh._atlasFromPSD_RB.y));
_matBatch.SetPass_Color();
_matBatch.SetClippingSize(_glScreenClippingSize);
GL.Begin(GL.LINES);
DrawLine(pos_LT, pos_RT, atlasBorderColor, false);
DrawLine(pos_RT, pos_RB, atlasBorderColor, false);
DrawLine(pos_RB, pos_LB, atlasBorderColor, false);
DrawLine(pos_LB, pos_LT, atlasBorderColor, false);
GL.End();
}
//외곽선을 그려주자
//float imageWidthHalf = mesh._textureData._width * 0.5f;
//float imageHeightHalf = mesh._textureData._height * 0.5f;
float imageWidthHalf = mesh.LinkedTextureData._width * 0.5f;
float imageHeightHalf = mesh.LinkedTextureData._height * 0.5f;
Vector2 pos_TexOutline_LT = matrix.MultiplyPoint(new Vector2(-imageWidthHalf, -imageHeightHalf));
Vector2 pos_TexOutline_RT = matrix.MultiplyPoint(new Vector2(imageWidthHalf, -imageHeightHalf));
Vector2 pos_TexOutline_LB = matrix.MultiplyPoint(new Vector2(-imageWidthHalf, imageHeightHalf));
Vector2 pos_TexOutline_RB = matrix.MultiplyPoint(new Vector2(imageWidthHalf, imageHeightHalf));
_matBatch.SetPass_Color();
_matBatch.SetClippingSize(_glScreenClippingSize);
GL.Begin(GL.LINES);
DrawLine(pos_TexOutline_LT, pos_TexOutline_RT, atlasBorderColor, false);
DrawLine(pos_TexOutline_RT, pos_TexOutline_RB, atlasBorderColor, false);
DrawLine(pos_TexOutline_RB, pos_TexOutline_LB, atlasBorderColor, false);
DrawLine(pos_TexOutline_LB, pos_TexOutline_LT, atlasBorderColor, false);
GL.End();
//3. Edge를 렌더링하자 (전체 / Ouline)
if (isDrawEdge)
{
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);
}
}