/*]  Copyright (c) 2009-2010, Charles McGarvey  [**************************
**]  All rights reserved.
*
* vi:ts=4 sw=4 tw=75
*
* Distributable under the terms and conditions of the 2-clause BSD license;
* see the file COPYING for a complete text of the license.
*
**************************************************************************/

#ifndef _MOOF_LINE_HH_
#define _MOOF_LINE_HH_

#include <Moof/Drawable.hh>
#include <Moof/Math.hh>
#include <Moof/OpenGL.hh>
#include <Moof/Ray.hh>
#include <Moof/Shape.hh>
#include <Moof/Texture.hh>


namespace Mf {


template <int D>
struct Line : public Drawable, public Shape<D>
{
	typedef cml::vector< Scalar, cml::fixed<D> > Vector;

	Vector	a;
	Vector	b;


	Line() {}

	Line(const Vector& point1, const Vector& point2) :
		a(point1),
		b(point2) {}

	bool intersectRay(const Ray<2>& ray, Ray<2>::Intersection& hit) const
	{
		// solve: Cx + r*Dx = Ax + s(Bx - Ax)
		//        Cy + r*Dy = Ay + s(By - Ay)
		// where: 0 <= s <= 1 if intersection
		// given: A = a
		//        B = b
		//        C = ray.point
		//        D = ray.direction

		Scalar denom = ray.direction[0] * (b[1] - a[1]) +
					   ray.direction[1] * (a[0] - b[0]);

		// check if the ray and line are parallel
		//if (isEqual(denom, SCALAR(0.0)))
		if (denom == SCALAR(0.0))
		{
			Scalar numer = a[0] * (ray.point[1] - b[1]) +
						   b[0] * (a[1] - ray.point[1]) +
						   ray.point[0] * (b[1] - a[1]);

			// check if they are collinear
			if (isEqual(numer, SCALAR(0.0)))
			{
				hit.distance = SCALAR(0.0);
				hit.normal.set(0.0, 0.0);
				return true;
			}

			return false;
		}

		Scalar s = (ray.direction[0] * (ray.point[1] - a[1]) +
					ray.direction[1] * (a[0] - ray.point[0])) / denom;

		// check if the ray hits the segment
		if (s < SCALAR(0.0) || s > SCALAR(1.0)) return false;

		hit.distance = -(a[0] * (ray.point[1] - b[1]) +
						 b[0] * (a[1] - ray.point[1]) +
						 ray.point[0] * (b[1] - a[1])) / denom;
		if (hit.distance < SCALAR(0.0)) return false;

		Vector normal = cml::perp(a - b);
		if (cml::dot(a - ray.point, normal) < 0) hit.normal = normal;
		else                                     hit.normal = -normal;
		return true;
	}

	void draw(Scalar alpha = 0.0) const
	{
		Mf::Texture::resetBind();
		glBegin(GL_LINES);
			glVertex(a);
			glVertex(b);
		glEnd();
	}
};


template <int D, int N>
struct Polygon : public Shape<D>
{
	typedef cml::vector< Scalar, cml::fixed<D> > Vector;

	Vector	points[N];
};


} // namespace Mf

#endif // _MOOF_LINE_HH_