// 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 "stdpacs.h"

#include "retriever_instance.h"
#include "global_retriever.h"

using namespace std;
using namespace NLMISC;



NLPACS::CRetrieverInstance::CRetrieverInstance()
{
	reset();
}


void	NLPACS::CRetrieverInstance::resetLinks()
{
	uint	i;
	// WARNING !!
	// this is a HARD reset !
	// only the instance i reset, no care about neighbors !!
	for (i=0; i<_Neighbors.size(); ++i)
		_Neighbors[i] = -1;
	_BorderChainLinks.clear();

	_ExteriorEdgeQuad.removeLinks();
}

void	NLPACS::CRetrieverInstance::resetLinks(uint32 id)
{
	vector<sint32>::iterator	rit;
	for (rit=_Neighbors.begin(); rit!=_Neighbors.end(); )
		if (*rit == (sint32)id)
			rit = _Neighbors.erase(rit);
		else
			++rit;

	uint	i;
	for (i=0; i<_BorderChainLinks.size(); ++i)
		if (_BorderChainLinks[i].Instance == (uint16)id)
			_BorderChainLinks[i].reset();

	_ExteriorEdgeQuad.removeLinks(id);
}

void	NLPACS::CRetrieverInstance::reset()
{
	// WARNING !!
	// this is a HARD reset !
	// only the instance i reset, no care about neighbors !!
	_NodesInformation.clear();
	_InstanceId = -1;
	_RetrieverId = -1;
	_Orientation = 0;
	_Origin = CVector::Null;
	_Type = CLocalRetriever::Landscape;
	_BorderChainLinks.clear();
	_ExteriorEdgeQuad.clear();

	resetLinks();
}

void	NLPACS::CRetrieverInstance::init(const CLocalRetriever &retriever)
{
	if (!retriever.isLoaded())
		return;
/*
	_NodesInformation.resize(retriever.getSurfaces().size());
	uint	i;

	// Resets _NodesInformation for later pathfinding graph annotation.
	for (i=0; i<_NodesInformation.size(); ++i)
	{
		CVector	pos = getGlobalPosition(retriever.getSurfaces()[i].getCenter());
		_NodesInformation[i].Position = CVector2f(pos.x, pos.y);
	}
*/

	_Type = retriever.getType();
	_BorderChainLinks.resize(retriever.getBorderChains().size());
}

void	NLPACS::CRetrieverInstance::make(sint32 instanceId, sint32 retrieverId, const CLocalRetriever &retriever,
										 uint8 orientation, const CVector &origin)
{
	if (_InstanceId != -1 || _RetrieverId != -1)
	{
		nlwarning("in call to NLPACS::CRetrieverInstance::make");
		nlwarning("_InstanceId=%d _RetrieverId=%d _Orientation=%d", _InstanceId, _RetrieverId, _Orientation);
		nlwarning("instanceId=%d retrieverId=%d orientation=%d", instanceId, retrieverId, orientation);
		nlerror("Retriever instance %d has already been set", _InstanceId);
	}

	_InstanceId = instanceId;
	_RetrieverId = retrieverId;
	_Orientation = (orientation%4);
	_Origin = origin;

	_BBox = retriever.getBBox();
	_BBox.setCenter(_BBox.getCenter()+_Origin);

	if (_Orientation == 1 || _Orientation == 3)
	{
		CVector	hs = _BBox.getHalfSize();
		std::swap(hs.x, hs.y);
		_BBox.setHalfSize(hs);
	}

	init(retriever);
}

//
void	NLPACS::CRetrieverInstance::initEdgeQuad(NLPACS::CGlobalRetriever &gr)
{
	const CLocalRetriever	&lr = gr.getRetriever(_RetrieverId);

	if (lr.getType() != CLocalRetriever::Interior)
	{
		nlerror("Attempt to init the edgequad of instance %d whereas local retriever %d is not interior", _InstanceId, _RetrieverId);
	}

	// build the edge quad
	_ExteriorEdgeQuad.build(lr.getExteriorMesh(), gr, gr.getInternalCST(),_InstanceId);
}

void	NLPACS::CRetrieverInstance::linkEdgeQuad(NLPACS::CGlobalRetriever &gr)
{
	const CLocalRetriever				&lr = gr.getRetriever(_RetrieverId);
	const CExteriorMesh					&em = lr.getExteriorMesh();

	const vector<CExteriorEdgeEntry>	&ee = _ExteriorEdgeQuad.getEdgeEntries();

	// here we fill (partially) the _BorderChainLinks table
	uint	i;
	for (i=0; i<ee.size(); ++i)
	{
		const CExteriorMesh::CEdge	&edge = em.getEdge(ee[i].EdgeId);
		if (edge.Link != -1)
		{
			const CExteriorMesh::CLink		&link = em.getLink(edge.Link);

			if (link.SurfaceId != 0xFFFF && link.ChainId != 0xFFFF && link.BorderChainId != 0xFFFF)
			{
				CRetrieverInstance::CLink	&borderLink = _BorderChainLinks[link.BorderChainId];
				borderLink.ChainId = 0xFFFF;		// no opposite chain
				borderLink.BorderChainId = 0xFFFF;	// idem
				if ((borderLink.Instance == 0xFFFF && borderLink.SurfaceId == 0xFFFF) ||
					(borderLink.Instance == (uint16)(ee[i].Exterior.RetrieverInstanceId) &&
					 borderLink.SurfaceId == (uint16)(ee[i].Exterior.SurfaceId) ))
				{
					borderLink.Instance = (uint16)(ee[i].Exterior.RetrieverInstanceId);
					borderLink.SurfaceId = (uint16)(ee[i].Exterior.SurfaceId);
				}
				else
				{
					nlwarning("Instance %d, borderLink %d: link already set to inst=%d, surf=%d, try to set to inst=%d, surf=%d",
								_InstanceId, link.BorderChainId, borderLink.Instance, borderLink.SurfaceId,
								(uint16)(ee[i].Exterior.RetrieverInstanceId), (uint16)(ee[i].Exterior.SurfaceId));
				}
			}
		}
	}
}

/* Links the current retriever instance to another instance
 * on the given edge.
 */
void	NLPACS::CRetrieverInstance::link(CRetrieverInstance &neighbor,
										 const vector<CLocalRetriever> &retrievers)
{
	uint	i, j;
	for (i=0; i<_Neighbors.size(); ++i)
		if (_Neighbors[i] == neighbor._InstanceId)
			return;

	const CLocalRetriever						&retriever = retrievers[_RetrieverId];
	const CLocalRetriever						&nRetriever = retrievers[neighbor._RetrieverId];

	const vector<CChain>						&chains = retriever.getChains(),
												&nChains = nRetriever.getChains();
	const vector<uint16>						&borderChains = retriever.getBorderChains(),
												&nBorderChains = nRetriever.getBorderChains();

	vector< pair<CVector,CVector> >				chainTips,
												nChainTips;

	_BorderChainLinks.resize(borderChains.size());
	neighbor._BorderChainLinks.resize(nBorderChains.size());

/*
	for (i=0; i<borderChains.size(); ++i)
		chainTips.push_back(make_pair(retriever.getTip(chains[borderChains[i]].getStartTip()).Point,
									  retriever.getTip(chains[borderChains[i]].getStopTip()).Point));
*/
	for (i=0; i<borderChains.size(); ++i)
		chainTips.push_back(make_pair(retriever.getStartVector(borderChains[i]),
									  retriever.getStopVector(borderChains[i])));

	CVector	translation = neighbor._Origin - _Origin;
/*
	for (i=0; i<nBorderChains.size(); ++i)
		nChainTips.push_back(make_pair(nRetriever.getTip(nChains[nBorderChains[i]].getStartTip()).Point+translation,
									   nRetriever.getTip(nChains[nBorderChains[i]].getStopTip()).Point+translation));
*/
	for (i=0; i<nBorderChains.size(); ++i)
		nChainTips.push_back(make_pair(nRetriever.getStartVector(nBorderChains[i])+translation,
									   nRetriever.getStopVector(nBorderChains[i])+translation));

	for (i=0; i<borderChains.size(); ++i)
	{
		// if the chain is already linked, just step
		if (_BorderChainLinks[i].Instance != 0xFFFF || _BorderChainLinks[i].BorderChainId != 0xFFFF ||
			_BorderChainLinks[i].ChainId != 0xFFFF || _BorderChainLinks[i].SurfaceId != 0xFFFF)
			continue;

		float	bestDist = 1.0f;
		sint	best = -1;

		for (j=0; j<nBorderChains.size(); ++j)
		{
			if (neighbor._BorderChainLinks[j].Instance != 0xFFFF || neighbor._BorderChainLinks[j].BorderChainId != 0xFFFF ||
				neighbor._BorderChainLinks[j].ChainId != 0xFFFF || neighbor._BorderChainLinks[j].SurfaceId != 0xFFFF)
				continue;

			float	d = (chainTips[i].first-nChainTips[j].second).norm()+(chainTips[i].second-nChainTips[j].first).norm();
			if (d < bestDist)
			{
				bestDist = d;
				best = j;
			}
		}

		// if no best match, just don't link
		if (bestDist > 1.0e-1f || best == -1)
			continue;

		_BorderChainLinks[i].Instance = (uint16)neighbor._InstanceId;
		_BorderChainLinks[i].BorderChainId = (uint16)best;
		_BorderChainLinks[i].ChainId = nBorderChains[_BorderChainLinks[i].BorderChainId];
		_BorderChainLinks[i].SurfaceId = (uint16)nChains[_BorderChainLinks[i].ChainId].getLeft();

		neighbor._BorderChainLinks[best].Instance = (uint16)_InstanceId;
		neighbor._BorderChainLinks[best].BorderChainId = (uint16)i;
		neighbor._BorderChainLinks[best].ChainId = borderChains[neighbor._BorderChainLinks[best].BorderChainId];
		neighbor._BorderChainLinks[best].SurfaceId = (uint16)chains[neighbor._BorderChainLinks[best].ChainId].getLeft();
	}

	_Neighbors.push_back(neighbor._InstanceId);
	neighbor._Neighbors.push_back(_InstanceId);
}


void	NLPACS::CRetrieverInstance::unlink(vector<CRetrieverInstance> &instances)
{
	uint	i;

	for (i=0; i<_Neighbors.size(); ++i)
		instances[_Neighbors[i]].resetLinks(_InstanceId);

	resetLinks();
}




void	NLPACS::CRetrieverInstance::retrievePosition(const NLMISC::CVector &estimated, const CLocalRetriever &retriever, CCollisionSurfaceTemp &cst, bool sortByDistance) const
//NLPACS::CLocalRetriever::CLocalPosition	NLPACS::CRetrieverInstance::retrievePosition(const NLMISC::CVector &estimated, const CLocalRetriever &retriever, CCollisionSurfaceTemp &cst) const
{
/*
	CVector							localEstimated;
	CLocalRetriever::CLocalPosition	retrieved;

	// get local coordinates
	localEstimated = getLocalPosition(estimated);
	// Yoyo: must snap vector.
	CRetrieverInstance::snapVector(localEstimated);

	// fills _RetrieveTable by retrievingPosition.
	retriever.retrievePosition(localEstimated, cst);

	uint	i, surf;
	sint	bestSurf = -1;
	sint	lastSurf = -1;
	float	bestDistance = 1.0e10f;
	float	bestHeight;
	bool	lfound;

	// for each surface in the retriever
	for (i=0; i<cst.PossibleSurfaces.size(); ++i)
	{
		surf = cst.PossibleSurfaces[i];
		cst.SurfaceLUT[surf].first = false;
		// if the surface contains the estimated position.
		if (cst.SurfaceLUT[surf].second != 0)
		{
			// at least remembers the last seen surface...
			cst.SurfaceLUT[surf].second = 0;
			float			meanHeight;
			const CQuadLeaf	*leaf;
			ULocalPosition	lp;
			lfound = false;

			switch (_Type)
			{
			case CLocalRetriever::Landscape:
				// for landscape
				// search in the surface's quad tree for the actual height
				leaf = retriever.getSurfaces()[surf].getQuadTree().getLeaf(localEstimated);
				// if there is no acceptable leaf, just give up
				if (leaf == NULL)
					continue;
				meanHeight = leaf->getMaxHeight();
				lfound = true;
				break;
			case CLocalRetriever::Interior:
				// for interior
				// get the exact position
				lp.Surface = surf;
				lp.Estimation = localEstimated;
				meanHeight = localEstimated.z;
				retriever.snapToInteriorGround(lp, lfound);
				if (lfound)
					meanHeight = lp.Estimation.z;
				break;
			default:
				// hu?
				continue;
			}

			// if it is closer to the estimation than the previous remembered...
			float	distance = (float)fabs(localEstimated.z-meanHeight);
			if (distance < bestDistance && lfound)
			{
				bestDistance = distance;
				bestHeight = meanHeight;
				bestSurf = surf;
			}
		}
	}

	if (bestSurf != -1)
	{
		// if there is a best surface, returns it
		retrieved.Surface = bestSurf;
		retrieved.Estimation = CVector(localEstimated.x, localEstimated.y, bestHeight);
	}
	else
	{
		// else return the last remembered...
		retrieved.Surface = lastSurf;
		retrieved.Estimation = localEstimated;
	}

	return retrieved;
*/
	retrievePosition(CVectorD(estimated), retriever, cst, sortByDistance);
}

void	NLPACS::CRetrieverInstance::retrievePosition(const NLMISC::CVectorD &estimated, const CLocalRetriever &retriever, CCollisionSurfaceTemp &cst, bool sortByDistance) const
{
	CVector							localEstimated;

//	nldebug("PACS: retrievePosition in instance %d (retriever %d)", _InstanceId, _RetrieverId);

	// get local coordinates
	localEstimated = getLocalPosition(estimated);
	// Yoyo: must snap vector.
	CRetrieverInstance::snapVector(localEstimated);

	// fills _RetrieveTable by retrievingPosition.
	retriever.retrievePosition(localEstimated, cst);

	uint	i, surf;
/*	sint	bestSurf = -1;
	sint	lastSurf = -1;
	float	bestDistance = 1.0e10f;
	float	bestHeight;*/
	bool	found = false;

	switch (_Type)
	{
	case CLocalRetriever::Landscape:
		// for landscape
		for (i=0; i<cst.PossibleSurfaces.size(); ++i)
		{
			surf = cst.PossibleSurfaces[i];

//			nldebug("PACS: surface %d: count %d", surf, cst.SurfaceLUT[surf].Counter);

			// if the surface contains the estimated position.
			if (cst.SurfaceLUT[surf].Counter == 2)
			{
				float			meanHeight;
/*
				const CQuadLeaf	*leaf;

				// search in the surface's quad tree for the actual height
				leaf = retriever.getSurfaces()[surf].getQuadTree().getLeaf(localEstimated);
				// if there is no acceptable leaf, just give up
				if (leaf != NULL)
				{
					meanHeight = leaf->getMaxHeight();
					//meanHeight = retriever.getSurfaces()[surf].getQuadTree().getInterpZ(localEstimated);

					// if it is closer to the estimation than the previous remembered...
					found = true;
					float	distance = (float)fabs(localEstimated.z-meanHeight);
					cst.SortedSurfaces.push_back(CCollisionSurfaceTemp::CDistanceSurface(distance, (uint16)surf, (uint16)_InstanceId, cst.SurfaceLUT[surf].FoundCloseEdge));
				}
*/

				meanHeight = retriever.getSurface(surf).getQuantHeight()*2.0f + 1.0f;

				// if it is closer to the estimation than the previous remembered...
				found = true;
				float	distance = sortByDistance ? (float)fabs(localEstimated.z-meanHeight) : meanHeight;
				cst.SortedSurfaces.push_back(CCollisionSurfaceTemp::CDistanceSurface(distance, (uint16)surf, (uint16)_InstanceId, cst.SurfaceLUT[surf].FoundCloseEdge));

			}
			else if (cst.SurfaceLUT[surf].Counter != 0)
			{
				nlwarning("PACS: unexpected surface (%d) count (%d) at instance %d (pos=(%f,%f,%f))", surf, cst.SurfaceLUT[surf].Counter, _InstanceId, estimated.x, estimated.y, estimated.z);
			}

			cst.SurfaceLUT[surf].reset();
		}

		break;

	case CLocalRetriever::Interior:
		// for interior
		for (i=0; i<cst.PossibleSurfaces.size(); ++i)
		{
			surf = cst.PossibleSurfaces[i];
			// if the surface contains the estimated position.
			if (cst.SurfaceLUT[surf].Counter == 2)
			{
				ULocalPosition	lp;
				bool			lfound = false;

				// get the exact position
				lp.Surface = surf;
				lp.Estimation = localEstimated;
				retriever.snapToInteriorGround(lp, lfound);
				if (lfound)
				{
					// if it is closer to the estimation than the previous remembered...
					found = true;
					float	distance = sortByDistance ? (float)fabs(localEstimated.z-lp.Estimation.z) : lp.Estimation.z;
					cst.SortedSurfaces.push_back(CCollisionSurfaceTemp::CDistanceSurface(distance, (uint16)surf, (uint16)_InstanceId, cst.SurfaceLUT[surf].FoundCloseEdge));
				}
			}
			else if (cst.SurfaceLUT[surf].Counter != 0)
			{
				nlwarning("PACS: unexpected surface (%d) count (%d) at instance %d (pos=(%f,%f,%f))", surf, cst.SurfaceLUT[surf].Counter, _InstanceId, estimated.x, estimated.y, estimated.z);
			}

			cst.SurfaceLUT[surf].reset();
		}
		break;

	default:
		nlerror("Unknown instance type %d !!", _Type);
		break;
	}

	cst.OutCounter = 0;
}



void	NLPACS::CRetrieverInstance::snapToInteriorGround(NLPACS::ULocalPosition &position,
														 const NLPACS::CLocalRetriever &retriever) const
{
	bool	lfound;
	retriever.snapToInteriorGround(position, lfound);
}

void	NLPACS::CRetrieverInstance::snap(NLPACS::ULocalPosition &position, const NLPACS::CLocalRetriever &retriever) const
{
	if (_Type == CLocalRetriever::Landscape)
	{
		// search in the surface's quad tree for the actual height
//		position.Estimation.z = retriever.getSurfaces()[position.Surface].getQuadTree().getInterpZ(position.Estimation);

		position.Estimation.z = retriever.getHeight(position);

/*
		const CQuadLeaf	*leaf = retriever.getSurfaces()[position.Surface].getQuadTree().getLeaf(position.Estimation);
		// if there is no acceptable leaf, just give up
		if (leaf != NULL)
		{
			position.Estimation.z = leaf->getMaxHeight();
		}
		else
		{
			nlwarning("PACS: couldn't snap position (%f,%f,%f) on surface %d instance %d", position.Estimation.x, position.Estimation.y, position.Estimation.z, position.Surface, _InstanceId);
		}
*/
	}
	else if (_Type == CLocalRetriever::Interior)
	{
		bool	lfound;
		retriever.snapToInteriorGround(position, lfound);
	}
	else
	{
		nlwarning("PACS: unknown instance (%d) type %d", _InstanceId, _Type);
	}
}





CVector	NLPACS::CRetrieverInstance::getLocalPosition(const CVector &globalPosition) const
{
	switch (_Orientation)
	{
	default:
		nlwarning("in NLPACS::CRetrieverInstance::getLocalPosition()");
		nlerror("unexpected orientation value (%d)", _Orientation);
	case 0:
		return CVector(+globalPosition.x-_Origin.x, +globalPosition.y-_Origin.y, globalPosition.z-_Origin.z);
		break;
	case 1:
		return CVector(+globalPosition.y-_Origin.y, -globalPosition.x+_Origin.x, globalPosition.z-_Origin.z);
		break;
	case 2:
		return CVector(-globalPosition.x+_Origin.x, -globalPosition.y+_Origin.y, globalPosition.z-_Origin.z);
		break;
	case 3:
		return CVector(-globalPosition.y+_Origin.y, +globalPosition.x-_Origin.x, globalPosition.z-_Origin.z);
		break;
	}
}

CVector	NLPACS::CRetrieverInstance::getLocalPosition(const CVectorD &globalPosition) const
{
	switch (_Orientation)
	{
	default:
		nlwarning("in NLPACS::CRetrieverInstance::getLocalPosition()");
		nlerror("unexpected orientation value (%d)", _Orientation);
	case 0:
		return CVector((float)(+globalPosition.x-_Origin.x), (float)(+globalPosition.y-_Origin.y), (float)(globalPosition.z-_Origin.z));
		break;
	case 1:
		return CVector((float)(+globalPosition.y-_Origin.y), (float)(-globalPosition.x+_Origin.x), (float)(globalPosition.z-_Origin.z));
		break;
	case 2:
		return CVector((float)(-globalPosition.x+_Origin.x), (float)(-globalPosition.y+_Origin.y), (float)(globalPosition.z-_Origin.z));
		break;
	case 3:
		return CVector((float)(-globalPosition.y+_Origin.y), (float)(+globalPosition.x-_Origin.x), (float)(globalPosition.z-_Origin.z));
		break;
	}
}

CVector	NLPACS::CRetrieverInstance::getGlobalPosition(const CVector &localPosition) const
{
	switch (_Orientation)
	{
	default:
		nlwarning("in NLPACS::CRetrieverInstance::getLocalPosition()");
		nlerror("unexpected orientation value (%d)", _Orientation);
	case 0:
		return CVector(+localPosition.x+_Origin.x, +localPosition.y+_Origin.y, localPosition.z+_Origin.z );
		break;
	case 1:
		return CVector(-localPosition.y+_Origin.x, +localPosition.x+_Origin.y, localPosition.z+_Origin.z );
		break;
	case 2:
		return CVector(-localPosition.x+_Origin.x, -localPosition.y+_Origin.y, localPosition.z+_Origin.z );
		break;
	case 3:
		return CVector(+localPosition.y+_Origin.x, -localPosition.x+_Origin.y, localPosition.z+_Origin.z );
		break;
	}
}

CVectorD	NLPACS::CRetrieverInstance::getDoubleGlobalPosition(const CVector &localPosition) const
{
	switch (_Orientation)
	{
	default:
		nlwarning("in NLPACS::CRetrieverInstance::getLocalPosition()");
		nlerror("unexpected orientation value (%d)", _Orientation);
	case 0:
		return CVectorD(+(double)localPosition.x+(double)_Origin.x, +(double)localPosition.y+(double)_Origin.y, (double)localPosition.z+(double)_Origin.z );
		break;
	case 1:
		return CVectorD(-(double)localPosition.y+(double)_Origin.x, +(double)localPosition.x+(double)_Origin.y, (double)localPosition.z+(double)_Origin.z );
		break;
	case 2:
		return CVectorD(-(double)localPosition.x+(double)_Origin.x, -(double)localPosition.y+(double)_Origin.y, (double)localPosition.z+(double)_Origin.z );
		break;
	case 3:
		return CVectorD(+(double)localPosition.y+(double)_Origin.x, -(double)localPosition.x+(double)_Origin.y, (double)localPosition.z+(double)_Origin.z );
		break;
	}
}



// ***************************************************************************
void	NLPACS::CRetrieverInstance::testExteriorCollision(NLPACS::CCollisionSurfaceTemp &cst, const CAABBox &bboxMove, const CVector2f &transBase, const NLPACS::CLocalRetriever &retriever) const
{
	sint	i;

	// 0. select ordered chains in the chainquad.
	//=====================================
	sint	nEei= _ExteriorEdgeQuad.selectEdges(bboxMove, cst);
	// NB: cst.OChainLUT is assured to be full of 0xFFFF after this call (if was right before).


	// 1. regroup them in chains. build cst.CollisionChains
	//=====================================
	// NB: use cst.OChainLUT to look if a Chain has been inserted before.
	uint16	*edgeLUT= cst.OChainLUT;

	// bkup where we begin to add chains.
	uint	firstChainAdded= (uint)cst.CollisionChains.size();

	// For all exterioredge entry.
	for(i=0;i<nEei;i++)
	{
		// get the edge entry and the edge
		uint16						eei = cst.ExteriorEdgeIndexes[i];
		const CExteriorEdgeEntry	&eee = _ExteriorEdgeQuad.getEdgeEntry(eei);

		// WELL ACTUALLY DO BOTHER ABOUT DOORS !!
/*
		// don't bother about doors
		if (eee.Interior.RetrieverInstanceId != -1)
			continue;
*/

		// add/retrieve the id in cst.CollisionChains.
		//=================================
		uint				ccId;
		// if never added.
		if(edgeLUT[eei]==0xFFFF)
		{
			// add a new CCollisionChain.
			ccId= (uint)cst.CollisionChains.size();
			cst.CollisionChains.push_back(CCollisionChain());
			// Fill it with default.
			cst.CollisionChains[ccId].Tested= false;
			cst.CollisionChains[ccId].ExteriorEdge = true;
			cst.CollisionChains[ccId].FirstEdgeCollide= 0xFFFFFFFF;
			cst.CollisionChains[ccId].ChainId= eei;
			// Fill Left right info.
			cst.CollisionChains[ccId].LeftSurface = eee.Interior;
			cst.CollisionChains[ccId].RightSurface = eee.Exterior;

			// store this Id in the LUT of chains.
			edgeLUT[eei]= uint16(ccId);
		}
		else
		{
			// get the id of this collision chain.
			ccId= edgeLUT[eei];

			// ACTUALLY, THIS SHOULD NEVER HAPPEN
			// since ext edge are only 1 segment
		}

		// add edge collide to the list.
		//=================================
		CCollisionChain			&colChain= cst.CollisionChains[ccId];

		CVector2f	p0 = CVector2f(retriever._ExteriorMesh.getEdge(eee.EdgeId).Start);
		CVector2f	p1 = CVector2f(retriever._ExteriorMesh.getEdge(eee.EdgeId+1).Start);

		// alloc a new edgeCollide.
		uint32	ecnId= cst.allocEdgeCollideNode();
		CEdgeCollideNode	&ecn= cst.getEdgeCollideNode(ecnId);

		// append to the front of the list.
		ecn.Next= colChain.FirstEdgeCollide;
		colChain.FirstEdgeCollide= ecnId;

		// build this edge.
		p0+= transBase;
		p1+= transBase;
		ecn.make(p0, p1);
	}



	// 2. Reset LUT to 0xFFFF.
	//=====================================

	// for all collisions chains inserted (starting from firstChainAdded), reset LUT.
	for(i=firstChainAdded; i<(sint)cst.CollisionChains.size(); i++)
	{
		uint	ccId= cst.CollisionChains[i].ChainId;
		edgeLUT[ccId]= 0xFFFF;
		cst.CollisionChains[i].ChainId = _ExteriorEdgeQuad.getEdgeEntry(ccId).EdgeId;
	}

}




void	NLPACS::CRetrieverInstance::serial(NLMISC::IStream &f)
{
	/*
	Version 0:
		- base version.
	Version 1:
		- added type and _EdgeQuad
	*/
	sint	ver= f.serialVersion(1);

	f.serial(_InstanceId, _RetrieverId, _Orientation, _Origin);
	f.serialCont(_Neighbors);
	f.serialCont(_BorderChainLinks);
	f.serial(_BBox);

	// serialises the number of nodes
	uint16	totalNodes = uint16(_NodesInformation.size());
	f.serial(totalNodes);
	if (f.isReading())
	{
		// if the stream is reading, reinits the temps table...
		_NodesInformation.resize(totalNodes);
	}

	if (ver >= 1)
	{
		f.serialEnum(_Type);
		f.serial(_ExteriorEdgeQuad);

		// a fix for old versions (with wrong _Type value)
		if (_Type != CLocalRetriever::Interior)	_Type = CLocalRetriever::Landscape;
	}
}



void	NLPACS::CRetrieverInstance::resetBorderChainLinks(const vector<uint> &links)
{
	uint	i;
	for (i=0; i<links.size(); ++i)
	{
		if (links[i] >= _BorderChainLinks.size())
			_BorderChainLinks.resize(links[i]+1);

		_BorderChainLinks[links[i]].reset();
	}
}