#ifndef __TRIANGLE_HPP
#define __TRIANGLE_HPP

#include "plane.hpp"
#include <string.h>

typedef Vector Triangle[3];

/*******************************************************************************
** TriangleCopy
*******************************************************************************/
inline void
TriangleCopy(Triangle dst, Triangle src)
{
   memcpy(dst, src, sizeof(Triangle));
}
/*******************************************************************************
** TrianglesAreEqual
*******************************************************************************/
inline int
TrianglesAreEqual(Triangle a, Triangle b)
{
   return
      VectorsAreEqual(a[0], b[0]) &&
      VectorsAreEqual(a[1], b[1]) &&
      VectorsAreEqual(a[2], b[2]);     
}
/*******************************************************************************
** TriangleNormal
*******************************************************************************/
inline void
TriangleNormal(Vector normal, Triangle triangle)
{
   Vector A, B;

   VectorSubtract(A, triangle[1], triangle[0]);
   VectorSubtract(B, triangle[2], triangle[1]);
   VectorCrossProduct(normal, A, B);
   VectorNormalize(normal, normal);
}

/*******************************************************************************
** TrianglePlane
*******************************************************************************/
inline void
TrianglePlane(Triangle dst, Plane plane)
{
   Vector normal;

   TriangleNormal(normal, dst);
   
   PlaneInit(plane, normal, dst[0]); 
}
/*******************************************************************************
** TriangleTransform
*******************************************************************************/
inline void
TriangleTransform(Triangle dst, Triangle src, Matrix matrix)
{
   VectorTransform(dst[0], src[0], matrix);
   VectorTransform(dst[1], src[1], matrix);
   VectorTransform(dst[2], src[2], matrix);
}
/*******************************************************************************
** TriangleEdges
*******************************************************************************/
inline void
TriangleEdges(Triangle dst, Triangle src)
{
   VectorSubtract(dst[0], src[1], src[0]);
   VectorSubtract(dst[1], src[2], src[1]);
   VectorSubtract(dst[2], src[0], src[2]);   
}
/*******************************************************************************
** TriangleHull
*******************************************************************************/
inline void
TriangleHull(Plane hull[3], Triangle triangle)
{
   Vector   normal, v;
   Triangle edges;
   
   VectorSubtract(edges[0], triangle[1], triangle[0]);
   VectorSubtract(edges[1], triangle[2], triangle[1]);
   VectorSubtract(edges[2], triangle[0], triangle[2]);

   VectorCrossProduct(normal, edges[0], edges[1]);

   VectorCrossProduct(v, edges[0], normal); PlaneInit(hull[0], v, triangle[0]);
   VectorCrossProduct(v, edges[1], normal); PlaneInit(hull[1], v, triangle[1]);
   VectorCrossProduct(v, edges[2], normal); PlaneInit(hull[2], v, triangle[2]);      
}
/*******************************************************************************
** TriangleScan
*******************************************************************************/
inline int
TriangleScan(Triangle dst, FILE* fp)
{
   return fscanf(fp, "%f %f %f %f %f %f %f %f %f",
         &dst[0][0], &dst[0][1], &dst[0][2],
         &dst[1][0], &dst[1][1], &dst[1][2],
         &dst[2][0], &dst[2][1], &dst[2][2]) == 9;
}
/*******************************************************************************
** TrianglePrint
*******************************************************************************/
inline int
TrianglePrint(Triangle dst, FILE* fp)
{
   return fprintf(fp, "%f %f %f %f %f %f %f %f %f\n",
         &dst[0][0], &dst[0][1], &dst[0][2],
         &dst[1][0], &dst[1][1], &dst[1][2],
         &dst[2][0], &dst[2][1], &dst[2][2]) > 0;
}

#endif