// 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/misc/hierarchical_timer.h"
#include "nel/misc/polygon.h"
#include "nel/3d/shadow_poly_receiver.h"
#include "nel/3d/shadow_map.h"
#include "nel/3d/driver.h"
#include "nel/3d/camera_col.h"


using	namespace std;
using	namespace NLMISC;

namespace NL3D {


// ***************************************************************************
CShadowPolyReceiver::CShadowPolyReceiver(uint quadGridSize, float quadGridCellSize)
{
	_Vertices.reserve(64);
	_FreeVertices.reserve(64);
	_FreeTriangles.reserve(64);
	_Triangles.reserve(64);

	_TriangleGrid.create(quadGridSize, quadGridCellSize);

	_VB.setVertexFormat(CVertexBuffer::PositionFlag);
	_VB.setName("CShadowPolyReceiver");
	// lock volatile, to avoid cpu stall when rendering multiple shadows in the same polyReceiver
	_VB.setPreferredMemory(CVertexBuffer::RAMVolatile, false);
	_RenderTriangles.setPreferredMemory(CIndexBuffer::RAMVolatile, false);
	_RenderTriangles.setFormat(NL_DEFAULT_INDEX_BUFFER_FORMAT);
	NL_SET_IB_NAME(_RenderTriangles, "CShadowPolyReceiver");
}


// ***************************************************************************
uint			CShadowPolyReceiver::addTriangle(const NLMISC::CTriangle &tri)
{
	uint	id;

	// Look for a free triangle entry.
	if(_FreeTriangles.empty())
	{
		_Triangles.push_back(TTriangleGrid::CIterator());
		id= (uint)_Triangles.size()-1;
		// enlarge render size.
		_RenderTriangles.setNumIndexes((uint32)_Triangles.size() * 3);
	}
	else
	{
		id= _FreeTriangles.back();
		_FreeTriangles.pop_back();
	}

	// Allocate vertices, reusing same ones.
	CTriangleId		triId;
	CVector			v[3];
	v[0]= tri.V0;
	v[1]= tri.V1;
	v[2]= tri.V2;
	for(uint i=0;i<3;i++)
	{
		// Find the vertex in the map.
		TVertexMap::iterator	it;
		it= _VertexMap.find(v[i]);
		// if not found, allocate it
		if(it==_VertexMap.end())
		{
			triId.Vertex[i]= allocateVertex(v[i]);
		}
		// else get its id
		else
		{
			triId.Vertex[i]= it->second;
		}

		// increment the reference of this vertex
		incVertexRefCount(triId.Vertex[i]);
	}

	// Insert the triangle in the quadGrid.
	CAABBox		bb;
	bb.setCenter(tri.V0);
	bb.extend(tri.V1);
	bb.extend(tri.V2);
	// insert in QuadGrid and store iterator for future remove
	_Triangles[id]= _TriangleGrid.insert(bb.getMin(), bb.getMax(), triId);

	return id;
}

// ***************************************************************************
void			CShadowPolyReceiver::removeTriangle(uint id)
{
	nlassert(id<_Triangles.size());
	// Must not be NULL iterator.
	nlassert(_Triangles[id]!=_TriangleGrid.end());

	// Release Vertices
	const CTriangleId		&triId= *_Triangles[id];
	releaseVertex(triId.Vertex[0]);
	releaseVertex(triId.Vertex[1]);
	releaseVertex(triId.Vertex[2]);

	// Delete Triangle.
	_TriangleGrid.erase(_Triangles[id]);
	_Triangles[id]= _TriangleGrid.end();
	// Append to free list.
	_FreeTriangles.push_back(id);
}


// ***************************************************************************
uint			CShadowPolyReceiver::allocateVertex(const CVector &v)
{
	uint	id;

	// if not valid double, will crash cause map<float,...> crash when float are not valid
	nlassert(isValidDouble(v.x) && isValidDouble(v.y) && isValidDouble(v.z));

	// Look for a free vertex entry.
	if(_FreeVertices.empty())
	{
		// Add the vertex, and init refCount to 0.
		_Vertices.push_back(v);
		id= (uint)_Vertices.size()-1;

		// Resize the VBuffer at max possible
		_VB.setNumVertices((uint32)_Vertices.size());
	}
	else
	{
		id= _FreeVertices.back();
		_FreeVertices.pop_back();
		// init entry
		_Vertices[id]= v;
		_Vertices[id].RefCount= 0;
	}

	// insert in the map (should not be here)
	_VertexMap.insert( make_pair(v, id) );

	return id;
}

// ***************************************************************************
void			CShadowPolyReceiver::releaseVertex(uint id)
{
	nlassert(id<_Vertices.size());
	// dec ref
	nlassert(_Vertices[id].RefCount>0);
	_Vertices[id].RefCount--;
	// no more used?
	if(_Vertices[id].RefCount==0)
	{
		// Free it.
		_FreeVertices.push_back(id);
		// Remove it from map.
		TVertexMap::iterator	it= _VertexMap.find(_Vertices[id]);
		if (it!=_VertexMap.end())
			_VertexMap.erase(it);
		else
			nlwarning("vertex %u doesn't exist in _VertexMap, this should not happen", id);
	}
}

// ***************************************************************************
void			CShadowPolyReceiver::incVertexRefCount(uint id)
{
	nlassert(id<_Vertices.size());
	nlassert(_Vertices[id].RefCount < NL3D_SPR_MAX_REF_COUNT);
	_Vertices[id].RefCount++;
}



// ***************************************************************************
inline void	CShadowPolyReceiver::renderSelection(IDriver *drv, CMaterial &shadowMat, const CShadowMap *shadowMap, const CVector &casterPos, const CVector &vertDelta)
{
	uint	i, j;
	// For all triangles, reset vertices flags.
	TTriangleGrid::CIterator	it;
	for(it=_TriangleGrid.begin();it!=_TriangleGrid.end();it++)
	{
		CTriangleId		&triId= *it;
		for(i=0;i<3;i++)
		{
			_Vertices[triId.Vertex[i]].Flags= 0;
			_Vertices[triId.Vertex[i]].VBIdx= -1;
		}
	}

	// Compute the world Clip Volume
	static	std::vector<CPlane>		worldClipPlanes;
	CMatrix		worldMat;
	// set -casterPos, because to transform a plane, we must do plane * M-1
	worldMat.setPos(-casterPos);
	// Allow max bits of planes clip.
	worldClipPlanes.resize(min((uint)shadowMap->LocalClipPlanes.size(), (uint)NL3D_SPR_NUM_CLIP_PLANE));
	// Transform into world
	for(i=0;i<worldClipPlanes.size();i++)
	{
		worldClipPlanes[i]= shadowMap->LocalClipPlanes[i] * worldMat;
	}

	uint	currentTriIdx= 0;
	{
		// Volatile: must resize before lock
		_VB.setNumVertices((uint32)_Vertices.size());
		_RenderTriangles.setNumIndexes((uint32)_Triangles.size() * 3);

		// lock volatile, to avoid cpu stall
		CVertexBufferReadWrite vba;
		_VB.lock(vba);
		CIndexBufferReadWrite iba;
		_RenderTriangles.lock (iba);
		TIndexType *triPtr = (TIndexType *) iba.getPtr();

		// For All triangles, clip them.
		uint	currentVbIdx= 0;
		for(it=_TriangleGrid.begin();it!=_TriangleGrid.end();it++)
		{
			CTriangleId		&triId= *it;
			uint			triFlag= NL3D_SPR_NUM_CLIP_PLANE_MASK;

			// for all vertices, clip them
			for(i=0;i<3;i++)
			{
				uint	vid= triId.Vertex[i];
				uint	vertexFlags= _Vertices[vid].Flags;

				// if this vertex is still not computed
				if(!vertexFlags)
				{
					// For all planes of the Clip Volume, clip this vertex.
					for(j=0;j<worldClipPlanes.size();j++)
					{
						// out if in front
						bool	out= worldClipPlanes[j]*_Vertices[vid] > 0;

						vertexFlags|= ((uint)out)<<j;
					}

					// add the bit flag to say "computed".
					vertexFlags|= NL3D_SPR_NUM_CLIP_PLANE_SHIFT;

					// store
					_Vertices[vid].Flags= vertexFlags;
				}

				// And all vertex bits.
				triFlag&= vertexFlags;
			}

			// if triangle not clipped, add the triangle
			if( (triFlag & NL3D_SPR_NUM_CLIP_PLANE_MASK)==0 )
			{
				// Add the 3 vertices to the VB, and to the index buffer.
				for(i=0;i<3;i++)
				{
					uint	vid= triId.Vertex[i];
					sint	vbId= _Vertices[vid].VBIdx;

					// if not yet inserted in the VB, do it.
					if(vbId==-1)
					{
						// allocate a new place in the VBuffer
						vbId= currentVbIdx++;
						_Vertices[vid].VBIdx= vbId;
						// set the coord
						vba.setVertexCoord(vbId, _Vertices[vid]+vertDelta);
					}

					// add the index to the tri list.
					triPtr[currentTriIdx++]= (TIndexType) vbId;
				}
			}
		}
	}


	// **** Render
	drv->activeVertexBuffer(_VB);
	drv->activeIndexBuffer(_RenderTriangles);
	drv->renderTriangles(shadowMat, 0, currentTriIdx/3);
	// TestYoyo. Show in Red triangles selected
	/*static	CMaterial	tam;
	tam.initUnlit();
	tam.setColor(CRGBA(255,0,0,128));
	tam.setZFunc(CMaterial::always);
	tam.setZWrite(false);
	tam.setBlend(true);
	tam.setBlendFunc(CMaterial::srcalpha, CMaterial::invsrcalpha);
	tam.setDoubleSided(true);
	drv->renderTriangles(tam, &_RenderTriangles[0], currentTriIdx/3);*/
}

// ***************************************************************************
void CShadowPolyReceiver::computeClippedTrisWithPolyClip(const CShadowMap *shadowMap, const CVector &casterPos, const CVector &vertDelta, const NLMISC::CPolygon2D &poly, std::vector<CRGBAVertex> &destTris, bool colorUpfacingVertices)
{
	nlctassert(sizeof(CRGBAVertex) == 12 + 4); // ensure padding works as expected
	destTris.clear();
	selectPolygon(poly);
	if (_TriangleGrid.begin() == _TriangleGrid.end()) return;
	uint	i, j;


	static	std::vector<CVector>	vertexNormals; // normal for each vertex
	static	std::vector<uint8>	vertexNormalsUndefined; // normal for each vertex
	static  std::vector<CTriangleId *> visibleTris; // triangles that passed the clip
	vertexNormals.resize(_Vertices.size());
	vertexNormalsUndefined.resize(_Vertices.size(), 1);
	visibleTris.clear();

	// For all triangles, reset vertices flags.
	TTriangleGrid::CIterator	it;
	for(it=_TriangleGrid.begin();it!=_TriangleGrid.end();it++)
	{
		CTriangleId		&triId= *it;
		for(i=0;i<3;i++)
		{
			_Vertices[triId.Vertex[i]].Flags= 0;
		}
	}

	// Compute the world Clip Volume
	static	std::vector<CPlane>		worldClipPlanes;
	CMatrix		worldMat;
	// set -casterPos, because to transform a plane, we must do plane * M-1
	worldMat.setPos(-casterPos);
	// Allow max bits of planes clip.
	worldClipPlanes.resize(min((uint)shadowMap->LocalClipPlanes.size(), (uint)NL3D_SPR_NUM_CLIP_PLANE));
	// Transform into world
	for(i=0;i<worldClipPlanes.size();i++)
	{
		worldClipPlanes[i]= shadowMap->LocalClipPlanes[i] * worldMat;
	}

	static NLMISC::CPolygon clippedTri;

	CVector triNormal;


	// For All triangles, clip them.
	for(it=_TriangleGrid.begin();it!=_TriangleGrid.end();it++)
	{
		CTriangleId		&triId= *it;
		uint			triFlag= NL3D_SPR_NUM_CLIP_PLANE_MASK;


		CVectorId *vid[3] = { &_Vertices[triId.Vertex[0]],
							  &_Vertices[triId.Vertex[1]],
							  &_Vertices[triId.Vertex[2]]
							};

		// for all vertices, clip them
		for(i=0;i<3;i++)
		{

			// if this vertex is still not computed
			if(!vid[i]->Flags)
			{
				// For all planes of the Clip Volume, clip this vertex.
				for(j=0;j<worldClipPlanes.size();j++)
				{
					// out if in front
					bool	out= worldClipPlanes[j]* *vid[i] > 0;

					vid[i]->Flags |= ((uint)out)<<j;
				}
				// add the bit flag to say "computed".
				vid[i]->Flags |= NL3D_SPR_NUM_CLIP_PLANE_SHIFT;
			}

			vertexNormalsUndefined[triId.Vertex[i]] = 1; // invalidate normal for next pass

			// And all vertex bits.
			triFlag&= vid[i]->Flags;
		}
		// if triangle not clipped, do finer clip then add resulting triangles
		if( (triFlag & NL3D_SPR_NUM_CLIP_PLANE_MASK)==0 )
		{
			visibleTris.push_back(&triId);
		}
	}

	uint numVisibleTris = (uint)visibleTris.size();
	// compute normals if needed
	if (colorUpfacingVertices)
	{
		for (uint triIndex = 0; triIndex < numVisibleTris; ++triIndex)
		{
			CTriangleId		&triId= *visibleTris[triIndex];
			CVectorId *vid[3] = { &_Vertices[triId.Vertex[0]],
								  &_Vertices[triId.Vertex[1]],
								  &_Vertices[triId.Vertex[2]]
								};
			// compute normal for this tri
			triNormal = ((*vid[1] - *vid[0]) ^ (*vid[2] - *vid[0])).normed();

			// for all vertices, clip them
			for(i=0;i<3;i++)
			{
				sint vertIndex = triId.Vertex[i];
				if (vertexNormalsUndefined[vertIndex])
				{
					vertexNormals[vertIndex] = triNormal;
					vertexNormalsUndefined[vertIndex] = 0;
				}
				else
				{
					vertexNormals[vertIndex] += triNormal;
				}
			}
		}
	}


	if (colorUpfacingVertices)
	{
		for (uint triIndex = 0; triIndex < numVisibleTris; ++triIndex)
		{
			CTriangleId		&triId= *visibleTris[triIndex];
			// use CPlane 'uv cliping', store 'color' in 'U'
			static std::vector<CVector> corner0;
			static std::vector<CVector> corner1;
			static std::vector<CUV> uv0;
			static std::vector<CUV> uv1;
			uv0.resize(3 + worldClipPlanes.size());
			uv1.resize(3 + worldClipPlanes.size());
			corner0.resize(3 + worldClipPlanes.size());
			corner1.resize(3 + worldClipPlanes.size());
			//
			corner0[0] = _Vertices[triId.Vertex[0]];
			corner0[1] = _Vertices[triId.Vertex[1]];
			corner0[2] = _Vertices[triId.Vertex[2]];
			//
			uv0[0].set(vertexNormals[triId.Vertex[0]].z >= 0.f ? 1.f : 0.f, 0.f);
			uv0[1].set(vertexNormals[triId.Vertex[1]].z >= 0.f ? 1.f : 0.f, 0.f);
			uv0[2].set(vertexNormals[triId.Vertex[2]].z >= 0.f ? 1.f : 0.f, 0.f);
			//
			sint numVerts = 3;
			//
			for (uint k = 0; k < worldClipPlanes.size(); ++k)
			{
				numVerts = worldClipPlanes[k].clipPolygonBack(&corner0[0], &uv0[0], &corner1[0], &uv1[0], numVerts);
				nlassert(numVerts <= (sint) corner1.size());
				if (numVerts == 0) break;
				uv0.swap(uv1);
				corner0.swap(corner1);
			}
			for (sint k = 0; k < numVerts - 2; ++k)
			{
				uint8 alpha[3] =
				{
					(uint8) (255.f * uv0[0].U),
					(uint8) (255.f * uv0[k + 1].U),
					(uint8) (255.f * uv0[k + 2].U)
				};
				if (alpha[0] != 0 || alpha[1] != 0 || alpha[2] != 0)
				{
					destTris.push_back(CRGBAVertex(corner0[0] + vertDelta, CRGBA(255, 255, 255, alpha[0])));
					destTris.push_back(CRGBAVertex(corner0[k + 1] + vertDelta, CRGBA(255, 255, 255, alpha[1])));
					destTris.push_back(CRGBAVertex(corner0[k + 2] + vertDelta, CRGBA(255, 255, 255, alpha[2])));
				}
			}
		}
	}
	else
	{
		for (uint triIndex = 0; triIndex < numVisibleTris; ++triIndex)
		{
			CTriangleId		&triId= *visibleTris[triIndex];
			clippedTri.Vertices.resize(3);
			clippedTri.Vertices[0] = _Vertices[triId.Vertex[0]];
			clippedTri.Vertices[1] = _Vertices[triId.Vertex[1]];
			clippedTri.Vertices[2] = _Vertices[triId.Vertex[2]];
			clippedTri.clip(worldClipPlanes);
			if (clippedTri.Vertices.size() >= 3)
			{
				for(uint k = 0; k < clippedTri.Vertices.size() - 2; ++k)
				{
					destTris.push_back(CRGBAVertex(clippedTri.Vertices[0] + vertDelta, CRGBA::White));
					destTris.push_back(CRGBAVertex(clippedTri.Vertices[k + 1] + vertDelta,	CRGBA::White));
					destTris.push_back(CRGBAVertex(clippedTri.Vertices[k + 2] + vertDelta,	CRGBA::White));
				}
			}
		}
	}

}

// ***************************************************************************
void			CShadowPolyReceiver::render(IDriver *drv, CMaterial &shadowMat, const CShadowMap *shadowMap, const CVector &casterPos, const CVector &vertDelta)
{

	// **** Fill Triangles that are hit by the Caster
	// First select with quadGrid
	CAABBox		worldBB;
	worldBB= shadowMap->LocalBoundingBox;
	worldBB.setCenter(worldBB.getCenter() + casterPos);
	_TriangleGrid.select(worldBB.getMin(), worldBB.getMax());
	if (_TriangleGrid.begin() == _TriangleGrid.end()) return;
	renderSelection(drv, shadowMat, shadowMap, casterPos, vertDelta);
}


// ***************************************************************************
void CShadowPolyReceiver::selectPolygon(const NLMISC::CPolygon2D &poly)
{
	static TTriangleGrid::TSelectionShape selectionShape;
	_TriangleGrid.buildSelectionShape(selectionShape, poly);
	_TriangleGrid.select(selectionShape);
}

// ***************************************************************************
void			CShadowPolyReceiver::renderWithPolyClip(IDriver *drv, CMaterial &shadowMat, const CShadowMap *shadowMap, const CVector &casterPos, const CVector &vertDelta, const NLMISC::CPolygon2D &poly)
{

	selectPolygon(poly);
	renderSelection(drv, shadowMat, shadowMap, casterPos, vertDelta);
}

// ***************************************************************************
float			CShadowPolyReceiver::getCameraCollision(const CVector &start, const CVector &end, TCameraColTest testType, float radius)
{
	// **** build the camera collision info
	CCameraCol	camCol;
	if(testType==CameraColSimpleRay)
		camCol.buildRay(start, end);
	else
		camCol.build(start, end, radius, testType==CameraColCone);

	// select with quadGrid
	if(testType==CameraColSimpleRay)
	{
		_TriangleGrid.selectRay(start, end);
	}
	else
	{
		_TriangleGrid.select(camCol.getBBox().getMin(), camCol.getBBox().getMax());
	}

	// **** For all triangles, test if intersect the camera collision
	TTriangleGrid::CIterator	it;
	float		sqrMinDist= FLT_MAX;
	for(it=_TriangleGrid.begin();it!=_TriangleGrid.end();it++)
	{
		CTriangleId		&triId= *it;
		camCol.minimizeDistanceAgainstTri(
			_Vertices[triId.Vertex[0]],
			_Vertices[triId.Vertex[1]],
			_Vertices[triId.Vertex[2]],
			sqrMinDist);
	}

	// **** return the collision found, between [0,1]
	if(sqrMinDist == FLT_MAX)
		return 1;
	else
	{
		float	f= 1;
		float	d= camCol.getRayLen();
		if(d>0)
		{
			f= sqrtf(sqrMinDist) / d;
			f= min(f, 1.f);
		}
		return f;
	}
}





} // NL3D