// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#include "std3d.h"
#include "nel/3d/camera_col.h"
#include "nel/misc/matrix.h"
#include "nel/misc/triangle.h"

using namespace std;
using namespace NLMISC;


namespace NL3D {


// ***************************************************************************
const	float	NL3D_CameraSmoothRadiusFactor= 4;
const	float	NL3D_CameraSmoothNumZSample= 20;
const	float	NL3D_CameraSmoothNumAngleSample= 10;

// ***************************************************************************
CCameraCol::CCameraCol()
{
}

// ***************************************************************************
void		CCameraCol::build(const CVector &start, const CVector &end, float radius, bool cone)
{
	// copy
	_Start= start;
	_End= end;
	_Radius= radius;
	_Cone= cone;
	_SimpleRay= false;

	// For camera smoothing
	float	maxRadiusFactor= NL3D_CameraSmoothRadiusFactor;

	// not a Cone? => no smoothing
	if(!_Cone)
		maxRadiusFactor= 1;

	// **** Compute Camera smooth infos
	_MaxRadius= radius * maxRadiusFactor;
	_MinRadiusProj= _Radius / (end-start).norm();
	_MaxRadiusProj= _MaxRadius / (end-start).norm();
	_RayNorm= (end-start).normed();
	_RayLen= (end-start).norm();
	_OODeltaRadiusProj= 0;
	if(_MaxRadiusProj>_MinRadiusProj)
		_OODeltaRadiusProj= 1.f / (_MaxRadiusProj-_MinRadiusProj);

	// **** build the pyramid, with MaxRadius
	// approximate with a box
	CMatrix		mat;
	// Precision note: make the pyramid local to Start
	mat.setRot(CVector::I, (start-end).normed(), CVector::K);
	mat.normalize(CMatrix::YZX);
	// build the start 4 points
	CVector		ps[4];
	// cone or cylinder?
	if(cone)
	{
		_NPlanes= 5;
		// local to start!
		ps[0]= CVector::Null;
		ps[1]= CVector::Null;
		ps[2]= CVector::Null;
		ps[3]= CVector::Null;
	}
	else
	{
		_NPlanes= 6;
		// local to start!
		ps[0]= mat * CVector(_MaxRadius, 0, -_MaxRadius);
		ps[1]= mat * CVector(_MaxRadius, 0, _MaxRadius);
		ps[2]= mat * CVector(-_MaxRadius, 0, _MaxRadius);
		ps[3]= mat * CVector(-_MaxRadius, 0, -_MaxRadius);
	}
	// build the end 4 points
	CVector		pe[4];
	// local to start!
	mat.setPos(end-start);
	pe[0]= mat * CVector(_MaxRadius, 0, -_MaxRadius);
	pe[1]= mat * CVector(_MaxRadius, 0, _MaxRadius);
	pe[2]= mat * CVector(-_MaxRadius, 0, _MaxRadius);
	pe[3]= mat * CVector(-_MaxRadius, 0, -_MaxRadius);
	// try to roder for optimisation
	// left/right
	_Pyramid[0].make(ps[3], pe[3], pe[2]);
	_Pyramid[1].make(ps[1], pe[1], pe[0]);
	// back
	_Pyramid[2].make(pe[0], pe[1], pe[2]);
	// top-bottom
	_Pyramid[3].make(ps[2], pe[2], pe[1]);
	_Pyramid[4].make(ps[0], pe[0], pe[3]);
	// front if not cone
	if(!cone)
		_Pyramid[5].make(ps[0], ps[2], ps[1]);

	// **** build the bbox
	_BBox.setCenter(start);
	_BBox.extend(end);
	// enlarge a bit for radius
	_BBox.setHalfSize(_BBox.getHalfSize()+CVector(_MaxRadius, _MaxRadius, _MaxRadius));

}


// ***************************************************************************
void		CCameraCol::buildRay(const CVector &start, const CVector &end)
{
	// copy
	_Start= start;
	_End= end;
	_Radius= 0.f;
	_Cone= false;
	_SimpleRay= true;

	// compute infos
	_MaxRadius= 0.f;
	_MinRadiusProj= 0.f;
	_MaxRadiusProj= 0.f;
	_RayNorm= (end-start).normed();
	_RayLen= (end-start).norm();
	_OODeltaRadiusProj= 0;

	// Don't need to build the pyramids here

	// **** build the bbox
	_BBox.setCenter(start);
	_BBox.extend(end);
	// enlarge a bit for radius
	_BBox.setHalfSize(_BBox.getHalfSize()+CVector(0.01f, 0.01f, 0.01f));
}


// ***************************************************************************
void		CCameraCol::setApplyMatrix(const CCameraCol &other, const NLMISC::CMatrix &matrix)
{
	// get parameters modified by matrix
	CVector		start= matrix * other._Start;
	CVector		end= matrix * other._End;
	float		radius= other._Radius;

	// scale the radius
	if(matrix.hasScalePart())
	{
		// get the uniform scale
		if(matrix.hasScaleUniform())
			radius*= matrix.getScaleUniform();
		// Tricky code, deduce a uniform scale. Should not arise
		else
		{
			float	meanScale= matrix.getI().norm() + matrix.getJ().norm() + matrix.getK().norm();
			meanScale/= 3;
			radius*= meanScale;
		}
	}

	// rebuild
	build(start, end, radius, other._Cone);
}


// ***************************************************************************
void		CCameraCol::minimizeDistanceAgainstTri(const CVector &p0, const CVector &p1, const CVector &p2, float &sqrMinDist)
{
	// If the camera collision is actually a ray test, use a simpler method
	if(_SimpleRay)
	{
		intersectRay(p0, p1, p2, sqrMinDist);
		return;
	}

	// Else compute the distance with a smoother way.
	CVector		*pIn= _ArrayIn;
	CVector		*pOut= _ArrayOut;

	// **** clip triangle against the pyramid
	// build the triangle, local to start for precision problems
	pIn[0]= p0 - _Start;
	pIn[1]= p1 - _Start;
	pIn[2]= p2 - _Start;
	sint	nVert= 3;
	// clip
	for(uint i=0;i<_NPlanes;i++)
	{
		nVert= _Pyramid[i].clipPolygonBack(pIn, pOut, nVert);
		swap(pIn, pOut);
		if(!nVert)
			break;
	}

	// **** if clipped => collision
	if(nVert)
	{
		/*
			Polygon nearest distance to a point is:
				- the nearest distance of all vertices
				- or the nearest distance to the plane (if the project lies in the polygon)
				- or the nearest distance to each edge

			NB: testing only points works with low radius, but may fails in general case
		*/

		// compute first the poly min distance
		float	sqrPolyMinDist= FLT_MAX;

		// **** get the nearest distance for all points (avoid precision problem if doing only edge ones)
		sint	i;
		for(i=0;i<nVert;i++)
		{
			// NB: pIn[i] is already local to start
			float	sqrDist= pIn[i].sqrnorm();
			if(sqrDist<sqrPolyMinDist)
				sqrPolyMinDist= sqrDist;
		}

		// **** get the nearest distance of the Start against each edge
		for(i=0;i<nVert;i++)
		{
			const	CVector	&v0= pIn[i];
			const	CVector	&v1= pIn[(i+1)%nVert];
			CVector	vDir= v1-v0;
			// project on line
			float	fLen= vDir.sqrnorm();	// same as  vDir * (v1 - v0)
			// NB: Project CVector::Null, since we are local to start here!
			float	fStart= vDir * (-v0);
			// if start projection in the edge
			if(fStart>0 && fStart<fLen)
			{
				// compute distance to line
				CVector	proj= v0 + (fStart / fLen) * vDir;
				// proj is local to Start
				float	sqrDist= proj.sqrnorm();
				if(sqrDist<sqrPolyMinDist)
					sqrPolyMinDist= sqrDist;
			}
		}

		// **** get the nearest distance of the Start against the plane
		// get the plane local to start
		CPlane	plane;
		plane.make(p0-_Start, p1-_Start, p2-_Start);
		// plane * StartLocalToStart == plane * CVector::Null == plane.d !
		float	planeDist= plane.d;
		// need to do the poly inclusion test only if the plane dist is better than the vertices
		float	sqrPlaneDist= sqr(planeDist);
		if(sqrPlaneDist < sqrPolyMinDist)
		{
			CVector	normal= plane.getNormal();

			// the projection of Start on the plane: StartLocalToStart +
			CVector	proj= planeDist * normal;
			// test poly inclusion
			sint	sign= 0;
			for(i=0;i<nVert;i++)
			{
				const	CVector	&v0= pIn[i];
				const	CVector	&v1= pIn[(i+1)%nVert];
				float	d = ((v1-v0)^normal)*(proj-v0);
				if(d<0)
				{
					if(sign==1) break;
					else	sign=-1;
				}
				else if(d>0)
				{
					if(sign==-1) break;
					else	sign=1;
				}
				else
					break;
			}

			// if succeed, minimize
			if(i==nVert)
				sqrPolyMinDist= sqrPlaneDist;
		}

		// **** Camera Smoothing: modulate according to angle of poly against cone
		// Camera smooth not enabled?
		if(_MaxRadiusProj<=_MinRadiusProj)
		{
			// then just take minum
			if(sqrPolyMinDist<sqrMinDist)
				sqrMinDist= sqrPolyMinDist;
		}
		// Camera Smooth mode. if the unmodulated distance is lower than the current minDist,
		// then this poly may be interesting, else don't have a chance
		else if(sqrPolyMinDist<sqrMinDist)
		{
			float	sampleZSize= _RayLen / NL3D_CameraSmoothNumZSample;
			float	sampleProjSize= 2*_MaxRadiusProj / NL3D_CameraSmoothNumAngleSample;

			// **** Compute num Subdivision required
			// To compute the number of subdivision, let's take the max of 2 req:
			// the subdivision in Z (for Distance part of the function)
			// the subdivision in Projection (for angle part of the function)

			// Project all vertices to the plane
			static	CVector	pProj[3+MaxNPlanes];
			float	minZ= _RayLen;
			float	maxZ= 0;
			for(i=0;i<nVert;i++)
			{
				float	z= pIn[i] * _RayNorm;
				minZ= min(minZ, z);
				maxZ= max(maxZ, z);
				// cause of pyramid cliping, z should be >=0
				if(z>0)
					pProj[i]= pIn[i] / z;
				else
					pProj[i]= CVector::Null;

				// make local
				pProj[i]-= _RayNorm;
			}
			// Compute perimeter of projected poly
			float	perimeterProj= 0;
			for(i=0;i<nVert;i++)
			{
				perimeterProj+= (pProj[(i+1)%nVert]-pProj[i]).norm();
			}

			// compute the number of subdivision required on Z
			uint	numSubdivZ= (uint)((maxZ-minZ) / sampleZSize);
			// suppose a full projected quad perimeter will require max samples
			uint	numSubdivAngle= (uint)(perimeterProj / (4*sampleProjSize));
			// the number of subdivision
			uint	numSubdiv= max(numSubdivZ, numSubdivAngle);
			numSubdiv= max(numSubdiv, (uint)1);
			float	ooNumSubdiv= 1.f / (float)numSubdiv;

			// **** Sample the polygon, to compute the minimum of the function
			// for each tri of the polygon
			for(sint tri=0;tri<nVert-2;tri++)
			{
				CVector		lp[3];
				// optim: prediv by numSubdiv
				lp[0]= pIn[0] * ooNumSubdiv;
				lp[1]= pIn[tri+1] * ooNumSubdiv;
				lp[2]= pIn[tri+2] * ooNumSubdiv;

				// sample using barycentric coordinates
				for(uint i=0;i<=numSubdiv;i++)
				{
					for(uint j=0;j<=numSubdiv-i;j++)
					{
						uint	k= numSubdiv - i - j;
						CVector	sample= lp[0] * (float)i + lp[1] * (float)j + lp[2] * (float)k;

						// NB: sample is already local to start
						float	sqrDist= sample.sqrnorm();

						// **** get the point projection
						float		z= sample * _RayNorm;
						CVector		proj;
						// cause of pyramid cliping, z should be >=0
						if(z>0)
							proj= sample / z;
						else
							proj= CVector::Null;
						// make local
						proj-= _RayNorm;

						// **** compute the Cone Linear factor (like a spot light)
						float	rayDist= proj.norm();
						float	angleFactor= (rayDist-_MinRadiusProj) * _OODeltaRadiusProj;
						clamp(angleFactor, 0.f, 1.f);
						// avoid C1 discontinuity when angleFactor==0
						angleFactor= sqr(angleFactor);

						// **** modulate, but to a bigger value! (ie raylen)
						sqrDist= _RayLen * angleFactor + sqrtf(sqrDist) * (1-angleFactor);
						sqrDist= sqr(sqrDist);

						// if distance is lesser, take it
						if(sqrDist<sqrMinDist)
							sqrMinDist= sqrDist;
					}
				}
			}
		}
	}
}


// ***************************************************************************
void		CCameraCol::intersectRay(const CVector &p0, const CVector &p1, const CVector &p2, float &sqrMinDist)
{
	// build the triangle and the plane from p0,p1,p2
	CTriangle	tri;
	tri.V0= p0;
	tri.V1= p1;
	tri.V2= p2;
	CPlane	plane;
	plane.make(p0,p1,p2);

	// If doesn't intersect, quit
	CVector	hit;
	if(!tri.intersect(_Start, _End, hit, plane))
		return;

	// Else compute the intersection distance factor
	float	f= (hit-_Start) * _RayNorm;
	clamp(f, 0.f, _RayLen);
	// set the result if less
	f= sqr(f);
	if(f<sqrMinDist)
		sqrMinDist= f;
}


/*
			// Perspective Project each vertices on the plane normalized to the ray, at Start + rayNormed * 1
			// And then make local to the Point Start + rayNormed * 1 (ie _RayNorm since we are local to Start!).
			for(i=0;i<nVert;i++)
			{
				float	z= pIn[i] * _RayNorm;
				// cause of pyramid cliping, z should be >=0
				if(z>0)
					pIn[i]= pIn[i] / z;
				else
					pIn[i]= CVector::Null;

				// make local
				pIn[i]-= _RayNorm;
			}

			// Compute now poly distance to the ray
			//	If the ray intersect the poly this is 0!!!
			//	else this is the min distance of each edge/vertex against CVector::Null
			// test poly inclusion
			sint	sign= 0;
			for(i=0;i<nVert;i++)
			{
				const	CVector	&v0= pIn[i];
				const	CVector	&v1= pIn[(i+1)%nVert];
				// _RayNorm should be the plane 's normal of the poly
				float	d = ((v1-v0)^_RayNorm)*(-v0);
				if(d<0)
				{
					if(sign==1) break;
					else	sign=-1;
				}
				else if(d>0)
				{
					if(sign==-1) break;
					else	sign=1;
				}
				else
					break;
			}
			// if succeed, then the poly fully intersect the ray => just minimize
			if(i==nVert)
				sqrMinDist= sqrPolyMinDist;
			// else smooth distance!
			else
			{
				// must get min distance of each projected edge/vertex againt origin
				float	sqrMinRayDist= FLT_MAX;

				// get min distance of each vertex against origin
				for(i=0;i<nVert;i++)
				{
					float	sqrDist= pIn[i].sqrnorm();
					if(sqrDist<sqrMinRayDist)
						sqrMinRayDist= sqrDist;
				}

				// get distance of each edge against origin
				for(i=0;i<nVert;i++)
				{
					const	CVector	&v0= pIn[i];
					const	CVector	&v1= pIn[(i+1)%nVert];
					CVector	vDir= v1-v0;
					// project on line
					float	fLen= vDir.sqrnorm();	// same as  vDir * (v1 - v0)
					// NB: Project CVector::Null
					float	fStart= vDir * (-v0);
					// if origin projection in the edge
					if(fStart>0 && fStart<fLen)
					{
						// compute distance to line
						CVector	proj= v0 + (fStart / fLen) * vDir;
						// proj is local to Start
						float	sqrDist= proj.sqrnorm();
						if(sqrDist<sqrMinRayDist)
							sqrMinRayDist= sqrDist;
					}
				}

				float	minRayDist= sqrtf(sqrMinRayDist);

				// OK! now we have the minRayDist
				// compute the Cone Linear factor (like a spot light)
				float	angleFactor= (minRayDist-_MinRadiusProj) / (_MaxRadiusProj-_MinRadiusProj);
				clamp(angleFactor, 0.f, 1.f);
				// avoid C1 discontinuity when angleFactor==0
				angleFactor= sqr(angleFactor);

				// modulate, but to a bigger value! (ie raylen)
				sqrPolyMinDist= _RayLen * angleFactor + sqrtf(sqrPolyMinDist) * (1-angleFactor);
				sqrPolyMinDist= sqr(sqrPolyMinDist);

				// then if the modified distance is still lower than minDist, set
				if(sqrPolyMinDist<sqrMinDist)
					sqrMinDist= sqrPolyMinDist;
			}
*/

/*
const	float	sampleSize= 0.1f;

// Sample the triangle, to compute the minimum of the function
CVector		lp[3];
float		len[3];
lp[0]= p0-Start;
lp[1]= p1-Start;
lp[2]= p2-Start;
// compute max and min edge length
len[0]= (lp[1]-lp[0]).norm();
len[1]= (lp[2]-lp[1]).norm();
len[2]= (lp[0]-lp[2]).norm();
float	meanLen= (len[0] + len[1] + len[2])/3;
// the number of subdivision
uint	numSubdiv= meanLen / sampleSize;
numSubdiv= max(numSubdiv, (uint)1);
// preca
lp[0]/= numSubdiv;
lp[1]/= numSubdiv;
lp[2]/= numSubdiv;

// sample using barycentric coordinates
for(uint i=0;i<=numSubdiv;i++)
{
	for(uint j=0;j<=numSubdiv-i;j++)
	{
		uint	k= numSubdiv - i - j;
		CVector	sample= lp[0] * i + lp[1] * j + lp[2] * k;

		// NB: sample is already local to start
		float	sqrDist= sample.sqrnorm();

		// **** get the point projection
		float		z= sample * _RayNorm;
		CVector		proj;
		// cause of pyramid cliping, z should be >=0
		if(z>0)
			proj= sample / z;
		else
			proj= CVector::Null;
		// make local
		proj-= _RayNorm;

		// **** compute the Cone Linear factor (like a spot light)
		float	rayDist= proj.norm();
		float	angleFactor= (rayDist-_MinRadiusProj) / (_MaxRadiusProj-_MinRadiusProj);
		clamp(angleFactor, 0.f, 1.f);
		// avoid C1 discontinuity when angleFactor==0
		angleFactor= sqr(angleFactor);

		// **** modulate, but to a bigger value! (ie raylen)
		sqrDist= _RayLen * angleFactor + sqrtf(sqrDist) * (1-angleFactor);
		sqrDist= sqr(sqrDist);

		// if distance is lesser, take it
		if(sqrDist<sqrMinDist)
			sqrMinDist= sqrDist;
	}
}
*/

} // NL3D