// 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/zone.h"
#include "nel/3d/landscape.h"
#include "nel/3d/zone_symmetrisation.h"
#include "nel/misc/common.h"
#include "nel/misc/hierarchical_timer.h"


using namespace NLMISC;
using namespace std;


// define it only for debug bind.
//#define	NL3D_DEBUG_DONT_BIND_PATCH


namespace NL3D
{



// ***************************************************************************
// ***************************************************************************
// CPatchInfo
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
void			CPatchInfo::setCornerSmoothFlag(uint corner, bool smooth)
{
	nlassert(corner<=3);
	uint	mask= 1<<corner;
	if(smooth)
		_CornerSmoothFlag|= mask;
	else
		_CornerSmoothFlag&= ~mask;
}

// ***************************************************************************
bool			CPatchInfo::getCornerSmoothFlag(uint corner) const
{
	nlassert(corner<=3);
	uint	mask= 1<<corner;
	return	(_CornerSmoothFlag & mask)!=0;
}


// ***************************************************************************
// ***************************************************************************
// CZone
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
CZone::CZone()
{
	ZoneId= 0;
	Compiled= false;
	Landscape= NULL;
	ClipResult= ClipOut;
}
// ***************************************************************************
CZone::~CZone()
{
	// release() must have been called.
	nlassert(!Compiled);
}


// ***************************************************************************
void			CZone::computeBBScaleBias(const CAABBox	&bb)
{
	ZoneBB= bb;
	// Take a security for noise. (useful for zone clipping).
	ZoneBB.setHalfSize(ZoneBB.getHalfSize()+CVector(NL3D_NOISE_MAX, NL3D_NOISE_MAX, NL3D_NOISE_MAX));
	CVector	hs= ZoneBB.getHalfSize();
	float	rmax= maxof(hs.x, hs.y, hs.z);
	PatchScale= rmax / 32760;		// Prevent from float imprecision by taking 32760 and not 32767.
	PatchBias= ZoneBB.getCenter();
}


// ***************************************************************************
void			CZone::build(uint16 zoneId, const std::vector<CPatchInfo> &patchs, const std::vector<CBorderVertex> &borderVertices, uint32 numVertices)
{
	CZoneInfo	zinfo;
	zinfo.ZoneId= zoneId;
	zinfo.Patchs= patchs;
	zinfo.BorderVertices= borderVertices;

	build(zinfo, numVertices);
}
// ***************************************************************************
void			CZone::build(const CZoneInfo &zoneInfo, uint32 numVertices)
{
	sint	i,j;
	nlassert(!Compiled);

	// Ref inupt
	uint16		zoneId= zoneInfo.ZoneId;
	const std::vector<CPatchInfo> &patchs= zoneInfo.Patchs;
	const std::vector<CBorderVertex> &borderVertices= zoneInfo.BorderVertices;


	ZoneId= zoneId;
	BorderVertices= borderVertices;

	// Compute the bbox and the bias/scale.
	//=====================================
	CAABBox		bb;
	if(patchs.size())
		bb.setCenter(patchs[0].Patch.Vertices[0]);
	bb.setHalfSize(CVector::Null);
	for(j=0;j<(sint)patchs.size();j++)
	{
		const CBezierPatch	&p= patchs[j].Patch;
		for(i=0;i<4;i++)
			bb.extend(p.Vertices[i]);
		for(i=0;i<8;i++)
			bb.extend(p.Tangents[i]);
		for(i=0;i<4;i++)
			bb.extend(p.Interiors[i]);
	}
	// Compute BBox, and Patch Scale Bias, according to Noise.
	computeBBScaleBias(bb);


	// Compute/compress Patchs.
	//=========================
	Patchs.resize(patchs.size());
	PatchConnects.resize(patchs.size());
	sint	maxVertex=-1;
	for(j=0;j<(sint)patchs.size();j++)
	{
		const CPatchInfo	&pi= patchs[j];
		const CBezierPatch	&p= pi.Patch;
		CPatch				&pa= Patchs[j];
		CPatchConnect		&pc= PatchConnects[j];

		// Smoothing flags
		pa.Flags&=~NL_PATCH_SMOOTH_FLAG_MASK;
		pa.Flags|=NL_PATCH_SMOOTH_FLAG_MASK&(pi.Flags<<NL_PATCH_SMOOTH_FLAG_SHIFT);


		// Noise Data
		// copy noise rotation.
		pa.NoiseRotation= pi.NoiseRotation;
		// copy all noise smoothing info.
		for(i=0;i<4;i++)
		{
			pa.setCornerSmoothFlag(i, pi.getCornerSmoothFlag(i));
		}

		// Copy order of the patch
		pa.OrderS= pi.OrderS;
		pa.OrderT= pi.OrderT;

		// Build the patch.
		for(i=0;i<4;i++)
			pa.Vertices[i].pack(p.Vertices[i], PatchBias, PatchScale);
		for(i=0;i<8;i++)
			pa.Tangents[i].pack(p.Tangents[i], PatchBias, PatchScale);
		for(i=0;i<4;i++)
			pa.Interiors[i].pack(p.Interiors[i], PatchBias, PatchScale);
		pa.Tiles= pi.Tiles;
		pa.TileColors= pi.TileColors;
		/* Copy TileLightInfluences. It is possible that pi.TileLightInfluences.size()!= 0
			and pi.TileLightInfluences.size()!= (uint)(pi.OrderS/2+1)*(pi.OrderT/2+1)
			Because of a preceding bug where pa.OrderS and pa.OrderT were not initialized before the
			pa.resetTileLightInfluences();
		*/
		if( pi.TileLightInfluences.size()!= (uint)(pi.OrderS/2+1)*(pi.OrderT/2+1) )
		{
			pa.resetTileLightInfluences();
		}
		else
		{
			pa.TileLightInfluences= pi.TileLightInfluences;
		}

		// Number of lumels in this patch
		uint lumelCount=(pi.OrderS*NL_LUMEL_BY_TILE)*(pi.OrderT*NL_LUMEL_BY_TILE);

		// Lumel empty ?
		if (pi.Lumels.size ()==lumelCount)
		{
			// Pack the lumel map
			pa.packShadowMap (&pi.Lumels[0]);
		}
		else
		{
			// Reset lightmap
			pa.resetCompressedLumels ();
		}

		nlassert(pa.Tiles.size()== (uint)pi.OrderS*pi.OrderT);
		nlassert(pa.TileColors.size()== (uint)(pi.OrderS+1)*(pi.OrderT+1));

		// Build the patchConnect.
		pc.ErrorSize= pi.ErrorSize;
		for(i=0;i<4;i++)
		{
			pc.BaseVertices[i]= pi.BaseVertices[i];
			maxVertex= max((sint)pc.BaseVertices[i], maxVertex);
		}
		for(i=0;i<4;i++)
			pc.BindEdges[i]= pi.BindEdges[i];
	}

	NumVertices= maxVertex+1;
	NumVertices= max((uint32)NumVertices, numVertices);

	// Init the Clip Arrays
	_PatchRenderClipped.resize((uint)Patchs.size());
	_PatchOldRenderClipped.resize((uint)Patchs.size());
	_PatchRenderClipped.setAll();
	_PatchOldRenderClipped.setAll();

	// Copy PointLights.
	//=========================
	// build array, lights are sorted
	std::vector<uint>	plRemap;
	_PointLightArray.build(zoneInfo.PointLights, plRemap);
	// Check TileLightInfluences integrity, and remap PointLight Indices.
	for(j=0;j<(sint)patchs.size();j++)
	{
		CPatch				&pa= Patchs[j];
		for(uint k= 0; k<pa.TileLightInfluences.size(); k++)
		{
			CTileLightInfluence		&tli= pa.TileLightInfluences[k];
			for(uint l=0; l<CTileLightInfluence::NumLightPerCorner; l++)
			{
				// If NULL light, break and continue to next TileLightInfluence.
				if(tli.Light[l]== 0xFF)
					break;
				else
				{
					// Check good index.
					nlassert(tli.Light[l] < _PointLightArray.getPointLights().size());
					// Remap index, because of light sorting.
					tli.Light[l]= plRemap[tli.Light[l]];
				}

			}
		}
	}
}

// ***************************************************************************
void			CZone::retrieve(std::vector<CPatchInfo> &patchs, std::vector<CBorderVertex> &borderVertices)
{
	CZoneInfo	zinfo;

	retrieve(zinfo);

	patchs= zinfo.Patchs;
	borderVertices= zinfo.BorderVertices;
}

// ***************************************************************************
void			CZone::retrieve(CZoneInfo &zoneInfo)
{
	sint i,j;

	// Ref on input.
	std::vector<CPatchInfo> &patchs= zoneInfo.Patchs;
	std::vector<CBorderVertex> &borderVertices= zoneInfo.BorderVertices;
	// Copy zoneId.
	zoneInfo.ZoneId= getZoneId();


	// uncompress Patchs.
	//=========================
	patchs.resize(Patchs.size());
	for(j=0;j<(sint)patchs.size();j++)
	{
		CPatchInfo			&pi= patchs[j];
		CBezierPatch		&p= pi.Patch;
		CPatch				&pa= Patchs[j];
		CPatchConnect		&pc= PatchConnects[j];


		// Smoothing flags
		pi.Flags= (pa.Flags&NL_PATCH_SMOOTH_FLAG_MASK)>>NL_PATCH_SMOOTH_FLAG_SHIFT;


		// Noise Data
		// copy noise rotation.
		pi.NoiseRotation= pa.NoiseRotation;
		// copy all noise smoothing info.
		for(i=0;i<4;i++)
		{
			pi.setCornerSmoothFlag(i, pa.getCornerSmoothFlag(i));
		}


		// re-Build the uncompressed bezier patch.
		for(i=0;i<4;i++)
			pa.Vertices[i].unpack(p.Vertices[i], PatchBias, PatchScale);
		for(i=0;i<8;i++)
			pa.Tangents[i].unpack(p.Tangents[i], PatchBias, PatchScale);
		for(i=0;i<4;i++)
			pa.Interiors[i].unpack(p.Interiors[i], PatchBias, PatchScale);
		pi.Tiles= pa.Tiles;
		pi.TileColors= pa.TileColors;
		pi.TileLightInfluences= pa.TileLightInfluences;
		pi.Lumels.resize ((pa.OrderS*4)*(pa.OrderT*4));
		pi.Flags=(pa.Flags&NL_PATCH_SMOOTH_FLAG_MASK)>>NL_PATCH_SMOOTH_FLAG_SHIFT;

		// Unpack the lumel map
		pa.unpackShadowMap (&pi.Lumels[0]);

		// from the patchConnect.
		pi.OrderS= pa.OrderS;
		pi.OrderT= pa.OrderT;
		pi.ErrorSize= pc.ErrorSize;
		for(i=0;i<4;i++)
		{
			pi.BaseVertices[i]= pc.BaseVertices[i];
		}
		for(i=0;i<4;i++)
			pi.BindEdges[i]= pc.BindEdges[i];
	}

	// retrieve bordervertices.
	//=========================
	borderVertices= BorderVertices;

	// retrieve PointLights.
	//=========================
	zoneInfo.PointLights= _PointLightArray.getPointLights();

}


// ***************************************************************************
void			CZone::build(const CZone &zone)
{
	nlassert(!Compiled);

	ZoneId= zone.ZoneId;
	BorderVertices= zone.BorderVertices;

	// Compute the bbox and the bias/scale.
	//=====================================
	ZoneBB= zone.ZoneBB;
	PatchScale= zone.PatchScale;
	PatchBias= zone.PatchBias;


	// Compute/compress Patchs.
	//=========================
	Patchs= zone.Patchs;
	PatchConnects= zone.PatchConnects;

	// Init the Clip Arrays
	_PatchRenderClipped.resize((uint)Patchs.size());
	_PatchOldRenderClipped.resize((uint)Patchs.size());
	_PatchRenderClipped.setAll();
	_PatchOldRenderClipped.setAll();


	// copy pointLights.
	//=========================
	_PointLightArray= zone._PointLightArray;


	NumVertices= zone.NumVertices;
}



// ***************************************************************************
void			CBorderVertex::serial(NLMISC::IStream &f)
{
	/* ***********************************************
	 *	WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
	 *	It can be loaded/called through CAsyncFileManager for instance
	 * ***********************************************/
	(void)f.serialVersion(0);

	f.xmlSerial (CurrentVertex, "CURRENT_VERTEX");
	f.xmlSerial (NeighborZoneId, "NEIGHTBOR_ZONE_ID");
	f.xmlSerial (NeighborVertex, "NEIGHTBOR_VERTEX");
}
void			CZone::CPatchConnect::serial(NLMISC::IStream &f)
{
	/* ***********************************************
	 *	WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
	 *	It can be loaded/called through CAsyncFileManager for instance
	 * ***********************************************/
	uint	ver= f.serialVersion(1);

	if (ver<1)
		f.serial(OldOrderS, OldOrderT, ErrorSize);
	else
		f.serial(ErrorSize);
	f.xmlSerial (BaseVertices[0], BaseVertices[1], BaseVertices[2], BaseVertices[3], "BASE_VERTICES");
	f.xmlSerial (BindEdges[0], BindEdges[1], BindEdges[2], BindEdges[3], "BIND_EDGES");
}
void			CPatchInfo::CBindInfo::serial(NLMISC::IStream &f)
{
	/* ***********************************************
	 *	WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
	 *	It can be loaded/called through CAsyncFileManager for instance
	 * ***********************************************/
	(void)f.serialVersion(0);
	f.xmlSerial(NPatchs, "NPATCH");
	nlassert ( (NPatchs==0) | (NPatchs==1) | (NPatchs==2) | (NPatchs==4) | (NPatchs==5) );
	f.xmlSerial (ZoneId, "ZONE_ID");
	f.xmlSerial (Next[0], Next[1], Next[2], Next[3], "NEXT_PATCH");
	f.xmlSerial (Edge[0], Edge[1], Edge[2], Edge[3], "NEXT_EDGE");
}

// ***************************************************************************
void			CZone::serial(NLMISC::IStream &f)
{
	/* ***********************************************
	 *	WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
	 *	It can be loaded/called through CAsyncFileManager for instance
	 * ***********************************************/
	/*
	Version 4:
		- PointLights
	Version 3:
		- Lumels compression version 2.
	Version 2:
		- Lumels.
	Version 1:
		- Tile color.
	Version 0:
		- base verison.
	*/
	uint	ver= f.serialVersion(4);

	// No more compatibility before version 3
	if (ver<3)
	{
		throw EOlderStream(f);
	}

	f.serialCheck((uint32)'ENOZ');

	f.xmlSerial (ZoneId, "ZONE_ID");
	f.xmlSerial (ZoneBB, "BB");
	f.xmlSerial (PatchBias, "PATCH_BIAS");
	f.xmlSerial (PatchScale, "PATCH_SCALE");
	f.xmlSerial (NumVertices, "NUM_VERTICES");

	f.xmlPush ("BORDER_VERTICES");
	f.serialCont(BorderVertices);
	f.xmlPop ();

	f.xmlPush ("PATCHES");
	f.serialCont(Patchs);
	f.xmlPop ();

	f.xmlPush ("PATCH_CONNECTS");
	f.serialCont(PatchConnects);
	f.xmlPop ();

	if (ver>=4)
	{
		f.xmlPush ("POINT_LIGHTS");
		f.serial(_PointLightArray);
		f.xmlPop ();
	}

	// If read, must create and init Patch Clipped state to true (clipped even if not compiled)
	if(f.isReading())
	{
		_PatchRenderClipped.resize((uint)Patchs.size());
		_PatchOldRenderClipped.resize((uint)Patchs.size());
		_PatchRenderClipped.setAll();
		_PatchOldRenderClipped.setAll();
	}

	// If read and version 0, must init default TileColors of patchs.
	//===============================================================
	// if(f.isReading() && ver<2) ...
	// Deprecated, because ver<3 not supported
}



// ***************************************************************************
void			CZone::compile(CLandscape *landscape, TZoneMap &loadedZones)
{
	sint	i,j;
	TZoneMap		neighborZones;

	//nlinfo("Compile Zone: %d \n", (sint32)getZoneId());

	// Can't compile if compiled.
	nlassert(!Compiled);
	Landscape= landscape;

	// Attach this to loadedZones.
	//============================
	nlassert(loadedZones.find(ZoneId)==loadedZones.end());
	loadedZones[ZoneId]= this;

	// Create/link the base vertices according to present neigbor zones.
	//============================
	BaseVertices.clear();
	BaseVertices.resize(NumVertices);
	// First try to link vertices to other.
	for(i=0;i<(sint)BorderVertices.size();i++)
	{
		sint	cur= BorderVertices[i].CurrentVertex;
		sint	vertto= BorderVertices[i].NeighborVertex;
		sint	zoneto= BorderVertices[i].NeighborZoneId;
		nlassert(cur<NumVertices);

		if(loadedZones.find(zoneto)!=loadedZones.end())
		{
			CZone	*zone;
			zone= (*loadedZones.find(zoneto)).second;
			nlassert(zone!=this);
			// insert the zone in the neigborood (if not done...).
			neighborZones[zoneto]= zone;
			// Doesn't matter if BaseVertices is already linked to another zone...
			// This should be the same pointer in this case...
			BaseVertices[cur]=  zone->getBaseVertex(vertto);
		}
	}
	// Else, create unbounded vertices.
	for(i=0;i<(sint)BaseVertices.size();i++)
	{
		if(BaseVertices[i]==NULL)
		{
			BaseVertices[i]=  new CTessBaseVertex;
		}
	}


	// compile() the patchs.
	//======================
	for(j=0;j<(sint)Patchs.size();j++)
	{
		CPatch				&pa= Patchs[j];
		CPatchConnect		&pc= PatchConnects[j];
		CTessVertex			*baseVertices[4];

		baseVertices[0]= &(BaseVertices[pc.BaseVertices[0]]->Vert);
		baseVertices[1]= &(BaseVertices[pc.BaseVertices[1]]->Vert);
		baseVertices[2]= &(BaseVertices[pc.BaseVertices[2]]->Vert);
		baseVertices[3]= &(BaseVertices[pc.BaseVertices[3]]->Vert);
		pa.compile(this, j, pa.OrderS, pa.OrderT, baseVertices, pc.ErrorSize);
	};

	// compile() the Clip information for the patchs.
	//======================
	_PatchBSpheres.resize(Patchs.size());
	for(j=0;j<(sint)Patchs.size();j++)
	{
		CPatch				&pa= Patchs[j];

		// Buil the BSPhere of the patch.
		CAABBox	bb= pa.buildBBox();
		_PatchBSpheres[j].Center= bb.getCenter();
		_PatchBSpheres[j].Radius= bb.getRadius();
	}

	// bind() the patchs. (after all compiled).
	//===================
	for(j=0;j<(sint)Patchs.size();j++)
	{
		CPatch				&pa= Patchs[j];
		CPatchConnect		&pc= PatchConnects[j];

		// bind the patch. This is the original bind, not a rebind.
		bindPatch(loadedZones, pa, pc, false);
	}


	// rebindBorder() on neighbor zones.
	//==================================
	ItZoneMap		zoneIt;
	// Traverse the neighborood.
	for(zoneIt= neighborZones.begin(); zoneIt!=neighborZones.end(); zoneIt++)
	{
		(*zoneIt).second->rebindBorder(loadedZones);
	}

	// End!!
	Compiled= true;
}

// ***************************************************************************
void			CZone::release(TZoneMap &loadedZones)
{
	sint	i,j;

	if(!Compiled)
		return;

	// detach this zone to loadedZones.
	//=================================
	nlassert(loadedZones.find(ZoneId)!=loadedZones.end());
	loadedZones.erase(ZoneId);
	// It doesn't server to unbindPatch(), since patch is not binded to neigbors.


	// unbind() the patchs.
	//=====================
	for(j=0;j<(sint)Patchs.size();j++)
	{
		CPatch				&pa= Patchs[j];
		unbindPatch(pa);
	}


	// rebindBorder() on neighbor zones.
	//==================================
	// Build the nieghborood.
	TZoneMap		neighborZones;
	for(i=0;i<(sint)BorderVertices.size();i++)
	{
		sint	cur= BorderVertices[i].CurrentVertex;
		sint	zoneto= BorderVertices[i].NeighborZoneId;
		nlassert(cur<NumVertices);

		if(loadedZones.find(zoneto)!=loadedZones.end())
		{
			CZone	*zone;
			zone= (*loadedZones.find(zoneto)).second;
			nlassert(zone!=this);
			// insert the zone in the neigborood (if not done...).
			neighborZones[zoneto]= zone;
		}
	}
	// rebind borders.
	ItZoneMap		zoneIt;
	// Traverse the neighborood.
	for(zoneIt= neighborZones.begin(); zoneIt!=neighborZones.end(); zoneIt++)
	{
		// Since
		(*zoneIt).second->rebindBorder(loadedZones);
	}


	// release() the patchs.
	//======================
	// unbind() need compiled neigbor patchs, so do the release after all unbind (so after rebindBorder() too...).
	for(j=0;j<(sint)Patchs.size();j++)
	{
		CPatch				&pa= Patchs[j];
		pa.release();
	}


	// destroy/unlink the base vertices (internal..), according to present neigbor zones.
	//=================================
	// Just release the smartptrs (easy!!). Do it after patchs released...
	BaseVertices.clear();


	// End!!
	Compiled= false;
	Landscape= NULL;
	ClipResult= ClipOut;
}


// ***************************************************************************
// ***************************************************************************
// Private part.
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
void			CZone::rebindBorder(TZoneMap &loadedZones)
{
	sint	j;

	// rebind patchs which are on border.
	for(j=0;j<(sint)Patchs.size();j++)
	{
		CPatch				&pa= Patchs[j];
		CPatchConnect		&pc= PatchConnects[j];

		if(patchOnBorder(pc))
		{
			// rebind the patch. This is a rebind.
			bindPatch(loadedZones, pa, pc, true);
		}
	}
}

// ***************************************************************************
CPatch		*CZone::getZonePatch(TZoneMap &loadedZones, sint zoneId, sint patch)
{
#ifdef NL3D_DEBUG_DONT_BIND_PATCH
	return NULL;
#endif
	if(loadedZones.find(zoneId)==loadedZones.end())
		return NULL;
	else
		return (loadedZones[zoneId])->getPatch(patch);
}


// ***************************************************************************
void		CZone::buildBindInfo(uint patchId, uint edge, CZone *neighborZone, CPatch::CBindInfo	&paBind)
{
	nlassert(patchId < Patchs.size());
	nlassert(neighborZone);

	CPatchConnect	&pc= PatchConnects[patchId];


	// Get the bind info of this patch to his neighbor on "edge".
	CPatchInfo::CBindInfo	&pcBind= pc.BindEdges[edge];
	nlassert(pcBind.NPatchs==0 || pcBind.NPatchs==1 || pcBind.NPatchs==2 || pcBind.NPatchs==4 || pcBind.NPatchs==5);


	// copy zone ptr.
	paBind.Zone= neighborZone;


	// Special case of a small patch connected to a bigger.
	if(pcBind.NPatchs==5)
	{
		paBind.NPatchs= 1;
		paBind.Next[0]= neighborZone->getPatch(pcBind.Next[0]);
		paBind.Edge[0]= pcBind.Edge[0];

		// Get the twin bindInfo of pcBind.
		const CPatchInfo::CBindInfo	&pcBindNeighbor=
			neighborZone->getPatchConnect(pcBind.Next[0])->BindEdges[pcBind.Edge[0]];
		// must have a multiple bind.
		nlassert(pcBindNeighbor.NPatchs == 2 || pcBindNeighbor.NPatchs == 4);

		// number of bind is stored on the twin bindInfo.
		paBind.MultipleBindNum= pcBindNeighbor.NPatchs;

		// Search our patchId on neighbor;
		paBind.MultipleBindId= 255;
		for(sint i=0; i<paBind.MultipleBindNum; i++)
		{
			if(pcBindNeighbor.Next[i]==patchId)
				paBind.MultipleBindId= i;
		}
		nlassert(paBind.MultipleBindId!= 255);
	}
	else
	{
		paBind.MultipleBindNum= 0;
		paBind.NPatchs= pcBind.NPatchs;
		for(sint i=0;i<paBind.NPatchs; i++)
		{
			paBind.Next[i]= neighborZone->getPatch(pcBind.Next[i]);
			paBind.Edge[i]= pcBind.Edge[i];
		}
	}


}


// ***************************************************************************
void		CZone::bindPatch(TZoneMap &loadedZones, CPatch &pa, CPatchConnect &pc, bool rebind)
{
	CPatch::CBindInfo	edges[4];

	// Fill all edges.
	for(sint i=0;i<4;i++)
	{
		CPatchInfo::CBindInfo	&pcBind= pc.BindEdges[i];
		CPatch::CBindInfo		&paBind= edges[i];

		nlassert(pcBind.NPatchs==0 || pcBind.NPatchs==1 || pcBind.NPatchs==2 || pcBind.NPatchs==4 || pcBind.NPatchs==5);
		paBind.NPatchs= pcBind.NPatchs;


		// Find the zone.
		TZoneMap::iterator	itZoneMap;
		// If no neighbor, or if zone neighbor not loaded.
		if( paBind.NPatchs==0 || (itZoneMap=loadedZones.find(pcBind.ZoneId)) == loadedZones.end() )
			paBind.Zone= NULL;
		else
			paBind.Zone= itZoneMap->second;


		// Special case of a small patch connected to a bigger.
		if(paBind.NPatchs==5)
		{
			paBind.Edge[0]= pcBind.Edge[0];
			paBind.Next[0]= CZone::getZonePatch(loadedZones, pcBind.ZoneId, pcBind.Next[0]);
			// If not loaded, don't bind to this edge.
			if(!paBind.Next[0])
				paBind.NPatchs=0;
			else
			{
				// pa.bind() will do the job.
				// Leave it flagged with NPatchs==5.
				continue;
			}
		}


		// Bind 1/1 and 1/2,1/4
		if(paBind.NPatchs>=1)
		{
			paBind.Edge[0]= pcBind.Edge[0];
			paBind.Next[0]= CZone::getZonePatch(loadedZones, pcBind.ZoneId, pcBind.Next[0]);
			// If not loaded, don't bind to this edge.
			if(!paBind.Next[0])
				paBind.NPatchs=0;
		}
		if(paBind.NPatchs>=2)
		{
			paBind.Edge[1]= pcBind.Edge[1];
			paBind.Next[1]= CZone::getZonePatch(loadedZones, pcBind.ZoneId, pcBind.Next[1]);
			// If not loaded, don't bind to this edge.
			if(!paBind.Next[1])
				paBind.NPatchs=0;
		}
		if(paBind.NPatchs>=4)
		{
			paBind.Edge[2]= pcBind.Edge[2];
			paBind.Edge[3]= pcBind.Edge[3];
			paBind.Next[2]= CZone::getZonePatch(loadedZones, pcBind.ZoneId, pcBind.Next[2]);
			paBind.Next[3]= CZone::getZonePatch(loadedZones, pcBind.ZoneId, pcBind.Next[3]);
			// If not loaded, don't bind to this edge.
			if(!paBind.Next[2] || !paBind.Next[3])
				paBind.NPatchs=0;
		}
	}

	// First, unbind.
	pa.unbind();

	// Then bind.
	pa.bind(edges, rebind);
}


// ***************************************************************************
void		CZone::unbindPatch(CPatch &pa)
{
	/*
		Remind: the old version with CPatch::unbindFrom*() doesn't work because of CZone::release(). This function
		first erase the zone from loadedZones...
		Not matter here. We use CPatch::unbind() which should do all the good job correctly (unbind pa from ohters
		, and unbind others from pa at same time).
	*/

	pa.unbind();
}


// ***************************************************************************
bool			CZone::patchOnBorder(const CPatchConnect &pc) const
{
	// If only one of neighbor patch is not of this zone, we are on a border.

	// Test all edges.
	for(sint i=0;i<4;i++)
	{
		const CPatchInfo::CBindInfo	&pcBind= pc.BindEdges[i];

		nlassert(pcBind.NPatchs==0 || pcBind.NPatchs==1 || pcBind.NPatchs==2 || pcBind.NPatchs==4 || pcBind.NPatchs==5);
		if(pcBind.NPatchs>=1)
		{
			if(pcBind.ZoneId != ZoneId)
				return true;
		}
	}

	return false;
}


// ***************************************************************************
// ***************************************************************************
// Render part.
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
const CBSphere	&CZone::getPatchBSphere(uint patch) const
{
	static	CBSphere	dummySphere;
	if(patch<_PatchBSpheres.size())
		return _PatchBSpheres[patch];
	else
		return dummySphere;
}


// ***************************************************************************
void			CZone::clip(const std::vector<CPlane>	&pyramid)
{
	H_AUTO( NLMISC_ClipZone );

	nlassert(Compiled);

	// bkup old ClipResult. NB: by default, it is ClipOut (no VB created).
	sint	oldClipResult= ClipResult;

	// Pyramid with only the planes that clip the zone
	static std::vector<CPlane>		patchPyramid(10);
	static std::vector<uint>		patchPyramidIndex(10);
	patchPyramidIndex.clear();

	// Compute ClipResult.
	//-------------------
	ClipResult= ClipIn;
	for(sint i=0;i<(sint)pyramid.size();i++)
	{
		// If entirely out.
		if(!ZoneBB.clipBack(pyramid[i]))
		{
			ClipResult= ClipOut;
			// If out of only one plane, out of all.
			break;
		}
		// If partially IN (ie not entirely out, and not entirely IN)
		else if(ZoneBB.clipFront(pyramid[i]))
		{
			// Force ClipResult to be ClipSide, and not ClipIn.
			ClipResult=ClipSide;
			// Append the plane index to list to test
			patchPyramidIndex.push_back(i);
		}
	}


	// Easy Clip  :)
	if(Patchs.empty())
	{
		ClipResult= ClipOut;
		// don't need to go below...
		return;
	}


	// Clip By Patch Pass.
	//--------------------
	if(ClipResult==ClipOut)
	{
		H_AUTO( NLMISC_ClipZone_Out );

		// Set All RenderClip flags to true.
		_PatchRenderClipped.setAll();
	}
	else if(ClipResult==ClipIn)
	{
		H_AUTO( NLMISC_ClipZone_In );

		// Set All RenderClip flags to false.
		_PatchRenderClipped.clearAll();
	}
	else
	{
		H_AUTO( NLMISC_ClipZone_Side );

		// Copy only the pyramid planes of interest
		patchPyramid.resize(patchPyramidIndex.size());
		uint i;
		for(i=0;i<patchPyramidIndex.size();i++)
		{
			patchPyramid[i]= pyramid[patchPyramidIndex[i]];
		}

		// clip all patchs with the simplified pyramid
		clipPatchs(patchPyramid);
	}


	// delete / reallocate / fill VBuffers.
	//-------------------
	// If there is a change in the Clip of the zone, or if patchs may have change (ie ClipSide is undetermined).
	if(oldClipResult!=ClipResult || oldClipResult==ClipSide)
	{
		// get BitSet as Raw Array of uint32
		uint32	*oldRenderClip= const_cast<uint32*>(&_PatchOldRenderClipped.getVector()[0]);
		const	uint32	*newRenderClip= &_PatchRenderClipped.getVector()[0];
		uint	numPatchs= (uint)Patchs.size();
		// Then, we must test by patch.
		for(uint i=0;i<numPatchs;oldRenderClip++, newRenderClip++)
		{
			uint32	oldWord= *oldRenderClip;
			uint32	newWord= *newRenderClip;
			// process at max 32 patch
			uint	maxNumBits= min((numPatchs-i), 32U);
			uint32	mask= 1;
			for(;maxNumBits>0;maxNumBits--, mask<<=1, i++)
			{
				// same as: if(_PatchOldRenderClipped[i] != _PatchRenderClipped[i])
				if( (oldWord^newWord)&mask )
				{
					// set the flag.
					*oldRenderClip&= ~mask;
					*oldRenderClip|= newWord&mask;
					// update clip patch
					Patchs[i].updateClipPatchVB( (newWord&mask)!=0 );
				}
			}
		}

	}

}


// ***************************************************************************
void			CZone::clipPatchs(const std::vector<CPlane>	&pyramid)
{
	// Init all to Not clipped
	_PatchRenderClipped.clearAll();

	for(uint j=0;j<_PatchBSpheres.size();j++)
	{
		CBSphere	&bSphere= _PatchBSpheres[j];
		for(sint i=0;i<(sint)pyramid.size();i++)
		{
			// If entirely out.
			if(!bSphere.clipBack(pyramid[i]))
			{
				_PatchRenderClipped.set(j, true);
				break;
			}
		}
	}
}


// ***************************************************************************
// DebugYoyo.
// Code for Debug test Only.. Do not erase it, may be used later :)
/*
static	void	cleanTess(CTessFace *face)
{
	if(!face->isLeaf())
	{
		cleanTess(face->SonLeft);
		cleanTess(face->SonRight);
	}
	// If has father, clean it.
	if(face->Father)
	{
		CTessFace	*face1=face->Father;
		CTessFace	*face2=face->Father->FBase;
		face1->FLeft= face1->SonLeft->FBase;
		face1->FRight= face1->SonRight->FBase;
		if(face2!=NULL)
		{
			face2->FLeft= face2->SonLeft->FBase;
			face2->FRight= face2->SonRight->FBase;
		}
	}
}
static	void	testTess(CTessFace *face)
{
	if(!face->isLeaf())
	{
		testTess(face->SonLeft);
		testTess(face->SonRight);
	}
	// Test validity.
	nlassert(!face->FBase || face->FBase->Patch!=(CPatch*)0xdddddddd);
	nlassert(!face->FLeft || face->FLeft->Patch!=(CPatch*)0xdddddddd);
	nlassert(!face->FRight || face->FRight->Patch!=(CPatch*)0xdddddddd);
}
static	void	checkTess()
{
	// This test should be inserted at begin of CZone::refine().
	// And it needs hacking public/private.
	CPatch		*pPatch;
	sint		n;
	pPatch= &(*Patchs.begin());
	for(n=(sint)Patchs.size();n>0;n--, pPatch++)
	{
		cleanTess(pPatch->Son0);
		cleanTess(pPatch->Son1);
	}
	pPatch= &(*Patchs.begin());
	for(n=(sint)Patchs.size();n>0;n--, pPatch++)
	{
		testTess(pPatch->Son0);
		testTess(pPatch->Son1);
	}
}
*/


// ***************************************************************************
void			CZone::excludePatchFromRefineAll(uint patch, bool exclude)
{
	nlassert(Compiled);
	nlassert(patch<Patchs.size());

	if(patch>=Patchs.size())
		return;

	Patchs[patch].ExcludeFromRefineAll= exclude;
}


// ***************************************************************************
void			CZone::refineAll()
{
	nlassert(Compiled);

	if(Patchs.size()==0)
		return;

	// DO NOT do a forceNoRenderClip(), to avoid big allocation of Near/Far VB vertices in driver.
	// DO NOT modify ClipResult, to avoid big allocation of Near/Far VB vertices in driver.

	// refine ALL patchs (even those which may be invisible).
	CPatch		*pPatch= &(*Patchs.begin());
	sint n;
	for(n=(sint)Patchs.size();n>0;n--, pPatch++)
	{
		// For Pacs construction: may exclude some patch from refineAll (for speed improvement).
		if(!pPatch->ExcludeFromRefineAll)
			pPatch->refineAll();
	}

}


// ***************************************************************************
void			CZone::averageTesselationVertices()
{
	nlassert(Compiled);

	if(Patchs.size()==0)
		return;

	// averageTesselationVertices of ALL patchs.
	CPatch		*pPatch= &(*Patchs.begin());
	for(sint n=(sint)Patchs.size();n>0;n--, pPatch++)
	{
		pPatch->averageTesselationVertices();
	}
}


// ***************************************************************************
void			CZone::preRender()
{
	nlassert(Compiled);

	// Must be 2^X-1.
	static const	uint	updateFarRefineFreq= 15;
	// Take the renderDate here.
	uint		curDateMod= CLandscapeGlobals::CurrentRenderDate & updateFarRefineFreq;

	// If no patchs, do nothing.
	if(Patchs.empty())
		return;

	/* If patchs invisible, must still update their Far Textures,
		else, there may be slowdown when we turn the head.
	*/


	// If all the zone is invisible.
	if(ClipResult==ClipOut)
	{
		// No patchs are visible, but maybe update the far textures.
		if( curDateMod==(ZoneId & updateFarRefineFreq) )
		{
			// updateTextureFarOnly for all patchs.
			for(uint i=0;i<Patchs.size();i++)
			{
				Patchs[i].updateTextureFarOnly(_PatchBSpheres[i]);
			}
		}
	}
	// else If some patchs only are visible.
	else if(ClipResult==ClipSide)
	{
		// PreRender Pass, or updateTextureFarOnly(), according to _PatchRenderClipped state.
		for(uint i=0;i<Patchs.size();i++)
		{
			// If the patch is visible
			if(!_PatchRenderClipped[i])
			{
				// Then preRender it.
				Patchs[i].preRender(_PatchBSpheres[i]);
			}
			else
			{
				// else maybe updateFar it.
				// ZoneId+i for better repartition.
				if( curDateMod==((ZoneId+i) & updateFarRefineFreq) )
					Patchs[i].updateTextureFarOnly(_PatchBSpheres[i]);
			}
		}
	}
	else	// ClipResult==ClipIn
	{
		// PreRender Pass for All
		for(uint i=0;i<Patchs.size();i++)
		{
			Patchs[i].preRender(_PatchBSpheres[i]);
		}
	}

}


// ***************************************************************************
void			CZone::resetRenderFarAndDeleteVBFV()
{
	for(uint i=0;i<Patchs.size();i++)
	{
		// If patch is visible
		if(!_PatchRenderClipped[i])
		{
			// release VertexBuffer, and FaceBuffer
			Patchs[i].deleteVBAndFaceVector();
			// Flag.
			_PatchRenderClipped.set(i, true);
		}

		Patchs[i].resetRenderFar();
	}
}


// ***************************************************************************
void			CZone::forceMergeAtTileLevel()
{
	CPatch		*pPatch=0;
	if(Patchs.size()>0)
		pPatch= &(*Patchs.begin());
	for(sint n=(sint)Patchs.size();n>0;n--, pPatch++)
	{
		pPatch->forceMergeAtTileLevel();
	}
}


// ***************************************************************************
// ***************************************************************************
// Misc part.
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
void			CZone::changePatchTextureAndColor (sint numPatch, const std::vector<CTileElement> *tiles, const std::vector<CTileColor> *colors)
{
	nlassert(numPatch>=0);
	nlassert(numPatch<getNumPatchs());


	// Update the patch texture.
	if (tiles)
	{
		nlassert( Patchs[numPatch].Tiles.size() == tiles->size() );
		Patchs[numPatch].Tiles = *tiles;
	}

	// Update the patch colors.
	if (colors)
	{
		nlassert( Patchs[numPatch].TileColors.size() == colors->size() );
		Patchs[numPatch].TileColors = *colors;
	}

	if (Compiled)
	{
		// If the patch is visible, then we must LockBuffers, because new VertexVB may be created.
		if(!_PatchRenderClipped[numPatch])
			Landscape->updateGlobalsAndLockBuffers(CVector::Null);

		// Recompute UVs for new setup of Tiles.
		Patchs[numPatch].deleteTileUvs();
		Patchs[numPatch].recreateTileUvs();

		// unlockBuffers() if necessary.
		if(!_PatchRenderClipped[numPatch])
		{
			Landscape->unlockBuffers();
			// This patch is visible, and TileFaces have been deleted / added.
			// So must update TessBlock.
			Landscape->updateTessBlocksFaceVector();
		}
	}
}


// ***************************************************************************
void			CZone::refreshTesselationGeometry(sint numPatch)
{
	nlassert(numPatch>=0);
	nlassert(numPatch<getNumPatchs());
	nlassert(Compiled);

	// At next render, we must re-fill the entire unclipped VB, so change are taken into account.
	Landscape->_RenderMustRefillVB= true;

	Patchs[numPatch].refreshTesselationGeometry();
}


// ***************************************************************************
const std::vector<CTileElement> &CZone::getPatchTexture(sint numPatch) const
{
	nlassert(numPatch>=0);
	nlassert(numPatch<getNumPatchs());

	// Update the patch texture.
	return Patchs[numPatch].Tiles;
}


// ***************************************************************************
const std::vector<CTileColor> &CZone::getPatchColor(sint numPatch) const
{
	nlassert(numPatch>=0);
	nlassert(numPatch<getNumPatchs());

	// Update the patch texture.
	return Patchs[numPatch].TileColors;
}

// ***************************************************************************
void CZone::setTileColor(bool monochrome, float factor)
{
	nlassert(factor >= 0.0f); // factor must not be negative as its a multiplier

	if (monochrome)
	{
		for (uint32 i = 0; i < Patchs.size(); ++i)
		{
			vector<CTileColor> &rTC = Patchs[i].TileColors;
			for (uint32 j =  0; j < rTC.size(); ++j)
			{
				float fR = (rTC[j].Color565 & 31) / 32.0f;
				float fG = ((rTC[j].Color565 >> 5) & 63) / 64.0f;
				float fB = ((rTC[j].Color565 >> 11) & 31) / 32.0f;

				fR = 0.28f * fR + 0.59f * fG + 0.13f * fB;

				nlassert(fR < 0.99f);

				fR *= factor;
				if (fR > 0.99f) fR = 0.99f; // Avoid reaching 1

				uint16 nR = (uint16)(fR * 32.0f);
				uint16 nG = (uint16)(fR * 64.0f);
				uint16 nB = (uint16)(fR * 32.0f);

				rTC[j].Color565 = nR + (nG << 5) + (nB << 11);
			}
		}
	}
	else
	{
		if (factor != 1.0f)
		{
			for (uint32 i = 0; i < Patchs.size(); ++i)
			{
				vector<CTileColor> &rTC = Patchs[i].TileColors;
				for (uint32 j =  0; j < rTC.size(); ++j)
				{
					float fR = (rTC[j].Color565 & 31) / 32.0f;
					float fG = ((rTC[j].Color565 >> 5) & 63) / 64.0f;
					float fB = ((rTC[j].Color565 >> 11) & 31) / 32.0f;

					fR *= factor;
					fG *= factor;
					fB *= factor;

					if (fR > 0.99f) fR = 0.99f;
					if (fG > 0.99f) fG = 0.99f;
					if (fB > 0.99f) fB = 0.99f;

					uint16 nR = (uint16)(fR * 32.0f);
					uint16 nG = (uint16)(fG * 64.0f);
					uint16 nB = (uint16)(fB * 32.0f);

					rTC[j].Color565 = nR + (nG << 5) + (nB << 11);
				}
			}
		}
	}
}

// ***************************************************************************
void			CZone::debugBinds(FILE *f)
{
	fprintf(f, "*****************************\n");
	fprintf(f, "ZoneId: %d. NPatchs:%zu\n", ZoneId, PatchConnects.size());
	sint i;
	for(i=0;i<(sint)PatchConnects.size();i++)
	{
		CPatchConnect	&pc= PatchConnects[i];
		fprintf(f, "patch%d:\n", i);
		for(sint j=0;j<4;j++)
		{
			CPatchInfo::CBindInfo	&bd= pc.BindEdges[j];
			fprintf(f, "    edge%d: Zone:%d. NPatchs:%d. ", j, bd.ZoneId, bd.NPatchs);
			for(sint k=0;k<bd.NPatchs;k++)
			{
				fprintf(f, "p%de%d - ", bd.Next[k], bd.Edge[k]);
			}
			fprintf(f, "\n");
		}
	}

	fprintf(f,"Vertices :\n");
	for(i=0;i<(sint)BorderVertices.size();i++)
	{
		fprintf(f,"current : %d -> (zone %d) vertex %d\n",BorderVertices[i].CurrentVertex,
											BorderVertices[i].NeighborZoneId,
											BorderVertices[i].NeighborVertex);
	}
}


// ***************************************************************************
void			CZone::applyHeightField(const CLandscape &landScape)
{
	sint	i,j;
	vector<CBezierPatch>	patchs;

	// no patch, do nothing.
	if(Patchs.size()==0)
		return;

	// 0. Unpack patchs to Bezier Patchs.
	//===================================
	patchs.resize(Patchs.size());
	for(j=0;j<(sint)patchs.size();j++)
	{
		CBezierPatch		&p= patchs[j];
		CPatch				&pa= Patchs[j];

		// re-Build the uncompressed bezier patch.
		for(i=0;i<4;i++)
			pa.Vertices[i].unpack(p.Vertices[i], PatchBias, PatchScale);
		for(i=0;i<8;i++)
			pa.Tangents[i].unpack(p.Tangents[i], PatchBias, PatchScale);
		for(i=0;i<4;i++)
			pa.Interiors[i].unpack(p.Interiors[i], PatchBias, PatchScale);
	}

	// 1. apply heightfield on bezier patchs.
	//===================================
	for(j=0;j<(sint)patchs.size();j++)
	{
		CBezierPatch		&p= patchs[j];

		// apply delta.
		for(i=0;i<4;i++)
			p.Vertices[i]+= landScape.getHeightFieldDeltaZ(p.Vertices[i].x, p.Vertices[i].y);
		for(i=0;i<8;i++)
			p.Tangents[i]+= landScape.getHeightFieldDeltaZ(p.Tangents[i].x, p.Tangents[i].y);
		for(i=0;i<4;i++)
			p.Interiors[i]+= landScape.getHeightFieldDeltaZ(p.Interiors[i].x, p.Interiors[i].y);
	}


	// 2. Re-compute Patch Scale/Bias, and Zone BBox.
	//===================================
	CAABBox		bb;
	bb.setCenter(patchs[0].Vertices[0]);
	bb.setHalfSize(CVector::Null);
	for(j=0;j<(sint)patchs.size();j++)
	{
		// extend bbox.
		const CBezierPatch	&p= patchs[j];
		for(i=0;i<4;i++)
			bb.extend(p.Vertices[i]);
		for(i=0;i<8;i++)
			bb.extend(p.Tangents[i]);
		for(i=0;i<4;i++)
			bb.extend(p.Interiors[i]);
	}
	// Compute BBox, and Patch Scale Bias, according to Noise.
	computeBBScaleBias(bb);


	// 3. Re-pack patchs.
	//===================================
	for(j=0;j<(sint)patchs.size();j++)
	{
		CBezierPatch		&p= patchs[j];
		CPatch				&pa= Patchs[j];

		// Build the packed patch.
		for(i=0;i<4;i++)
			pa.Vertices[i].pack(p.Vertices[i], PatchBias, PatchScale);
		for(i=0;i<8;i++)
			pa.Tangents[i].pack(p.Tangents[i], PatchBias, PatchScale);
		for(i=0;i<4;i++)
			pa.Interiors[i].pack(p.Interiors[i], PatchBias, PatchScale);
	}
}

// ***************************************************************************
void CZone::setupColorsFromTileFlags(const NLMISC::CRGBA colors[4])
{
	for (uint k = 0; k < Patchs.size(); ++k)
	{
		Patchs[k].setupColorsFromTileFlags(colors);
	}
}


// ***************************************************************************
void CZone::copyTilesFlags(sint destPatchId, const CPatch *srcPatch)
{
	CPatch *destPatch = getPatch(destPatchId);

	destPatch->copyTileFlagsFromPatch(srcPatch);
}


// ***************************************************************************
bool CPatchInfo::getNeighborTile (uint patchId, uint edge, sint position, uint &patchOut, sint &sOut, sint &tOut,
								  const vector<CPatchInfo> &patchInfos) const
{
	nlassert (edge<4);

	// S or T ?
	uint length = (edge&1) ? OrderS : OrderT;
	nlassert ((uint)position<length);

	// What kind of case ?
	switch (BindEdges[edge].NPatchs)
	{
	case 1:
	case 2:
	case 4:
		{
			// Get neighbor index and position in neighbor
			uint neighborLength = (length / BindEdges[edge].NPatchs);
			uint neighbor = position / neighborLength;
			uint neighborPosition = neighborLength - (position % neighborLength) - 1;
			uint neighborEdge = BindEdges[edge].Edge[neighbor];

			// Patch id
			patchOut = BindEdges[edge].Next[neighbor];

			// Check neighbor
			uint neighborRealLength = (neighborEdge&1) ? patchInfos[patchOut].OrderS : patchInfos[patchOut].OrderT;
			if (neighborRealLength == neighborLength)
			{
				// Get final coordinate
				switch (neighborEdge)
				{
				case 0:
					sOut = 0;
					tOut = neighborPosition;
					break;
				case 1:
					sOut = neighborPosition;
					tOut = patchInfos[patchOut].OrderT-1;
					break;
				case 2:
					sOut = patchInfos[patchOut].OrderS-1;
					tOut = patchInfos[patchOut].OrderT-neighborPosition-1;
					break;
				case 3:
					sOut = patchInfos[patchOut].OrderS-neighborPosition-1;
					tOut = 0;
					break;
				}

				// Ok todo remove
				return true;
			}
		}
		break;

	case 5:
		{
			// Find in the neighbor where we are
			patchOut = BindEdges[edge].Next[0];
			uint neighborEdge = BindEdges[edge].Edge[0];
			uint neighborEdgeCount = patchInfos[patchOut].BindEdges[neighborEdge].NPatchs;

			// Check neighbor
			uint neighborRealLength = (neighborEdge&1) ? patchInfos[patchOut].OrderS : patchInfos[patchOut].OrderT;

			// Good length ?
			if ((neighborRealLength / neighborEdgeCount) == length)
			{
				// Find us in the neighbor
				uint neighborPosition;
				for (neighborPosition=0; neighborPosition<neighborEdgeCount; neighborPosition++)
				{
					// Found ?
					if (patchInfos[patchOut].BindEdges[neighborEdge].Next[neighborPosition] == patchId)
						break;
				}

				// Must be found
				nlassert (neighborPosition!=neighborEdgeCount);
				neighborPosition = (neighborPosition + 1) * (neighborRealLength / neighborEdgeCount) - position - 1;

				// Get final coordinate
				switch (neighborEdge)
				{
				case 0:
					sOut = 0;
					tOut = neighborPosition;
					break;
				case 1:
					sOut = neighborPosition;
					tOut = patchInfos[patchOut].OrderT-1;
					break;
				case 2:
					sOut = patchInfos[patchOut].OrderS-1;
					tOut = patchInfos[patchOut].OrderT-neighborPosition-1;
					break;
				case 3:
					sOut = patchInfos[patchOut].OrderS-neighborPosition-1;
					tOut = 0;
					break;
				}

				// Ok
				return true;
			}
		}
		break;
	}

	return false;
}


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

bool CPatchInfo::getTileSymmetryRotate (const CTileBank &bank, uint tile, bool &symmetry, uint &rotate)
{
	// Need check the tile ?
	if ( (symmetry || (rotate != 0)) && (tile != 0xffffffff) )
	{
		// Tile exist ?
		if (tile < (uint)bank.getTileCount())
		{
			// Get xref
			int tileSet;
			int number;
			CTileBank::TTileType type;

			// Get tile xref
			bank.getTileXRef ((int)tile, tileSet, number, type);

			if ((tileSet < 0) || (tileSet >= bank.getTileSetCount()))
			{
				nlwarning("tile %d has an unknown tileSet (%d)",tile, tileSet);
				return false;
			}

			// Is it an oriented tile ?
			if (bank.getTileSet (tileSet)->getOriented())
			{
				// New rotation value
				rotate = 0;
			}

			// Ok
			return true;
		}

		return false;
	}
	else
		return true;
}

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

bool CPatchInfo::transformTile (const CTileBank &bank, uint &tile, uint &tileRotation, bool symmetry, uint rotate, bool goofy)
{
	// Tile exist ?
	if ( (rotate!=0) || symmetry )
	{
		if (tile < (uint)bank.getTileCount())
		{
			// Get xref
			int tileSet;
			int number;
			CTileBank::TTileType type;

			// Get tile xref
			bank.getTileXRef ((int)tile, tileSet, number, type);

			// Transition ?
			if (type == CTileBank::transition)
			{
				// Rotation for transition
				uint transRotate = rotate;

				// Number should be ok
				nlassert (number>=0);
				nlassert (number<CTileSet::count);

				// Tlie set number
				const CTileSet *pTileSet = bank.getTileSet (tileSet);

				// Get border desc
				CTileSet::TFlagBorder oriented[4] =
				{
					pTileSet->getOrientedBorder (CTileSet::left, CTileSet::getEdgeType ((CTileSet::TTransition)number, CTileSet::left)),
					pTileSet->getOrientedBorder (CTileSet::bottom, CTileSet::getEdgeType ((CTileSet::TTransition)number, CTileSet::bottom)),
					pTileSet->getOrientedBorder (CTileSet::right, CTileSet::getEdgeType ((CTileSet::TTransition)number, CTileSet::right)),
					pTileSet->getOrientedBorder (CTileSet::top, CTileSet::getEdgeType ((CTileSet::TTransition)number, CTileSet::top))
				};

				// Symmetry ?
				if (symmetry)
				{
					if ( (tileRotation & 1) ^ goofy )
					{
						CTileSet::TFlagBorder tmp = oriented[1];
						oriented[1] = CTileSet::getInvertBorder (oriented[3]);
						oriented[3] = CTileSet::getInvertBorder (tmp);
						oriented[2] = CTileSet::getInvertBorder (oriented[2]);
						oriented[0] = CTileSet::getInvertBorder (oriented[0]);
					}
					else
					{
						CTileSet::TFlagBorder tmp = oriented[0];
						oriented[0] = CTileSet::getInvertBorder (oriented[2]);
						oriented[2] = CTileSet::getInvertBorder (tmp);
						oriented[1] = CTileSet::getInvertBorder (oriented[1]);
						oriented[3] = CTileSet::getInvertBorder (oriented[3]);
					}
				}

				// Rotation
				CTileSet::TFlagBorder edges[4];
				edges[0] = pTileSet->getOrientedBorder (CTileSet::left, oriented[(0 + transRotate )&3]);
				edges[1] = pTileSet->getOrientedBorder (CTileSet::bottom, oriented[(1 + transRotate )&3]);
				edges[2] = pTileSet->getOrientedBorder (CTileSet::right, oriented[(2 + transRotate )&3]);
				edges[3] = pTileSet->getOrientedBorder (CTileSet::top, oriented[(3 + transRotate )&3]);

				// Get the good tile number
				CTileSet::TTransition transition = pTileSet->getTransitionTile (edges[3], edges[1], edges[0], edges[2]);
				nlassert ((CTileSet::TTransition)transition != CTileSet::notfound);
				tile = (uint)(pTileSet->getTransition (transition)->getTile ());
			}

			// Transform rotation: invert rotation
			tileRotation += rotate;

			// If goofy, add +2
			if (goofy && symmetry)
				tileRotation += 2;

			// Mask the rotation
			tileRotation &= 3;
		}
		else
			return false;
	}

	// Ok
	return true;
}

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

void CPatchInfo::transform256Case (const CTileBank &bank, uint8 &case256, uint tileRotation, bool symmetry, uint rotate, bool goofy)
{
	// Tile exist ?
	if ( (rotate!=0) || symmetry )
	{
		// Symmetry ?
		if (symmetry)
		{
			// Take the symmetry
			uint symArray[4] = {3, 2, 1, 0};
			case256 = symArray[case256];

			if (goofy && ((tileRotation & 1) ==0))
				case256 += 2;
			if ((!goofy) && (tileRotation & 1))
				case256 += 2;
		}

		// Rotation ?
		case256 -= rotate;
		case256 &= 3;
	}
}

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

bool CPatchInfo::transform (std::vector<CPatchInfo> &patchInfo, NL3D::CZoneSymmetrisation &zoneSymmetry, const NL3D::CTileBank &bank, bool symmetry, uint rotate, float snapCell, float weldThreshold, const NLMISC::CMatrix &toOriginalSpace)
{
	uint patchCount = (uint)patchInfo.size ();
	uint i;

	// --- Export tile info Symmetry of the bind info.
	// --- Parse each patch and each edge

	// For each patches
	NL3D::CZoneSymmetrisation::CError error;

	// Build the structure
	if (!zoneSymmetry.build (patchInfo, snapCell, weldThreshold, bank, error, toOriginalSpace))
	{
		return false;
	}

	// Symmetry ?
	if (symmetry)
	{
		for(i=0 ; i<patchCount; i++)
		{
			// Ref on the current patch
			CPatchInfo &pi = patchInfo[i];

			// --- Symmetry vertex indexes

			// Vertices
			CVector tmp = pi.Patch.Vertices[0];
			pi.Patch.Vertices[0] = pi.Patch.Vertices[3];
			pi.Patch.Vertices[3] = tmp;
			tmp = pi.Patch.Vertices[1];
			pi.Patch.Vertices[1] = pi.Patch.Vertices[2];
			pi.Patch.Vertices[2] = tmp;

			// Tangents
			tmp = pi.Patch.Tangents[0];
			pi.Patch.Tangents[0] = pi.Patch.Tangents[5];
			pi.Patch.Tangents[5] = tmp;
			tmp = pi.Patch.Tangents[1];
			pi.Patch.Tangents[1] = pi.Patch.Tangents[4];
			pi.Patch.Tangents[4] = tmp;
			tmp = pi.Patch.Tangents[2];
			pi.Patch.Tangents[2] = pi.Patch.Tangents[3];
			pi.Patch.Tangents[3] = tmp;
			tmp = pi.Patch.Tangents[6];
			pi.Patch.Tangents[6] = pi.Patch.Tangents[7];
			pi.Patch.Tangents[7] = tmp;

			// Interior
			tmp = pi.Patch.Interiors[0];
			pi.Patch.Interiors[0] = pi.Patch.Interiors[3];
			pi.Patch.Interiors[3] = tmp;
			tmp = pi.Patch.Interiors[1];
			pi.Patch.Interiors[1] = pi.Patch.Interiors[2];
			pi.Patch.Interiors[2] = tmp;

			// ** Symmetries tile colors

			uint u,v;
			uint countU = pi.OrderS/2+1;
			uint countV = pi.OrderT+1;
			for (v=0; v<countV; v++)
			for (u=0; u<countU; u++)
			{
				// Store it in the tile info
				uint index0 = u+v*(pi.OrderS+1);
				uint index1 = (pi.OrderS-u)+v*(pi.OrderS+1);

				// XChg
				uint16 tmp = pi.TileColors[index0].Color565;
				pi.TileColors[index0].Color565 = pi.TileColors[index1].Color565;
				pi.TileColors[index1].Color565 = tmp;
			}

			// Smooth flags
			uint flags = (uint)(pi.getSmoothFlag (0))<<2;
			flags |= (uint)(pi.getSmoothFlag (2))<<0;
			flags |= (uint)(pi.getSmoothFlag (1))<<1;
			flags |= (uint)(pi.getSmoothFlag (3))<<3;
			pi.Flags &= ~3;
			pi.Flags |= flags;
		}

		// --- Symmetry of the bind info.
		// --- Parse each patch and each edge
		// For each patches
		for (i=0 ; i<patchCount; i++)
		{
			// Ref on the patch info
			CPatchInfo &pi = patchInfo[i];

			// Xchg left and right
			swap (pi.BindEdges[0], pi.BindEdges[2]);
			swap (pi.BaseVertices[0], pi.BaseVertices[3]);
			swap (pi.BaseVertices[1], pi.BaseVertices[2]);

			// Flip edges
			for (uint edge=0; edge<4; edge++)
			{
				// Ref on the patch info
				CPatchInfo::CBindInfo &bindEdge = pi.BindEdges[edge];

				uint next;
				// Look if it is a bind ?
				if ( (bindEdge.NPatchs>1) && (bindEdge.NPatchs!=5) )
				{
					for (next=0; next<(uint)bindEdge.NPatchs/2; next++)
					{
						swap (bindEdge.Next[bindEdge.NPatchs - next - 1], bindEdge.Next[next]);
						swap (bindEdge.Edge[bindEdge.NPatchs - next - 1], bindEdge.Edge[next]);
					}
				}

				// Look if we are binded on a reversed edge
				uint bindCount = (bindEdge.NPatchs==5) ? 1 : bindEdge.NPatchs;
				for (next=0; next<bindCount; next++)
				{
					// Left or right ?
					if ( (bindEdge.Edge[next] & 1) == 0)
					{
						// Invert
						bindEdge.Edge[next] += 2;
						bindEdge.Edge[next] &= 3;
					}
				}
			}
		}
	}

	// For each patches
	for (i=0 ; i<patchCount; i++)
	{
		// Tile infos
		CPatchInfo &pi = patchInfo[i];

		// Backup tiles
		std::vector<CTileElement>	tiles = pi.Tiles;

		int u,v;
		for (v=0; v<pi.OrderT; v++)
		for (u=0; u<pi.OrderS; u++)
		{
			// U tile
			int uSymmetry = symmetry ? (pi.OrderS-u-1) : u;

			// Destination tile
			CTileElement &element = pi.Tiles[u+v*pi.OrderS];

			// Copy the orginal symmetrical element
			element = tiles[uSymmetry+v*pi.OrderS];

			// For each layer
			for (int l=0; l<3; l++)
			{
				// Empty ?
				if (element.Tile[l] != 0xffff)
				{
					// Get the tile index
					uint tile = element.Tile[l];
					uint tileRotation = element.getTileOrient (l);

					// Get rot and symmetry for this tile
					uint tileRotate = rotate;
					bool tileSymmetry = symmetry;
					bool goofy = symmetry && (zoneSymmetry.getTileState (i, uSymmetry+v*pi.OrderS, l) == CZoneSymmetrisation::Goofy);

					// Transform the transfo
					if (getTileSymmetryRotate (bank, tile, tileSymmetry, tileRotate))
					{
						// Transform the tile
						if (!transformTile (bank, tile, tileRotation, tileSymmetry, (4-tileRotate)&3, goofy))
						{
							// Info
							nlwarning ("Error getting symmetrical / rotated zone tile.");
							return false;
						}
					}
					else
					{
						// Info
						nlwarning ("Error getting symmetrical / rotated zone tile.");
						return false;
					}

					// Set the tile
					element.Tile[l] = tile;
					element.setTileOrient (l, (uint8)tileRotation);
				}
			}

			// Empty ?
			if (element.Tile[0]!=0xffff)
			{
				// Get 256 info
				bool is256x256;
				uint8 uvOff;
				element.getTile256Info (is256x256, uvOff);

				// 256 ?
				if (is256x256)
				{
					// Get rot and symmetry for this tile
					uint tileRotate = rotate;
					bool tileSymmetry = symmetry;
					uint tileRotation = tiles[uSymmetry+v*pi.OrderS].getTileOrient (0);
					bool goofy = symmetry && (zoneSymmetry.getTileState (i, uSymmetry+v*pi.OrderS, 0) == CZoneSymmetrisation::Goofy);

					// Transform the transfo
					getTileSymmetryRotate (bank, element.Tile[0], tileSymmetry, tileRotate);

					// Transform the case
					transform256Case (bank, uvOff, tileRotation, tileSymmetry, (4-tileRotate)&3, goofy);

					element.setTile256Info (true, uvOff);
				}
			}
		}
	}

	// Ok
	return true;
}

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

} // NL3D