/******************************************************************************

 @File         PVRTMisc.cpp

 @Title        PVRTMisc

 @Version      

 @Copyright    Copyright (C)  Imagination Technologies Limited.

 @Platform     ANSI compatible

 @Description  Miscellaneous functions used in 3D rendering.

******************************************************************************/
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include "PVRTGlobal.h"
#include "PVRTContext.h"
#include "PVRTFixedPoint.h"
#include "PVRTMatrix.h"
#include "PVRTMisc.h"



/*!***************************************************************************
 @Function			PVRTMiscCalculateIntersectionLinePlane
 @Input				pfPlane			Length 4 [A,B,C,D], values for plane
									equation
 @Input				pv0				A point on the line
 @Input				pv1				Another point on the line
 @Output			pvIntersection	The point of intersection
 @Description		Calculates coords of the intersection of a line and an
					infinite plane
*****************************************************************************/
void PVRTMiscCalculateIntersectionLinePlane(
	PVRTVECTOR3			* const pvIntersection,
	const VERTTYPE		pfPlane[4],
	const PVRTVECTOR3	* const pv0,
	const PVRTVECTOR3	* const pv1)
{
	PVRTVECTOR3	vD;
	VERTTYPE fN, fD, fT;

	/* Calculate vector from point0 to point1 */
	vD.x = pv1->x - pv0->x;
	vD.y = pv1->y - pv0->y;
	vD.z = pv1->z - pv0->z;

	/* Denominator */
	fD =
		VERTTYPEMUL(pfPlane[0], vD.x) +
		VERTTYPEMUL(pfPlane[1], vD.y) +
		VERTTYPEMUL(pfPlane[2], vD.z);

	/* Numerator */
	fN =
		VERTTYPEMUL(pfPlane[0], pv0->x) +
		VERTTYPEMUL(pfPlane[1], pv0->y) +
		VERTTYPEMUL(pfPlane[2], pv0->z) +
		pfPlane[3];

	fT = VERTTYPEDIV(-fN, fD);

	/* And for a finale, calculate the intersection coordinate */
	pvIntersection->x = pv0->x + VERTTYPEMUL(fT, vD.x);
	pvIntersection->y = pv0->y + VERTTYPEMUL(fT, vD.y);
	pvIntersection->z = pv0->z + VERTTYPEMUL(fT, vD.z);
}


/*!***************************************************************************
 @Function		PVRTMiscCalculateInfinitePlane
 @Input			nStride			Size of each vertex structure containing pfVtx
 @Input			pvPlane			Length 4 [A,B,C,D], values for plane equation
 @Input			pmViewProjInv	The inverse of the View Projection matrix
 @Input			pFrom			Position of the camera
 @Input			fFar			Far clipping distance
 @Output		pfVtx			Position of the first of 3 floats to receive
								the position of vertex 0; up to 5 vertex positions
								will be written (5 is the maximum number of vertices
								required to draw an infinite polygon clipped to screen
								and far clip plane).
 @Returns		Number of vertices in the polygon fan (Can be 0, 3, 4 or 5)
 @Description	Calculates world-space coords of a screen-filling
				representation of an infinite plane The resulting vertices run
				counter-clockwise around the screen, and can be simply drawn using
				non-indexed TRIANGLEFAN
*****************************************************************************/
int PVRTMiscCalculateInfinitePlane(
	VERTTYPE			* const pfVtx,
	const int			nStride,
	const PVRTVECTOR4	* const pvPlane,
	const PVRTMATRIX 	* const pmViewProjInv,
	const PVRTVECTOR3	* const pFrom,
	const VERTTYPE		fFar)
{
	PVRTVECTOR3		pvWorld[5];
	PVRTVECTOR3		*pvPolyPtr;
	unsigned int	dwCount;
	bool			bClip;
	int				nVert;
	VERTTYPE		fDotProduct;

	/*
		Check whether the plane faces the camera
	*/
	fDotProduct =
		VERTTYPEMUL((pFrom->x + VERTTYPEMUL(pvPlane->x, pvPlane->w)), pvPlane->x) +
		VERTTYPEMUL((pFrom->y + VERTTYPEMUL(pvPlane->y, pvPlane->w)), pvPlane->y) +
		VERTTYPEMUL((pFrom->z + VERTTYPEMUL(pvPlane->z, pvPlane->w)), pvPlane->z);

	if(fDotProduct < 0) {
		/* Camera is behind plane, hence it's not visible */
		return 0;
	}

	/*
		Back transform front clipping plane into world space,
		to give us a point on the line through each corner of the screen
		(from the camera).
	*/

	/*             x = -1.0f;    y = -1.0f;     z = 1.0f;      w = 1.0f */
	pvWorld[0].x = VERTTYPEMUL((-pmViewProjInv->f[ 0] - pmViewProjInv->f[ 4] + pmViewProjInv->f[ 8] + pmViewProjInv->f[12]), fFar);
	pvWorld[0].y = VERTTYPEMUL((-pmViewProjInv->f[ 1] - pmViewProjInv->f[ 5] + pmViewProjInv->f[ 9] + pmViewProjInv->f[13]), fFar);
	pvWorld[0].z = VERTTYPEMUL((-pmViewProjInv->f[ 2] - pmViewProjInv->f[ 6] + pmViewProjInv->f[10] + pmViewProjInv->f[14]), fFar);
	/*             x =  1.0f,    y = -1.0f,     z = 1.0f;      w = 1.0f */
	pvWorld[1].x = VERTTYPEMUL(( pmViewProjInv->f[ 0] - pmViewProjInv->f[ 4] + pmViewProjInv->f[ 8] + pmViewProjInv->f[12]), fFar);
	pvWorld[1].y = VERTTYPEMUL(( pmViewProjInv->f[ 1] - pmViewProjInv->f[ 5] + pmViewProjInv->f[ 9] + pmViewProjInv->f[13]), fFar);
	pvWorld[1].z = VERTTYPEMUL(( pmViewProjInv->f[ 2] - pmViewProjInv->f[ 6] + pmViewProjInv->f[10] + pmViewProjInv->f[14]), fFar);
	/*             x =  1.0f,    y =  1.0f,     z = 1.0f;      w = 1.0f */
	pvWorld[2].x = VERTTYPEMUL(( pmViewProjInv->f[ 0] + pmViewProjInv->f[ 4] + pmViewProjInv->f[ 8] + pmViewProjInv->f[12]), fFar);
	pvWorld[2].y = VERTTYPEMUL(( pmViewProjInv->f[ 1] + pmViewProjInv->f[ 5] + pmViewProjInv->f[ 9] + pmViewProjInv->f[13]), fFar);
	pvWorld[2].z = VERTTYPEMUL(( pmViewProjInv->f[ 2] + pmViewProjInv->f[ 6] + pmViewProjInv->f[10] + pmViewProjInv->f[14]), fFar);
	/*             x = -1.0f,    y =  1.0f,     z = 1.0f;      w = 1.0f */
	pvWorld[3].x = VERTTYPEMUL((-pmViewProjInv->f[ 0] + pmViewProjInv->f[ 4] + pmViewProjInv->f[ 8] + pmViewProjInv->f[12]), fFar);
	pvWorld[3].y = VERTTYPEMUL((-pmViewProjInv->f[ 1] + pmViewProjInv->f[ 5] + pmViewProjInv->f[ 9] + pmViewProjInv->f[13]), fFar);
	pvWorld[3].z = VERTTYPEMUL((-pmViewProjInv->f[ 2] + pmViewProjInv->f[ 6] + pmViewProjInv->f[10] + pmViewProjInv->f[14]), fFar);

	/* We need to do a closed loop of the screen vertices, so copy the first vertex into the last */
	pvWorld[4] = pvWorld[0];

	/*
		Now build a pre-clipped polygon
	*/

	/* Lets get ready to loop */
	dwCount		= 0;
	bClip		= false;
	pvPolyPtr	= (PVRTVECTOR3*)pfVtx;

	nVert = 5;
	while(nVert)
	{
		nVert--;

		/*
			Check which side of the Plane this corner of the far clipping
			plane is on. [A,B,C] of plane equation is the plane normal, D is
			distance from origin; hence [pvPlane->x * -pvPlane->w,
										 pvPlane->y * -pvPlane->w,
										 pvPlane->z * -pvPlane->w]
			is a point on the plane
		*/
		fDotProduct =
			VERTTYPEMUL((pvWorld[nVert].x + VERTTYPEMUL(pvPlane->x, pvPlane->w)), pvPlane->x) +
			VERTTYPEMUL((pvWorld[nVert].y + VERTTYPEMUL(pvPlane->y, pvPlane->w)), pvPlane->y) +
			VERTTYPEMUL((pvWorld[nVert].z + VERTTYPEMUL(pvPlane->z, pvPlane->w)), pvPlane->z);

		if(fDotProduct < 0)
		{
			/*
				Behind plane; Vertex does NOT need clipping
			*/
			if(bClip == true)
			{
				/* Clipping finished */
				bClip = false;

				/*
					We've been clipping, so we need to add an additional
					point on the line to this point, where clipping was
					stopped.
				*/
				PVRTMiscCalculateIntersectionLinePlane(pvPolyPtr, &pvPlane->x, &pvWorld[nVert+1], &pvWorld[nVert]);
				pvPolyPtr = (PVRTVECTOR3*)((char*)pvPolyPtr + nStride);
				dwCount++;
			}

			if(!nVert)
			{
				/* Abort, abort: we've closed the loop with the clipped point */
				break;
			}

			/* Add the current point */
			PVRTMiscCalculateIntersectionLinePlane(pvPolyPtr, &pvPlane->x, pFrom, &pvWorld[nVert]);
			pvPolyPtr = (PVRTVECTOR3*)((char*)pvPolyPtr + nStride);
			dwCount++;
		}
		else
		{
			/*
				Before plane; Vertex DOES need clipping
			*/
			if(bClip == true)
			{
				/* Already in clipping, skip point */
				continue;
			}

			/* Clipping initiated */
			bClip = true;

			/* Don't bother with entry point on first vertex; will take care of it on last vertex (which is a repeat of first vertex) */
			if(nVert != 4)
			{
				/* We need to add an additional point on the line to this point, where clipping was started */
				PVRTMiscCalculateIntersectionLinePlane(pvPolyPtr, &pvPlane->x, &pvWorld[nVert+1], &pvWorld[nVert]);
				pvPolyPtr = (PVRTVECTOR3*)((char*)pvPolyPtr + nStride);
				dwCount++;
			}
		}
	}

	/* Valid vertex counts are 0, 3, 4, 5 */
	_ASSERT(dwCount <= 5);
	_ASSERT(dwCount != 1);
	_ASSERT(dwCount != 2);

	return dwCount;
}


/*!***************************************************************************
 @Function			SetVertex
 @Modified			Vertices
 @Input				index
 @Input				x
 @Input				y
 @Input				z
 @Description		Writes a vertex in a vertex array
*****************************************************************************/
void SetVertex(VERTTYPE** Vertices, int index, VERTTYPE x, VERTTYPE y, VERTTYPE z)
{
	(*Vertices)[index*3+0] = x;
	(*Vertices)[index*3+1] = y;
	(*Vertices)[index*3+2] = z;
}

/*!***************************************************************************
 @Function			SetUV
 @Modified			UVs
 @Input				index
 @Input				u
 @Input				v
 @Description		Writes a texture coordinate in a texture coordinate array
*****************************************************************************/
void SetUV(VERTTYPE** UVs, int index, VERTTYPE u, VERTTYPE v)
{
	(*UVs)[index*2+0] = u;
	(*UVs)[index*2+1] = v;
}

/*!***************************************************************************
 @Function		PVRTCreateSkybox
 @Input			scale			Scale the skybox
 @Input			adjustUV		Adjust or not UVs for PVRT compression
 @Input			textureSize		Texture size in pixels
 @Output		Vertices		Array of vertices
 @Output		UVs				Array of UVs
 @Description	Creates the vertices and texture coordinates for a skybox
*****************************************************************************/
void PVRTCreateSkybox(float scale, bool adjustUV, int textureSize, VERTTYPE** Vertices, VERTTYPE** UVs)
{
	*Vertices = new VERTTYPE[24*3];
	*UVs = new VERTTYPE[24*2];

	VERTTYPE unit = f2vt(1);
	VERTTYPE a0 = 0, a1 = unit;

	if (adjustUV)
	{
		VERTTYPE oneover = f2vt(1.0f / textureSize);
		a0 = VERTTYPEMUL(f2vt(4.0f), oneover);
		a1 = unit - a0;
	}

	// Front
	SetVertex(Vertices, 0, -unit, +unit, -unit);
	SetVertex(Vertices, 1, +unit, +unit, -unit);
	SetVertex(Vertices, 2, -unit, -unit, -unit);
	SetVertex(Vertices, 3, +unit, -unit, -unit);
	SetUV(UVs, 0, a0, a1);
	SetUV(UVs, 1, a1, a1);
	SetUV(UVs, 2, a0, a0);
	SetUV(UVs, 3, a1, a0);

	// Right
	SetVertex(Vertices, 4, +unit, +unit, -unit);
	SetVertex(Vertices, 5, +unit, +unit, +unit);
	SetVertex(Vertices, 6, +unit, -unit, -unit);
	SetVertex(Vertices, 7, +unit, -unit, +unit);
	SetUV(UVs, 4, a0, a1);
	SetUV(UVs, 5, a1, a1);
	SetUV(UVs, 6, a0, a0);
	SetUV(UVs, 7, a1, a0);

	// Back
	SetVertex(Vertices, 8 , +unit, +unit, +unit);
	SetVertex(Vertices, 9 , -unit, +unit, +unit);
	SetVertex(Vertices, 10, +unit, -unit, +unit);
	SetVertex(Vertices, 11, -unit, -unit, +unit);
	SetUV(UVs, 8 , a0, a1);
	SetUV(UVs, 9 , a1, a1);
	SetUV(UVs, 10, a0, a0);
	SetUV(UVs, 11, a1, a0);

	// Left
	SetVertex(Vertices, 12, -unit, +unit, +unit);
	SetVertex(Vertices, 13, -unit, +unit, -unit);
	SetVertex(Vertices, 14, -unit, -unit, +unit);
	SetVertex(Vertices, 15, -unit, -unit, -unit);
	SetUV(UVs, 12, a0, a1);
	SetUV(UVs, 13, a1, a1);
	SetUV(UVs, 14, a0, a0);
	SetUV(UVs, 15, a1, a0);

	// Top
	SetVertex(Vertices, 16, -unit, +unit, +unit);
	SetVertex(Vertices, 17, +unit, +unit, +unit);
	SetVertex(Vertices, 18, -unit, +unit, -unit);
	SetVertex(Vertices, 19, +unit, +unit, -unit);
	SetUV(UVs, 16, a0, a1);
	SetUV(UVs, 17, a1, a1);
	SetUV(UVs, 18, a0, a0);
	SetUV(UVs, 19, a1, a0);

	// Bottom
	SetVertex(Vertices, 20, -unit, -unit, -unit);
	SetVertex(Vertices, 21, +unit, -unit, -unit);
	SetVertex(Vertices, 22, -unit, -unit, +unit);
	SetVertex(Vertices, 23, +unit, -unit, +unit);
	SetUV(UVs, 20, a0, a1);
	SetUV(UVs, 21, a1, a1);
	SetUV(UVs, 22, a0, a0);
	SetUV(UVs, 23, a1, a0);

	for (int i=0; i<24*3; i++) (*Vertices)[i] = VERTTYPEMUL((*Vertices)[i], f2vt(scale));
}

/*!***************************************************************************
 @Function		PVRTDestroySkybox
 @Input			Vertices	Vertices array to destroy
 @Input			UVs			UVs array to destroy
 @Description	Destroy the memory allocated for a skybox
*****************************************************************************/
void PVRTDestroySkybox(VERTTYPE* Vertices, VERTTYPE* UVs)
{
	delete [] Vertices;
	delete [] UVs;
}

/*!***************************************************************************
 @Function		GetPOTHigher
 @Input			uiOriginalValue	Base value
 @Input			iTimesHigher		Multiplier
 @Description	When iTimesHigher is one, this function will return the closest
				power-of-two value above the base value.
				For every increment beyond one for the iTimesHigher value,
				the next highest power-of-two value will be calculated.
*****************************************************************************/
unsigned int GetPOTHigher(unsigned int uiOriginalValue, int iTimesHigher)
{
	if(uiOriginalValue == 0 || iTimesHigher < 0)
	{
		return 0;
	}

	unsigned int uiSize = 1;
	while (uiSize < uiOriginalValue) uiSize *= 2;

	// Keep increasing the POT value until the iTimesHigher value has been met
	for(int i = 1 ; i < iTimesHigher; ++i)
	{
		uiSize *= 2;
	}

	return uiSize;
}

/*!***************************************************************************
 @Function		GetPOTLower
 @Input			uiOriginalValue	Base value
 @Input			iTimesLower		Multiplier
 @Description	When iTimesLower is one, this function will return the closest
				power-of-two value below the base value.
				For every increment beyond one for the iTimesLower value,
				the next lowest power-of-two value will be calculated. The lowest
				value that can be reached is 1.
*****************************************************************************/
// NOTE: This function should be optimised
unsigned int GetPOTLower(unsigned int uiOriginalValue, int iTimesLower)
{
	if(uiOriginalValue == 0 || iTimesLower < 0)
	{
		return 0;
	}
	unsigned int uiSize = GetPOTHigher(uiOriginalValue,1);
	uiSize >>= 1;//uiSize /=2;

	for(int i = 1; i < iTimesLower; ++i)
	{
		uiSize >>= 1;//uiSize /=2;
		if(uiSize == 1)
		{
			// Lowest possible value has been reached, so break
			break;
		}
	}
	return uiSize;
}



/*****************************************************************************
 End of file (PVRTMisc.cpp)
*****************************************************************************/

