#include "CFTTConvex.h"
#include "CFTTPlane32.h"
#include "Matrix.h"
#include "XSYS.h"
//-------------------------------------------------------------------------------------------------
//001C1380 //^_^
CFTTConvex::CFTTConvex() {
}
//-------------------------------------------------------------------------------------------------
//001C1394 //^_^
CFTTConvex::CFTTConvex(TFTTVertex *p_r1, TFTTEdge *p_r2, TFTTFace *p_r3, uchar uc_arg_0, uchar uc_arg_4, uchar uc_arg_8) {
}
//-------------------------------------------------------------------------------------------------
//001C13B8 //^_^
CFTTConvex::~CFTTConvex() {
}
//-------------------------------------------------------------------------------------------------
//001C0418 //^_^
void CFTTConvex::Set(TFTTVertex *p_r1_arg, TFTTEdge *p_r2_arg, TFTTFace *p_r3, uchar uc_arg0, uchar uc_arg4, uchar uc_arg8) {
}
//-------------------------------------------------------------------------------------------------
//001C0488
//???问题：常量赋值
void CFTTConvex::Split(CFTTPlane32 const &plane_r1_arg, CFTTConvex *&p_convex_r2_arg) {
  return;
}
//-------------------------------------------------------------------------------------------------
//001C0734 //^_^
void CFTTConvex::SetTetraBuffer(TFTTTetrahedron *p_r1_arg, uchar uc_r2_arg) {
}
//-------------------------------------------------------------------------------------------------
//001C0B24
//???汇编指令完全相同，寄存器不同
float CFTTConvex::GetVolume(bool b_r1_arg) {
  return 0;
}
//-------------------------------------------------------------------------------------------------
//001C0B60
//static函数
uint CFTTConvex::Split(CFTTPlane32 const &plane32_r1_arg, CFTTConvex *&p_convex_r2_arg, CFTTConvex *&p_convex_r3_arg) {
  return 0;
}
//-------------------------------------------------------------------------------------------------
//001C0BA4
uchar CFTTConvex::GetNumTetras() {
  return 0;
}
//-------------------------------------------------------------------------------------------------
//001C0BAC
CFTTVector32 CFTTConvex::GenerateRandomTetra() {
	CFTTVector32 ret;
	return ret;
}
//-------------------------------------------------------------------------------------------------
//001C0D00
void CFTTConvex::SetTriangleBuffer(TFTTTriangle *, uchar) {
}
//-------------------------------------------------------------------------------------------------
//001C0D10
void CFTTConvex::GenerateTriangles() {
}
//-------------------------------------------------------------------------------------------------
//001C107C
void CFTTConvex::ProjectTriangles(CFTTVector32) {
}
//-------------------------------------------------------------------------------------------------
//001C11EC
float CFTTConvex::GetArea(bool) {
	return 0;
}
//-------------------------------------------------------------------------------------------------
//001C122C
CFTTVector32 CFTTConvex::GenerateRandomTri(CFTTVector32) {
	CFTTVector32 ret;
	return ret;
}
//-------------------------------------------------------------------------------------------------
//001C13F8
//???问题：优化了*(float*)((int)this->list_TFTTVertex_field_0 + i_r4，两次变一次
int CFTTConvex::GetSplitType(CFTTPlane32 const &plane_r1) {
  return 0;
}
//-------------------------------------------------------------------------------------------------
//001C148C
void CFTTConvex::FlipDistances() {
  int a = 0;
}
//-------------------------------------------------------------------------------------------------
//001C14B0
void CFTTConvex::Clip() {
}
//-------------------------------------------------------------------------------------------------
//001C14CE
void CFTTConvex::Clone(CFTTConvex const &) {
  int a = 0;
}
//-------------------------------------------------------------------------------------------------
//001C154C
void CFTTConvex::ProcessVertices() {
}
//-------------------------------------------------------------------------------------------------
//001C15BC
void CFTTConvex::ProcessEdges() {
}
//-------------------------------------------------------------------------------------------------
//001C16D8
void CFTTConvex::ProcessFaces() {
}
//-------------------------------------------------------------------------------------------------
//001C17FC
void CFTTConvex::Cleanup() {
}
//-------------------------------------------------------------------------------------------------
//001C1A28
bool CFTTConvex::GetOpenPolyline(TFTTFace const &, uchar &, uchar &) {
  return 0;
}
//-------------------------------------------------------------------------------------------------
// 001C0740 //^_-
//测试到第10关,OK
void CFTTConvex::GenerateTetrahedra() {
  uint iFaceCount_R12 = 0;

  // 001C074E
  for (uint8 i_R3 = 0; i_R3 < field_86; i_R3++) {  // 001C0756

    TFTTFace* pFace_i_r10 = list_TFTTFace_field_8 + i_R3;

    iFaceCount_R12 += (pFace_i_r10->field_8 + 0xFE);

    pFace_i_r10->field_0[0] = list_TFTTEdge_field_4[pFace_i_r10->field_4[0]].field_1;
    list_TFTTEdge_field_4[pFace_i_r10->field_4[0]].field_8 = 0;

    // 001C0760
    for (int j_R5 = 1; pFace_i_r10->field_8 > j_R5; j_R5++) {  // 001C079C
      int iIndex_e_j = pFace_i_r10->field_4[j_R5];
      TFTTEdge* pEdge_index_j = list_TFTTEdge_field_4 + iIndex_e_j;
      pEdge_index_j->field_8 = 1;
    }  // 001C07BE

    uint8 iCount_R0 = 0;
    // 001C07C2
    for (int j_R5 = 0; pFace_i_r10->field_8 > j_R5; j_R5++) {  // 001C07D0
      int iIndex_e_j = pFace_i_r10->field_4[j_R5];
      TFTTEdge* pEdge_index_j_r6 = list_TFTTEdge_field_4 + iIndex_e_j;

      // 001C07E8
      if (pEdge_index_j_r6->field_8) {  // 001C07EC
        float f_R12 = pEdge_index_j_r6->field_0;
        float f_R7  = pEdge_index_j_r6->field_1;
        // 001C07FA
        if (f_R12 == pFace_i_r10->field_0[iCount_R0]) {  // 001C07FE
          iCount_R0++;
          pFace_i_r10->field_0[iCount_R0] = f_R7;
          pEdge_index_j_r6->field_8 = 0;
          j_R5 = 0;
        }  // 001C0812
        // 001C0802
        else if (f_R7 == pFace_i_r10->field_0[iCount_R0]) {  // 001C0806
          iCount_R0++;
          pFace_i_r10->field_0[iCount_R0] = f_R12;
          pEdge_index_j_r6->field_8 = 0;
          j_R5 = 0;
        }  // 001C0812

        // 001C0818
        if (pFace_i_r10->field_8 - 1 == iCount_R0) {
          break;
        }
      }  // 001C07C8
    }    // 001C081C
  }      // 001C082E

  // 此处for判断 原版 ++ BCC跳入
  // loc_1C0840
  //	LDRB.W          R3, [R8,#0x85]
  //	CMP             R0, R3
  //	BCC             loc_1C0836
  // 新编译成了 -- BNE跳入
  //	CMP             R1, #0
  //	BNE             loc_BBAFC
  // 001C082E
  for (uint8 i_R0 = 0; i_R0 < field_85; i_R0++) {  // 001C0836
    list_TFTTEdge_field_4[i_R0].field_8 = 1;
  }  // 001C0848

  // 此处for判断 原版 ++ BCC跳入
  // loc_1C085A
  //	LDRB.W          R3, [R8,#0x84]
  //	CMP             R2, R3
  //	BCC             loc_1C0850
  // 新编译成了 -- BNE跳入
  //	CMP             R1, #0
  //	BNE             loc_BBB1E
  // 001C084C
  for (uint8 i_R2 = 0; i_R2 < field_84; i_R2++) {  // 001C0850
    list_TFTTVertex_field_0[i_R2].field_10 = 0;
  }  // 001C0862

  uint8 iTetraCount_R6 = 0;
  // 此处for判断 原版 ++ BCC跳入
  // loc_1C0964
  //	LDRB.W          R0, [R8,#0x86]
  //	CMP             R1, R0
  //	BCC.W           loc_1C086C
  // 新编译成了 -- BNE跳入
  //	CMP             R2, R4
  //	BNE             loc_BBB2A
  // 001C0862
  for (uint8 i_R1 = 0; i_R1 < field_86; i_R1++) {  // 001C086C
    TFTTFace* pFace_i = list_TFTTFace_field_8 + i_R1;
    uint8 iIndex_R4 = 0;
    uint8 iMax_R0 = pFace_i->field_0[0];

    // 001C0880
    for (uint8 j_R1 = 0; pFace_i->field_8 > j_R1; j_R1++) {  // 001C088A
      // 001C0890
      if (pFace_i->field_0[j_R1] < iMax_R0) {  // 001C0894
        iIndex_R4 = j_R1;
        iMax_R0 = pFace_i->field_0[j_R1];
      }  // 001C0898
    }    // 001C08A0

    uint8 iMod0 = (iIndex_R4 + 1) % pFace_i->field_8;
    // 001C08BA
    for (uint8 j_R10 = 0; pFace_i->field_8 - 2 > j_R10; j_R10++) {  // 001C08C0
      TFTTTetrahedron* pTetra_n = list_TFTTTetrahedron_field_7C + iTetraCount_R6;
      pTetra_n->field_30 = pFace_i->field_0[iIndex_R4];
      pTetra_n->field_31 = pFace_i->field_0[iMod0];

      uint8 iMod1 = (iIndex_R4 + 2 + j_R10) % pFace_i->field_8;
      pTetra_n->field_32 = pFace_i->field_0[iMod1];

      list_TFTTVertex_field_0[pFace_i->field_0[iIndex_R4]].field_10++;
      list_TFTTVertex_field_0[pFace_i->field_0[iMod0]].field_10++;
      list_TFTTVertex_field_0[pFace_i->field_0[iMod1]].field_10++;

      iTetraCount_R6++;
    }  // 001C095C
  }    // 001C096E

  uint8 iTetraCount_R1 = 0;
  // 001C0976
  for (uint8 i_R3 = 0; i_R3 < iFaceCount_R12; i_R3++) {  // 001C097A
    TFTTTetrahedron* pTetra_i = list_TFTTTetrahedron_field_7C + i_R3;
    // 001C098A && 001C0992 && 001C0998
    if (pTetra_i->field_30 != 0 && pTetra_i->field_31 != 0 && pTetra_i->field_32 != 0) {  // 001C099A
      TFTTTetrahedron* pTetra_n = list_TFTTTetrahedron_field_7C + iTetraCount_R1;
      pTetra_n->field_30 = pTetra_i->field_30;
      pTetra_n->field_31 = pTetra_i->field_31;
      pTetra_n->field_32 = pTetra_i->field_32;
      pTetra_n->field_33 = i_R3;
      iTetraCount_R1++;
    }  // 001C09BA

  }  // 001C09C2

  // float f_S16 = 6.0;

  field_87 = iTetraCount_R1;
  field_8C = 0;

  // 001C09CC
  for (uint8 i_R7 = 0; i_R7 < field_87; i_R7++) {  // 001C09DC
    TFTTTetrahedron* pTetra_i = list_TFTTTetrahedron_field_7C + i_R7;

    TFTTVertex* pVertex0_R0 = list_TFTTVertex_field_0 + pTetra_i->field_30;
    TFTTVertex* pVertex1_R3 = list_TFTTVertex_field_0 + pTetra_i->field_31;
    TFTTVertex* pVertex2_R3 = list_TFTTVertex_field_0 + pTetra_i->field_32;
    TFTTVertex* pVertex3_R1 = list_TFTTVertex_field_0 + pTetra_i->field_33;

    pTetra_i->vec32_0.float_0 = pVertex1_R3->vector_0.float_0 - pVertex0_R0->vector_0.float_0;
    pTetra_i->vec32_0.float_4 = pVertex1_R3->vector_0.float_4 - pVertex0_R0->vector_0.float_4;
    pTetra_i->vec32_0.float_8 = pVertex1_R3->vector_0.float_8 - pVertex0_R0->vector_0.float_8;

    pTetra_i->vec32_C.float_0 = pVertex2_R3->vector_0.float_0 - pVertex0_R0->vector_0.float_0;
    pTetra_i->vec32_C.float_4 = pVertex2_R3->vector_0.float_4 - pVertex0_R0->vector_0.float_4;
    pTetra_i->vec32_C.float_8 = pVertex2_R3->vector_0.float_8 - pVertex0_R0->vector_0.float_8;

    pTetra_i->vec32_18.float_0 = pVertex3_R1->vector_0.float_0 - pVertex0_R0->vector_0.float_0;
    pTetra_i->vec32_18.float_0 = pVertex3_R1->vector_0.float_4 - pVertex0_R0->vector_0.float_4;
    pTetra_i->vec32_18.float_0 = pVertex3_R1->vector_0.float_8 - pVertex0_R0->vector_0.float_8;

    pTetra_i->vec32_24.float_0 = pVertex0_R0->vector_0.float_0;
    pTetra_i->vec32_24.float_4 = pVertex0_R0->vector_0.float_4;
    pTetra_i->vec32_24.float_8 = pVertex0_R0->vector_0.float_8;
    // memcpy(&pTetra_i->vec32_24, &pVertex0_R0, 0x0C);
    CFTTVector32 vertor_var3C = CrossProduct(pTetra_i->vec32_C, pTetra_i->vec32_18);

    float fAll = pTetra_i->vec32_0.float_0 * vertor_var3C.float_0 +
                 pTetra_i->vec32_0.float_4 * vertor_var3C.float_4 +
                 pTetra_i->vec32_0.float_8 * vertor_var3C.float_8;
    fAll = fabs(fAll);
    fAll = fAll * 6.0;
    pTetra_i->field_34 = fAll;

    field_8C += pTetra_i->field_34;
  }  // 001C0B18
}