//============================================================================
// common.cpp : pt-list common object and object list class implementation
//============================================================================

#include "common.hpp"

//----------------------------------------------------------------------------
// OBJECT
//----------------------------------------------------------------------------

// DEFAULT CONSTRUCTOR AND THE DESTRUCTOR
PtSetObj::PtSetObj() 
{ 
  NumPts=0; 
}

PtSetObj::~PtSetObj() 
{ 
  delete[] Pts; 
}
     
// POINT-LIST OBJECT CONSTRUCTOR
PtSetObj::PtSetObj(int numpts, int id)
{
  ID = id;
  NumPtsAlloced = numpts;
  Pts = new Vect3d[NumPtsAlloced];
  NumPts = 0;        // NO POINTS ACTUALLY ADDED YET!
}

// POINT-LIST OBJECT CONSTRUCTOR (ID becomes ptr to Vect3d array - Vect3d*)
PtSetObj::PtSetObj(int numpts)
{
  NumPtsAlloced = numpts;
  Pts = new Vect3d[NumPtsAlloced];
  NumPts = 0;        // NO POINTS ACTUALLY ADDED YET!
  ID = (int)Pts;
}

// TRIANGLE OBJECT CONSTRUCTOR (COMMON)
PtSetObj::PtSetObj(Vect3d A, Vect3d B, Vect3d C, int id)
{
  ID = id;
  NumPts = 3;
  NumPtsAlloced = 3;
  Pts = new Vect3d[3];
  Pts[0]=A; Pts[1]=B; Pts[2]=C;
}

// ADDS A POINT TO THE POINT-LIST
void PtSetObj::AddPt(float x, float y, float z)
{
  if (NumPts==NumPtsAlloced) { printf("ERROR: too many points added!\n"); } 
  Pts[NumPts].Set(x,y,z);
  NumPts++;
}
     
// CALCULATE MEAN POINT OF THE POINT SET
void PtSetObj::CalcMean()
{
  MeanPt.Set(0,0,0);
  for (int i=0; i<NumPts; i++) MeanPt+=Pts[i];
  MeanPt /= (float)NumPts;
}

void PtSetObj::Print()
{
  printf("    Object ID: %d\n", ID);
  printf("       NumPts: %d\n", NumPts);
  printf("NumPtsAlloced: %d\n", NumPtsAlloced);
  for (int i=0; i<NumPts; i++)
  printf("       Pts[%d]: %f %f %f\n", i, Pts[i].x, Pts[i].y, Pts[i].z);
}  

//----------------------------------------------------------------------------
// OBJECT LIST
//----------------------------------------------------------------------------

PtSetObjList::PtSetObjList(int numobjs) 
{
  NumObjs = 0;       // NUMBER ACTUALLY ADDED
  NumObjsAlloced = numobjs;
  Objs = new int[NumObjsAlloced];
}
     
// CONSTRUCTOR FOR READING MODEL DIRECTLY FROM TRI FILE
PtSetObjList::PtSetObjList(char* FileName)
{ 
  printf("loading tris [%s]. . .", FileName);
  FILE* fp = fopen(FileName,"r");     // OPEN THE "TRIANGLE" FILE
  if (fp==NULL) { printf("ERROR: Cannot open tris file [%s]!\n", FileName); }
  fscanf(fp, "%d", &NumObjsAlloced);  // READ IN # OF TRIS
  Objs = new int[NumObjsAlloced];     // ALLOCATE OBJECT LIST
  NumObjs = 0;                        // SET # OBJECTS ACTUALLY ADDED
  Vect3d A,B,C;                       // STORAGE FOR TRIANGLE VERTICES
  for (int i=0; i<NumObjsAlloced; i++)       // READ IN THE TRIS
  {
    fscanf(fp,"%f %f %f %f %f %f %f %f %f", 
           &A.x,&A.y,&A.z,&B.x,&B.y,&B.z,&C.x,&C.y,&C.z);
    AddTri(A,B,C,i);                  // ADD THE TRI (ID IS TRI INDEX)
  }
  fclose(fp);
  printf("DONE!\n");
}

PtSetObjList::~PtSetObjList()
{ 
  delete[] Objs;
}

void PtSetObjList::AddPtSetObj(PtSetObj* NewPtSetObj)
{ 
  if (NumObjs==NumObjsAlloced) { printf("ERROR: too many objects added!\n"); }
  NewPtSetObj->CalcMean();
  Objs[NumObjs] = (int)NewPtSetObj;
  NumObjs++;
}
    
void PtSetObjList::AddTri(Vect3d A, Vect3d B, Vect3d C, int id)
{ 
  PtSetObj* TriObj = new PtSetObj(A,B,C,id);  // CREATE A TRIANGLE OBJECT (ptr to it)
  AddPtSetObj(TriObj);
}
      
void PtSetObjList::Print()
{ 
  printf("       NumObjs: %d\n", NumObjs);
  printf("NumObjsAlloced: %d\n", NumObjsAlloced);
  printf("--------------------\n");
  for (int i=0; i<NumObjs; i++) ((PtSetObj*)Objs[i])->Print();
}