} // void _LoadNaviFromTemplate()
public bool resetGlobal_constantObjects(CTriCollector triCollector, bool bConstantlyCreateObj)
{
if (triCollector.m_listTris_naviStart.Count > 0)
{
foreach (int iTriStart in triCollector.m_listTris_naviStart)
{
CTRI triStartCurr = triCollector.getTri(iTriStart);
if (null != triStartCurr)
{
m_intervalUnitWalking.newIntervalConstantly(iTriStart,
m_processInput._respawnunitwalking,
m_processInput._timeinterval_unitwalking,
triStartCurr.GetCenterTri());
}
}
}
else
{
m_intervalUnitWalking.workprocessInterval = false;
}
m_intervalUnitWalking.workprocessInterval = bConstantlyCreateObj;
return(true);
}
public int getTriHypotenuse(CNAVICELL.CADJ_TRI[] arrAdjTri, List <CTRI> listTris, int iSeqTri)
{
if (arrAdjTri.Length < 1 || iSeqTri < 0)
{
return(-1);
}
CNAVICELL.CADJ_TRI tri_Adj = arrAdjTri[iSeqTri];
CTRI tri = listTris[iSeqTri];
int iEdge_Hyptenuse = tri.GetHypotenuseEdge();
if (CTRI.NULL_TRI_EDGE == iEdge_Hyptenuse)
{
return(-1);
}
int iTri_Hypotenuse = tri_Adj._arrTrisAdjacent[iEdge_Hyptenuse];
if (iTri_Hypotenuse == CNAVICELL.NULL_CELL)
{
return(-1);
}
return(iTri_Hypotenuse);
}
//@ Construct All Triangles RenderLines
public void drawAllTrisOneDrawcall(List <CTRI> listTriangle, Color colorTriangles)
{
if (null == m_drawRenderMesh_triCollector)
{
return;
}
if (listTriangle.Count < 1)
{
return;
}
int iLengthMapping = listTriangle.Count * 3;
Vector3[] arrVertexmapping = new Vector3[iLengthMapping];
for (int iSeqTri = 0; iSeqTri < listTriangle.Count; ++iSeqTri)
{
CTRI triCurr = listTriangle[iSeqTri];
for (int iPnt = 0; iPnt < 3; ++iPnt)
{
int iSeqPnt = iSeqTri * 3 + iPnt;
Vector3 v3PntCurr = triCurr._arrv3PT[iPnt];
arrVertexmapping[iSeqPnt] = v3PntCurr;
}
}
m_iSequenceRenderMesh_forDebug = m_drawRenderMesh_triCollector.DrawNewRendermesh(DFLT_IDX_RENDERNAVIMESH,
arrVertexmapping,
colorTriangles,
CMATH.FEPSILON_F3,
-1.0f);
} // public void drawAllTrisOneDrawcall()
//@ Intersect ray to tries iteration.
public CBASE__ GetIntersectedRay(Vector3 lineOrigin, Vector3 lineDir)
{
if (true == m_listTris.IsNullOrEmpty())
{
return(null);
}
List <CTRI> triesForIteration = m_listTris.Where(t => { return(null != t.GetBaseLinked); }).ToListOrDefault();
if (true == triesForIteration.IsNullOrEmpty())
{
return(null);
}
CTRI intersectedTri = triesForIteration.FirstOrDefault(t =>
{
return(CMATH.IntersectRayTriSimple(lineOrigin, lineDir, t._arrv3PT[0], t._arrv3PT[1], t._arrv3PT[2]));
});
if (null == intersectedTri)
{
return(null);
}
CBASE__ intersectedBase = intersectedTri.GetBaseLinked;
return(intersectedBase);
}
} // public bool setNewBase_fromListTris( List<CBASE__> listBase_ )
//@ Construct New Base__
protected int setNewBase_fromListTris(List <int> listTriIdx_Instant)
{
if (true == m_listTrisAll_copy.IsNullOrEmpty() ||
true == listTriIdx_Instant.IsNullOrEmpty())
{
Debug.LogError("(true == m_listTrisAll_copy.IsNullOrEmpty() || true == listTriIdx_Instant.IsNullOrEmpty())");
return(-1);
}
int iFirstIdx = listTriIdx_Instant[0];
CBASE__ baseNew = new CBASE__();
for (int iTri_ = 0; iTri_ < listTriIdx_Instant.Count; ++iTri_)
{
int iSeqTri_ = listTriIdx_Instant[iTri_];
CTRI triPicked = m_listTrisAll_copy.GetSafe(iSeqTri_);
if (null == triPicked)
{
Debug.LogError("(null == triPicked)/setNewBase_fromListTris");
continue;
}
baseNew.InsertNewTri(iSeqTri_, triPicked, false);
}
baseNew.CalculateBase__(iFirstIdx);
m_listBase__.Add(baseNew);
Clear_InstantTriangles_All();
return(m_listBase__.Count);
}
//@ Post-Initialize
//@ Insert Cells Basic Information and calculate internal cell distance from cell center to each cell edge middle.
// It use for which cell is shortest way to GOAL.
public void SetComponentCell(int iSeqCell_, CTRI Tri_)
{
m_iSeqCell = iSeqCell_;
m_tri_linker = Tri_;
Array.Copy(Tri_._arrv3PT, m_arrv3PT, Tri_._arrv3PT.Length);
computeCellData();
} // protected void SetComponentCell(Vector3[] arv3TriPT, Vector3 v3NormalCell)
//@ Construct New Triangle
protected void SetNewTri(int iSeqTri, CTRI tri_in)
{
for (int iSeqPnt = 0; iSeqPnt < tri_in._arrv3PT.Length; ++iSeqPnt)
{
Vector3 v3PntTri = tri_in._arrv3PT[iSeqPnt];
_listv3Pnts.Add(v3PntTri);
}
_listIdxTris.Add(iSeqTri);
_listIdxTris.Sort();
}
public bool getTri(int iIdxTriangle, ref CTRI tri_out)
{
if (iIdxTriangle > m_listTris.Count)
{
Debug.Log("Accessed Index is out of range in Triangle Container");
return(false);
}
tri_out = m_listTris[iIdxTriangle];
return(true);
}
//@ Collect all isoscelles right trignales
public bool collectAll_IsoscellesRightTriangles(ref List <int> listIRTris)
{
for (int iSeqTri = 0; iSeqTri < m_listTris.Count; ++iSeqTri)
{
CTRI triCurr = m_listTris[iSeqTri];
if (true == triCurr.IsoscelesRightAngleTriangle(0.05f))
{
listIRTris.Add(iSeqTri);
}
}
return(listIRTris.Count > 0);
}
public Vector3 GetSatartTriagleCenterPosition(int startIndex)
{
if (m_GroundStartPoint_List.Count <= startIndex)
{
return(Vector3.zero);
}
int index = m_GroundStartPoint_List[startIndex];
CTRI tri = m_MapTriangle[index];
Vector3 startPosition = (tri._arrv3PT[0] + tri._arrv3PT[1] + tri._arrv3PT[2]) / 3.0f;;
return(startPosition);
}
Vector3 GetStartTriangleRandomPosition(CTriCollector tricollector, int idxTriangle)
{
CTRI tri = tricollector.getTri(idxTriangle);
float r1 = Random.Range(0.1f, 0.8f);
float r2 = Random.Range(0.1f, (1.0f - r1 - 0.1f));
float r3 = 1.0f - r1 - r2;
float positionX = tri._arrv3PT[0].x * r1 + tri._arrv3PT[1].x * r2 + tri._arrv3PT[2].x * r3;
float positionZ = tri._arrv3PT[0].z * r1 + tri._arrv3PT[1].z * r2 + tri._arrv3PT[2].z * r3;
return(new Vector3(positionX, tri._arrv3PT[0].y, positionZ));
}
public void AddToBlockEdge_Tri(CTRI tri_B, int iSeqTri)
{
if (m_listSeqBlockTri.Count > 0)
{
if (-1 < m_listSeqBlockTri.BinarySearch(iSeqTri))
{
return;
}
} // if (m_listSeqBlockTri.Count > 0)
EDGE__ edge01 = new EDGE__(tri_B._arrv3PT[0], tri_B._arrv3PT[1]);
EDGE__ edge12 = new EDGE__(tri_B._arrv3PT[1], tri_B._arrv3PT[2]);
EDGE__ edge20 = new EDGE__(tri_B._arrv3PT[2], tri_B._arrv3PT[0]);
AddToBlockEdge(edge01);
AddToBlockEdge(edge12);
AddToBlockEdge(edge20);
} // void AddToBlockEdgeTri(CTRI tri_B)
public Vector3 GetStartTriangleRandomPosition(int startIndex)
{
if (m_GroundStartPoint_List.Count <= startIndex)
{
return(Vector3.zero);
}
int index = m_GroundStartPoint_List[startIndex];
CTRI tri = m_MapTriangle[index];
float r1 = Random.Range(0.1f, 0.8f);
float r2 = Random.Range(0.1f, (1.0f - r1 - 0.1f));
float r3 = 1.0f - r1 - r2;
float positionX = tri._arrv3PT[0].x * r1 + tri._arrv3PT[1].x * r2 + tri._arrv3PT[2].x * r3;
float positionZ = tri._arrv3PT[0].z * r1 + tri._arrv3PT[1].z * r2 + tri._arrv3PT[2].z * r3;
return(new Vector3(positionX, tri._arrv3PT[0].y, positionZ));
}
} // protected bool BuildAdjacentATri
// 함수:ConstructTrisToCells
// 네비게이션을 위한 모든 셀들과 인접 셀들을 생성한다
//@ Construct all adjacent Cells for navigation.
protected void ConstructTrisToCells(List <CTRI> listTris_)
{
int iCntTris = listTris_.Count;
m_arrNavicells = new CNAVICELL[iCntTris]; // Tri카운트 만큼 네비셀 생성
for (int iTri = 0; iTri < iCntTris; iTri++)
{
CTRI triCurr = listTris_[iTri];
CNAVICELL naviCell = new CNAVICELL();
naviCell.InitializeNaviCell(); // 각 셀들의 초기화
//@ Compute each middle edge to Center
naviCell.SetComponentCell(iTri, triCurr); // Tri 기본 정보를 네비셀에 전달 그리고 각각의 미들 엣지,센터를 계산
m_arrNavicells[iTri] = naviCell;
}
buildupAdjacentAll(ref m_arrNavicells); // 인접 셀 빌드업
}
protected void DrawInstantTris(List <int> listTris_Instant)
{
if (null == m_drawRenderMesh)
{
return;
}
m_drawRenderMesh.DeleteDrawMesh_Range(m_iID_Instant_DrawForDEBUG, m_iID_Instant_DrawForDEBUG + m_listTrisAll_copy.Count);
foreach (int iterIdxTri in listTris_Instant)
{
CTRI triRenderDebug = m_listTrisAll_copy[iterIdxTri];
//@ Just For Draw Debug Triangles
m_drawRenderMesh.DrawNewRendermesh(m_iID_Instant_DrawForDEBUG + iterIdxTri,
triRenderDebug._arrv3PT,
m_colorInstantSelect,
m_fEpsilon_forZfight,
CDrawRenderMesh.scaleadjust_render_093);
}
}
// ÇÔ¼ö:InitializeNaviCell()
//@ Process °¢ ³×ºñ¼¿µéÀÇ ÃʱâÈ ÀÛ¾÷
//@ Set all properties unprocessed and set NULL.
public void InitializeNaviCell()
{
m_iSeqCell = NULL_CELL;
for (int i = 0; i < 3; ++i)
{
m_arriAdjCells[i] = NULL_CELL;
m_arrfcosttoGoal_edge[i] = -1.0f;
}
m_iLevelToGoal = NULL_LEVELFROMGOAL;
m_eEdge_bestway = E_CELL_SIDEEDGE.E_EDGE_NULL;
m_fcosttoGoal_ex = CMATH.FLOAT_MAX;
m_fcosttoGoal_cen = CMATH.FLOAT_MAX;
m_tri_linker = null;
m_eStatusCell = E_CELL_STATUS.CELL_STATUS_ROAD;
m_bUseWaytoPortal = false;
}
//@ Construct All Triangles RenderLines
public void drawRenderTris_selectlist(List <CTRI> listTriangle, List <int> listTrisIdx, Color colorTris)
{
if (null == m_drawRenderMesh_triCollector)
{
return;
}
if (listTriangle.Count < 1 || listTrisIdx.Count < 1)
{
Debug.Log("drawAllTrisOneDrawcall():listTriangle.Count < 1 || listTrisIdx.Count < 1");
return;
}
int iLengthMapping = listTrisIdx.Count * 3;
Vector3[] arrVertexmapping = new Vector3[iLengthMapping];
for (int iSeqTri = 0; iSeqTri < listTrisIdx.Count; ++iSeqTri)
{
int iTriIdxCurr = listTrisIdx[iSeqTri];
CTRI triCurr = listTriangle[iTriIdxCurr];
for (int iPnt = 0; iPnt < 3; ++iPnt)
{
int iSeqPnt = iSeqTri * 3 + iPnt;
Vector3 v3PntCurr = triCurr._arrv3PT[iPnt];
arrVertexmapping[iSeqPnt] = v3PntCurr;
}
} // for (int iSeqTri = 0; iSeqTri < listTrisIdx.Count; ++iSeqTri )
m_iSequenceRenderMesh_forDebug = m_drawRenderMesh_triCollector.DrawNewRendermesh(DFLT_IDX_RENDERNAVI_TRIS_IR,
arrVertexmapping,
colorTris,
0.001f,
-1.0f);
} // public void drawRenderTris_selectlist()
//@ Triangle Collection Composition all renderLine of triangles.
public void _drawRenderLine_AllTris_Debug(CTriCollector triCollector)
{
if (null == m_drawRenderLine_triCollector)
{
return;
}
List <CTRI> listTriangle = triCollector.getTris();
if (listTriangle.Count < 1)
{
return;
}
if (m_iSequenceRenderLine_forDebug >= 0)
{
return;
}
int iLengthMapping = listTriangle.Count * 3;
Vector3[] arrVertexmapping = new Vector3[iLengthMapping];
for (int iSeqTri = 0; iSeqTri < listTriangle.Count; ++iSeqTri)
{
CTRI triCurr = listTriangle[iSeqTri];
for (int iPnt = 0; iPnt < 3; ++iPnt)
{
int iSeqPnt = iSeqTri * 3 + iPnt;
Vector3 v3PntCurr = triCurr._arrv3PT[iPnt];
arrVertexmapping[iSeqPnt] = v3PntCurr;
}
}
m_iSequenceRenderLine_forDebug = m_drawRenderLine_triCollector.DrawNewLine_user(arrVertexmapping);
} // public void _drawRenderLine_AllTris_Debug()
//@ For DEBUG, Set Draw way StartCell to Goal
public void drawStartCellToGoal(CNavigation navigation, CTriCollector tricollector)
{
UndrawStartCellToGoal();
_SetundrawNaviCells_Text3D();
if (null == navigation.m_arrNavicells)
{
return;
}
bool bResultOrganized = navigation.collectWay_allStartsToGoal(tricollector, ref m_arrSequenceCell);
if (false == bResultOrganized)
{
return;
}
CNAVICELL[] arrNavicells = navigation.m_arrNavicells;
List <int> listSeqTri = getListSequenceOrganized();
int iBasisUniqueNum = m_iBasisUniqueNum_RenderMesh;
for (int iTriAdj = 0; iTriAdj < listSeqTri.Count; ++iTriAdj)
{
int iSeqUniqueNum = iBasisUniqueNum + listSeqTri[iTriAdj];
CTRI triAdj_ = arrNavicells[listSeqTri[iTriAdj]].trilinkcell;
m_drawRenderMesh_navi.DrawNewRendermesh(iSeqUniqueNum,
triAdj_._arrv3PT,
Color.Lerp(Color.gray, Color.black, 0.5f),
CMATH.FEPSILON_F3 + CMATH.FEPSILON_F3,
CDrawRenderMesh.scaleadjust_render_070);
}
_drawText3D_SeqCells(tricollector, tricollector.m_listTris_naviStart);
} // private void drawStartCellToGoal()
//@ Debug Draw for Tri Eachtype
public void drawAllTri_eachFunctional(CTriCollector triCollector, bool bRepresentBlocks)
{
if (null == m_drawRenderMesh_triCollector)
{
return;
}
undrawAllTri();
List <int> listTrisPicked_naviGoal = triCollector.m_listTris_naviGoal;
List <int> listTrisPicked_naviBlock = triCollector.m_listTris_naviBlock;
List <int> listTrisPicked_naviBlockRoad = triCollector.m_listTris_naviBlockRoad;
List <int> listTrisPicked_naviStart = triCollector.m_listTris_naviStart;
// Blocks
if (true == bRepresentBlocks)
{
if (listTrisPicked_naviBlock.Count > 0)
{
foreach (int iIdxTri in listTrisPicked_naviBlock)
{
CTRI triRenderDebug = triCollector.getTri(iIdxTri);
m_drawRenderMesh_triCollector.DrawNewRendermesh(DFLT_IDX_RENDERTRI_TYPE + iIdxTri,
triRenderDebug._arrv3PT,
Color.Lerp(Color.blue, Color.black, 0.5f),
CMATH.FEPSILON_F2 * 3.0f,
CDrawRenderMesh.scaleadjust_render_095);
}
}
// BlockRoads
if (listTrisPicked_naviBlockRoad.Count > 0)
{
foreach (int iIdxTri in listTrisPicked_naviBlockRoad)
{
CTRI triRenderDebug = triCollector.getTri(iIdxTri);
m_drawRenderMesh_triCollector.DrawNewRendermesh(DFLT_IDX_RENDERTRI_TYPE + iIdxTri,
triRenderDebug._arrv3PT,
Color.Lerp(Color.blue, Color.white, 0.2f),
CMATH.FEPSILON_F2 * 3.0f,
CDrawRenderMesh.scaleadjust_render_095);
}
}
} // if (true == bRepresentBlocks)
// Goals
if (listTrisPicked_naviGoal.Count > 0)
{
foreach (int iIdxTri in listTrisPicked_naviGoal)
{
CTRI triRenderDebug = triCollector.getTri(iIdxTri);
m_drawRenderMesh_triCollector.DrawNewRendermesh(DFLT_IDX_RENDERTRI_TYPE + iIdxTri,
triRenderDebug._arrv3PT,
Color.red,
CMATH.FEPSILON_F2 * 3.0f,
CDrawRenderMesh.scaleadjust_render_093);
}
}
// Starts
if (listTrisPicked_naviStart.Count > 0)
{
foreach (int iIdxTri in listTrisPicked_naviStart)
{
CTRI triRenderDebug = triCollector.getTri(iIdxTri);
m_drawRenderMesh_triCollector.DrawNewRendermesh(DFLT_IDX_RENDERTRI_TYPE + iIdxTri,
triRenderDebug._arrv3PT,
Color.yellow,
CMATH.FEPSILON_F2 * 3.0f,
CDrawRenderMesh.scaleadjust_render_093);
}
}
} // public void drawAllTri_eachFunctional()
public bool LoadStage()
{
if (null == m_Filename)
{
return(false);
}
Release();
string filepath = m_Forder + m_Filename + m_Ext;
CFileManager tFile = CFileManager.GetInstance;
// load stream
Stream ms = tFile.LoadFile(filepath);
if (null == ms)
{
return(false);
}
BinaryReader br = new BinaryReader(ms);
// MapTri
int count = 0;
int count2 = 0;
count = br.ReadInt32();
CTRI tri = null;
for (int i = 0; i < count; i++)
{
tri = new CTRI();
for (int j = 0; j < 3; j++)
{
tri._arrv3PT[j].x = br.ReadSingle();
tri._arrv3PT[j].y = br.ReadSingle();
tri._arrv3PT[j].z = br.ReadSingle();
tri._arriIV[j] = br.ReadInt32();
}
tri._v3TriNormal.x = br.ReadSingle();
tri._v3TriNormal.y = br.ReadSingle();
tri._v3TriNormal.z = br.ReadSingle();
tri._arrEdgeLength[0] = br.ReadSingle();
tri._arrEdgeLength[1] = br.ReadSingle();
tri._arrEdgeLength[2] = br.ReadSingle();
AddTriangle(tri);
}
// MapArrageBase
count = br.ReadInt32();
CBASE__ towerArrange = null;
for (int i = 0; i < count; i++)
{
towerArrange = new CBASE__();
count2 = br.ReadInt32();
for (int j = 0; j < count2; j++)
{
towerArrange._listIdxTris.Add(br.ReadInt32());
}
count2 = br.ReadInt32();
for (int j = 0; j < count2; j++)
{
Vector3 vec = new Vector3(br.ReadSingle(), br.ReadSingle(), br.ReadSingle());
towerArrange._listv3Pnts.Add(vec);
}
// 중앙포지션
towerArrange._v3PositionCenter.x = br.ReadSingle();
towerArrange._v3PositionCenter.y = br.ReadSingle();
towerArrange._v3PositionCenter.z = br.ReadSingle();
// 삼각형 정보
count2 = br.ReadInt32();
for (int j = 0; j < count2; j++)
{
Vector3 vec = new Vector3(br.ReadSingle(), br.ReadSingle(), br.ReadSingle());
towerArrange._listv3PntsSrc.Add(vec);
}
AddBaseTower(towerArrange);
m_BaseTowerMeshIndex.Add(towerArrange._listIdxTris[0], i);
m_BaseTowerMeshIndex.Add(towerArrange._listIdxTris[1], i);
}
// MainCoreList
count = br.ReadInt32();
BaseInfo core;
for (int i = 0; i < count; i++)
{
core = new BaseInfo();
core.CoreLoad(br);
AddMainCore(core);
}
// SubCoreList
count = br.ReadInt32();
for (int i = 0; i < count; i++)
{
core = new BaseInfo();
core.CoreLoad(br);
AddSubCore(core);
}
// StartBaseList
count = br.ReadInt32();
for (int i = 0; i < count; i++)
{
core = new BaseInfo();
core.CoreLoad(br);
AddStartBase(core);
}
// BlockBaseList
count = br.ReadInt32();
for (int i = 0; i < count; i++)
{
core = new BaseInfo();
core.CoreLoad(br);
AddBlockBase(core);
}
// GoalPoint
count = br.ReadInt32();
for (int i = 0; i < count; i++)
{
AddGoalPoint(br.ReadInt32());
}
// GroundMonster_StartPoint
count = br.ReadInt32();
for (int i = 0; i < count; i++)
{
AddGroundStartPoint(br.ReadInt32());
}
// BlockPoint
count = br.ReadInt32();
for (int i = 0; i < count; i++)
{
AddGroundBlockPoint(br.ReadInt32());
}
// BlockRoadPoint
count = br.ReadInt32();
for (int i = 0; i < count; i++)
{
AddGroundBlockRoadPoint(br.ReadInt32());
}
// flyPath list
count = br.ReadInt32();
CSplineGenerator path = null;
for (int i = 0; i < count; i++)
{
path = new CSplineGenerator();
path.SetTypeSplineCurve((E_TYPE_SPLINE)br.ReadUInt32());
path.SetDivisionWeight(br.ReadSingle());
count2 = br.ReadInt32();
for (int j = 0; j < count2; j++)
{
Vector3 vec = new Vector3(br.ReadSingle(), br.ReadSingle(), br.ReadSingle());
path.SetNewCurvePoint_spline(vec);
}
AddFlyPath(path);
}
// 파일포인터 맨처음으로
ms.Seek(0, SeekOrigin.Begin);
return(true);
}
} //protected bool CTriContainer::constructAllTris_IVrecompute(
//@ Construct all Triangle refer to Index Buffers, Vertex Buffers.
protected bool constructAllTris_IV(int[] arrTri_in,
Vector3[] arrVertex_in,
ref List <CTRI> listTris_out)
{
Vector3[] arrv3TriVer = new Vector3[CTRI.CNTPNTTRI];
int[] ariTriIdx = new int[CTRI.CNTPNTTRI];
int iCntVB = arrVertex_in.Length;
int iCntIV = arrTri_in.Length;
if (iCntIV < 1 || iCntVB < 1)
{
Debug.Log("(iCntIV < 1 || iCntVB < 1)");
return(false);
}
//int iCntTries = (iCntIV / CTRI.CNTPNTTRI) + 1;
CTRI triCurrent;
Vector3 v3MinAABB = new Vector3(CMATH.FLOAT_MAX, CMATH.FLOAT_MAX, CMATH.FLOAT_MAX),
v3MaxAABB = new Vector3(-CMATH.FLOAT_MAX, -CMATH.FLOAT_MAX, -CMATH.FLOAT_MAX);
Vector3 v3VerTri;
for (int iSeqIdx = 0, iTri = 0; iSeqIdx < iCntIV; iSeqIdx += 3, ++iTri)
{
ariTriIdx[0] = arrTri_in[iSeqIdx];
ariTriIdx[1] = arrTri_in[iSeqIdx + 1];
ariTriIdx[2] = arrTri_in[iSeqIdx + 2];
for (int itV = 0; itV < 3; ++itV)
{
v3VerTri = new Vector3(arrVertex_in[ariTriIdx[itV]].x, arrVertex_in[ariTriIdx[itV]].y, arrVertex_in[ariTriIdx[itV]].z);
if (v3VerTri.x > v3MaxAABB.x)
{
v3MaxAABB.x = v3VerTri.x;
}
if (v3VerTri.y > v3MaxAABB.y)
{
v3MaxAABB.y = v3VerTri.y;
}
if (v3VerTri.z > v3MaxAABB.z)
{
v3MaxAABB.z = v3VerTri.z;
}
if (v3VerTri.x < v3MinAABB.x)
{
v3MinAABB.x = v3VerTri.x;
}
if (v3VerTri.y < v3MinAABB.y)
{
v3MinAABB.y = v3VerTri.y;
}
if (v3VerTri.z < v3MinAABB.z)
{
v3MinAABB.z = v3VerTri.z;
}
arrv3TriVer[itV] = v3VerTri;
}
triCurrent = new CTRI();
triCurrent.Set(arrv3TriVer, ariTriIdx);
listTris_out.Add(triCurrent);
}
return(true);
} //protected bool constructAllTris_IV(
//@ Collect All BaseTower List which calculated Perfect Square.
static public bool CollectAll_perfectSqre_exceptGoalTri(CNAVICELL[] arrNavicells,
CTriCollector tricollector,
ref List <CBASE__> listBase)
{
int iCntNaviCell = arrNavicells.Length;
if (iCntNaviCell < 1)
{
Debug.Log("if(iCntNaviCell < 1)");
return(false);
}
List <int> listIdxTrisGoal = tricollector.m_listTris_naviGoal;
List <int> listIdxTrisStart = tricollector.m_listTris_naviStart;
List <int> listTriIR = new List <int>();
CNAVICELL.CADJ_TRI[] arrAdjs_ = tricollector.arrayAllTriAdjacent;
tricollector.collectAll_IsoscellesRightTriangles(ref listTriIR);
List <int> listTri_Instant__ = new List <int>();
bool bValidatedBase_perfectSquare = false;
foreach (int iIdxTri in listTriIR)
{
CNAVICELL.CADJ_TRI adjTri = arrAdjs_[iIdxTri];
CTRI triCurr = tricollector.getTri(iIdxTri);
bValidatedBase_perfectSquare = false;
//@ process skip
if (true == triCurr.inclinedPlane())
{
continue;
}
if (-1 < listIdxTrisGoal.BinarySearch(iIdxTri))
{
continue;
}
if (-1 < listIdxTrisStart.BinarySearch(iIdxTri))
{
continue;
}
int iEdge_Hyptenuse = triCurr.GetHypotenuseEdge();
if (CTRI.NULL_TRI_EDGE == iEdge_Hyptenuse)
{
continue;
}
int iTri_Hypotenuse = adjTri._arrTrisAdjacent[iEdge_Hyptenuse];
if (iTri_Hypotenuse == CNAVICELL.NULL_CELL)
{
continue;
}
CTRI triHyptenuse = tricollector.getTri(iTri_Hypotenuse);
if (triHyptenuse.IsisoscelesRightAngle() == true)
{
bValidatedBase_perfectSquare = true;
listTri_Instant__.Add(iIdxTri);
listTri_Instant__.Add(iTri_Hypotenuse);
}
if (true == bValidatedBase_perfectSquare)
{
CBASE__ base__New = new CBASE__();
for (int iTri_ = 0; iTri_ < listTri_Instant__.Count; ++iTri_)
{
int iSeqTri_ = listTri_Instant__[iTri_];
CTRI triPicked = tricollector.getTri(iSeqTri_);
base__New.InsertNewTri(iSeqTri_, triPicked, false);
}
bool bAlreadyExisted = false;
foreach (CBASE__ base__Sub in listBase)
{
if (true == base__Sub.IsSimilar(base__New))
{
bAlreadyExisted = true;
break;
}
}
if (false == bAlreadyExisted)
{
base__New.CalculateBase__(iIdxTri);
listBase.Add(base__New);
}
listTri_Instant__.Clear();
} // if(true==bValidatedBase_perfectSquare)
} // foreach(int iIdxTri in listTriIR)
return(true);
} // static public bool CollectAll_perfectSqre_exceptGoalTri()
public void AddTriangle(CTRI tri) // Add tri
{
m_MapTriangle.Add(tri);
}
// Collect all blocks start to goal. And then buildup shortest way start to goal.
// 처음 스타트 부터 골까지의 모든 네비 블럭을 모은다(가장 짧은 길을 택한다)
static public void collectWayToGoalLinear(CNAVICELL[] arrNavicells_,
CNAVICELL cellStart_,
ref List <CNAVICELL> listSequenceCell_,
ref CComputeEdgeBlock processorEdge_)
{
bool bOrganizedComplete = false;
Vector3 v3PntEdge0 = new Vector3();
Vector3 v3PntEdge1 = new Vector3();
CNAVICELL cellWay = cellStart_;
bOrganizedComplete = false;
listSequenceCell_.Add(cellWay); //First unit is startcell.
//@ first collect all blocks start -> goal.
while (false == bOrganizedComplete)
{
CTRI triWaytoGoal = cellWay.trilinkcell;
//@ if Adjacent cell is NULL, add new EDGE list. //이웃셀이 없다면 추가한다
for (int iSeqAdj = 0; iSeqAdj < cellWay.m_arriAdjCells.Length; ++iSeqAdj)
{
int iIdxAdj = cellWay.m_arriAdjCells[iSeqAdj];
CTRI.E_TRI_EDGE eEdge = (CTRI.E_TRI_EDGE)iSeqAdj;
//@ Checkup adjacent Edge Tri //
if (CNAVICELL.NULL_CELL == iIdxAdj)
{
triWaytoGoal.GetEdgePoint(eEdge, ref v3PntEdge0, ref v3PntEdge1);
processorEdge_.AddToBlockEdge(v3PntEdge0, v3PntEdge1); //-> Add Edge to Block List
}
else
{
CNAVICELL cellAdj = arrNavicells_[iIdxAdj];
//@ Adj cell is block cell, then into list.
if (cellAdj.IsBlockCell())
{
processorEdge_.AddToBlockEdge_Tri(cellAdj.trilinkcell, iIdxAdj); //-> Add Edge to Block List
}
}
} // for (int iAdj = 0; iAdj < naviCellNextWay.m_arriAdjCells.Length; ++iAdj)
int iIdxCellBestWay = cellWay.getIdxCell_nextWay();
if (CNAVICELL.NULL_CELL == iIdxCellBestWay)
{
return;
}
cellWay = arrNavicells_[iIdxCellBestWay];
listSequenceCell_.Add(cellWay); // Last unit must be goalcell.
if (true == cellWay.IsGoalCell())
{
bOrganizedComplete = true;
}
} // while (false == bOrganizedComplete)
} // protected void collectWayToGoalLinear()
//@ Function has little risk about triangle match.
protected bool constructAllTris_IVrecompute(int[] arrTri_in,
Vector3[] arrVertex_in,
ref List <CTRI> listTris_out)
{
Vector3[] arrv3TriVer = new Vector3[CTRI.CNTPNTTRI];
int[] ariTriIdx = new int[CTRI.CNTPNTTRI];
int iCntVB = arrVertex_in.Length;
int iCntIV = arrTri_in.Length;
//CHECKOVERLAPPED
int iCntSameVer__ = 0;
if (iCntIV < 1 || iCntVB < 1)
{
return(false);
}
int[] arrIBConvert = new int[iCntIV];
int iIVConvert = 0, iIVCurr = 0;
bool bfindEQ = false;
for (int iterIV = 0; iterIV < iCntIV; ++iterIV)
{
arrIBConvert[iterIV] = arrTri_in[iterIV];
}
for (int iterIV = 0; iterIV < iCntVB; ++iterIV)
{
Vector3 v3VBCurr = arrVertex_in[iterIV];
iIVCurr = iterIV; bfindEQ = false;
for (int iIVin = 0; iIVin < iIVCurr; ++iIVin)
{
Vector3 v3VBCurr_ = arrVertex_in[iIVin];
//bfindEQ = CMATH.similarVector3_FIn(v3VBCurr, v3VBCurr_, 0.4f);
bfindEQ = (v3VBCurr == v3VBCurr_);
if (bfindEQ)
{
//FORTEST
iCntSameVer__++;
iIVConvert = iIVin;
break;
}
} // for(int iIVin=0; iIVin<iterIV; ++IV_)
if (true == bfindEQ)
{
for (int iSeqIV = 0; iSeqIV < iCntIV; ++iSeqIV)
{
int iIBCurr = (int)arrTri_in[iSeqIV];
if (iIBCurr == iterIV)
{
arrIBConvert[iSeqIV] = iIVConvert;
}
}
}
} // for(int iterIV=0; iterIV<arrVertex_in.size(); ++iterIV)
//@ Overlap vertex
if (0 < iCntSameVer__)
{
Debug.Log("Notice! (overlapped:" + iCntSameVer__ + " vertices.) Count of exactly same position vertices//constructAllTris_IVrecompute()//arrTri_in.Length=" + arrTri_in.Length);
}
//@Insert only validation succeeded triangle.
CTRI triCurrent;
int iSeqTriCurr = 0, iSeqTri_ = 0;
Vector3 v3MinAABB = new Vector3(CMATH.FLOAT_MAX, CMATH.FLOAT_MAX, CMATH.FLOAT_MAX),
v3MaxAABB = new Vector3(-CMATH.FLOAT_MAX, -CMATH.FLOAT_MAX, -CMATH.FLOAT_MAX);
Vector3 v3VerTri;
//@ overlap triangles
int iCntExactlySameTris = 0, iCntNotValidatePoly = 0;
List <CTRI> listTriOverlap = new List <CTRI>();
for (int iSeqIdx = 0, iTri = 0; iSeqIdx < iCntIV; iSeqIdx += 3, ++iTri)
{
ariTriIdx[0] = arrIBConvert[iSeqIdx];
ariTriIdx[1] = arrIBConvert[iSeqIdx + 1];
ariTriIdx[2] = arrIBConvert[iSeqIdx + 2];
for (int itV = 0; itV < 3; ++itV)
{
v3VerTri = new Vector3(arrVertex_in[ariTriIdx[itV]].x, arrVertex_in[ariTriIdx[itV]].y, arrVertex_in[ariTriIdx[itV]].z);
if (v3VerTri.x > v3MaxAABB.x)
{
v3MaxAABB.x = v3VerTri.x;
}
if (v3VerTri.y > v3MaxAABB.y)
{
v3MaxAABB.y = v3VerTri.y;
}
if (v3VerTri.z > v3MaxAABB.z)
{
v3MaxAABB.z = v3VerTri.z;
}
if (v3VerTri.x < v3MinAABB.x)
{
v3MinAABB.x = v3VerTri.x;
}
if (v3VerTri.y < v3MinAABB.y)
{
v3MinAABB.y = v3VerTri.y;
}
if (v3VerTri.z < v3MinAABB.z)
{
v3MinAABB.z = v3VerTri.z;
}
arrv3TriVer[itV] = v3VerTri;
}
triCurrent = new CTRI();
triCurrent.Set(arrv3TriVer, ariTriIdx);
if (true == triCurrent.isValidateASPoly())
{
bool bBeExistExactlysame = false;
for (int iSeqIdx__ = 0; iSeqIdx__ < iSeqTriCurr; ++iSeqIdx__)
{
if (iSeqIdx__ != iSeqIdx)
{
CTRI tri__ = listTris_out[iSeqIdx__];
if (tri__.isEqual(triCurrent))
{
//FORTEST
++iCntExactlySameTris;
listTriOverlap.Add(triCurrent);
//FORTEST
bBeExistExactlysame = true;
break;
}
}
} // for (int iSeqIdx__ = 0; iSeqIdx__ < iSeqTriCurr; ++iSeqIdx__)
if (false == bBeExistExactlysame)
{
iSeqTriCurr = iSeqTri_++;
listTris_out.Add(triCurrent);
}
else
{
Debug.Log("!ERROR. Overlapped Triangle. Exist Exactly same TRI");
}
} // if(true==triCurrent.isValidateASPoly())
else
{ // //CHECKOVERLAPPED
++iCntNotValidatePoly;
} // if(true==triCurrent.isValidateASPoly())
} // for( uint iSeqIdx=0, iTri=0; iSeqIdx<iCntIV; iSeqIdx+=3,++iTri )
//CHECKOVERLAPPED
//@ maya에서 같은 위치에 Overlap된 polygon 작업이 있는 지 여부 검사.
if (listTriOverlap.Count > 0)
{
int iSeq = 0;
foreach (CTRI triOverlap in listTriOverlap)
{
m_drawRenderMesh_forcheckoverlap.DrawNewRendermesh(CMATH.INT_MAX_DIV248 + (iSeq++), triOverlap._arrv3PT, color_overllaped_triangle, CMATH.FEPSILON_F2, -1.0f);
}
string strDebugOut = "!ERROR triangles overlapped. //count=" + listTriOverlap.Count + "\n";
strDebugOut += "!constructAllTris_IVrecompute:CountTris=" + listTris_out.Count + "//" +
"ExactlySameTris=" + iCntExactlySameTris + "//" + "NoValidateTris=" + iCntNotValidatePoly + "//" + UnityEngine.Random.Range(10.0f, 10000.0f);
Debug.Log(strDebugOut);
} // if(listTriOverlap.Count > 0)
//CHECKOVERLAPPED
return(true);
} //protected bool CTriContainer::constructAllTris_IVrecompute(
//@ Construct Triangle
public bool InsertNewTri(int iSeqTri, CTRI tri_in, bool bConfirm)
{
bool bAlreadyExisted = false;
if (_listIdxTris.Count > 0)
{
bAlreadyExisted = (-1 < _listIdxTris.BinarySearch(iSeqTri));
}
if (true == bAlreadyExisted)
{
return(false);
}
for (int iPnt = 0; iPnt < tri_in._arrv3PT.Length; ++iPnt)
{
_listv3PntsSrc.Add(tri_in._arrv3PT[iPnt]);
}
if (_listv3Pnts.Count < 1)
{
SetNewTri(iSeqTri, tri_in);
}
else
{
List <Vector3> listInsertPnt = new List <Vector3>();
bool bAlreadyPutin = false;
for (int iPntTri = 0; iPntTri < 3; ++iPntTri)
{
Vector3 v3PntTri = tri_in._arrv3PT[iPntTri];
bAlreadyPutin = false;
for (int iSeqPnt = 0; iSeqPnt < _listv3Pnts.Count; ++iSeqPnt)
{
Vector3 v3Pnt_ = _listv3Pnts[iSeqPnt];
if (CMATH.similarVector3_f2(v3PntTri, v3Pnt_))
{
bAlreadyPutin = true;
break;
}
}
if (false == bAlreadyPutin)
{
listInsertPnt.Add(v3PntTri);
}
} // for(int iPntTri = 0; iPntTri < 3; ++iPntTri)
if (listInsertPnt.Count > 0)
{
if (listInsertPnt.Count == tri_in._arrv3PT.Length)
{
Debug.Log("(Wrong value.//listInsertPnt.Count > 0)//(listInsertPnt.Count == tri_in._arrv3PT.Length)//");
}
for (int iSeq = 0; iSeq < listInsertPnt.Count; ++iSeq)
{
Vector3 v3Pnt = listInsertPnt[iSeq];
_listv3Pnts.Add(v3Pnt);
}
listInsertPnt.Clear();
} // if(listInsertPnt.Count>0)
_listIdxTris.Add(iSeqTri);
_listIdxTris.Sort();
} // if(_listv3Pnts.Count<1)
tri_in.SetBaseLinked(this);
return(true);
} // public void InsertNewTri(int iSeqTri, CTRI tri_in)
//@ Actually build up relationship with adjacent Cells and calculate cost of the way to GOAL.
//@ Not acceptable 1 or more NULL CELL which status is CNAVICELL.NULL_CELL
protected bool BuildAdjacentATri(ref CNAVICELL cellLeft,
ref CNAVICELL[] arrNavicells)
{
if (true == cellLeft.DidSetAllAdjacent())
{
return(false);
}
int[] aruiIVleft = cellLeft.trilinkcell._arriIV;
int[] aruiIVRight;
bool bFoundShared = false;
int iFoundShared = 0;
int[] ariPointsShared_left = new int[3];
int[] ariPointsShared_right = new int[3];
int iCntCells = arrNavicells.Length;
for (int iSeqcell = 0; iSeqcell < iCntCells; ++iSeqcell)
{
CNAVICELL cellRight = arrNavicells[iSeqcell];
CTRI triRight_ = cellRight.trilinkcell;
if (cellRight.seqCell == cellLeft.seqCell)
{
continue;
}
for (int i = 0; i < 3; ++i)
{
ariPointsShared_left[i] = ariPointsShared_right[i] = CNAVICELL.NULL_CELL;
}
aruiIVRight = triRight_._arriIV;
iFoundShared = 0;
int iSharedIV_left = 0, iSharedIV_right = 0;
for (int iL = 0; iL < 3; ++iL)
{
for (int iR = 0; iR < 3; ++iR)
{
if (aruiIVleft[iL] == aruiIVRight[iR])
{
ariPointsShared_left[iL] = aruiIVleft[iL];
ariPointsShared_right[iR] = aruiIVRight[iR];
iSharedIV_left = iSharedIV_left + iL;
iSharedIV_right = iSharedIV_right + iR;
++iFoundShared;
}
} // for( int iR=0; iR<3; ++iR )
} // for( int iL=0; iL<3; ++iL )
bFoundShared = (iFoundShared > 1);
if (true == bFoundShared)
{
if (iFoundShared > 2)
{
break;
}
cellLeft.SetAdjacentCell(CNAVICELL.getTypeEdge(iSharedIV_left), cellRight.seqCell);
cellRight.SetAdjacentCell(CNAVICELL.getTypeEdge(iSharedIV_right), cellLeft.seqCell);
if (cellLeft.DidSetAllAdjacent() == true)
{
break;
}
} // if( iFoundShared>1 )
} // for( it_=iterBegin; it_!=iterEnd; ++it_ )
return(true);
} // protected bool BuildAdjacentATri
