/*
 * Core
 */

#include "Core.h"

/*
 * InterpolateDirection
 */
float InterpolateDirection(uint32 nStart, uint32 nEnd, float fParameter)
{
	//A+t*(B-A)
	if(nStart == Direction_North)
	{
		if(nEnd == Direction_East)
		{
			//-90 -> 0
			return -(D3DX_PI / 2.0f) * (1.0f - fParameter) + 0.0f * fParameter;
			//return (-(D3DX_PI / 2.0f)) + fParameter * ((0.0f) - -(D3DX_PI / 2.0f)));
		}
		else

		if(nEnd == Direction_West)
		{
			//-90 -> -180
			return -(D3DX_PI / 2.0f) * (1.0f - fParameter) - D3DX_PI * fParameter;
			//return (A) + fParameter * ((B) - (A));
			//return (-(D3DX_PI / 2.0f)) + fParameter * ((-D3DX_PI) - (-(D3DX_PI / 2.0f)));
		}
	}
	else

	if(nStart == Direction_East)
	{
		if(nEnd == Direction_North)
		{
			//0 -> -90
			return 0.0f * (1.0f - fParameter) - (D3DX_PI / 2.0f) * fParameter;
		}
		else

		if(nEnd == Direction_South)
		{
			//-360 -> -270
			return -2.0f * D3DX_PI * (1.0f - fParameter) - (3.0f * D3DX_PI / 2.0f) * fParameter;
		}
	}
	else

	if(nStart == Direction_South)
	{
		if(nEnd == Direction_East)
		{
			//-270 -> -360
			return -(3.0f * D3DX_PI / 2.0f) * (1.0f - fParameter) - 2.0f * D3DX_PI * fParameter;
		}
		else

		if(nEnd == Direction_West)
		{
			//-270 -> -180
			return -(3.0f * D3DX_PI / 2.0f) * (1.0f - fParameter) - (2.0f * D3DX_PI / 2.0f) * fParameter;
		}
	}
	else

	if(nStart == Direction_West)
	{
		if(nEnd == Direction_North)
		{
			//-180 -> -90
			return -(2.0f * D3DX_PI / 2.0f) * (1.0f - fParameter) - (1.0f * D3DX_PI / 2.0f) * fParameter;
		}
		else

		if(nEnd == Direction_South)
		{
			//-180 -> -270
			return -(2.0f * D3DX_PI / 2.0f) * (1.0f - fParameter) - (3.0f * D3DX_PI / 2.0f) * fParameter;
		}
	}

	return 0.0f;
}

/*
 * ComputePickRay
 */
void ComputePickRay(float fScreenX, float fScreenY, const D3DVIEWPORT9& kViewport, const D3DXMATRIX& kProjection, const D3DXMATRIX& kView, D3DXVECTOR3* pOrigin, D3DXVECTOR3* pDirection)
{
	const float fHalfSizeX	= 0.5f * kViewport.Width;
	const float fHalfSizeY	= 0.5f * kViewport.Height;
	const float fAspect		= fHalfSizeX / fHalfSizeY; 
	const float fViewAngle	= D3DX_PI / 4.0f;
	const float fNear		= 1.0f;
	const float fFar		= 1024.0f;

	const float fX = tanf(0.5f * fViewAngle) * (fScreenX / fHalfSizeX - 1.0f) / fAspect;
	const float fY = tanf(0.5f * fViewAngle) * (1.0f - fScreenY / fHalfSizeY);

	//const float fX = +(2.0f * (fScreenX / kViewport.Width) - 1.0f) / kProjection._11;
	//const float fY = -(2.0f * (fScreenY / kViewport.Height) - 1.0f) / kProjection._22;
	//const float fZ = 1.0f;

	D3DXMATRIX kInverseView;
	D3DXMatrixInverse(&kInverseView, NULL, &kView);

	D3DXVECTOR3 kPointA(fNear * fX, fNear * fY, fNear);
	D3DXVECTOR3 kPointB(fFar * fX, fFar * fY, fFar);

	D3DXVECTOR3 kWorldA;
	D3DXVec3TransformCoord(&kWorldA, &kPointA, &kInverseView);

	D3DXVECTOR3 kWorldB;
	D3DXVec3TransformCoord(&kWorldB, &kPointB, &kInverseView);

	if(pOrigin)
		*pOrigin = kWorldA;

	if(pDirection)
	{
		D3DXVec3Normalize(pDirection, &(kWorldB - kWorldA));
		//*pDirection = kWorldB - kWorldA;
	}

	/*
	if(pOrigin)
	{
		pOrigin->x = kInverseView._41;
		pOrigin->y = kInverseView._42;
		pOrigin->z = kInverseView._43;
	}

	if(pDirection)
	{
		pDirection->x = fX * kInverseView._11 + fY * kInverseView._21 + fZ * kInverseView._31;
		pDirection->y = fX * kInverseView._12 + fY * kInverseView._22 + fZ * kInverseView._32;
		pDirection->z = fX * kInverseView._13 + fY * kInverseView._23 + fZ * kInverseView._33;
	}
	*/
}

/*
 * ComputeOrigin
 */
const D3DXVECTOR3 ComputeOrigin(float fScreenX, float fScreenY, const D3DVIEWPORT9& kViewport, const D3DXMATRIX& kProjection, const D3DXMATRIX& kView)
{
	const D3DXVECTOR3 kPlaneNormal(0.0f, 1.0f, 0.0f);
	const D3DXVECTOR3 kPlaneOrigin(0.0f, 0.0f, 0.0f);

	D3DXVECTOR3 kCameraOrigin;
	D3DXVECTOR3 kCameraDirection;

	ComputePickRay(fScreenX, fScreenY, kViewport, kProjection, kView, &kCameraOrigin, &kCameraDirection);

	D3DXVECTOR3 kDelta;
	D3DXVec3Subtract(&kDelta, &kCameraOrigin, &kPlaneOrigin);

	//float fD = D3DXVec3Dot(&kPlaneNormal, &kCameraDirection);
	//float fT = fD != 0.0f ? D3DXVec3Dot(&kPlaneNormal, &kDelta) / fD : 0.0f;
	const float fT = -D3DXVec3Dot(&kPlaneNormal, &kDelta) / D3DXVec3Dot(&kPlaneNormal, &kCameraDirection);

	return kCameraOrigin + fT * kCameraDirection;
}