//----------------------------------------------------------------------------
// William Baxter III's Ray Tracer
//
//     Project for Comp 238, Raster Graphics
//     University of North Carolina at Chapel Hill
//     
// $Id:$
//----------------------------------------------------------------------------

#ifndef WB3TRIANGLE_H
#define WB3TRIANGLE_H

#include <vec3f.hpp>
#include "wb3Plane.hpp"

class wb3Triangle : public wb3Plane
{
public:
  wb3Triangle(const Vec3f& p1, const Vec3f& p2, const Vec3f& p3);
  wb3Triangle(const Vec3f verts[3]);
  ~wb3Triangle();

  virtual const wb3Artifact* Intersect(const Ray3f& r, float *dist,
                                       const wb3Artifact* ignore =0) const;
  
  float Dist(const Vec3f& point) const;

  void Set(const Vec3f& normal, const Vec3f& point);
  void SetPoint(const Vec3f& point);
  void Normalize();

protected:
  int ptInTri3D(const Vec3f& P) const;

  bool m_bBFCull; // backface culling or not
  Vec3f m_vert[3];  // verticies of triangle
};


//----------------------------------------------------------------------------
inline wb3Triangle::wb3Triangle(
  const Vec3f& p0, const Vec3f& p1, const Vec3f& p2)
{
  m_vert[0] = p0;
  m_vert[1] = p1;
  m_vert[2] = p2;
  // compute normal to plane
  Vec3f u(p1-p0);
  Vec3f v(p2-p0);
  m_N = u/v; // cross prod
  m_N.Normalize();
  // last part of plane eq
  m_fD = -(p0 * m_N);
} 
//----------------------------------------------------------------------------
inline wb3Triangle::wb3Triangle(const Vec3f verts[3])
{
  m_vert[0] = verts[0];
  m_vert[1] = verts[1];
  m_vert[2] = verts[2];
  // compute normal to plane
  Vec3f u(verts[1]-verts[0]);
  Vec3f v(verts[2]-verts[0]);
  m_N = u/v; // cross prod
  m_N.Normalize();
  // last part of plane eq
  m_fD = -(verts[0] * m_N);
} 
//----------------------------------------------------------------------------
inline void wb3Triangle::SetPoint(const Vec3f& point)
{
  m_fD = -(point * m_N);
}
//----------------------------------------------------------------------------
inline void wb3Triangle::Normalize()
{
  float len = m_N.Length();
  if (len>0) {
    float leninv = 1.0f/len;
    m_N *= leninv;
    m_fD *= leninv;
  }
}
//----------------------------------------------------------------------------
inline float wb3Triangle::Dist(const Vec3f &point) const
{
  // i don't think this is correct
  return (point * m_N) + m_fD;
} 
//----------------------------------------------------------------------------
inline void wb3Triangle::Set(const Vec3f& normal, const Vec3f& point)
{
  m_N = normal;
  m_fD = -(point * m_N);
}
//----------------------------------------------------------------------------
#endif