// DECLARATION:

class BoundingVolume
{
	public:

		enum TestResult
		{
			TEST_OUTSIDE,
			TEST_INTERSECT,
			TEST_INSIDE
		};

	public:
	
		virtual TestResult testIntersection( const vec3 &point ) const = 0;
		virtual TestResult testIntersection( shared_ptr<const BoundingBox> box ) const = 0;
		virtual TestResult testIntersection( shared_ptr<const BoundingSphere> sphere ) const = 0;
};

class BoundingBox : public BoundingVolume
{
	public:
	
		vec3 minimum;
		vec3 maximum;
		
		vec3 position;

	public:

		BoundingBox( vec3 minimum, vec3 maximum, vec3 position = vec3(0.0f) ) : BoundingVolume()
		{
			this->minimum = minimum;
			this->maximum = maximum;
			
			this->position = position;
		}

		virtual vec3 getPositiveVertex( const vec3 &normal ) const;
		virtual vec3 getNegativeVertex( const vec3 &normal ) const;

		TestResult testIntersection( const vec3 &point ) const;
		TestResult testIntersection( shared_ptr<const BoundingBox> box ) const;
		TestResult testIntersection( shared_ptr<const BoundingSphere> sphere ) const;
};

class Frustum : public BoundingVolume
{
	public:

		enum Plane
		{
			PLANE_BACK,
			PLANE_FRONT,
			PLANE_RIGHT,
			PLANE_LEFT,
			PLANE_TOP,
			PLANE_BOTTOM
		};

	public:

		Frustum( const mat4 &viewMatrix, const mat4 &projectionMatrix );

		const vec4 &getPlane( const int plane ) const;
		
		TestResult testIntersection( const vec3 &point ) const;
		TestResult testIntersection( shared_ptr<const BoundingBox> box ) const;
		TestResult testIntersection( shared_ptr<const BoundingSphere> sphere ) const;

   	protected:

		vec4 m_planes[6];
};



// RELEVANT IMPLEMENTATION:

// compute frustum planes from view and projection matrices
Frustum::Frustum( const mat4 &viewMatrix, const mat4 &projectionMatrix ) : BoundingVolume()
{
	const mat4 &v = viewMatrix;
	const mat4 &p = projectionMatrix;

	mat4 clipMatrix;

	clipMatrix[0][0] = v[0][0 ]*p[0][0]+v[0][1]*p[1][0]+v[0][2]*p[2][0]+v[0][3]*p[3][0];
	clipMatrix[1][0] = v[0][0]*p[0][1]+v[0][1]*p[1][1]+v[0][2]*p[2][1]+v[0][3]*p[3][1];
	clipMatrix[2][0] = v[0][0]*p[0][2]+v[0][1]*p[1][2]+v[0][2]*p[2][2]+v[0][3]*p[3][2];
	clipMatrix[3][0] = v[0][0]*p[0][3]+v[0][1]*p[1][3]+v[0][2]*p[2][3]+v[0][3]*p[3][3];
	clipMatrix[0][1] = v[1][0]*p[0][0]+v[1][1]*p[1][0]+v[1][2]*p[2][0]+v[1][3]*p[3][0];
	clipMatrix[1][1] = v[1][0]*p[0][1]+v[1][1]*p[1][1]+v[1][2]*p[2][1]+v[1][3]*p[3][1];
	clipMatrix[2][1] = v[1][0]*p[0][2]+v[1][1]*p[1][2]+v[1][2]*p[2][2]+v[1][3]*p[3][2];
	clipMatrix[3][1] = v[1][0]*p[0][3]+v[1][1]*p[1][3]+v[1][2]*p[2][3]+v[1][3]*p[3][3];
	clipMatrix[0][2] = v[2][0]*p[0][0]+v[2][1]*p[1][0]+v[2][2]*p[2][0]+v[2][3]*p[3][0];
	clipMatrix[1][2] = v[2][0]*p[0][1]+v[2][1]*p[1][1]+v[2][2]*p[2][1]+v[2][3]*p[3][1];
	clipMatrix[2][2] = v[2][0]*p[0][2]+v[2][1]*p[1][2]+v[2][2]*p[2][2]+v[2][3]*p[3][2];
	clipMatrix[3][2] = v[2][0]*p[0][3]+v[2][1]*p[1][3]+v[2][2]*p[2][3]+v[2][3]*p[3][3];
	clipMatrix[0][3] = v[3][0]*p[0][0]+v[3][1]*p[1][0]+v[3][2]*p[2][0]+v[3][3]*p[3][0];
	clipMatrix[1][3] = v[3][0]*p[0][1]+v[3][1]*p[1][1]+v[3][2]*p[2][1]+v[3][3]*p[3][1];
	clipMatrix[2][3] = v[3][0]*p[0][2]+v[3][1]*p[1][2]+v[3][2]*p[2][2]+v[3][3]*p[3][2];
	clipMatrix[3][3] = v[3][0]*p[0][3]+v[3][1]*p[1][3]+v[3][2]*p[2][3]+v[3][3]*p[3][3];

	m_planes[PLANE_RIGHT].x = clipMatrix[3][0]-clipMatrix[0][0];
	m_planes[PLANE_RIGHT].y = clipMatrix[3][1]-clipMatrix[0][1];
	m_planes[PLANE_RIGHT].z = clipMatrix[3][2]-clipMatrix[0][2];
	m_planes[PLANE_RIGHT].w = clipMatrix[3][3]-clipMatrix[0][3];

	m_planes[PLANE_LEFT].x = clipMatrix[3][0]+clipMatrix[0][0];
	m_planes[PLANE_LEFT].y = clipMatrix[3][1]+clipMatrix[0][1];
	m_planes[PLANE_LEFT].z = clipMatrix[3][2]+clipMatrix[0][2];
	m_planes[PLANE_LEFT].w = clipMatrix[3][3]+clipMatrix[0][3];

	m_planes[PLANE_BOTTOM].x = clipMatrix[3][0]+clipMatrix[1][0];
	m_planes[PLANE_BOTTOM].y = clipMatrix[3][1]+clipMatrix[1][1];
	m_planes[PLANE_BOTTOM].z = clipMatrix[3][2]+clipMatrix[1][2];
	m_planes[PLANE_BOTTOM].w = clipMatrix[3][3]+clipMatrix[1][3];

	m_planes[PLANE_TOP].x = clipMatrix[3][0]-clipMatrix[1][0];
	m_planes[PLANE_TOP].y = clipMatrix[3][1]-clipMatrix[1][1];
	m_planes[PLANE_TOP].z = clipMatrix[3][2]-clipMatrix[1][2];
	m_planes[PLANE_TOP].w = clipMatrix[3][3]-clipMatrix[1][3];

	m_planes[PLANE_BACK].x = clipMatrix[3][0]-clipMatrix[2][0];
	m_planes[PLANE_BACK].y = clipMatrix[3][1]-clipMatrix[2][1];
	m_planes[PLANE_BACK].z = clipMatrix[3][2]-clipMatrix[2][2];
	m_planes[PLANE_BACK].w = clipMatrix[3][3]-clipMatrix[2][3];

	m_planes[PLANE_FRONT].x = clipMatrix[3][0]+clipMatrix[2][0];
	m_planes[PLANE_FRONT].y = clipMatrix[3][1]+clipMatrix[2][1];
	m_planes[PLANE_FRONT].z = clipMatrix[3][2]+clipMatrix[2][2];
	m_planes[PLANE_FRONT].w = clipMatrix[3][3]+clipMatrix[2][3];

	for( int i = 0; i < 6; i++ )
	{
		m_planes[i] = glm::normalize( m_planes[i] );
	}
}

// check whether an AABB intersects the frustum
BoundingVolume::TestResult Frustum::testIntersection( shared_ptr<const BoundingBox> box ) const
{
	TestResult result = TEST_INSIDE;

	for( uint i = 0; i < 6; i++ )
	{
		const float pos = m_planes[i].w;
		const vec3 normal = vec3(m_planes[i]);

		if( glm::dot(normal, box->getPositiveVertex(normal))+pos < 0.0f )
		{
			return TEST_OUTSIDE;
		}

		if( glm::dot(normal, box->getNegativeVertex(normal))+pos < 0.0f )
		{
			result = TEST_INTERSECT;
		}
	}

	return result;
}

vec3 BoundingBox::getPositiveVertex( const vec3 &normal ) const
{
	vec3 positiveVertex = minimum;

	if( normal.x >= 0.0f ) positiveVertex.x = maximum.x;
	if( normal.y >= 0.0f ) positiveVertex.y = maximum.y;
	if( normal.z >= 0.0f ) positiveVertex.z = maximum.z;

	return position+positiveVertex;
}

vec3 BoundingBox::getNegativeVertex( const vec3 &normal ) const
{
	vec3 negativeVertex = maximum;

	if( normal.x >= 0.0f ) negativeVertex.x = minimum.x;
	if( normal.y >= 0.0f ) negativeVertex.y = minimum.y;
	if( normal.z >= 0.0f ) negativeVertex.z = minimum.z;

	return position+negativeVertex;
}