/*]  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.
*
**************************************************************************/

#include <Moof/Aabb.hh>
#include <Moof/Frustum.hh>
#include <Moof/Sphere.hh>


namespace Mf {


void Frustum::init(const Matrix4& modelview, const Matrix4& projection)
{
	Scalar planes[6][4];

	cml::extract_frustum_planes(modelview, projection, planes,
								cml::z_clip_neg_one);

	mPlanes[0] = Plane(planes[0][0], planes[0][1],
					   planes[0][2], planes[0][3]);
	mPlanes[1] = Plane(planes[1][0], planes[1][1],
					   planes[1][2], planes[1][3]);
	mPlanes[2] = Plane(planes[2][0], planes[2][1],
					   planes[2][2], planes[2][3]);
	mPlanes[3] = Plane(planes[3][0], planes[3][1],
					   planes[3][2], planes[3][3]);
	mPlanes[4] = Plane(planes[4][0], planes[4][1],
					   planes[4][2], planes[4][3]);
	mPlanes[5] = Plane(planes[5][0], planes[5][1],
					   planes[5][2], planes[5][3]);
}

void Frustum::init(const Matrix4& modelview, Scalar fovy, Scalar aspect,
				   Scalar abutting, Scalar distant)
{
	Matrix4 projection;

	cml::matrix_perspective_yfov_RH(projection, fovy, aspect, abutting,
									distant, cml::z_clip_neg_one);

	init(modelview, projection);
}

Frustum::Collision Frustum::contains(const Aabb<3>& aabb) const
{
	Vector3 corners[8];
	int nTotalInside = 0;

	aabb.getCorners(corners);

	for (int i = 0; i < 6; ++i)
	{
		int nInside = 8;

		for (int j = 0; j < 8; ++j)
		{
			if (mPlanes[i].intersects(corners[j]) == Plane::NEGATIVE)
			{
				--nInside;
			}
		}

		if (nInside == 0)      return OUTSIDE;
		else if (nInside == 8) ++nTotalInside;
	}

	if (nTotalInside == 6) return INSIDE;
	else                   return INTERSECT;
}


Frustum::Collision Frustum::contains(const Sphere<3>& sphere) const
{
	for (int i = 0; i < 6; ++i)
	{
		Plane::Halfspace halfspace = mPlanes[i].intersects(sphere);
		
		if (halfspace == Plane::NEGATIVE)       return OUTSIDE;
		else if (halfspace == Plane::INTERSECT) return INTERSECT;
	}

	return INSIDE;
}


} // namespace Mf