#include "stdafx.h"
#include "nel_patch_paint.h"
#include "resource.h"

#include "nel/3d/scene.h"
#include "nel/3d/camera.h"
#include "nel/3d/nelu.h"
#include "nel/3d/light.h"
#include "nel/3d/landscape_model.h"
#include "nel/3d/landscape.h"
#include "nel/3d/event_mouse_listener.h"
#include "nel/3d/dru.h"
#include "nel/3d/texture_mem.h"
#include "nel/3d/transform_shape.h"
#include "nel/3d/zone_corner_smoother.h"
#include "nel/3d/zone_symmetrisation.h"

#include "nel/misc/vector.h"
#include "nel/misc/event_server.h"
#include "nel/misc/event_listener.h"
#include "nel/misc/events.h"
#include "nel/misc/file.h"

#include "nel/ligo/ligo_config.h"

#include "paint_ui.h"
#include "paint_vcolor.h"
#include "paint_to_nel.h"
#include "paint_fill.h"
#include "paint_tileset.h"
#include "paint_light.h"
#include "../nel_mesh_lib/export_nel.h"

using namespace NL3D;
using namespace NLMISC;
using namespace NLLIGO;

// Paint mouse proc

#define MAIN_Width 800
#define MAIN_Height 600

#define MOD_WIDTH 8
#define MOD_HEIGHT 6

#define TILE_SIZE_COUNT 2

#define DEPTH_SEARCH_MAX 8

#define REGKEY_EDIT_PATCH "Software\\Nevrax\\Ryzom\\edit_patch"

// Bank bitmaps
CBankCont*	bankCont;

// Tileset land
CTileSetSelection	tileSetSelector;

bool bWarningInvalidTileSet;

CVector maxToNel (const Point3& p)
{
	return CVector (p.x, p.y, p.z);
}

CRGBA maxToNel (COLORREF ref)
{
	return CRGBA ((uint8)(ref&0xff), (uint8)((ref>>8)&0xff), (uint8)((ref>>16)&0xff));
}

COLORREF nelToMax (CRGBA ref)
{
	return RGB (ref.R, ref.G, ref.B);
}

void WarningInvalidTileSet ()
{
	if (!bWarningInvalidTileSet)
	{
		bWarningInvalidTileSet=true;
		MessageBox (NULL, "The tile bank is not compatible with your zone.\nPlease use the good bank or erase and repaint the zone.", 
			"Tile paint", MB_OK|MB_ICONEXCLAMATION);
	}
}

int brushValue[BRUSH_COUNT]=
{
	0, 4, 8
};

// Alocate and load a bitmap
ITexture* allocateAndLoadBitmap (uint8* bitmap, uint size)
{
	return new CTextureMem (bitmap, size, false);
}

// Call when painter starts
void enterPainter (CTileBank& banktoLoad)
{
	// Load some tiles from the bank
	bankCont=new CBankCont (banktoLoad, hInstance);

	// Get background color
	HKEY hKey;
	if (RegOpenKeyEx(HKEY_CURRENT_USER, REGKEY_EDIT_PATCH, 0, KEY_READ, &hKey)==ERROR_SUCCESS)
	{
		DWORD len=4;
		DWORD type;
		RegQueryValueEx (hKey, "Background", 0, &type, (LPBYTE)&backGround, &len);
		RegQueryValueEx (hKey, "Color1", 0, &type, (LPBYTE)&color1, &len);
		RegQueryValueEx (hKey, "Color2", 0, &type, (LPBYTE)&color2, &len);
		RegQueryValueEx (hKey, "Opa1", 0, &type, (LPBYTE)&opa1, &len);
		RegQueryValueEx (hKey, "Opa2", 0, &type, (LPBYTE)&opa2, &len);
		RegQueryValueEx (hKey, "Hard1", 0, &type, (LPBYTE)&hard1, &len);
		RegQueryValueEx (hKey, "Hard2", 0, &type, (LPBYTE)&hard2, &len);
		RegCloseKey (hKey);
	}
}

// Call when painter quit
void exitPainter ()
{
	// Delete some tiles from the bank
	delete bankCont;

	// Set background color
	HKEY hKey;
	if (RegCreateKey(HKEY_CURRENT_USER, REGKEY_EDIT_PATCH, &hKey)==ERROR_SUCCESS)
	{
		RegSetValueEx(hKey, "Background", 0, REG_DWORD, (LPBYTE)&backGround, 4);
		RegSetValueEx(hKey, "Color1", 0, REG_DWORD, (LPBYTE)&color1, 4);
		RegSetValueEx(hKey, "Color2", 0, REG_DWORD, (LPBYTE)&color2, 4);
		RegSetValueEx(hKey, "Opa1", 0, REG_DWORD, (LPBYTE)&opa1, 4);
		RegSetValueEx(hKey, "Opa2", 0, REG_DWORD, (LPBYTE)&opa2, 4);
		RegSetValueEx(hKey, "Hard1", 0, REG_DWORD, (LPBYTE)&hard1, 4);
		RegSetValueEx(hKey, "Hard2", 0, REG_DWORD, (LPBYTE)&hard2, 4);
		RegCloseKey (hKey);
	}
}

/*-------------------------------------------------------------------*/

std::vector<CZoneSymmetrisation> symVector;

/*-------------------------------------------------------------------*/

// Painter modes
enum TModePaint { ModeTile, ModeColor, ModeDisplace};
enum TModeMouse { ModePaint, ModeSelect, ModePick, ModeFill, ModeGetState };

/*-------------------------------------------------------------------*/

// Draw GUI
void drawVertexColorBox (float x0, float y0, float x1, float y1, CRGBA color, float opacity, float hardness, IDriver& driver)
{
	// Draw a white frame behind
	CDRU::drawQuad (x0, y0, x1, y1, driver, CRGBA (0x40, 0x40, 0x40), CViewport());
			
	// Compute the colors with alpha to show the hardness
	CRGBA fullFull=color;
	CRGBA full=color;
	full.A=(uint8)(opacity*255.f);
	CRGBA medium=color;
	medium.A=(uint8)(255.f*hardness*opacity);
	CRGBA empty=color;
	empty.A=(uint8)(255.f*std::max (std::min (opacity*(1.f+1.414213f*(hardness-1.f)), 1.f), 0.f));

	// Center
	float xc=(x0+x1)/2.f;
	float yc=(y0+y1)/2.f;

	// Draw 4 quads if texture exist
	CDRU::drawQuad (x0, y0, xc, yc, empty, medium, full, medium, driver, CViewport());
	CDRU::drawQuad (xc, y0, x1, yc, fullFull, fullFull, fullFull, fullFull, driver, CViewport());
	CDRU::drawQuad (xc, yc, x1, y1, fullFull, fullFull, fullFull, fullFull, driver, CViewport());
	CDRU::drawQuad (x0, yc, xc, y1, medium, full, medium, empty, driver, CViewport());
}


// Draw GUI
void drawInterface (TModeMouse select, TModePaint mode, PaintPatchMod *pobj, IDriver& driver, CLandscapeModel& landscape, CPaintColor &paintColor)
{
	// Select a texture..
	if (select==ModeSelect)
	{
		// Select a tileSet
		if (mode==ModeTile)
		{
			uint num=tileSetSelector.getTileCount ();
			for (uint t=0; t<num; t++)
			{
				// TileSet number
				int tileSet=tileSetSelector.getTileSet (t);

				// 128 tile in this bank ?
				if (bank.getTileSet (tileSet)->getNumTile128()>0)
				{
					// Get a 128 tile number
					int nTile=bank.getTileSet (tileSet)->getTile128(0);
					nlassert (nTile!=-1);

					// Get a texture of this tile
					ITexture *texture=bankCont->TileSet[tileSet].MainBitmap;
					if (texture)
						CDRU::drawBitmap ( (float)((t+1)%MOD_WIDTH)/(float)MOD_WIDTH, (float)((t+1)/MOD_WIDTH)/(float)MOD_HEIGHT, 1.f/(float)MOD_WIDTH,
							1.f/(float)MOD_HEIGHT, *texture, driver, CViewport(), false);
				}
			}
		}
		// Select a tileSet
		else if (mode==ModeDisplace)
		{
			// No tileset
			if (pobj->DisplaceTileSet!=-1)
			{
				// A is a valid tile set selected ?
				for (uint t=0; t<CTileSet::CountDisplace; t++)
				{
					// Get the texture
					ITexture *texture=bankCont->TileSet[pobj->DisplaceTileSet].DisplaceBitmap[t];

					// Draw the texture
					if (texture)
						CDRU::drawBitmap ( (float)(t%MOD_WIDTH)/(float)MOD_WIDTH, (float)(t/MOD_WIDTH)/(float)MOD_HEIGHT, 1.f/(float)MOD_WIDTH,
							1.f/(float)MOD_HEIGHT, *texture, driver, CViewport(), false);
					else
						CDRU::drawQuad ( (float)(t%MOD_WIDTH)/(float)MOD_WIDTH, (float)(t/MOD_WIDTH)/(float)MOD_HEIGHT, 
							(float)(t%MOD_WIDTH)/(float)MOD_WIDTH+1.f/(float)MOD_WIDTH,
							(float)(t/MOD_WIDTH)/(float)MOD_HEIGHT+1.f/(float)MOD_HEIGHT, driver, 
							CRGBA (128, 128, 128), CViewport());
				}
			}
		}
	}
	else
	{
		// Mode paint, draw the GUI

		// Automatic lighting ?
		if (pobj->automaticLighting)
		{
			// Get pointer
			ITexture *tex=bankCont->lightBitmap;

			// Draw the bitmap
			CDRU::drawBitmap ( (float)(MOD_WIDTH-1)/(float)MOD_WIDTH, (float)(MOD_HEIGHT-1)/(float)MOD_HEIGHT, 1.f/(float)MOD_WIDTH, 1.f/(float)MOD_HEIGHT, *tex, driver, CViewport(), true);
		}

		// Lock borders ?
		if (pobj->lockBorders)
		{
			// Get pointer
			ITexture *tex=bankCont->lockBitmap;

			// Draw the bitmap
			CDRU::drawBitmap ( (float)(MOD_WIDTH-1)/(float)MOD_WIDTH, (float)(MOD_HEIGHT-2)/(float)MOD_HEIGHT, 1.f/(float)MOD_WIDTH, 1.f/(float)MOD_HEIGHT, *tex, driver, CViewport(), true);
		}

		// *** Draw the current tile
		if ((pobj->CurrentTileSet!=-1)&&(mode==ModeTile))
		{
			// Draw the oriented icon
			if (bank.getTileSet (pobj->CurrentTileSet)->getOriented())
			{
				// Get pointer
				ITexture *tex=bankCont->orientedBitmap;

				// Draw the bitmap
				CDRU::drawBitmap ( (float)(MOD_WIDTH-1)/(float)MOD_WIDTH, (float)(0)/(float)MOD_HEIGHT, 1.f/(float)MOD_WIDTH, 1.f/(float)MOD_HEIGHT, *tex, driver, CViewport(), true);
			}

			if (pobj->TileGroup==0)
			{
				// Get pointer
				ITexture *tex=bankCont->TileSet[pobj->CurrentTileSet].MainBitmap;

				// Default: all tile are used
				if (tex)
					CDRU::drawBitmap ( 0, (float)(MOD_HEIGHT-1)/(float)MOD_HEIGHT, 1.f/(float)MOD_WIDTH, 1.f/(float)MOD_HEIGHT, *tex, driver, CViewport(), true);
			}
			else
			{
				bool full=false;

				// 128 or 256 ?
				if (pobj->tileSize==0)
				{
					if (bankCont->TileSet[pobj->CurrentTileSet].GroupTile128[pobj->TileGroup-1].size()!=0)
						full=true;
				}
				else
				{
					if (bankCont->TileSet[pobj->CurrentTileSet].GroupTile256[pobj->TileGroup-1].size()!=0)
						full=true;
				}

				if (full)
				{
					// Get pointer
					ITexture *tex=bankCont->TileSet[pobj->CurrentTileSet].GroupBitmap[pobj->TileGroup-1];

					// Show the tile from a group
					if (tex)
						CDRU::drawBitmap ( 0, (float)(MOD_HEIGHT-1)/(float)MOD_HEIGHT, 1.f/(float)MOD_WIDTH, 1.f/(float)MOD_HEIGHT, *tex, driver, CViewport(), true);
				}
			}
		}

		// *** Draw the current noise
		if (mode==ModeDisplace)
		{
			if (pobj->DisplaceTileSet!=-1)
			{
				// Get pointer
				ITexture *tex=bankCont->TileSet[pobj->DisplaceTileSet].DisplaceBitmap[pobj->DisplaceTile];

				// Draw if texture exist
				if (tex)
					CDRU::drawBitmap ( 0, (float)(MOD_HEIGHT-1)/(float)MOD_HEIGHT, 1.f/(float)MOD_WIDTH, 1.f/(float)MOD_HEIGHT, *tex, driver, CViewport(), true);
				else
				{
					// 4 Corners
					float x0=0.f;
					float y0=(float)(MOD_HEIGHT-1)/(float)MOD_HEIGHT;
					float x1=1.f/(float)MOD_WIDTH;
					float y1=1.f;

					CDRU::drawQuad (x0, y0, x1, y1, driver, CRGBA (128, 128, 128), CViewport());
				}
			}
		}

		// *** Draw the current color
		if (mode==ModeColor)
		{

			// 4 Corners
			float x0=0.f;
			float y0=(float)(MOD_HEIGHT-1)/(float)MOD_HEIGHT;
			float x1=1.f/(float)MOD_WIDTH;
			float y1=1.f;

#define		BORDER_COLOR (0.2f)

			// Draw second color
			drawVertexColorBox (x0+(x1-x0)*BORDER_COLOR, y0, x1, y1+(y0-y1)*BORDER_COLOR, maxToNel (color2), opa2, hard2, driver);

			// Draw first color
			drawVertexColorBox (x0, y0+(y1-y0)*BORDER_COLOR, x1+(x0-x1)*BORDER_COLOR, y1, maxToNel (color1), opa1, hard1, driver);
		}

		// *** Draw the current bursh size
		if ((mode==ModeTile)||(mode==ModeDisplace))
		{
			ITexture* burshSize[BRUSH_COUNT]={bankCont->_smallBitmap, bankCont->mediumBitmap, bankCont->largeBitmap};

			// Draw brush icon
			CDRU::drawBitmap ( 0, (float)(MOD_HEIGHT-3)/(float)MOD_HEIGHT, 1.f/(float)MOD_WIDTH, 1.f/(float)MOD_HEIGHT, *(burshSize[pobj->brushSize]), driver, CViewport(), true);
		}
		else if (mode==ModeColor)
		{
			// 4 points
			float x0=0.f;
			float y0=(float)(MOD_HEIGHT-2)/(float)MOD_HEIGHT;
			float x1=1.f/(float)MOD_WIDTH;
			float y1=(float)(MOD_HEIGHT-1)/(float)MOD_HEIGHT;

			// Center
			float xc=(x0+x1)/2.f;
			float yc=(y0+y1)/2.f;

			// Scale factor
			float scaleFactor=0.9f*(float)PaintPatchMod::ColorBushSize/(float)COLOR_BRUSH_STEP+0.1f;
			clamp (scaleFactor, 0.f, 1.f);

			// Scale it
			x0=(x0-xc)*scaleFactor+xc;
			y0=(y0-yc)*scaleFactor+yc;
			x1=(x1-xc)*scaleFactor+xc;
			y1=(y1-yc)*scaleFactor+yc;

			// Draw brush icon
			CDRU::drawBitmap ( x0, y0, x1-x0, y1-y0, *bankCont->largeBitmap, driver, CViewport(), true);
		}

		// For tiles only
		if (mode==ModeTile)
		{
			// *** Draw the current size
			ITexture* size[2]={bankCont->_128Bitmap, bankCont->_256Bitmap};

			// Draw brush icon
			CDRU::drawBitmap ( 0, (float)(MOD_HEIGHT-2)/(float)MOD_HEIGHT, 1.f/(float)MOD_WIDTH, 1.f/(float)MOD_HEIGHT, *(size[pobj->tileSize]), driver, CViewport(), true);
		}

		if ((pobj->CurrentTileSet!=-1)&&(mode==ModeTile))
		{
			// *** Draw the current group
			ITexture* group[NL3D_CTILE_NUM_GROUP+1]={bankCont->allBitmap, bankCont->_0Bitmap, bankCont->_1Bitmap, bankCont->_2Bitmap, bankCont->_3Bitmap, 
								bankCont->_4Bitmap, bankCont->_5Bitmap, bankCont->_6Bitmap, bankCont->_7Bitmap, bankCont->_8Bitmap, bankCont->_9Bitmap,
								bankCont->_10Bitmap, bankCont->_11Bitmap};

			// Draw group icon
			CDRU::drawBitmap ( 0, (float)(MOD_HEIGHT-4)/(float)MOD_HEIGHT, 1.f/(float)MOD_WIDTH, 1.f/(float)MOD_HEIGHT, *(group[pobj->TileGroup]), driver, CViewport(), true);
		}

		// For color only
		if (paintColor.getBrushMode ()&&(mode==ModeColor))
		{
			// Draw brush icon
			CDRU::drawBitmap ( 0, (float)(MOD_HEIGHT-3)/(float)MOD_HEIGHT, 1.f/(float)MOD_WIDTH, 1.f/(float)MOD_HEIGHT, paintColor.getBrush (), driver, CViewport(), false);
		}

		// For color only
		if (pobj->ShowCurrentState && ((int)pobj->CurrentState<3) && ((int)pobj->CurrentState>=0))
		{
			// Draw brush icon
			ITexture* bitmaps[3]={bankCont->nothingBitmap, bankCont->regularBitmap, bankCont->goofyBitmap};
			CDRU::drawBitmap ( 0, (float)(MOD_HEIGHT-5)/(float)MOD_HEIGHT, 1.f/(float)MOD_WIDTH, 1.f/(float)MOD_HEIGHT, *(bitmaps[(int)pobj->CurrentState]), driver, CViewport(), true);
		}
	}
}

/*-------------------------------------------------------------------*/

#define WELD_THRESOLD 1.f

/*-------------------------------------------------------------------*/

void addNeLZone ( Object *object, INode *current, std::vector<EPM_Mesh> &vectMesh, PatchMesh *patch, RPatchMesh *rpatch, PaintPatchData *patchData, ModContext *mod, INode *original, uint &nelIndex)
{
	// Not the same
	if ((current->GetObjectRef() == object) && (!current->IsHidden()))
	{
		vectMesh.push_back (EPM_Mesh (patch, rpatch, patchData, current, mod, nelIndex++, original == current));
	}

	// Call to child
	for (uint child=0; child<(uint)current->NumberOfChildren(); child++)
		addNeLZone ( object, current->GetChildNode(child), vectMesh, patch, rpatch, patchData, mod, original, nelIndex);
}

// Tile painting algorithm. watch "doc/3d/tile_algorithm.doc" for details

void makeVectMesh (std::vector<EPM_Mesh>& vectMesh, INodeTab& nodes, ModContextList& mcList, PaintPatchMod *pobj, TimeValue t)
{
	// Clear the mesh vector
	vectMesh.clear ();

	// Nel zone indexies
	uint nelIndex = 0;

	for (int i = 0; i < mcList.Count (); i++)
	{
		// 
		PaintPatchData *patchData = (PaintPatchData*)mcList[i]->localData;
		if (!patchData)
			continue;
		if (patchData->GetFlag(EPD_BEENDONE))
			continue;

		// If the mesh isn't yet cache, this will cause it to get cached.
		RPatchMesh *rpatch;
		PatchMesh *patch = patchData->TempData(pobj)->GetPatch(t, rpatch);
		if (!patch)
			continue;

		// Look for another node
		addNeLZone ( nodes[i]->GetObjectRef(), pobj->ip->GetRootNode(), vectMesh, patch, rpatch, patchData, mcList[i], nodes[i], nelIndex );
	}
}

void transformDesc (tileDesc &desc, bool symmetry, uint rotate, uint mesh, uint tile, std::vector<EPM_Mesh>& vectMesh)
{
	uint patch=tile/NUM_TILE_SEL;
	uint ttile=tile%NUM_TILE_SEL;
	uint v=ttile/MAX_TILE_IN_PATCH;
	uint u=ttile%MAX_TILE_IN_PATCH;

	// Get the patch
	int OrderS=(1<<vectMesh[mesh].RMesh->getUIPatch (patch).NbTilesU);
	uint symTile = OrderS*v+u;

	// 256 ?
	if (desc.getCase()!=0)
	{
		// Transform the case
		uint8 case256 = desc.getCase()-1;

		// Get rot and symmetry for this tile
		uint tileRotate = rotate;
		bool tileSymmetry = symmetry;
		uint tile = desc.getLayer (0).Tile;

		// XRef
		int tileSet;
		int number;
		CTileBank::TTileType type;
		bank.getTileXRef (tile, tileSet, number, type);

		// Transform the transfo		
		CPatchInfo::getTileSymmetryRotate (bank, desc.getLayer(0).Tile, tileSymmetry, tileRotate);

		// Get the state of the layer 0
		bool goofy = false;
		uint tileRotation = desc.getLayer (0).Rotate;
		if (symmetry)
		{
			if (bank.getTileSet (tileSet)->getOriented ())
			{
				if ((symVector[mesh].getOrientedTileBorderState (patch, symTile) != CZoneSymmetrisation::Nothing))
					goofy = (symVector[mesh].getOrientedTileBorderState (patch, symTile) == CZoneSymmetrisation::Goofy);
				else
					goofy = (symVector[mesh].getTileState (patch, symTile, 0) == CZoneSymmetrisation::Goofy);
			}
			else
			{
				if ((symVector[mesh].getTileBorderState (patch, symTile) != CZoneSymmetrisation::Nothing))
					goofy = (symVector[mesh].getTileBorderState (patch, symTile) == CZoneSymmetrisation::Goofy);
				else
					goofy = (symVector[mesh].getTileState (patch, symTile, 0) == CZoneSymmetrisation::Goofy);
			}
		}

		CPatchInfo::transform256Case (bank, case256, tileRotation, tileSymmetry, tileRotate, goofy);
		desc.setCase (case256+1);
	}

	for (int l=0; l<desc.getNumLayer (); l++)
	{
		// Tile and rot
		uint tile = desc.getLayer (l).Tile;
		uint tileRotation = desc.getLayer (l).Rotate;

		// XRef
		int tileSet;
		int number;
		CTileBank::TTileType type;
		bank.getTileXRef (tile, tileSet, number, type);

		// Get rot and symmetry for this tile
		uint tileRotate = rotate;
		bool tileSymmetry = symmetry;

		// Get the state of the
		bool goofy = false;
		if (symmetry)
		{
			if (bank.getTileSet (tileSet)->getOriented ())
			{
				if ((symVector[mesh].getOrientedTileBorderState (patch, symTile) != CZoneSymmetrisation::Nothing))
					goofy = (symVector[mesh].getOrientedTileBorderState (patch, symTile) == CZoneSymmetrisation::Goofy);
				else
					goofy = (symVector[mesh].getTileState (patch, symTile, l) == CZoneSymmetrisation::Goofy);
			}
			else
			{
				if ((symVector[mesh].getTileBorderState (patch, symTile) != CZoneSymmetrisation::Nothing))
					goofy = (symVector[mesh].getTileBorderState (patch, symTile) == CZoneSymmetrisation::Goofy);
				else
					goofy = (symVector[mesh].getTileState (patch, symTile, l) == CZoneSymmetrisation::Goofy);
			}
		}

		// Transform the transfo
		if (CPatchInfo::getTileSymmetryRotate (bank, tile, tileSymmetry, tileRotate))
		{
			// Transform it
			if (CPatchInfo::transformTile (bank, tile, tileRotation, tileSymmetry, tileRotate, goofy))
			{
				desc.getLayer (l).Tile = tile;
				desc.getLayer (l).Rotate = tileRotation;
			}
		}
	}
}

void transformInvDesc (tileDesc &desc, bool symmetry, uint rotate, uint mesh, uint tile, std::vector<EPM_Mesh>& vectMesh)
{
	transformDesc (desc, false, 4-rotate, mesh, tile, vectMesh);
	transformDesc (desc, symmetry, 0, mesh, tile, vectMesh);
}

void EPM_PaintMouseProc::SetTile (int mesh, int tile, const tileDesc& desc, std::vector<EPM_Mesh>& vectMesh, CLandscape* land, 
								  CNelPatchChanger& nelPatchChg, std::vector<CBackupValue>* backupStack, bool undo, bool updateDisplace)
{
	// Undo: get old value
	tileDesc oldDesc;
	GetTile (mesh, tile, oldDesc, vectMesh, land);

	// New desc
	tileDesc maxDesc=desc;

	// Backup if error
	if (backupStack)
		backupStack->push_back (CBackupValue (oldDesc, mesh, tile));

	// Update displace ?
	if (!updateDisplace)
	{
		// Copy old displacement map
		maxDesc.setDisplace (oldDesc.getDisplace());
	}

	// Transform tile 
	tileDesc copyDesc=maxDesc;
	transformInvDesc (maxDesc, vectMesh[mesh].Symmetry, 4-vectMesh[mesh].Rotate, mesh, tile, vectMesh);
	transformInvDesc (copyDesc, vectMesh[mesh].Symmetry, 0, mesh, tile, vectMesh);

	// 3dsmax update
	vectMesh[mesh].RMesh->setTileDesc (tile, maxDesc);

	// NeL update
	if (land)
	{
		// For each mesh
		for (uint i=0; i<vectMesh.size(); i++)
		{
			// Same mesh ?
			if (vectMesh[i].RMesh == vectMesh[mesh].RMesh)
			{
				int patch=tile/NUM_TILE_SEL;
				int ttile=tile%NUM_TILE_SEL;
				int v=ttile/MAX_TILE_IN_PATCH;
				int u=ttile%MAX_TILE_IN_PATCH;

				// Get the patch
				std::vector<CTileElement>& copyZone = *nelPatchChg.getTileArray (i, patch);
				RPatchMesh *pMesh=vectMesh[i].RMesh;
				int OrderS=(1<<pMesh->getUIPatch (patch).NbTilesU);

				// Get a desc for this tile
				tileDesc nelDesc=copyDesc;
				transformInvDesc (nelDesc, vectMesh[mesh].Symmetry, 4-vectMesh[mesh].Rotate, mesh, tile, vectMesh);
				transformDesc (nelDesc, vectMesh[i].Symmetry, 4-vectMesh[i].Rotate, mesh, tile, vectMesh);

				// Symmetry ?
				if (vectMesh[i].Symmetry)
				{
					u = OrderS - u - 1;
				}

				for (int l=0; l<3; l++)
				{
					if (l>=nelDesc.getNumLayer ())
					{
						copyZone[u+v*OrderS].Tile[l]=0xffff;
					}
					else
					{
						int toto=copyZone[u+v*OrderS].Tile[l];
						copyZone[u+v*OrderS].Tile[l]=nelDesc.getLayer (l).Tile;
						copyZone[u+v*OrderS].setTileOrient (l, nelDesc.getLayer (l).Rotate);

					}
				}
				if (copyZone[u+v*OrderS].Tile[0]==0xffff)
					copyZone[u+v*OrderS].setTile256Info (false, 0);
				else
				{
					if (nelDesc.getCase()==0)
						copyZone[u+v*OrderS].setTile256Info (false, 0);
					else
						copyZone[u+v*OrderS].setTile256Info (true, nelDesc.getCase()-1);
				}

				// Displace tile
				copyZone[u+v*OrderS].setTileSubNoise (nelDesc.getDisplace());

				// Undo: push new value
				if (undo)
				{
					CUndoElement undoEmlt (i, tile, CUndoStruct (oldDesc), CUndoStruct (desc));
					bankCont->Undo.toUndo (undoEmlt);
				}
			}
		}
	}
}

void EPM_PaintMouseProc::GetTile (int mesh, int tile, tileDesc& desc, std::vector<EPM_Mesh>& vectMesh, CLandscape* land)
{
	// NeL update
	if (land)
	{
		// Get the patch
		RPatchMesh *pMesh=vectMesh[mesh].RMesh;

		// Get tile desc
		desc=pMesh->getTileDesc (tile);

		// Transform it
		transformDesc (desc, vectMesh[mesh].Symmetry, 4-vectMesh[mesh].Rotate, mesh, tile, vectMesh);
	}
}

int EPM_PaintMouseProc::selectTile (uint tileSet, bool selectCycle, bool _256, uint group, const CTileBank& bank)
{
	// TileSet
	const CTileSet *TileSet=bank.getTileSet (tileSet);

	// The number
	int nTile;

	// Calc next tile index
	uint32 index;
	if (selectCycle)
		// Select a tile in a cycle
		index=TileIndex++;
	else
		// Select a random tile
		index=(uint32)rand();

	if (_256)
	{
		// Select in a group ?
		if (group==0)
		{
			// No, select in the global list
			nTile=TileSet->getTile256 (index%(uint32)TileSet->getNumTile256 ());
		}
		else
		{
			// Ref on the group tile array
			const std::vector<uint>& groupArray=bankCont->TileSet[tileSet].GroupTile256[group-1];

			// Check there is tiles in this group
			if (groupArray.size()==0)
				nTile=-1;
			else
			// No, select in the global list
			nTile=TileSet->getTile256 (groupArray[index%(uint32)groupArray.size ()]);
		}
	}
	else
	{
		// Select in a group ?
		if (group==0)
		{
			// No, select in the global list
			nTile=TileSet->getTile128 (index%(uint32)TileSet->getNumTile128 ());
		}
		else
		{
			// Ref on the group tile array
			const std::vector<uint>& groupArray=bankCont->TileSet[tileSet].GroupTile128[group-1];

			// Check there is tiles in this group
			if (groupArray.size()==0)
				nTile=-1;
			else
				// No, select in the global list
				nTile=TileSet->getTile128 (groupArray[index%(uint32)groupArray.size ()]);
		}
	}

	return nTile;
}

bool EPM_PaintMouseProc::isLockedEx (PaintPatchMod *pobj, EPM_PaintTile* pTile, std::vector<EPM_Mesh>& vectMesh, CLandscape* land)
{
	// Lock border ?
	if (pobj->lockBorders)
	{
		// get the tile desc
		tileDesc backup;
		GetTile (pTile->Mesh, pTile->tile, backup, vectMesh, land);

		// It is a 256 ?
		if (backup.getCase()>0)
		{
			// Align on the grid
			if (pTile->u&1)
				pTile=pTile->voisins[0];
			if (pTile->v&1)
				pTile=pTile->voisins[3];

			// Return status
			int nRot;
			return (pTile->locked!=0) || (pTile->getRight256 (0, nRot)->locked!=0) || (pTile->getBottom256 (0, nRot)->locked!=0) || (pTile->getRightBottom256 (0, nRot)->locked!=0);
		}
		else
			// Return lock status
			return (pTile->locked!=0);
	}

	// Not locked
	return false;
}

bool EPM_PaintMouseProc::isLocked256 (PaintPatchMod *pobj, EPM_PaintTile* pTile)
{
	// Lock border ?
	if (pobj->lockBorders)
	{
		// Align on the grid
		if (pTile->u&1)
			pTile=pTile->voisins[0];
		if (pTile->v&1)
			pTile=pTile->voisins[3];

		// Return status
		return (pTile->locked!=0) || (pTile->voisins[2]->locked!=0) || (pTile->voisins[1]->locked!=0) || (pTile->voisins[2]->voisins[1]->locked!=0);
	}

	// Not locked
	return false;
}

bool EPM_PaintMouseProc::ClearATile ( EPM_PaintTile* pTile, std::vector<EPM_Mesh>& vectMesh, 
								   CLandscape* land, CNelPatchChanger& nelPatchChg, bool _256, bool _force128)
{
	// ** 1) Backup of the tile
	tileDesc backup;
	GetTile (pTile->Mesh, pTile->tile, backup, vectMesh, land);

	// If we are over a 256, force mode 256
	if ((backup.getCase()>0) && !_force128)
		_256 = true;

	// If tile 256, must have delta pos aligned on 2x2
	if (_256)
	{
		if (pTile->u&1)
			pTile=pTile->voisins[0];
		if (pTile->v&1)
			pTile=pTile->voisins[3];
	}

	// Erase a 256 area ?
	if (_256)
	{
		tileDesc desc;
		desc.setTile (0, 0, 0, tileIndex (0,0), tileIndex (0,0), tileIndex (0,0));

		// Get right tile
		int nRot;
		EPM_PaintTile *neighbor[4] = { pTile, pTile->getRight256 (0, nRot), pTile->getBottom256 (0, nRot), pTile->getRightBottom256 (0, nRot) };

		// Check not locked
		uint n;
		for (n=0; n<4; n++)
		{
			// Ok ?
			nlassert (neighbor[n]);

			// Locked ?
			if (isLocked (pobj, neighbor[n]))
				return false;
		}

		// Clear them
		for (n=0; n<4; n++)
		{
			// Get the displace index
			tileDesc descOrig;
			GetTile (neighbor[n]->Mesh, neighbor[n]->tile, descOrig, vectMesh, land);

			// Not compatible, clear it
			desc.setDisplace (descOrig.getDisplace());
			SetTile (neighbor[n]->Mesh, neighbor[n]->tile, desc, vectMesh, land, nelPatchChg, NULL);
		}
	}
	else
	{
		// Check locked
		if (isLocked (pobj, pTile))
			return false;
		
		// Cleared descriptor
		tileDesc desc;
		desc.setTile (0, 0, 0, tileIndex (0,0), tileIndex (0,0), tileIndex (0,0));

		// Get the displace index
		tileDesc descOrig;
		GetTile (pTile->Mesh, pTile->tile, descOrig, vectMesh, land);

		// Not compatible, clear it
		desc.setDisplace (descOrig.getDisplace());
		SetTile (pTile->Mesh, pTile->tile, desc, vectMesh, land, nelPatchChg, NULL);
	}

	// Erased
	return true;
}

bool EPM_PaintMouseProc::PutATile ( EPM_PaintTile* pTile, int tileSet, int curRotation, const CTileBank& bank, 
								   bool selectCycle, std::set<EPM_PaintTile*>& visited, std::vector<EPM_Mesh>& vectMesh, 
								   CLandscape* land, CNelPatchChanger& nelPatchChg, bool _256)
{
	// If tile 256, must have delta pos aligned on 2x2
	if (_256)
	{
		if (pTile->u&1)
			pTile=pTile->voisins[0];
		if (pTile->v&1)
			pTile=pTile->voisins[3];
	}

	// 256 valide ?
	if ((_256)&&(!pTile->validFor256 (0)))
		return false;

	// Frozen ?
	if (pTile->frozen)
		return false;

	// Locked ?
	if (isLocked (pobj, pTile))
		return false;

	// *** Clip select patch
	// Patch number
	int patch=pTile->tile/NUM_TILE_SEL;

	// Check if we are in patch subobject and if this patch is selected
	
	if ((vectMesh[pTile->Mesh].PMesh->selLevel==EP_PATCH)&&(!vectMesh[pTile->Mesh].PMesh->patchSel[patch]))
		return false;

	// ** 1) Backup of the tile
	tileDesc backup;
	GetTile (pTile->Mesh, pTile->tile, backup, vectMesh, land);
	tileDesc backupRight, backupBottom, backupCorner;

	// Backup stack
	static std::vector<CBackupValue> backupStack;
	backupStack.reserve (300);
	backupStack.resize(0);

	if (_256)
	{
		// get right
		int nRot;
		EPM_PaintTile* other=pTile->getRight256 (0, nRot);
		nlassert (other);
		if (isLocked (pobj, other))
			return false;
		GetTile (other->Mesh, other->tile, backupRight, vectMesh, land);

		// get bottom
		other=pTile->getBottom256 (0, nRot);
		nlassert (other);
		if (isLocked (pobj, other))
			return false;
		GetTile (other->Mesh, other->tile, backupBottom, vectMesh, land);

		// get corner
		other=pTile->getRightBottom256 (0, nRot);
		nlassert (other);
		nlassert (other==pTile->getBottomRight256 (0, nRot));
		if (isLocked (pobj, other))
			return false;
		GetTile (other->Mesh, other->tile, backupCorner, vectMesh, land);
	}

	// ** 2) Add to visited tile set
	visited.insert (pTile);

	// Clear...
	if (tileSet==-1)
	{
		return ClearATile ( pTile, vectMesh, land, nelPatchChg, _256);
	}
	else
	{
		// Select a tile
		int nTile=selectTile (tileSet, selectCycle, _256, pobj->TileGroup, bank);

		// No tile, return
		if (nTile==-1)
			return false;

		// ** 3) Put the tile

		if (_256)
		{
			// Main tile
			tileDesc desc;
			desc.setTile (1, 1+((-curRotation)&3), 0, tileIndex (nTile, curRotation), tileIndex (0,0), tileIndex (0,0));

			// Main tile
			SetTile (pTile->Mesh, pTile->tile, desc, vectMesh, land, nelPatchChg, &backupStack);

			// get right
			int nRot;
			EPM_PaintTile* other=pTile->getRight256 (0, nRot);
			desc.setTile (1, 1+((-curRotation-1)&3), 0, tileIndex (nTile, (curRotation-nRot)&3), tileIndex (0,0), tileIndex (0,0));
			nlassert (other);
			SetTile (other->Mesh, other->tile, desc, vectMesh, land, nelPatchChg, &backupStack);
			
			// Add to visited tile set
			visited.insert (other);

			// get bottom
			other=pTile->getBottom256 (0, nRot);
			desc.setTile (1, 1+((-curRotation+1)&3), 0, tileIndex (nTile, (curRotation-nRot)&3), tileIndex (0,0), tileIndex (0,0));
			nlassert (other);
			SetTile (other->Mesh, other->tile, desc, vectMesh, land, nelPatchChg, &backupStack);
			
			// Add to visited tile set
			visited.insert (other);

			// get corner
			other=pTile->getRightBottom256 (0, nRot);
			desc.setTile (1, 1+((-curRotation+2)&3), 0, tileIndex (nTile, (curRotation-nRot)&3), tileIndex (0,0), tileIndex (0,0));
			nlassert (other);
			nlassert (other==pTile->getBottomRight256 (0, nRot));
			SetTile (other->Mesh, other->tile, desc, vectMesh, land, nelPatchChg, &backupStack);
			
			// Add to visited tile set
			visited.insert (other);
		}
		else
		{
			tileDesc desc;
			desc.setTile (1, 0, 0, tileIndex (nTile, curRotation), tileIndex (0,0), tileIndex (0,0));
			SetTile (pTile->Mesh, pTile->tile, desc, vectMesh, land, nelPatchChg, &backupStack);
		}
	}

	// return value
	bool bContinue=true;

	// Random offset
	uint offset=rand();

	if (_256)
	{

		// Visit neighbourhood in a random order
		for (int n=0; n<4; n++)
		{
			int nRot;
			EPM_PaintTile* other;

			switch ((offset+n)&0x3)
			{
			case 0:
				// Main
				if (pTile->voisins[3])
					if (!PropagateBorder (pTile->voisins[3], (pTile->rotate[3]+curRotation)&3, tileSet, visited, bank, 
							vectMesh, land, nelPatchChg, backupStack))
					{
						bContinue=false;
						goto zap;
					}
				if (pTile->voisins[0])
					if (!PropagateBorder (pTile->voisins[0], (pTile->rotate[0]+curRotation)&3, tileSet, visited, bank, 
							vectMesh, land, nelPatchChg, backupStack))
					{
						bContinue=false;
						goto zap;
					}
				break;

			case 1:
				// Bottom
				other=pTile->getBottom256 (0, nRot);
				if (other->voisins[(0-nRot)&3])
					if (!PropagateBorder (other->voisins[(0-nRot)&3], (other->rotate[(0-nRot)&3]+curRotation)&3, tileSet, visited, bank,
							vectMesh, land, nelPatchChg, backupStack))
					{
						bContinue=false;
						goto zap;
					}
				if (other->voisins[(1-nRot)&3])
					if (!PropagateBorder (other->voisins[(1-nRot)&3], (other->rotate[(1-nRot)&3]+curRotation)&3, tileSet, visited, bank,
							vectMesh, land, nelPatchChg, backupStack))
					{
						bContinue=false;
						goto zap;
					}
				break;

			case 2:
				// Corner
				other=pTile->getBottomRight256 (0, nRot);
				if (other->voisins[(1-nRot)&3])
					if (!PropagateBorder (other->voisins[(1-nRot)&3], (other->rotate[(1-nRot)&3]+curRotation)&3, tileSet, visited, bank,
							vectMesh, land, nelPatchChg, backupStack))
					{
						bContinue=false;
						goto zap;
					}
				if (other->voisins[(2-nRot)&3])
					if (!PropagateBorder (other->voisins[(2-nRot)&3], (other->rotate[(2-nRot)&3]+curRotation)&3, tileSet, visited, bank,
							vectMesh, land, nelPatchChg, backupStack))
					{
						bContinue=false;
						goto zap;
					}
				break;

			case 3:
				// Right
				other=pTile->getRight256 (0, nRot);
				if (other->voisins[(2-nRot)&3])
					if (!PropagateBorder (other->voisins[(2-nRot)&3], (other->rotate[(2-nRot)&3]+curRotation)&3, tileSet, visited, bank,
							vectMesh, land, nelPatchChg, backupStack))
					{
						bContinue=false;
						goto zap;
					}
				if (other->voisins[(3-nRot)&3])
					if (!PropagateBorder (other->voisins[(3-nRot)&3], (other->rotate[(3-nRot)&3]+curRotation)&3, tileSet, visited, bank,
							vectMesh, land, nelPatchChg, backupStack))
					{
						bContinue=false;
						goto zap;
					}
				break;
			default:
				nlassert (0);		// no!
			}
		}
zap:;
	}
	else
	{
		// For all patches voisins
		for (int i=0; i<4; i++)
		{
			// Random offset
			uint ii=(offset+i)&0x3;

			// 4) Propagate the borders to voisins
			if (pTile->voisins[ii])
			{
				if (!PropagateBorder (pTile->voisins[ii], (pTile->rotate[ii]+curRotation)&3, tileSet, visited, bank,
					vectMesh, land, nelPatchChg, backupStack))
				{
					bContinue=false;
					break;
				}
			}
		}
	}

	// Backup !!
	if (!bContinue)
	{
		// Backup all tiles
		for (int back=backupStack.size()-1; back>=0; back--)
		{
			// Yo!
			SetTile (backupStack[back].Mesh, backupStack[back].Tile, backupStack[back].Desc, vectMesh, land, nelPatchChg, NULL);
		}

		// Try to put a transition tile ?
		bool backup256 = (backup.getCase()>0);
		if (!_256 && !backup256)
		{
			// 4 cases
			// *****
			// *0*3*
			// *****
			// *1*2*
			// *****
			tileSetIndex tileSetCases[4][4];
			for (uint i=0; i<4; i++)
			for (uint j=0; j<4; j++)
			{
				tileSetCases[i][j].TileSet = -1;
				tileSetCases[i][j].Rotate = 0;
			}
			CTileSet::TFlagBorder borderEdges[4][2];

			// For each edge
			for (uint edge=0; edge<4; edge++)
			{
				// Neighbor ?
				if (pTile->voisins[edge])
				{
					// Get the neighbor corner
					tileSetIndex pVoisinCorner[4];
					CTileSet::TFlagBorder pBorder[4][3];
					tileDesc pVoisinIndex;

					// Tile is filled ?
					if (GetBorderDesc (pTile->voisins[edge], pVoisinCorner, pBorder, &pVoisinIndex, bank, vectMesh, nelPatchChg, land))
					{
						// Neighbor edge
						int neigborEdge = (2+edge+pTile->rotate[edge])&3;

						// Copy the tiles
						tileSetCases[edge][edge] = pVoisinCorner[(neigborEdge+1)&3];
						tileSetCases[edge][edge].Rotate -= pTile->rotate[edge];
						tileSetCases[edge][edge].Rotate &= 3;
						tileSetCases[edge][(edge+1)&3] = pVoisinCorner[neigborEdge];
						tileSetCases[edge][(edge+1)&3].Rotate -= pTile->rotate[edge];
						tileSetCases[edge][(edge+1)&3].Rotate &= 3;

						// Change the rotation

						// Get the transition used
						for (uint subTile=0; subTile<2; subTile++)
						{
							// Tileset
							int slot=getLayer (pTile, edge, pVoisinCorner[(neigborEdge+subTile)&3].TileSet, (pVoisinCorner[(neigborEdge+subTile)&3].Rotate - pTile->rotate[edge])&3, vectMesh, land);

							// Should be found
							nlassert (slot>=0);

							// Get the border
							borderEdges[edge][1-subTile] = CTileSet::getInvertBorder (pBorder[neigborEdge][slot]);
						}
					}
				}
			}

			// Make the final corner descriptor
			tileSetIndex finalCorner[4];
			for (uint corner=0; corner<4; corner++)
			{
				finalCorner[corner].TileSet = -1;
				
				// All the same or empty ?
				for (uint layer=0; layer<4; layer++)
				{
					// Compatible ?
					if ( ( finalCorner[corner].TileSet == -1 ) 
						|| ( tileSetCases[layer][corner].TileSet == -1 ) 
						|| ( tileSetCases[layer][corner] == finalCorner[corner] ) )
					{
						// Copy the tile
						if ( tileSetCases[layer][corner].TileSet  != -1 )
							finalCorner[corner] = tileSetCases[layer][corner];
					}
					else
					{
						// Not compatible
						return false;
					}
				}

				// Empty ?
				if (finalCorner[corner].TileSet == -1)
				{
					// New tileSet
					finalCorner[corner].TileSet = tileSet;
					finalCorner[corner].Rotate = curRotation;
				}
			}

			// Set of index
			std::vector<tileSetIndex> setIndex;

			// Set count
			for (uint v=0; v<4; v++)
			{
				// Should not be empty
				nlassert (finalCorner[v].TileSet!=-1);

				// Check for same tile with a +2 rotation
				bool bFind=false;

				for (int vv=0; vv<(int)setIndex.size(); vv++)
				{
					if (setIndex[vv].TileSet==finalCorner[v].TileSet)
					{
						tileSetIndex complet=finalCorner[v];
						complet.Rotate=(complet.Rotate+2)&3;
						if (setIndex[vv].Rotate==complet.Rotate)
							return false;
						if (finalCorner[v]==setIndex[vv])
							bFind=true;
					}
				}
				
				// no, ok push it back.
				if (!bFind)
					setIndex.push_back (finalCorner[v]);
			}

			// Sort the tile set
			std::sort (setIndex.begin(), setIndex.end());

			// Check for more than 3 materials
			if (setIndex.size()>3)
				return false;

			// Count materiaux
			tileIndex finalIndex[3];
			finalIndex[0].Tile=0;
			finalIndex[1].Tile=0;
			finalIndex[2].Tile=0;

			// For each layer
			for (int l=0; l<(int)setIndex.size(); l++)
			{
				if (l==0)
				{
					// Look for a tile without group
					finalIndex[l].Tile=selectTile (setIndex[l].TileSet, false, false, 0, bank);
					finalIndex[l].Rotate=(setIndex[l].Rotate&3);
				}
				else
				{
					// The 4 borders
					CTileSet::TFlagBorder border[4];

					// Corner filled or not
					bool bFilled[4];
					for (int c=0; c<4; c++)
						bFilled[c]=!(finalCorner[c]<setIndex[l]);

					// Fill the edge
					for (uint e=0; e<4; e++)
					{
						// Two filled ?
						if (bFilled[e] && bFilled[(e+1)&3])
							border[e]=CTileSet::_1111;
						else if ( (!bFilled[e]) && (!bFilled[(e+1)&3]) )
							border[e]=CTileSet::_0000;
						else
						{
							// Found
							bool found = false;

							// Get neighbor edge
							if (pTile->voisins[e])
							{
								// Filled corner
								uint filledCorner = bFilled[e]?e:(e+1)&3;

								// Get the neighbor corner
								tileSetIndex pVoisinCorner[4];
								CTileSet::TFlagBorder pBorder[4][3];
								tileDesc pVoisinIndex;

								// Tile is filled ?
								if (GetBorderDesc (pTile->voisins[e], pVoisinCorner, pBorder, &pVoisinIndex, bank, vectMesh, nelPatchChg, land))
								{
									// Neighbor edge
									int neigborEdge = (2+e+pTile->rotate[e])&3;

									// Get the slot
									int slot=getLayer (pTile, e, setIndex[l].TileSet, setIndex[l].Rotate, vectMesh, land);

									if ((slot != -1) && (pBorder[neigborEdge][slot] != CTileSet::dontcare))
									{
										// Invert the border
										border[e]=CTileSet::getInvertBorder (pBorder[neigborEdge][slot]);

										// Found it
										found = true;
									}
								}
							}

							// Found ?
							if ( !found )
							{
								// First filled ?
								if (bFilled[e])
									border[e]=CTileSet::_1000;
								else
									border[e]=CTileSet::_0001;
							}
						}
					}

					// Find the transitions
					const CTileSetTransition *tileTrans = FindTransition (setIndex[l].TileSet, setIndex[l].Rotate, border, bank);
					if (!tileTrans)
					{
						return false;
					}
					finalIndex[l].Rotate=(setIndex[l].Rotate&3);
					finalIndex[l].Tile=tileTrans->getTile();
				}
			}
			
			// Set the border desc
			tileDesc desc;
			GetTile (pTile->Mesh, pTile->tile, desc, vectMesh, land);
			switch (setIndex.size())
			{
			case 1:
				desc.setTile (1, 0, desc.getDisplace (), finalIndex[0], tileIndex (0,0), tileIndex (0,0));
				break;
			case 2:
				desc.setTile (2, 0, desc.getDisplace (), finalIndex[0], finalIndex[1], tileIndex (0,0));
				break;
			case 3:
				desc.setTile (3, 0, desc.getDisplace (), finalIndex[0], finalIndex[1], finalIndex[2]);
				break;
			default:
				nlassert (0);		// no!
				break;
			}
			SetTile (pTile->Mesh, pTile->tile, desc, vectMesh, land, nelPatchChg, NULL);

		}
		else
		{
			// Can't pos 256 transition tile
			return false;
		}
	}

	return true;
}

/*-------------------------------------------------------------------*/

void EPM_PaintMouseProc::PutADisplacetile ( EPM_PaintTile* pTile, const CTileBank& bank, 
								   std::vector<EPM_Mesh>& vectMesh, 
								   CLandscape* land, CNelPatchChanger& nelPatchChg)
{
	// Get tile description
	tileDesc desc;
	GetTile (pTile->Mesh, pTile->tile, desc, vectMesh, land);

	// Get the info about this tile
	int tileSet;
	int number;
	CTileBank::TTileType type;
	int tile=desc.getLayer (0).Tile;
	if ((tile>=0)&&(tile<bank.getTileCount ()))
	{
		bank.getTileXRef (tile, tileSet, number, type);

		// Pointer on the tileset
		const CTileSet *pTileSet=bank.getTileSet (tileSet);

		// Set the new displacement map
		desc.setDisplace (pobj->DisplaceTile);
		SetTile (pTile->Mesh, pTile->tile, desc, vectMesh, land, nelPatchChg, NULL, true, true);
	}
}

/*-------------------------------------------------------------------*/

bool EPM_PaintMouseProc::GetBorderDesc (EPM_PaintTile* tile, tileSetIndex *pVoisinCorner, CTileSet::TFlagBorder pBorder[4][3], 
										tileDesc *pVoisinIndex, const CTileBank& bank, std::vector<EPM_Mesh>& vectMesh, 
										CNelPatchChanger& nelPatchChg, CLandscape *land)
{
	// Tile info
	tileDesc backup;
	GetTile (tile->Mesh, tile->tile, backup, vectMesh, land);
	if (backup.isEmpty())
		return false;

	int nLayer=backup.getNumLayer ();
	tileIndex pIndexx[3];
	for (int nL=0; nL<nLayer; nL++)
	{
		// GetTileIndex 
		tileIndex index=backup.getLayer (nL);
		pIndexx[nL]=index;

		// Get layer info from base
		int tileSet;
		int number;
		CTileBank::TTileType type;

		if ((int)index.Tile>=bank.getTileCount())
		{
			WarningInvalidTileSet ();
			return false;	// Problem in tile info. Wrong tileSet ?
		}

		bank.getTileXRef (index.Tile, tileSet, number, type);

		// For each edge
		for (int i=0; i<4; i++)
		{
			// Border type
			CTileSet::TBorder toBorder[4]={CTileSet::left, CTileSet::bottom, CTileSet::right, CTileSet::top};
			CTileSet::TFlagBorder border=CTileSet::_1111;
			if (type==CTileBank::transition)
				border=CTileSet::getOrientedBorder (toBorder[i], CTileSet::getEdgeType ((CTileSet::TTransition)number, toBorder[i]));

			if (nL==0)
			{
				//nlassert (border==CTileSet::_1111);
				if (border!=CTileSet::_1111)
				{
					WarningInvalidTileSet ();
					return false;	// Problem in tile info. Wrong tileSet ?
				}
			}

			// Setup corner
			switch (border)
			{
			case CTileSet::_1111:
			case CTileSet::_1110:
			case CTileSet::_1000:
				pVoisinCorner[(i+backup.getLayer(nL).Rotate)&3].TileSet=tileSet;
				pVoisinCorner[(i+backup.getLayer(nL).Rotate)&3].Rotate=index.Rotate;
				break;
			}

			// Store border
			pBorder[(i+backup.getLayer(nL).Rotate)&3][nL]=border;
		}
	}

	pVoisinIndex->setTile (nLayer, backup.getCase(), backup.getDisplace(), pIndexx[0], pIndexx[1], pIndexx[2]);

	return true;
}

/*-------------------------------------------------------------------*/

const CTileSetTransition* EPM_PaintMouseProc::FindTransition (int nTileSet, int nRotate, const CTileSet::TFlagBorder *border, const CTileBank& bank)
{
	// Convert border to tile format
	CTileSet::TFlagBorder pBorderConverted[4];
	for (int i=0; i<4; i++)
	{
		CTileSet::TBorder toBorder[4]={CTileSet::left, CTileSet::bottom, CTileSet::right, CTileSet::top};
		pBorderConverted[i]=CTileSet::getOrientedBorder (toBorder[i], border[(i+nRotate)&3]);
	}

	// Look for good tile..
	CTileSet::TTransition nTransition=CTileSet::getTransitionTile 
		(pBorderConverted[3], pBorderConverted[1], pBorderConverted[0], pBorderConverted[2]);
	//nlassert (nTransition!=CTileSet::notfound);
	if (nTransition==CTileSet::notfound)
		return NULL;

	// Tile description
	return bank.getTileSet (nTileSet)->getTransition (nTransition);
}

/*-------------------------------------------------------------------*/

int EPM_PaintMouseProc::getLayer (EPM_PaintTile* tile, int border, int tileSet, int rotate, std::vector<EPM_Mesh>& vectMesh, CLandscape *land)
{
	int nLayer=-1;
	tileDesc desc;
	GetTile (tile->voisins[border]->Mesh, tile->voisins[border]->tile, desc, vectMesh, land);
	for (int o=0; o<desc.getNumLayer(); o++)
	{
		tileIndex index=desc.getLayer(o);
		index.Rotate-=tile->rotate[border];
		index.Rotate&=3;
		
		CTileBank::TTileType type;
		int TileSet, number;

		if ((int)index.Tile<bank.getTileCount())
		{
			bank.getTileXRef (index.Tile, TileSet, number, type);
			if ((TileSet==tileSet)&&(index.Rotate==rotate))
				nLayer=o;
		}
	}

	return nLayer;
}

/*-------------------------------------------------------------------*/

bool EPM_PaintMouseProc::PropagateBorder (EPM_PaintTile* tile, int curRotation, int curTileSet, std::set<EPM_PaintTile*>& visited, 
										  const CTileBank& bank, std::vector<EPM_Mesh>& vectMesh, 
										  CLandscape* land, CNelPatchChanger& nelPatchChg, std::vector<CBackupValue>& backupStack, bool recurseNoDiff)
{
	// 1) Already visited
	if (visited.find (tile)!=visited.end())
		return true;

	// Frozen ?
	/* if (vectMesh[tile->Mesh].Node->IsFrozen())
		return true;*/

	// Big trick
	if (pobj->TileTrick)
		return true;

	// 3) Backup tile
	tileDesc backup;
	GetTile (tile->Mesh, tile->tile, backup, vectMesh, land);

	// 2) Tile empty
	if (backup.isEmpty())
		return true;

	// *** Clip select patch
	// Patch number
	int patch=tile->tile/NUM_TILE_SEL;

	// Check if we are in patch subobject and if this patch is selected
	if ((vectMesh[tile->Mesh].PMesh->selLevel==EP_PATCH)&&(!vectMesh[tile->Mesh].PMesh->patchSel[patch]))
		return false;

	// 3) Add to visited tiles
	visited.insert (tile);

	// 4) 256 ?
	bool _256=(backup.getCase()>0);

	// Corner type
	bool bModified[4]=
	{
		false,
		false,
		false,
		false
	};
	// Corner type
	bool bTouched[4]=
	{
		false,
		false,
		false,
		false
	};
	bool bSameEdge[4]=
	{
		true,
		true,
		true,
		true
	};
	bool bVisited[4]=
	{
		false,
		false,
		false,
		false
	};
	int extraOrdinary[4]=
	{
		0,
		0,
		0,
		0
	};
	int extraOrdinarySmallEdge[4]=
	{
		0,
		0,
		0,
		0
	};
	tileSetIndex nCorner[4];
	int i;
	for (i=0; i<4; i++)
		nCorner[i].TileSet=-1;
	CTileSet::TFlagBorder nBorder[4][3];
	tileDesc pIndex;
	bool bFill=GetBorderDesc (tile, nCorner, nBorder, &pIndex, bank, vectMesh, nelPatchChg, land);
	//nlassert (bFill);	// Problem in tile info. Wrong tileSet ?
	if (!bFill)
	{
		WarningInvalidTileSet ();
		return false;
	}
	bool bDiff=false;

	// For each voisin
	int v;
	for (v=0; v<4; v++)
	{
		// Voisin already visited ?
		if (tile->voisins[v])
		{
			// ok.. already visited, so copy border
			tileSetIndex pVoisinCorner[4];
			CTileSet::TFlagBorder pBorder[4][3];
			tileDesc pVoisinIndex;
			bFill=GetBorderDesc (tile->voisins[v], pVoisinCorner, pBorder, &pVoisinIndex, bank, vectMesh, nelPatchChg, land);
			if (bFill)
			{
				int edge=(2+v+tile->rotate[v])&3;

				// Already visited or frozen ?
				if ((visited.find (tile->voisins[v])!=visited.end()) /*|| (vectMesh[tile->voisins[v]->Mesh].Node->IsFrozen())*/)
				{
					bVisited[v]=true;
					pVoisinCorner[(edge+1)&3].Rotate-=tile->rotate[v];
					pVoisinCorner[(edge+1)&3].Rotate&=3;
					pVoisinCorner[edge].Rotate-=tile->rotate[v];
					pVoisinCorner[edge].Rotate&=3;
					if (bTouched[v])
					{
						if (nCorner[v]!=pVoisinCorner[(edge+1)&3])
						{
							// Check if it is a valid corner
							int delta=(pVoisinCorner[(edge+1)&3].Rotate-nCorner[v].Rotate)&3;
							if (delta != 2)
							{
								if (nCorner[v]<pVoisinCorner[(edge+1)&3])
								{
									nCorner[v]=pVoisinCorner[(edge+1)&3];
									extraOrdinarySmallEdge[v]=(v-1)&3;
								}
								else
									extraOrdinarySmallEdge[v]=v;
							}
							else
							{
								// Bad corner
								return false;
							}
							extraOrdinary[v]++;
							bDiff=true;
						}					
					}
					else
					{
						if (nCorner[v]!=pVoisinCorner[(edge+1)&3])
						{
							nCorner[v]=pVoisinCorner[(edge+1)&3];
							bDiff=true;
							bModified[v]=true;
						}
						bTouched[v]=true;
					}
					int nNextCorner=(v+1)&3;
					if (bTouched[nNextCorner])
					{
						if (nCorner[nNextCorner]!=pVoisinCorner[edge])
						{
							// Check if it is a valid corner
							int delta=(pVoisinCorner[edge].Rotate-nCorner[nNextCorner].Rotate)&3;
							if (delta != 2)
							{
								if (nCorner[nNextCorner]<pVoisinCorner[edge])
								{
									nCorner[nNextCorner]=pVoisinCorner[edge];
									extraOrdinarySmallEdge[nNextCorner]=nNextCorner;
								}
								else
									extraOrdinarySmallEdge[nNextCorner]=v;
							}
							else
							{
								// Bad corner
								return false;
							}
							extraOrdinary[nNextCorner]++;
							bDiff=true;
						}
					}
					else
					{
						if (nCorner[nNextCorner]!=pVoisinCorner[edge])
						{
							nCorner[nNextCorner]=pVoisinCorner[edge];
							bDiff=true;
							bModified[nNextCorner]=true;
						}
						bTouched[nNextCorner]=true;
					}
				}
			}
		}
	}

	// Frozen ?
	bool _isLocked = isLocked (pobj, tile);

	// Force to visite tile in the same 256 in 256 mode..
	if (_256 && !tile->frozen)
	{
		// Case number
		int nCase=backup.getCase()-1;
		int nRotate=backup.getLayer(0).Rotate;
		nlassert (nCase>=0);
		nlassert (nCase<4);

		// Flag the voisin to force the visite
		EPM_PaintTile* other=tile->voisins[(1+nCase+nRotate)&3];
		if (other)
		{
			int	rot=tile->rotate[(1+nCase+nRotate)&3];
			tileDesc desc1;
			GetTile (other->Mesh, other->tile, desc1, vectMesh, land);
			if (!desc1.isEmpty())
			{
				if (
					(desc1.isEmpty())||
					(desc1.getCase()!=(1+((nCase+1)&3)))||
					(desc1.getLayer(0).Tile!=backup.getLayer(0).Tile)||
					(desc1.getLayer(0).Rotate!=((backup.getLayer(0).Rotate-rot)&3))
					)
					bDiff=true;
			}
			else
				bDiff=true;

			if (isLocked (pobj, other))
				_isLocked = true;
		}

		other=tile->voisins[(2+nCase+nRotate)&3];
		if (other)
		{
			int rot=tile->rotate[(2+nCase+nRotate)&3];
			tileDesc desc1;
			GetTile (other->Mesh, other->tile, desc1, vectMesh, land);
			if (!desc1.isEmpty())
			{
				if (
					(desc1.isEmpty())||
					(desc1.getCase()!=(1+((nCase+3)&3)))||
					(desc1.getLayer(0).Tile!=backup.getLayer(0).Tile)||
					(desc1.getLayer(0).Rotate!=((backup.getLayer(0).Rotate-rot)&3))					
					)
					bDiff=true;
			}
			else
				bDiff=true;

			if (isLocked (pobj, other))
				_isLocked = true;
		}
	}

	// C) Invalide tile (same tile and rotation only on the diagonal)
	for (i=0; i<2; i++)
	{
		if ((nCorner[i]==nCorner[(i+2)&3])&&
			(nCorner[(i+1)&3]!=nCorner[(i+2)&3])&&
			(nCorner[(i+3)&3]!=nCorner[(i+2)&3]))
		{
			return false;
		}
	}

	// Same edge ?
	for (v=0; v<4; v++)
	{
		if (tile->voisins[v]==NULL)
			bSameEdge[v]=false;
		else
		{
			tileDesc desc;
			GetTile (tile->voisins[v]->Mesh, tile->voisins[v]->tile, desc, vectMesh, land);
			if (bModified[v]||
				bModified[(v+1)&3]||
				(desc.isEmpty()))
				bSameEdge[v]=false;
		}
	}

	if ((!bDiff)&&pIndex.getNumLayer()==1)
		return true;

	// Frozen or locked ?
	if (tile->frozen || _isLocked)
		return false;

	// Count materiaux
	//set<tileSetIndex> setIndex;
	std::vector<tileSetIndex> setIndex;

	// Set count
	for (v=0; v<4; v++)
	{
		nlassert (nCorner[v].TileSet!=-1);
		// B) Check for same tile with a +2 rotation
		bool bFind=false;

		for (int vv=0; vv<(int)setIndex.size(); vv++)
		{
			if (setIndex[vv].TileSet==nCorner[v].TileSet)
			{
				tileSetIndex complet=nCorner[v];
				complet.Rotate=(complet.Rotate+2)&3;
				if (setIndex[vv].Rotate==complet.Rotate)
					return false;
				if (nCorner[v]==setIndex[vv])
					bFind=true;
			}
		}
		
		// no, ok push it back.
		if (!bFind)
			setIndex.push_back (nCorner[v]);
	}

	std::sort (setIndex.begin(), setIndex.end());

	// Check validity
	
	// A) Check for more than 3 materials
	if (setIndex.size()>3)
		return false;

	// Count materiaux
	std::vector<tileSetIndex>::iterator ite=setIndex.begin();
	tileIndex finalIndex[3];
	finalIndex[0].Tile=0;
	finalIndex[1].Tile=0;
	finalIndex[2].Tile=0;

	// Look for a tile resolving the constraints
	// Fill ?
	for (int l=0; l<(int)setIndex.size(); l++)
	{
		if (l==0)
		{
			// Filled, choose a random tile

			// Get tge tileSet
			// TileSet
			const CTileSet *TileSet=bank.getTileSet (ite->TileSet);

			// Select group
			int group=0;
			int nTile=-1;

			if (backup.getNumLayer ()==1)
			{
				// Get information about the tileSet
				int tileSet;
				int number;
				CTileBank::TTileType type;

				// Get XRef
				bank.getTileXRef (backup.getLayer (0).Tile, tileSet, number, type);

				// Check if it is the same tileSet
				if (tileSet==ite->TileSet)
				{
					// Get the group flags
					uint flags=bank.getTile (backup.getLayer (0).Tile)->getGroupFlags ();
					for (int f=0; f<32; f++)
					{
						// Group ?
						if (flags&(1<<f))
						{
							// Try to get a tile from this group
							nTile=selectTile (ite->TileSet, false, false, f+1, bank);

							// Find a tile ?
							if (nTile!=-1)
								break;
						}
					}
				}
			}

			// A tile as been found ?
			if (nTile==-1)
				// Look for a tile without group
				nTile=selectTile (ite->TileSet, false, false, 0, bank);

			// Set the tile slot
			finalIndex[0].Tile=nTile;
			finalIndex[0].Rotate=(ite->Rotate&3);
		}
		else
		{
			// Transition, choose the good tile

			// Get tge tileSet
			// TileSet
			// Borders
			CTileSet::TFlagBorder border[4];

			bool bFilled[4];
			int c;
			for (c=0; c<4; c++)
				bFilled[c]=!(nCorner[c]<*ite);

			for (c=0; c<4; c++)
			{
				if (bFilled[c])
				{
					if (bFilled[(c+1)&3])
						border[c]=CTileSet::_1111;
					else
					{
						// If extraordinary vertex and the small edge
						if ((extraOrdinary[c])&&(extraOrdinarySmallEdge[c]==c))
						{
							border[c]=CTileSet::_1000;
						}
						// If 3 mat, use a 3/4 border
						else if (setIndex.size()==3)
						{
							CTileSet::TFlagBorder wanted;
							CTileSet::TFlagBorder invWanted;

							// Last on the stack ?
							if (*ite<nCorner[c])
							{
								// no, 
								wanted=CTileSet::_1000;
								invWanted=CTileSet::_1110;
							}
							else
							{
								// yes, 
								wanted=CTileSet::_1110;
								invWanted=CTileSet::_1000;
							}
							border[c]=wanted;
							
							// If voisin already visited, force his transition to 3/4
							if (tile->voisins[c])
							{
								tileSetIndex pVoisinCorner[4];
								CTileSet::TFlagBorder pBorder[4][3];
								tileDesc pVoisinIndex;
								if (GetBorderDesc (tile->voisins[c], pVoisinCorner, pBorder, &pVoisinIndex, bank, vectMesh, nelPatchChg, land))
								{
									// Find the good layer in the dest tileDesc
									int nLayer=getLayer (tile, c, ite->TileSet, ite->Rotate, vectMesh, land);

									if (nLayer!=-1)
									{
										int edge=(2+c+tile->rotate[c])&3;
										if (pBorder[edge][nLayer]==CTileSet::getInvertBorder (invWanted))
										{
											pBorder[edge][nLayer]=CTileSet::getInvertBorder (wanted);

											// Voisin tile set
											CTileSet::TFlagBorder newBorder[4];
											for (int nB=0; nB<4; nB++)
												newBorder[nB]=pBorder[nB][nLayer];

											const CTileSetTransition* pTile=FindTransition (ite->TileSet, ite->Rotate+tile->rotate[c], newBorder, bank);
											if (!pTile)
											{
												WarningInvalidTileSet ();
												return false;
											}
											pVoisinIndex.getLayer(nLayer).Tile=pTile->getTile();

											// Is frozen ?
											if (tile->voisins[c]->frozen)
												// Yes, can't change it!
												return false;

											// Is locked ?
											if (isLocked (pobj, tile->voisins[c]))
												return false;

											// Set the tile..
											SetTile (tile->voisins[c]->Mesh, tile->voisins[c]->tile, pVoisinIndex, vectMesh, 
												land, nelPatchChg, &backupStack);
										}
										/*if (pBorder[edge][nLayer]==CTileSet::_0001)
											border[c]=CTileSet::_1000;*/
									}
									/*else
										border[c]=CTileSet::_1000;*/
								}
							}
						}
						// Normal, 
						else
						{
							// Voisin visited or frozen ?
							if (tile->voisins[c]&&((visited.find (tile->voisins[c])!=visited.end()) /*|| 
								(vectMesh[tile->voisins[c]->Mesh].Node->IsFrozen())*/ ))
							{
								// Yes, visited. Copy the border
								tileSetIndex pVoisinCorner[4];
								CTileSet::TFlagBorder pBorder[4][3];
								tileDesc pVoisinIndex;
								bool bOk=GetBorderDesc (tile->voisins[c], pVoisinCorner, pBorder, &pVoisinIndex, bank, vectMesh, nelPatchChg, land);
								
								// Should not be empty
								nlassert (bOk);
								int edge=(2+c+tile->rotate[c])&3;

								// Should have one of the following transition
								int nLayer=getLayer (tile, c, ite->TileSet, ite->Rotate, vectMesh, land);
								if (nLayer!=-1)
								{
									nlassert ((pBorder[edge][nLayer]==CTileSet::_0111)||(pBorder[edge][nLayer]==CTileSet::_0001));
								}

								// Copy inverted!
								border[c]=CTileSet::getInvertBorder (pBorder[edge][nLayer]);
							}
							else
							{
								// No, not yet visited
								
								// Choose transition by random
								bool bComputed=false;
								if ((bVisited[c]||!recurseNoDiff)&&bSameEdge[c])
								{
									bSameEdge[c]=false;
									// Yes, visited. Copy the border of the voisin
									tileSetIndex pVoisinCorner[4];
									CTileSet::TFlagBorder pBorder[4][3];
									tileDesc pVoisinIndex;
									bool bOk=GetBorderDesc (tile->voisins[c], pVoisinCorner, pBorder, &pVoisinIndex, bank, vectMesh, nelPatchChg, land);
								
									// ok voisin is here ?
									if (bOk)
									{
										// edge in the voisin
										int edge=(2+c+tile->rotate[c])&3;

										// layer where to find transition in the voisin
										int nLayer=getLayer (tile, c, ite->TileSet, ite->Rotate, vectMesh, land);

										// transition ok?
										if ((pBorder[edge][nLayer]==CTileSet::_0111)||(pBorder[edge][nLayer]==CTileSet::_0001))
										{
											// copy!
											border[c]=CTileSet::getInvertBorder (pBorder[edge][nLayer]);
											bSameEdge[c]=true;
											bComputed=true;
										}
									}
								}
								// No transition computed, random
								if (!bComputed)
								{
									bSameEdge[c]=false;
									if (rand()&1)
										border[c]=CTileSet::_1000;
									else
										border[c]=CTileSet::_1110;
								}
							}
						}
					}
				}
				else
				{
					int nNextCorner=(c+1)&3;
					if (!bFilled[nNextCorner])
						border[c]=CTileSet::_0000;
					else
					{
						// If extraordinary vertex and the small edge
						if ((extraOrdinary[nNextCorner])&&(extraOrdinarySmallEdge[nNextCorner]==c))
						{
							border[c]=CTileSet::_0001;
						}
						// If 3 mat, use a 3/4 border
						else if (setIndex.size()==3)
						{
							CTileSet::TFlagBorder wanted;
							CTileSet::TFlagBorder invWanted;

							// Last on the stack ?
							if (*ite<nCorner[c])
							{
								// no, 
								wanted=CTileSet::_0001;
								invWanted=CTileSet::_0111;
							}
							else
							{
								// yes, 
								wanted=CTileSet::_0111;
								invWanted=CTileSet::_0001;
							}
							border[c]=wanted;
							
							// If voisin already visited, force his transition to 3/4
							if (tile->voisins[c])//&&visited.find (tile->voisins[c])!=visited.end())
							{
								tileSetIndex pVoisinCorner[4];
								CTileSet::TFlagBorder pBorder[4][3];
								tileDesc pVoisinIndex;
								if (GetBorderDesc (tile->voisins[c], pVoisinCorner, pBorder, &pVoisinIndex, bank, vectMesh, nelPatchChg, land))
								{
									// Find the good layer in the dest tileDesc
									int nLayer=getLayer (tile, c, ite->TileSet, ite->Rotate, vectMesh, land);

									if (nLayer!=-1)
									{
										int edge=(2+c+tile->rotate[c])&3;
										if (pBorder[edge][nLayer]==CTileSet::getInvertBorder (invWanted))
										{
											pBorder[edge][nLayer]=CTileSet::getInvertBorder (wanted);

											// Voisin tile set
											CTileSet::TFlagBorder newBorder[4];
											for (int nB=0; nB<4; nB++)
												newBorder[nB]=pBorder[nB][nLayer];

											const CTileSetTransition* pTile=FindTransition (ite->TileSet, ite->Rotate+tile->rotate[c], newBorder, bank);
											if (!pTile)
											{
												WarningInvalidTileSet ();
												return false;
											}
											pVoisinIndex.getLayer(nLayer).Tile=pTile->getTile();

											// Is frozen ?
											if (tile->voisins[c]->frozen)
												// Yes, can't change it!
												return false;

											// Is locked ?
											if (isLocked (pobj, tile->voisins[c]))
												return false;

											// Set the tile..
											SetTile (tile->voisins[c]->Mesh, tile->voisins[c]->tile, pVoisinIndex, vectMesh, 
												land, nelPatchChg, &backupStack);
										}
										/*if (pBorder[edge][nLayer]==CTileSet::_1000)
											border[c]=CTileSet::_0001;*/
									}
									/*else
										border[c]=CTileSet::_0001;*/
								}
							}

						}
						// Normal, 
						else
						{
							// Voisin visited ?
							if ((tile->voisins[c])&& ((visited.find (tile->voisins[c])!=visited.end()) /*|| (vectMesh[tile->voisins[c]->Mesh].Node->IsFrozen())*/) )
							{
								// Yes, visited. Copy the border
								tileSetIndex pVoisinCorner[4];
								CTileSet::TFlagBorder pBorder[4][3];
								tileDesc pVoisinIndex;
								bool bOk=GetBorderDesc (tile->voisins[c], pVoisinCorner, pBorder, &pVoisinIndex, bank, vectMesh, nelPatchChg, land);
								
								// Should not be empty
								nlassert (bOk);
								int edge=(2+c+tile->rotate[c])&3;

								// Should have one of the following transition
								// Find the layer of the tile..
								int nLayer=getLayer (tile, c, ite->TileSet, ite->Rotate, vectMesh, land);
								if (nLayer!=-1)
								{
									nlassert ((pBorder[edge][nLayer]==CTileSet::_1110)||(pBorder[edge][nLayer]==CTileSet::_1000));
								}

								// Copy inverted!
								border[c]=CTileSet::getInvertBorder (pBorder[edge][nLayer]);
							}
							else
							{
								// No, not yet visited
								
								// Choose transition by random
								bool bComputed=false;
								if ((bVisited[c]||!recurseNoDiff)&&bSameEdge[c])
								{
									bSameEdge[c]=false;
									// Yes, visited. Copy the border of the voisin
									tileSetIndex pVoisinCorner[4];
									CTileSet::TFlagBorder pBorder[4][3];
									tileDesc pVoisinIndex;
									bool bOk=GetBorderDesc (tile->voisins[c], pVoisinCorner, pBorder, &pVoisinIndex, bank, vectMesh, nelPatchChg, land);
								
									// ok voisin is here ?
									if (bOk)
									{
										// edge in the voisin
										int edge=(2+c+tile->rotate[c])&3;

										// layer where to find transition in the voisin
										int nLayer=getLayer (tile, c, ite->TileSet, ite->Rotate, vectMesh, land);

										// transition ok?
										if ((pBorder[edge][nLayer]==CTileSet::_1110)||(pBorder[edge][nLayer]==CTileSet::_1000))
										{
											// copy!
											border[c]=CTileSet::getInvertBorder (pBorder[edge][nLayer]);
											bSameEdge[c]=true;
											bComputed=true;
										}
									}
								}
								// No transition computed, random
								if (!bComputed)
								{
									bSameEdge[c]=false;
									if (rand()&1)
										border[c]=CTileSet::_0001;
									else
										border[c]=CTileSet::_0111;
								}
							}
						}
					}
				}
			}

			// ok, find the good transition..
			const CTileSetTransition* pTile=FindTransition (ite->TileSet, ite->Rotate, border, bank);
			if (!pTile)
			{
				WarningInvalidTileSet ();
				return false;
			}
			finalIndex[l].Rotate=ite->Rotate;
			finalIndex[l].Tile=pTile->getTile();
		}
		ite++;
	}
	
	// Set the border desc
	tileDesc desc;
	GetTile (tile->Mesh, tile->tile, desc, vectMesh, land);
	switch (setIndex.size())
	{
	case 1:
		desc.setTile (1, 0, desc.getDisplace (), finalIndex[0], tileIndex (0,0), tileIndex (0,0));
		break;
	case 2:
		desc.setTile (2, 0, desc.getDisplace (), finalIndex[0], finalIndex[1], tileIndex (0,0));
		break;
	case 3:
		desc.setTile (3, 0, desc.getDisplace (), finalIndex[0], finalIndex[1], finalIndex[2]);
		break;
	default:
		nlassert (0);		// no!
		break;
	}
	SetTile (tile->Mesh, tile->tile, desc, vectMesh, land, nelPatchChg, &backupStack);

	// Force to visite tile in the same 256 in 256 mode..
	if (_256)
	{
		// Case number
		int nCase=backup.getCase()-1;
		int nRotate=backup.getLayer(0).Rotate;
		nlassert (nCase>=0);
		nlassert (nCase<4);

		// Flag the voisin to force the visite
		bSameEdge[(1+nCase+nRotate)&3]=false;
		bSameEdge[(2+nCase+nRotate)&3]=false;
	}

	// ** For all voisin tiles not visited on a border with modified corners :

	// Idem ?
	if ((!bDiff)&&(!recurseNoDiff))
		return true;

	bool bContinue=true;

	// For each voisin
	for (v=0; v<4; v++)
	{
		// Voisin not already visited and not frozen ?
		if ((tile->voisins[v]) && (visited.find (tile->voisins[v])==visited.end()) /* && (vectMesh[tile->voisins[v]->Mesh].Node->IsFrozen()==0)*/)
		{	
			// ok.. not visited, border with modified corner ?
			if (bModified[v]||bModified[(v+1)&3]||(!bSameEdge[v]))
			if (!PropagateBorder (tile->voisins[v], (tile->rotate[v]+curRotation)&3, curTileSet, visited, bank, vectMesh, land, nelPatchChg, 
									backupStack, false))
			{
				bContinue=false;
				break;
			}				
		}
	}
	if (!bContinue)
	{		
		return false;
	}
	
	return true;
}

/*-------------------------------------------------------------------*/

uint8 EPM_PaintMouseProc::CalcRotPath (EPM_PaintTile* from, EPM_PaintTile* to, int depth, int rotate, int& deltaX, int& deltaY, int& cost)
{
	static const int x[4]={-1, 0, 1, 0};
	static const int y[4]={0, 1, 0, -1};
	if (from==to)
	{
		cost=0;
		deltaX=0;
		deltaY=0;
		return 0;
	}
	if (depth>0)
	{
		uint8 ret=0xff;
		cost=1000000;
		int best;
		for (int i=0; i<4; i++)
		{
			if (from->voisins[i])
			{
				int myDeltaX;
				int myDeltaY;
				int myCost;
				int myRet=CalcRotPath (from->voisins[i], to, depth-1, (from->rotate[i]+rotate)&3, myDeltaX, myDeltaY, myCost);
				if (myRet!=0xff)
				{
					myDeltaX+=x[(i+rotate)&3];
					myDeltaY+=y[(i+rotate)&3];
					myCost++;
					if (myCost<cost)
					{
						cost=myCost;
						deltaX=myDeltaX;
						deltaY=myDeltaY;
						best=i;
						ret=myRet;
					}
				}
			}
		}
		if (ret!=0xff)
			return (from->rotate[best]+ret)&3;
	}
	return 0xff;
}

/*-------------------------------------------------------------------*/

static TModePaint nModeTexture=ModeTile;
static TModeMouse modeSelect=ModePaint;

void EPM_PaintMouseProc::RecursTile (EPM_PaintTile* pTile, const CTileBank& bank, int tileSet, std::vector<EPM_Mesh>& vectMesh, CLandscape* land, 
									 int recurs, std::set<EPM_PaintTile*>& alreadyRecursed, bool first, int rotation, 
									 CNelPatchChanger& nelPatchChg, bool _256)
{
	if (alreadyRecursed.find (pTile)==alreadyRecursed.end())
	{
		alreadyRecursed.insert (pTile);
		std::set<EPM_PaintTile*> visited;

		// Mode displace ?
		if (nModeTexture==ModeDisplace)
			PutADisplacetile ( pTile, bank, vectMesh, land, nelPatchChg);
		else
			PutATile ( pTile, tileSet, rotation, bank, first, visited, vectMesh, land, nelPatchChg, _256);
	}

	// Call fill
	if (recurs>0)
	{
		for (int i=0; i<4; i++)
		{
			if (_256)
			{
				if (pTile->get2Voisin(i))
					RecursTile (pTile->get2Voisin(i), bank, tileSet, vectMesh, land, recurs-2, alreadyRecursed, false, 
						(rotation+pTile->get2VoisinRotate(i))&3, nelPatchChg, true);
			}
			else
			{
				if (pTile->voisins[i])
					RecursTile (pTile->voisins[i], bank, tileSet, vectMesh, land, recurs-1, alreadyRecursed, false, (rotation+pTile->rotate[i])&3, 
						nelPatchChg, false);
			}
		}
	}
}

BOOL EPM_PaintMouseProc::PutDisplace (int tile, int mesh, const CTileBank& bank, std::vector<EPM_Mesh>& vectMesh, CLandscape* land, 
								  int recurs, std::set<EPM_PaintTile*>& alreadyRecursed, CNelPatchChanger& nelPatchChg)
{
	static sint32 MeshOld=-1;
	static int	tileOld=-1;
	bool lost=false;

	EPM_PaintTile* pTile=&metaTile[mesh][tile];

	// Ok recurse tiles
	RecursTile (pTile, bank, 0, vectMesh, land, brushValue[PaintPatchMod::brushSize], alreadyRecursed, true, 
		EPM_PaintMouseProc::Rotation, nelPatchChg, false);

	MeshOld=mesh;
	tileOld=tile;

	return TRUE;
}

BOOL EPM_PaintMouseProc::PutTile (int tile, int mesh, bool first, const CTileBank& bank, int tileSet, std::vector<EPM_Mesh>& vectMesh, CLandscape* land, 
								  int recurs, std::set<EPM_PaintTile*>& alreadyRecursed, CNelPatchChanger& nelPatchChg, bool _256)
{
	static sint32 MeshOld=-1;
	static int	tileOld=-1;
	bool lost=false;

	EPM_PaintTile* pTile=&metaTile[mesh][tile];

	alreadyRecursed.insert (pTile);
	if (first)
	{
		tileDesc desc;
		GetTile (pTile->Mesh, pTile->tile, desc, vectMesh, land);
		if (desc.isEmpty ())
			EPM_PaintMouseProc::Rotation=0;
		else
		{
			int i;
			for (i=0; i<desc.getNumLayer(); i++)
			{
				if ((sint)desc.getLayer (i).Tile==tile)
				{
					EPM_PaintMouseProc::Rotation=desc.getLayer (i).Rotate;
					break;
				}
			}
			if (i==desc.getNumLayer())
				EPM_PaintMouseProc::Rotation=desc.getLayer (0).Rotate;
		}
	}
	else
	{
		EPM_PaintTile* pOldTile=&metaTile[MeshOld][tileOld];
		int deltaX;
		int deltaY;
		int cost;
		uint8 deltaRot=CalcRotPath (pOldTile, pTile, DEPTH_SEARCH_MAX, 0, deltaX, deltaY, cost);

		if (deltaRot!=0xff)
		{
			EPM_PaintMouseProc::Rotation+=deltaRot;
			EPM_PaintMouseProc::Rotation&=3;
		}
		else
			lost=true;
	}

	if (!lost)
	{
		{
			std::set<EPM_PaintTile*> alreadyRecursed;

			// Ok recurse tiles
			RecursTile (pTile, bank, tileSet, vectMesh, land, brushValue[PaintPatchMod::brushSize], alreadyRecursed, first, 
				EPM_PaintMouseProc::Rotation, nelPatchChg, _256);
		}
		MeshOld=mesh;
		tileOld=tile;
	}

	return TRUE;
}

/*-------------------------------------------------------------------*/

int getOffset (int edge, int nU, int nV, bool symmetry)
{
	switch ((edge+(symmetry?1:0))&3)
	{
	case 0:
		return 0;
	case 1:
		return (nV-1)*MAX_TILE_IN_PATCH;
	case 2:
		return (nV-1)*MAX_TILE_IN_PATCH+nU-1;
	case 3:
		return nU-1;
	}
	nlassert (0);	//no!
	return 0;
}
/*int offset[4]={ 0, (nV-1)*MAX_TILE_IN_PATCH, (nV-1)*MAX_TILE_IN_PATCH+nU-1, nU-1 };
int offsetOther[4]={ 0, (nVOther-1)*MAX_TILE_IN_PATCH, (nVOther-1)*MAX_TILE_IN_PATCH+nUOther-1, nUOther-1 };*/

struct callThread
{
	callThread (std::vector<EPM_Mesh>&	vectMesh) : VectMesh (vectMesh) {}
	EPM_PaintMouseProc		*eproc;
	PaintPatchMod			*pobj;
	CVector					center;
	TimeValue				T;
	std::vector<EPM_Mesh>&	VectMesh;
};

void	mainproc(CScene& scene, CEventListenerAsync& AsyncListener, CEvent3dMouseListener& mouseListener, CLandscapeModel& landscape, IDriver& driver, callThread *pData, CPaintColor &paintColor)
{
	// Default mode is paint
	modeSelect=ModePaint;

	// Mode selection
	if (AsyncListener.isKeyDown ((TKey)PainterKeys[Select]))
		// Set mode
		modeSelect=ModeSelect;

	// Mode picking
	if (AsyncListener.isKeyDown ((TKey)PainterKeys[Pick]))
		// Set mode
		modeSelect=ModePick;

	// Mode picking
	if (AsyncListener.isKeyDown ((TKey)PainterKeys[GetState]))
		// Set mode
		modeSelect=ModeGetState;

	// Mode picking
	if (AsyncListener.isKeyDown ((TKey)PainterKeys[Fill0]))
	{
		// Set mode
		modeSelect=ModeFill;

		// Set fill rotation
		pData->pobj->TileFillRotation=0;
	}

	// Mode picking
	if (AsyncListener.isKeyDown ((TKey)PainterKeys[Fill1]))
		{
		// Set mode
		modeSelect=ModeFill;

		// Set fill rotation
		pData->pobj->TileFillRotation=1;
	}

	// Mode picking
	if (AsyncListener.isKeyDown ((TKey)PainterKeys[Fill2]))
		{
		// Set mode
		modeSelect=ModeFill;

		// Set fill rotation
		pData->pobj->TileFillRotation=2;
	}

	// Mode picking
	if (AsyncListener.isKeyDown ((TKey)PainterKeys[Fill3]))
		{
		// Set mode
		modeSelect=ModeFill;

		// Set fill rotation
		pData->pobj->TileFillRotation=3;
	}

	// Choose a color
	if ((AsyncListener.isKeyPushed ((TKey)PainterKeys[Select]))&&(nModeTexture==ModeColor))
		chooseAColor ();

	// Mode tile ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[MModeTile]))
		nModeTexture=ModeTile;

	// Mode color ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[MModeColor]))
		nModeTexture=ModeColor;

	// Mode displace ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[MModeDisplace]))
		nModeTexture=ModeDisplace;

	// Toggle couleur ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[ToggleColor]))
	{
		if (nModeTexture==ModeColor)
		{
			COLORREF tmp=color1;
			color1=color2;
			color2=tmp;
			float tmpF=opa1;
			opa1=opa2;
			opa2=tmpF;
			tmpF=hard1;
			hard1=hard2;
			hard2=tmpF;
		}
	}

	// Change brush ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[SizeDown]))
	{
		if ((nModeTexture==ModeTile)||(nModeTexture==ModeDisplace))
		{
			pData->pobj->brushSize--;
			if (pData->pobj->brushSize<0)
				pData->pobj->brushSize=0;
		}
		else if (nModeTexture==ModeColor)
		{
			pData->pobj->ColorBushSize--;
			if (pData->pobj->ColorBushSize<0)
				pData->pobj->ColorBushSize=0;
		}
	}

	// Change brush ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[SizeUp]))
	{
		if ((nModeTexture==ModeTile)||(nModeTexture==ModeDisplace))
		{
			pData->pobj->brushSize++;
			if (pData->pobj->brushSize>2)
				pData->pobj->brushSize=2;
		}
		else if (nModeTexture==ModeColor)
		{
			pData->pobj->ColorBushSize++;
			if (pData->pobj->ColorBushSize>COLOR_BRUSH_STEP)
				pData->pobj->ColorBushSize=COLOR_BRUSH_STEP;
		}
	}

	// Change size of tile ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[ToggleTileSize]))
	{
		pData->pobj->tileSize++;
		pData->pobj->tileSize&=1;
	}

	// Change group ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[GroupUp]))
	{
		pData->pobj->TileGroup++;
		if (pData->pobj->TileGroup>NL3D_CTILE_NUM_GROUP)
			pData->pobj->TileGroup=0;
	}

	// Change group ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[GroupDown]))
	{
		pData->pobj->TileGroup--;
		if (pData->pobj->TileGroup<0)
			pData->pobj->TileGroup=NL3D_CTILE_NUM_GROUP;
	}

	// Change background color ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[BackgroundColor]))
	{
		setBackgroundColor ();
	}

	// Toggle arrows ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[ToggleArrows]))
	{
		// Toggle
		pData->pobj->additiveTile^=true;

		// Go
		if (pData->pobj->additiveTile)
		{
			// Add a additive tile...
			int i;
			for (i=0; i<landscape.Landscape.TileBank.getTileCount(); i++)
			{
				landscape.Landscape.TileBank.getTile(i)->setFileName (CTile::additive, "arrow.tga");
				landscape.Landscape.releaseTiles(i, 1);
			}
		}
		else
		{
			// Copy original bank
			landscape.Landscape.TileBank = bank;

			// Add a additive tile...
			int i;
			for (i=0; i<landscape.Landscape.TileBank.getTileCount(); i++)
			{
				landscape.Landscape.releaseTiles(i, 1);
			}
		}

		// Touch all patches
		for (uint zone=0; zone<pData->VectMesh.size(); zone++)
		{
			// Get the zone
			CZone *pZone=landscape.Landscape.getZone (zone);
			if (pZone)
			{
				// For each patch
				uint numPatch=pZone->getNumPatchs();
				for (uint patch=0; patch<numPatch; patch++)
				{
					// Invalidate this patch
					pZone->changePatchTextureAndColor (patch, NULL, NULL);
					//pZone->refreshTesselationGeometry (patch);
				}
			}
		}
	}

	// Toggle automatic lighting ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[AutomaticLighting]))
	{
		// Toggle
		pData->pobj->automaticLighting^=true;

		// Enable / disable automatic lighting
		landscape.Landscape.enableAutomaticLighting (pData->pobj->automaticLighting);

		// Touch all patches
		for (uint zone=0; zone<pData->VectMesh.size(); zone++)
		{
			// Get the zone
			CZone *pZone=landscape.Landscape.getZone (zone);
			nlassert (pZone);

			// For each patch
			uint numPatch=pZone->getNumPatchs();
			for (uint patch=0; patch<numPatch; patch++)
			{
				// Invalidate this patch
				pZone->changePatchTextureAndColor (patch, NULL, NULL);
				pZone->refreshTesselationGeometry (patch);
			}
		}
	}


	// Toggle lock borders ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[LockBorders]))
	{
		// Toggle
		pData->pobj->lockBorders^=true;
	}

	// Select color brush ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[SelectColorBrush]))
	{
		// Create a dialog filter
		static char szFilter[] = 
			"Targa Files (*.tga)\0*.tga\0"
			"All Files (*.*)\0*.*\0\0";

		// Filename buffer
		char buffer[65535];
		buffer[0]=0;

		// Fill the (big) struct
		OPENFILENAME openFile;
		memset (&openFile, 0, sizeof (OPENFILENAME));
		openFile.lStructSize = sizeof (OPENFILENAME);
		openFile.hwndOwner = (HWND)CNELU::Driver->getDisplay();
		openFile.lpstrFilter = szFilter;
		openFile.nFilterIndex = 0;
		openFile.lpstrFile = buffer;
		openFile.nMaxFile = 65535;
		openFile.Flags = OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT|OFN_ENABLESIZING|OFN_EXPLORER;
		openFile.lpstrDefExt = "*.tga";

		// Open the dialog
		if (GetOpenFileName(&openFile))
		{		
			// Load the file
			paintColor.loadBrush (buffer);
			paintColor.setBrushMode (true);
		}
	}

	// Toggle brush mode ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[ToggleColorBrushMode]))
	{
		paintColor.setBrushMode (!paintColor.getBrushMode());
	}

	// Change hardness ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[HardnessUp]))
	{
		hard1+=0.2f;
		if (hard1>1.f)
			hard1=1.f;
	}

	// Change hardness ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[HardnessDown]))
	{
		hard1-=0.2f;
		if (hard1<0.f)
			hard1=0.f;
	}

	// Change opacity ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[OpacityUp]))
	{
		opa1+=0.2f;
		if (opa1>1.f)
			opa1=1.f;
	}

	// Change opacity ?
	if (AsyncListener.isKeyPushed ((TKey)PainterKeys[OpacityDown]))
	{
		opa1-=0.2f;
		if (opa1<0.f)
			opa1=0.f;
	}

	// Change hardness ?
	if (AsyncListener.isKeyDown ((TKey)PainterKeys[Zouille]))
		pData->pobj->TileTrick=true;
	else
		pData->pobj->TileTrick=false;

	// Set cursor
	if (modeSelect==ModeGetState)
		SetCursor (bankCont->HInspect);
	else if (modeSelect==ModePick)
		SetCursor (bankCont->HCur);
	else if (modeSelect==ModeFill)
		SetCursor (bankCont->HFill);
	else if (pData->pobj->TileTrick)
		SetCursor (bankCont->HTrick);
	else
		SetCursor (LoadCursor (NULL, IDC_ARROW));

	// Clear buffers
	CNELU::clearBuffers(CRGBA((uint8)(backGround&0xff), (uint8)((backGround>>8)&0xff), (uint8)((backGround>>16)&0xff)));

	if (modeSelect!=ModeSelect)
	{
		CVector	CameraRot(CVector::Null), CameraPos(0,0,0);


		// time mgt.
		static float t0= timeGetTime()*0.001f;
		static float t1;
		t1= timeGetTime()*0.001f;
		float	dt= t1-t0;

		// User Interaction.
		//==================
		// Speed.
		#define NSPEED	5
		static	float	Speed[NSPEED]= {1.66f, 3.33f, 8.33f, 40.0f, 200.0f};	// 6km/h, 12km/h, 30km/h, 144km/h, 700km/h.
		static	sint	idSpeed= 2;
		float	speed= Speed[idSpeed];
		float	rotSpeed= 80*(float)Pi/180;

		// Rot.
		if(AsyncListener.isKeyDown(KeyLEFT))		CameraRot.z+=rotSpeed*dt;
		if(AsyncListener.isKeyDown(KeyRIGHT))	CameraRot.z-=rotSpeed*dt;

		// Move.
		CVector	dir(0,speed*dt,0);
		CMatrix	mat;
		mat.identity();
		mat.rotateZ(CameraRot.z);
		mat.rotateX(CameraRot.x);
		dir= mat.mulVector(dir);
		if(AsyncListener.isKeyDown(KeyUP))		CameraPos+= dir;
		if(AsyncListener.isKeyDown(KeyDOWN))		CameraPos-= dir;

		/*if(AsyncListener.isKeyDown(KeyR))
		{
			CameraPos.set(0,0,0);
			CameraRot.set(0,0,0);
		}*/

		// Straff.
		float	straff=0;
		if(straff)
		{
			CMatrix	m;
			m.identity();
			m.rotateZ(CameraRot.z);
			m.rotateX(CameraRot.x);
			CameraPos+= m*CVector(straff,0,0);
		}

		CMatrix camKey;
		camKey.identity ();
		camKey.rotate(CameraRot, CMatrix::ZXY);

		// Zoom distance
		float zoom = 0;
		if (AsyncListener.isKeyDown ((TKey)PainterKeys[ZoomIn]))
			zoom -= ZoomSpeed * dt;
		if (AsyncListener.isKeyDown ((TKey)PainterKeys[ZoomOut]))
			zoom += ZoomSpeed * dt;

		// Add zoom
		CameraPos += (zoom * -camKey.getJ());

		camKey.setPos(CameraPos);

		camKey=mouseListener.getViewMatrix()*camKey;
		CNELU::Camera->setMatrix(camKey);
		mouseListener.setMatrix(camKey);

		// Render.
		//==================
		landscape.enableAdditive (true);

		scene.render();

		// first time: disable RefineMode, and compute all patchs tesselation.
		if(landscape.Landscape.getRefineMode())
		{
			landscape.Landscape.setRefineMode (false);
			landscape.Landscape.refineAll(camKey.getPos());
		}

		t0= t1;
	}
		
	// Draw interface
	drawInterface (modeSelect, nModeTexture, pData->pobj, driver, landscape, paintColor);

	CNELU::swapBuffers();
}

class MouseListener : public IEventListener
{
private:
	IObjParam*				_Ip;
	CCamera*				_Camera;
	CViewport*				_Viewport;
	PaintPatchMod*			_Pobj;
	EPM_PaintMouseProc*		_Eproc;
	CLandscape*				_Land;
	CEventListenerAsync*	_Async;
	CEvent3dMouseListener*	_3dMouseListener;
	CFillPatch				_FillTile;
	std::vector<EPM_Mesh>&	_VectMesh;
	TimeValue				_T;
public:
	bool					WindowActive;
	CPaintColor				PaintColor;
public:
	MouseListener (IObjParam *ip, CCamera *camera, CViewport *viewport, PaintPatchMod *pobj, EPM_PaintMouseProc *eproc, CLandscape* land, 
					CEventListenerAsync* async, CEvent3dMouseListener* mouseList, std::vector<EPM_Mesh>& vectMesh, TimeValue t)
		: PaintColor (pobj, land, &bankCont->Undo, eproc), _FillTile (pobj, land, &bankCont->Undo, eproc), _VectMesh(vectMesh)
	{
		_Ip=ip;
		_Camera=camera;
		_Viewport=viewport;
		_Pobj=pobj;
		_Eproc=eproc;
		_Land=land;
		_Async=async;
		_3dMouseListener=mouseList;
		WindowActive=true;
		_T=t;
	}
private:

	// Pick a tile
	void pick (int mesh, int tile, const CVector& hit, TModePaint mode);

	// Get the state of a tile
	CZoneSymmetrisation::TState MouseListener::getState (int mesh, int tile, const CVector& hit, std::vector<EPM_Mesh>& vectMesh);

	// Callback on mouse events
	virtual void operator ()(const CEvent& event)
	{
		if (event==EventDestroyWindowId)
		{
			WindowActive=false;
		}
		if (modeSelect!=ModeSelect)
		{
			int res = TRUE;
			static PatchMesh *shape1 = NULL;
			static int poly1, tile1, tile2, mesh1, mesh2, seg1;
			static bool pressed=false;
			static IPoint2 anchor, lastPoint;

			// Mouse down ?
			CEventMouse*	mouse=(CEventMouse*)&event;
			CEventKeyDown*	keyDown=(CEventKeyDown*)&event;

			if (event==EventMouseDownId)
			{
				if (pressed&&((mouse->Button&rightButton)&&((mouse->Button&(ctrlButton|shiftButton|altButton))==0)))
				{
					pressed=false;
								
					// Undo step
					bankCont->Undo.pushUndo ();

					// Call undo now
					bankCont->Undo.undo (*_Eproc, _VectMesh, _Land, _Pobj, PaintColor);
				}
				if (mouse->Button==leftButton)
				{
					CVector hotSpot;
					CVector topVector;
					if (_Eproc->HitATile(*_Viewport, *_Camera, mouse->X, mouse->Y, &tile1, &mesh1, _T, _VectMesh, hotSpot, topVector))
					{
						// Set hit as next hotspot
						if ( (modeSelect!=ModePick) && (modeSelect!=ModeGetState) )
							_3dMouseListener->setHotSpot (hotSpot);

						// Patch number
						int patch=tile1/NUM_TILE_SEL;

						// Mode paint ?
						if (modeSelect==ModePaint)
						{
							if ((nModeTexture==ModeTile)||(nModeTexture==ModeDisplace))
							{
								// Check if we are in patch subobject and if this patch is selected
								if ((_VectMesh[mesh1].PMesh->selLevel!=EP_PATCH)||(_VectMesh[mesh1].PMesh->patchSel[patch]))
								{
									std::set<EPM_PaintTile*> alreadyRecursed;

									// A nel manager
									CNelPatchChanger nelPatchChg (_Land);

									if (nModeTexture==ModeTile)
									{
										// Put the tile
										_Eproc->PutTile (tile1, mesh1, true, bank, _Pobj->CurrentTileSet, _VectMesh, _Land, brushValue[PaintPatchMod::brushSize], 
											alreadyRecursed, nelPatchChg, _Pobj->tileSize!=0);
									}
									else // (nModeTexture==ModeDisplace)
									{										
										// Put the tile
										_Eproc->PutDisplace (tile1, mesh1, bank, _VectMesh, _Land, brushValue[PaintPatchMod::brushSize], 
											alreadyRecursed, nelPatchChg);
									}

									// Flush nel chgt
									nelPatchChg.applyChanges ((nModeTexture==ModeDisplace)&&(_Pobj->automaticLighting));
								}
							}
							else if (nModeTexture==ModeColor)
							{
								// Paint
								PaintColor.paint (mesh1, tile1, hotSpot, topVector, _VectMesh);
							}

							// Button pressed
							pressed = true;
						}
						else if (modeSelect==ModePick)
						{
							// Pick tile
							pick (mesh1, tile1, hotSpot, nModeTexture);
						}
						else if (modeSelect==ModeGetState)
						{
							// Pick tile state
							CZoneSymmetrisation::TState state = getState (mesh1, tile1, hotSpot, _VectMesh);
							_Pobj->CurrentState = state;

							// Active show state
							_Pobj->ShowCurrentState = true;
						}
						else if (modeSelect==ModeFill)
						{
							// Paint mode
							if (nModeTexture==ModeTile)
								// Fill this patch with the current tile
								_FillTile.fillTile (mesh1, patch, _VectMesh, _Pobj->CurrentTileSet, _Pobj->TileFillRotation, _Pobj->TileGroup, _Pobj->tileSize!=0, 
													bank);
							else if (nModeTexture==ModeColor)
								// Fill this patch with the current color
								_FillTile.fillColor (mesh1, patch, _VectMesh, maxToNel (color1), (uint16)(256.f*opa1), PaintColor);

							else if (nModeTexture==ModeDisplace)
								// Fill this patch with the current color
								_FillTile.fillDisplace (mesh1, patch, _VectMesh, bank);
						}
					}
				}
				// Pick with right mouse
				if (mouse->Button==rightButton)
				{
					// Pick tile
					CVector hotSpot;
					pick (mesh1, tile1, hotSpot, nModeTexture);
				}
			}
			if (event==EventMouseUpId)
			{
				if (mouse->Button==leftButton)
				{
					pressed = false;
					_Pobj->ShowCurrentState = false;
					
					// Undo step
					bankCont->Undo.pushUndo ();
				}
			}
			// Mouse move ?
			if (event==EventMouseMoveId)
			{
				if ((pressed)&&(mouse->Button==leftButton))
				{
					CVector hotSpot;
					CVector topVector;
					if (_Eproc->HitATile(*_Viewport, *_Camera, mouse->X, mouse->Y, &tile2, &mesh2, _T, _VectMesh, hotSpot, topVector))
					{
						_3dMouseListener->setHotSpot (hotSpot);
						if ((tile1!=tile2)||(mesh1!=mesh2))
						{
							// Paint tiles ?
							if ((nModeTexture==ModeTile)||(nModeTexture==ModeDisplace))
							{
								// Patch number
								int patch=tile2/NUM_TILE_SEL;

								// Check if we are in patch subobject and if this patch is selected
								if ((_VectMesh[mesh1].PMesh->selLevel!=EP_PATCH)||(_VectMesh[mesh2].PMesh->patchSel[patch]))
								{
									std::set<EPM_PaintTile*> alreadyRecursed;

									// A nel manager
									CNelPatchChanger nelPatchChg (_Land);

									if (nModeTexture==ModeTile)
									{
										// Put the tile
										_Eproc->PutTile (tile2, mesh2, false, bank, _Pobj->CurrentTileSet, _VectMesh, _Land, 
											brushValue[PaintPatchMod::brushSize], alreadyRecursed, nelPatchChg, _Pobj->tileSize!=0);
									}
									else // (nModeTexture==ModeDisplace)
									{										
										// Put the tile
										_Eproc->PutDisplace (tile2, mesh2, bank, _VectMesh, _Land, brushValue[PaintPatchMod::brushSize], 
											alreadyRecursed, nelPatchChg);
									}

									// Flush nel chgt
									nelPatchChg.applyChanges ((nModeTexture==ModeDisplace)&&(_Pobj->automaticLighting));
								}
							}
							// Paint colors ?
							else if (nModeTexture==ModeColor)
							{
								// Paint
								PaintColor.paint (mesh2, tile2, hotSpot, topVector, _VectMesh);
							}

							// New tile touched
							tile1=tile2;
							mesh1=mesh2;
						}
					}
				}
			}
			// Key down ?
			if (event==EventKeyDownId)
			{
				// First time ?
				if (keyDown->FirstTime)
				{
					// Undo ?
					if ((keyDown->Key==KeyZ)&&(keyDown->Button==ctrlKeyButton))
					{
						// Undo !
						bankCont->Undo.undo (*_Eproc, _VectMesh, _Land, _Pobj, PaintColor);
					}

					// Redo ?
					if ((keyDown->Key==KeyE)&&(keyDown->Button==ctrlKeyButton))
					{
						// Redo !
						bankCont->Undo.redo (*_Eproc, _VectMesh, _Land, _Pobj, PaintColor);
					}
				}
			}
		}
		else if ((nModeTexture==ModeTile)||(nModeTexture==ModeDisplace))
		{
			// bTexture
			CEventMouse* mouse=(CEventMouse*)&event;
			if (event==EventMouseDownId)
			{
				int x=(int)(mouse->X*(float)MOD_WIDTH);
				int y=(int)((mouse->Y)*(float)MOD_HEIGHT);
				int tile=x+y*MOD_WIDTH;

				// Mode tiles ?
				if (nModeTexture==ModeTile)
				{
					if ((tile>=0)&&(tile<=bank.getTileSetCount()))
					{
						// Select bank tileset ?
						if (tile==0)
						{
							_Pobj->CurrentTileSet=-1;
						}
						// no...
						else
						{
							// Ask for the tileSet
							_Pobj->CurrentTileSet=tileSetSelector.getTileSet (tile-1);
							_Pobj->DisplaceTileSet=_Pobj->CurrentTileSet;
						}
					}			
				}

				// Mode displace ?
				if (nModeTexture==ModeDisplace)
				{
					if ((tile>=0)&&(tile<CTileSet::CountDisplace))
					{
						_Pobj->DisplaceTile=tile;
					}			
				}
			}
		}
	}
};

/*-------------------------------------------------------------------*/

// Pick a tile
void MouseListener::pick (int mesh, int tile, const CVector& hit, TModePaint mode)
{
	// Pick tile
	if ((mode==ModeTile)||(mode==ModeDisplace))
	{
		// Pick tile under the cursor
		tileDesc desc;
		_Eproc->GetTile (mesh, tile, desc, _VectMesh, _Land);

		if (desc.getNumLayer ()>0)
		{
			// Get info about this tile
			int tileSet;
			int number;
			CTileBank::TTileType type;
			bank.getTileXRef (desc.getLayer (0).Tile, tileSet, number, type);

			// Pickup a tile ?
			if (mode==ModeTile)
			{
				// Set the tileSet if this tile set is in the land
				if (tileSetSelector.isInArray (tileSet))
					_Pobj->CurrentTileSet=tileSet;
			}
			// Pickup a displace ?
			else
			{
				// Get the displace tile index 
				_Pobj->DisplaceTile=desc.getDisplace ();
				_Pobj->DisplaceTileSet=tileSet;
			}
		}
	}
	else if (mode==ModeColor)
	{
		// Get the tile pointer
		EPM_PaintTile *pTile=&_Eproc->metaTile[mesh][tile];

		// Coordoninates
		int u[4]={pTile->u, pTile->u, pTile->u+1, pTile->u+1};
		int v[4]={pTile->v, pTile->v+1, pTile->v+1, pTile->v};

		CRGBA bestColor;
		float fBestDist=FLT_MAX;

		// 4 coordinates
		for (int i=0; i<4; i++)
		{
			// Get another color
			CVector pos;
			CRGBA color;
			PaintColor.pickVertexColor (mesh, pTile->patch, u[i], v[i], pos, color, _VectMesh);

			// Get new dist
			float fDist=(pos-hit).norm();

			// Better dist ?
			if (fDist<fBestDist)
			{
				bestColor=color;
				fBestDist=fDist;
			}
		}

		// Set the color
		color1=nelToMax (bestColor);
	}
}

/*-------------------------------------------------------------------*/
// Pick a tile
CZoneSymmetrisation::TState MouseListener::getState (int mesh, int tile, const CVector& hit, std::vector<EPM_Mesh>& vectMesh)
{
	if (vectMesh[mesh].Symmetry || vectMesh[mesh].Rotate)
	{
		uint patch=tile/NUM_TILE_SEL;
		uint ttile=tile%NUM_TILE_SEL;
		uint v=ttile/MAX_TILE_IN_PATCH;
		uint u=ttile%MAX_TILE_IN_PATCH;

		// Get the patch
		int OrderS=(1<<vectMesh[mesh].RMesh->getUIPatch (patch).NbTilesU);
		uint symTile = OrderS*v+u;

		// Pick tile under the cursor
		return symVector[mesh].getTileState (patch, symTile, 0);
	}
	else
		return CZoneSymmetrisation::Nothing;
}

/*-------------------------------------------------------------------*/

DWORD WINAPI myThread (LPVOID vData);

int getBindedEdge (int nPatch, int nVertInPatch, const PatchMesh& patch, const RPatchMesh& rpatch)
{
	// Vert number in the patxhmesh
	int nVertInMesh=patch.patches[nPatch].v[nVertInPatch];

	// Should be binded
	nlassert (rpatch.getUIVertex (nVertInMesh).Binding.bBinded);

	// Some vertex
	int nVertexBefore=patch.patches[nPatch].v[(nVertInPatch-1)&3];
	int nVertexAfter=patch.patches[nPatch].v[(nVertInPatch+1)&3];

	// switch binding sort
	switch (rpatch.getUIVertex (nVertInMesh).Binding.nType)
	{
	case BIND_SINGLE:
		// Check if the point after is binded to the same patch, same edge
		if (patch.patches[rpatch.getUIVertex (nVertInMesh).Binding.nPatch].v[rpatch.getUIVertex (nVertInMesh).Binding.nEdge]==
				patch.patches[nPatch].v[(nVertInPatch+1)&3])
		{
			return nVertInPatch;
		}
		else
		{
#ifdef NL_DEBUG
			const UI_VERTEX &uiv = rpatch.getUIVertex (nVertInMesh);
			Patch &patch0 = patch.patches[uiv.Binding.nPatch];
			Patch &patch1 = patch.patches[nPatch];
			uint vertIndex0 = (uiv.Binding.nEdge+1)&3;
			uint vertIndex1 = (nVertInPatch-1)&3;
			uint vert0 = patch0.v[vertIndex0];
			uint vert1 = patch1.v[vertIndex1];
#endif // NL_DEBUG
			nlassert (patch.patches[rpatch.getUIVertex (nVertInMesh).Binding.nPatch].v[(rpatch.getUIVertex (nVertInMesh).Binding.nEdge+1)&3]==
				patch.patches[nPatch].v[(nVertInPatch-1)&3]);
			return (nVertInPatch-1)&3;
		}
		break;
	case BIND_25:
		// Check if the point after is binded to the same patch, same edge
		if ((rpatch.getUIVertex (nVertexBefore).Binding.bBinded)&&
			(rpatch.getUIVertex (nVertexBefore).Binding.nPatch==rpatch.getUIVertex (nVertInMesh).Binding.nPatch)&&
			(rpatch.getUIVertex (nVertexBefore).Binding.nEdge==rpatch.getUIVertex (nVertInMesh).Binding.nEdge)&&
			(rpatch.getUIVertex (nVertexBefore).Binding.nType==BIND_50))
		{
			return (nVertInPatch-1)&3;
		}
		else
		{
			nlassert (patch.patches[rpatch.getUIVertex (nVertInMesh).Binding.nPatch].v[rpatch.getUIVertex (nVertInMesh).Binding.nEdge]==
				patch.patches[nPatch].v[(nVertInPatch+1)&3]);
			return nVertInPatch;
		}
		break;
	case BIND_50:
		// Check if the point after is binded to the same patch, same edge
		if ((rpatch.getUIVertex (nVertexBefore).Binding.bBinded)&&
			(rpatch.getUIVertex (nVertexBefore).Binding.nPatch==rpatch.getUIVertex (nVertInMesh).Binding.nPatch)&&
			(rpatch.getUIVertex (nVertexBefore).Binding.nEdge==rpatch.getUIVertex (nVertInMesh).Binding.nEdge)&&
			(rpatch.getUIVertex (nVertexBefore).Binding.nType==BIND_75))
		{
			return (nVertInPatch-1)&3;
		}
		else
		{
			nlassert (rpatch.getUIVertex (nVertexAfter).Binding.bBinded);
			nlassert (rpatch.getUIVertex (nVertexAfter).Binding.nPatch==rpatch.getUIVertex (nVertInMesh).Binding.nPatch);
			nlassert (rpatch.getUIVertex (nVertexAfter).Binding.nEdge==rpatch.getUIVertex (nVertInMesh).Binding.nEdge);
			nlassert (rpatch.getUIVertex (nVertexAfter).Binding.nType==BIND_25);
			return nVertInPatch;
		}
		break;
	case BIND_75:
		// Check if the point after is binded to the same patch, same edge
		if ((rpatch.getUIVertex (nVertexAfter).Binding.bBinded)&&
			(rpatch.getUIVertex (nVertexAfter).Binding.nPatch==rpatch.getUIVertex (nVertInMesh).Binding.nPatch)&&
			(rpatch.getUIVertex (nVertexAfter).Binding.nEdge==rpatch.getUIVertex (nVertInMesh).Binding.nEdge)&&
			(rpatch.getUIVertex (nVertexAfter).Binding.nType==BIND_50))
		{
			return nVertInPatch;
		}
		else
		{
			nlassert (patch.patches[rpatch.getUIVertex (nVertInMesh).Binding.nPatch].v[(rpatch.getUIVertex (nVertInMesh).Binding.nEdge+1)&3]==
				patch.patches[nPatch].v[(nVertInPatch-1)&3]);
			return (nVertInPatch-1)&3;
		}
		break;
	}
	nlassert (0);	// no!
	return 0;
}

void EPM_PaintCMode::EnterMode ()
{
	if (pobj->hOpsPanel)
	{
		ICustButton *but = GetICustButton(GetDlgItem(pobj->hOpsPanel, IDC_PAINT));
		but->SetCheck(TRUE);
		ReleaseICustButton(but);
	}
}

void EPM_PaintCMode::DoPaint ()
{
	// Toremove
	static float best = 10000.f;

	// Set local to english
	setlocale (LC_NUMERIC, "English");

	if (pobj->hOpsPanel)
	{
		bWarningInvalidTileSet=false;

		// Build paint tile infos..
		nlassert (eproc.ip);
		ModContextList mcList;
		INodeTab nodes;
		TimeValue t = eproc.ip->GetTime();

		// Build modifier context list
		eproc.ip->GetModContexts(mcList, nodes);
		pobj->ClearPatchDataFlag(mcList, EPD_BEENDONE);
		theHold.Begin();

		// Mesh table
		std::vector<EPM_Mesh> vectMesh;
		makeVectMesh (vectMesh, nodes, mcList, pobj, t);

		// Size of the map
		eproc.metaTile.resize (vectMesh.size());
		eproc.bitArray.resize (vectMesh.size());

		// Calculate the boundind box..
		float fMinX=FLT_MAX;
		float fMinY=FLT_MAX;
		float fMinZ=FLT_MAX;
		float fMaxX=-FLT_MAX;
		float fMaxY=-FLT_MAX;
		float fMaxZ=-FLT_MAX;
		int i;
		for (i = 0; i < (int)vectMesh.size(); i++)
		{
			// Get pointers
			PaintPatchData *patchData = vectMesh[i].PatchData;
			RPatchMesh *rpatch = vectMesh[i].RMesh;
			PatchMesh *patch = vectMesh[i].PMesh;
			if ((!patchData)||(!patch)||(!rpatch))
				continue;

			// hold
			patchData->RecordTopologyTags(patch);
			patchData->BeginEdit(t);
			if (theHold.Holding())
				theHold.Put(new PatchRestore(patchData, pobj, patch, rpatch));

			// fill the tile map
			for (int p=0; p<patch->numPatches; p++)
			{
				int nU=1<<rpatch->getUIPatch (p).NbTilesU;
				int nV=1<<rpatch->getUIPatch (p).NbTilesV;
				for (int u=0; u<=nU; u++)
				for (int v=0; v<=nV; v++)
				{					
					Point3 pos=patch->patches[p].interp (patch, (float)u/(float)(nU), (float)v/(float)(nV));
					pos=pos*(vectMesh[i].Node->GetObjectTM (t));
					if (fMaxX<pos.x)
						fMaxX=pos.x;
					if (fMinX>pos.x)
						fMinX=pos.x;
					if (fMaxY<pos.y)
						fMaxY=pos.y;
					if (fMinY>pos.y)
						fMinY=pos.y;
					if (fMaxZ<pos.z)
						fMaxZ=pos.z;
					if (fMinZ>pos.z)
						fMinZ=pos.z;
				}
			}
		}

		// Create the quad to select
		CVector center ((fMinX+fMaxX)/2.f, (fMinY+fMaxY)/2.f, (fMinZ+fMaxZ)/2.f);
		CVector lookFrom (fMaxX, fMaxY, fMaxZ);
		eproc.quadTreeSelect.create (8, center, (float)std::max (std::max (fMaxX-fMinX, fMaxY-fMinY), fMaxZ-fMinZ));

		for (i = 0; i < (int)vectMesh.size(); i++)
		{
			// Get pointers
			PaintPatchData *patchData = vectMesh[i].PatchData;
			RPatchMesh *rpatch = vectMesh[i].RMesh;
			PatchMesh *patch = vectMesh[i].PMesh;
			if ((!patchData)||(!patch)||(!rpatch))
				continue;

			// paint mode
			rpatch->paint=true;
			rpatch->BuildMesh(t, *patch);

			// copy edge eproc.bitArray
			eproc.bitArray[i]=patch->edgeSel;

			// clear tile map
			eproc.metaTile[i].clear();
			eproc.metaTile[i].resize (NUM_TILE_SEL*patch->numPatches);

			// fill the tile map
			for (int p=0; p<patch->numPatches; p++)
			{
				int nU=1<<rpatch->getUIPatch (p).NbTilesU;
				int nV=1<<rpatch->getUIPatch (p).NbTilesV;
				for (int u=0; u<nU; u++)
				for (int v=0; v<nV; v++)
				{
					EPM_PaintTile *pTile=&eproc.metaTile[i][p*NUM_TILE_SEL+v*MAX_TILE_IN_PATCH+u];
					pTile->Mesh=i;
					pTile->patch=p;
					pTile->tile=p*NUM_TILE_SEL+v*MAX_TILE_IN_PATCH+u;
					pTile->voisins[3]= v==0 ? NULL : &eproc.metaTile[i][p*NUM_TILE_SEL+(v-1)*MAX_TILE_IN_PATCH+u];
					pTile->voisins[1]= v==(nV-1) ? NULL : &eproc.metaTile[i][p*NUM_TILE_SEL+(v+1)*MAX_TILE_IN_PATCH+u];
					pTile->voisins[0]= u==0 ? NULL : &eproc.metaTile[i][p*NUM_TILE_SEL+v*MAX_TILE_IN_PATCH+u-1];
					pTile->voisins[2]= u==(nU-1) ? NULL : &eproc.metaTile[i][p*NUM_TILE_SEL+v*MAX_TILE_IN_PATCH+u+1];
					pTile->rotate[3]=0;
					pTile->rotate[1]=0;
					pTile->rotate[0]=0;
					pTile->rotate[2]=0;
					pTile->u=u;
					pTile->v=v;
					
					// Compute bouding box of the tile
					fMinX=FLT_MAX;
					fMinY=FLT_MAX;
					fMaxX=-FLT_MAX;
					fMaxY=-FLT_MAX;

					// Compute the 4 corners of the tile
					Point3 pos[4];
					pos[0]=patch->patches[p].interp (patch, (float)u/(float)(nU), (float)v/(float)(nV));
					pos[0]=pos[0]*(vectMesh[i].Node->GetObjectTM (t));
					pos[1]=patch->patches[p].interp (patch, (float)(u+1)/(float)(nU), (float)v/(float)(nV));
					pos[1]=pos[1]*(vectMesh[i].Node->GetObjectTM (t));
					pos[2]=patch->patches[p].interp (patch, (float)(u+1)/(float)(nU), (float)(v+1)/(float)(nV));
					pos[2]=pos[2]*(vectMesh[i].Node->GetObjectTM (t));
					pos[3]=patch->patches[p].interp (patch, (float)u/(float)(nU), (float)(v+1)/(float)(nV));
					pos[3]=pos[3]*(vectMesh[i].Node->GetObjectTM (t));

					// Store its center
					pTile->Center=(maxToNel (pos[0])+maxToNel (pos[1])+maxToNel (pos[2])+maxToNel (pos[3]))/4.f;

					// Store its radius
					pTile->Radius=std::max 
									(
										std::max ( (maxToNel (pos[0])-pTile->Center).norm(), (maxToNel (pos[1])-pTile->Center).norm() ),
										std::max ( (maxToNel (pos[2])-pTile->Center).norm(), (maxToNel (pos[3])-pTile->Center).norm() )
									);

					// Bounding
					for (int i=0; i<4; i++)
					{
						if (fMaxX<pos[i].x)
							fMaxX=pos[i].x;
						if (fMinX>pos[i].x)
							fMinX=pos[i].x;
						if (fMaxY<pos[i].y)
							fMaxY=pos[i].y;
						if (fMinY>pos[i].y)
							fMinY=pos[i].y;
						if (fMaxZ<pos[i].z)
							fMaxZ=pos[i].z;
						if (fMinZ>pos[i].z)
							fMinZ=pos[i].z;
					}

					// Insert the tile in the quad tree
					eproc.quadTreeSelect.insert (CVector (fMinX, fMinY, fMinZ), CVector (fMaxX, fMaxY, fMaxZ), pTile);
				}
			}
		}

		// Watch for patch voisin
		for (i = 0; i < (int)vectMesh.size(); i++)
		{
			// Get pointers
			PaintPatchData *patchData = vectMesh[i].PatchData;
			RPatchMesh *rpatch = vectMesh[i].RMesh;
			PatchMesh *patch = vectMesh[i].PMesh;
			if ((!patchData)||(!patch)||(!rpatch))
				continue;

			// fill the tile map
			for (int p=0; p<patch->numPatches; p++)
			{
				// Find a voisin
				for (int e=0; e<4; e++)
				{
					EPM_PaintPatch patchVoisin;
					patchVoisin.patch=-1;
					int edgeVoisin;
					int offsetEdge=0;
					int dividEdge=0;
					int mYedge=patch->patches[p].edge[e];
					if (mYedge == -1)
					{
					 	std::string error = NLMISC::toString("Invalid edge '%i' with value '%i' in patch '%i' in PatchMesh", p, mYedge, e);
					 	nlwarning(error.c_str());
					 	MessageBox(NULL, error.c_str(), "NeL Patch Painter", MB_OK | MB_ICONSTOP);
					 	return;
					}
#if (MAX_RELEASE < 4000)
					int otherPatch=(patch->edges[mYedge].patch1==p)?patch->edges[mYedge].patch2:patch->edges[mYedge].patch1;
#else // (MAX_RELEASE < 4000)
					int otherPatch = -1;
					if(patch->edges[mYedge].patches.Count()>0)
					{
						if (patch->edges[mYedge].patches[0]==p) {
							if (patch->edges[mYedge].patches.Count() > 1)
								otherPatch = patch->edges[mYedge].patches[1];
						}
						else
							otherPatch = patch->edges[mYedge].patches[0];
					}
#endif // (MAX_RELEASE < 4000)
					int nMeshIndex;
					if (otherPatch!=-1)
					{
						patchVoisin.patch=otherPatch;
						patchVoisin.Mesh=i;
						edgeVoisin=WhereIsTheEdge (otherPatch, mYedge, *patch);
						nlassert (edgeVoisin!=-1);
						nMeshIndex=i;
					}
					else
					{
						// Binding ?
						int vertBinded=-1;
						if (rpatch->getUIVertex (patch->patches[p].v[e]).Binding.bBinded)
							vertBinded=e;
						if (rpatch->getUIVertex (patch->patches[p].v[(e+1)&3]).Binding.bBinded)
							vertBinded=(e+1)&3;
						if ((vertBinded!=-1)&&(getBindedEdge (p, vertBinded, *patch, *rpatch)==e))
						{
							int nVert=patch->patches[p].v[vertBinded];
							patchVoisin.patch=rpatch->getUIVertex (nVert).Binding.nPatch;
							otherPatch=rpatch->getUIVertex (nVert).Binding.nPatch;
							patchVoisin.Mesh=i;
							edgeVoisin=rpatch->getUIVertex (nVert).Binding.nEdge;
							nlassert (edgeVoisin!=-1);
							nMeshIndex=i;
							switch (rpatch->getUIVertex (nVert).Binding.nType)
							{
							case BIND_25:
								dividEdge=2;
								if (vertBinded==e)
									offsetEdge=3;
								else
									offsetEdge=2;
								break;
							case BIND_75:
								dividEdge=2;
								if (vertBinded==e)
									offsetEdge=1;
								else
									offsetEdge=0;
								break;
							case BIND_50:
								dividEdge=2;
								if (vertBinded==e)
									offsetEdge=2;
								else
									offsetEdge=1;
								break;
							case BIND_SINGLE:
								dividEdge=1;
								if (vertBinded==e)
									offsetEdge=2;
								else
									offsetEdge=0;
								break;
							}
						}
						else	// Look in the neighborhood for a voisin
						{
							// Vertex Number
							//Matrix3 m1=*mcList[i]->tm;
							Matrix3 m1=vectMesh[i].Node->GetObjectTM(t);
							Point3 vA1=patch->verts[patch->patches[p].v[e]].p * m1;
							Point3 vB1=patch->verts[patch->patches[p].v[(e+1)&3]].p * m1;

							// If symmetry, invert
							if (vectMesh[i].Symmetry)
							{
								Point3 tmp = vA1;
								vA1 = vB1;
								vB1 = tmp;
							}

							// Look for in other patchMesh
							for (int ii = 0; ii < (int)vectMesh.size(); ii++)
							{
								if (ii!=i)
								{
									// Get pointers
									PaintPatchData *patchData2 = vectMesh[ii].PatchData;
									RPatchMesh *rpatch2 = vectMesh[ii].RMesh;
									PatchMesh *patch2 = vectMesh[ii].PMesh;
									if ((!patchData2)||(!patch2)||(!rpatch2))
										continue;

									// Look for an open edge
									for (int ee=0; ee<patch2->numEdges; ee++)
									{
#if (MAX_RELEASE < 4000)
										if ((patch2->edges[ee].patch1==-1)||(patch2->edges[ee].patch2==-1))
										{
											//
											int pp=patch2->edges[ee].patch1==-1 ? patch2->edges[ee].patch2:patch2->edges[ee].patch1;
#else // (MAX_RELEASE < 4000)
										if (patch2->edges[ee].patches.Count()>0)
										{
											//
											int pp=patch2->edges[ee].patches[0];
#endif // (MAX_RELEASE < 4000)
											nlassert (pp!=-1);

											// Edge number
											int edge=WhereIsTheEdge (pp, ee, *patch2);
											//Matrix3 m2=*mcList[ii]->tm;
											Matrix3 m2=vectMesh[ii].Node->GetObjectTM(t);
											Point3 vA2=patch2->verts[patch2->patches[pp].v[edge]].p * m2;
											Point3 vB2=patch2->verts[patch2->patches[pp].v[(edge+1)&3]].p * m2;

											// If symmetry, invert
											if (vectMesh[ii].Symmetry)
											{
												Point3 tmp = vA2;
												vA2 = vB2;
												vB2 = tmp;
											}

											// The same ?

											// Toremove
											if ((vA1-vB2).Length () < best)
											{
												best = (vA1-vB2).Length ();
											}
											if ((vA2-vB1).Length () < best)
											{
												best = (vA2-vB1).Length ();
											}

											if (((vA1-vB2).Length ()<WELD_THRESOLD)&&((vA2-vB1).Length ()<WELD_THRESOLD))
											{
												// The same!!
												patchVoisin.patch=pp;
												patchVoisin.Mesh=ii;
												edgeVoisin=edge;
												nMeshIndex=ii;
												break;
											}
										}
									}
								}
							}
						}
					}
					if (patchVoisin.patch!=-1)
					{
						std::string first = vectMesh[i].Node->GetName();
						std::string second = vectMesh[patchVoisin.Mesh].Node->GetName();
						int rot = (2-((vectMesh[i].Symmetry)?(2-e):e)+((vectMesh[patchVoisin.Mesh].Symmetry)?(2-edgeVoisin):edgeVoisin))&3;
						int nU = 1 << rpatch->getUIPatch (p).NbTilesU;
						int nV = 1 << rpatch->getUIPatch (p).NbTilesV;
						int nUOther = 1 << vectMesh[patchVoisin.Mesh].RMesh->getUIPatch (patchVoisin.patch).NbTilesU;
						int nVOther = 1 << vectMesh[patchVoisin.Mesh].RMesh->getUIPatch (patchVoisin.patch).NbTilesV;
						int nTile= (e&1) ? nU : nV;
						int nTile2= (edgeVoisin&1) ? nUOther : nVOther;
						if (nTile==(nTile2>>dividEdge))
						{
							int offset=getOffset (e, nU, nV, vectMesh[i].Symmetry);
							int offsetOther=getOffset (edgeVoisin, nUOther, nVOther, vectMesh[patchVoisin.Mesh].Symmetry);
							static int delta[4] = { MAX_TILE_IN_PATCH, 1, -MAX_TILE_IN_PATCH, -1 };

							int symIndex = vectMesh[i].Symmetry?-1:1;
							int symIndexOther = vectMesh[patchVoisin.Mesh].Symmetry?-1:1;

							EPM_PaintTile *pTile1=&eproc.metaTile[i][p*NUM_TILE_SEL+offset];
							EPM_PaintTile *pTile2=&eproc.metaTile[nMeshIndex][patchVoisin.patch*NUM_TILE_SEL+offsetOther];
							pTile2+=(nTile2-1)*delta[edgeVoisin]*symIndexOther;
							pTile2-=(delta[edgeVoisin]*symIndexOther*nTile2*offsetEdge)>>2;

							for (int end=0; end<nTile; end++)
							{
								// tile dest
								pTile1->voisins[e]=pTile2;
								pTile1->rotate[e]=rot;

								// tile src..
								nlassert ((pTile2->voisins[edgeVoisin]==NULL)||(pTile2->voisins[edgeVoisin]==pTile1));
								pTile2->voisins[edgeVoisin]=pTile1;
								pTile2->rotate[edgeVoisin]=(-rot)&3;

								pTile1+=delta[e]*symIndex;
								pTile2-=delta[edgeVoisin]*symIndexOther;
							}
						}
						patch->edgeSel.Clear (mYedge);
					}
					else
					{
						patch->edgeSel.Set (mYedge);
					}
				}
			}
		}

		// Flag frozen and locked tiles
		for (i = 0; i < (int)vectMesh.size(); i++)
		{
			// Get pointers
			PaintPatchData *patchData = vectMesh[i].PatchData;
			RPatchMesh *rpatch = vectMesh[i].RMesh;
			PatchMesh *patch = vectMesh[i].PMesh;
			if ((!patchData)||(!patch)||(!rpatch))
				continue;

			// fill the tile map
			for (int p=0; p<patch->numPatches; p++)
			{
				int nU=1<<rpatch->getUIPatch (p).NbTilesU;
				int nV=1<<rpatch->getUIPatch (p).NbTilesV;
				for (int u=0; u<nU; u++)
				for (int v=0; v<nV; v++)
				{
					EPM_PaintTile *pTile=&eproc.metaTile[i][p*NUM_TILE_SEL+v*MAX_TILE_IN_PATCH+u];

					// frozen ?
					pTile->frozen = vectMesh[pTile->Mesh].Node->IsFrozen() != 0;

					// Not locked
					pTile->locked = 0;

					// Check that neighbor tiles are not frozen
					uint neighbor;					
					for (neighbor=0; neighbor<4; neighbor++)
					{
						// Neighbor exist ?
						EPM_PaintTile *neighborTile = pTile->voisins[neighbor];
						if (neighborTile)
						{
							// Not freezed ?
							if (vectMesh[neighborTile->Mesh].Node->IsFrozen())
								pTile->locked |= 1<<neighbor;
						}
						else
							pTile->locked |= 1<<neighbor;
					}
				}
			}
		}


		std::string sName=GetBankPathName ();
		if (sName!="")
		{
			CIFile file;
			if (file.open (sName))
			{
				try
				{
					bank.clear();
					bank.serial (file);
					bank.computeXRef ();
				}
				catch (EStream& stream)
				{
					MessageBox (NULL, stream.what(), "Error", MB_OK|MB_ICONEXCLAMATION);
				}
			}
		}

		// Enter painter mode
		enterPainter (bank);

		// Select the tilesets to use
		tileSetSelector.setSelection (GetBankTileSetSet (), bank);

		// Create a paint thread..
		//DWORD id;
		callThread *pData=new callThread (vectMesh);
		pData->eproc=&eproc;
		pData->pobj=pobj;
		pData->center=center;
		pData->T=t;
		
		myThread (pData);		// Do it without thread

		// Invalidate all objects
		for (i = 0; i < (int)vectMesh.size(); i++)
		{
			// Get pointers
			PaintPatchData *patchData = vectMesh[i].PatchData;
			RPatchMesh *rpatch = vectMesh[i].RMesh;
			PatchMesh *patch = vectMesh[i].PMesh;
			if ((!patchData)||(!patch)||(!rpatch))
				continue;

			// End of mode paint
			rpatch->paint=false;

			// Invalidate all modified parts
			patchData->UpdateChanges(patch, rpatch);
			patchData->TempData(pobj)->Invalidate(PART_ALL);

			patch->edgeSel=eproc.bitArray[vectMesh[i].McListIndex];

			patchData->SetFlag(EPD_BEENDONE, TRUE);
		}

		theHold.Accept("Patch change");

		nodes.DisposeTemporary();
		pobj->ClearPatchDataFlag(mcList, EPD_BEENDONE);
		pobj->NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);
		eproc.ip->RedrawViews(t, REDRAW_NORMAL);

		// Exit painter mode
		exitPainter ();
	}

	// Set locale to current
	setlocale (LC_NUMERIC, "");
}

extern HINSTANCE hInstance;
bool loadLigoConfigFile (CLigoConfig& config, Interface& it)
{
	// Get the module path
	HMODULE hModule = hInstance;
	if (hModule)
	{
		// Get the path
		char sModulePath[256];
		int res=GetModuleFileName(hModule, sModulePath, 256);
		// Success ?
		if (res)
		{
			// Path
			char sDrive[256];
			char sDir[256];
			_splitpath (sModulePath, sDrive, sDir, NULL, NULL);
			_makepath (sModulePath, sDrive, sDir, "ligoscape", ".cfg");
			try
			{
				// Load the config file
				config.readConfigFile (sModulePath, false);
				// ok
				return true;
			}
			catch (Exception& e)
			{
				// Print an error message
				char msg[512];
				smprintf (msg, 512, "Error loading the config file ligoscape.cfg: %s", e.what());
				nlwarning (msg);
			}
		}
	}
	// Can't found the module
	return false;
}
	
DWORD WINAPI myThread (LPVOID vData)
{	
	// Mega try
	try
	{
		/*************** new mode paint.. **************/
		callThread *pData=(callThread*)vData;

		// Build paint tile infos..
		nlassert (pData->eproc->ip);

		// Viewport parameters
		ViewExp*	vp;
		Matrix3		affineTM;
		float		minx,maxx,miny,maxy;
		vp=pData->eproc->ip->GetActiveViewport();
		vp->GetAffineTM(affineTM);
		if ( vp->IsPerspView() )
		{
			vp->GetGridDims(&minx,&maxx,&miny,&maxy);
		}

		// The scene
		
		// Loaf cfg files
		LoadKeyCfg ();
		LoadVarCfg ();

		// Init the scene
		CViewport viewport;

		try
		{
			CNELU::init(MAIN_Width, MAIN_Height, viewport);

			// Create a Landscape.
			CLandscapeModel	*TheLand= (CLandscapeModel*)CNELU::Scene->createModel(LandscapeModelId);
			TheLand->Landscape.setTileNear (1000.f);
			TheLand->Landscape.TileBank=bank;

			// Enbable automatique lighting
			TheLand->Landscape.enableAutomaticLighting (false);
			TheLand->Landscape.setupAutomaticLightDir (LightDirection);
			TheLand->Landscape.setupStaticLight (LightDiffuse, LightAmbiant, LightMultiply);

			// *******************
			CExportNel export_ (true, true, true, pData->eproc->ip, "NeL Patch Painter", NULL);

			// Add meshes in the scene
			if (pData->pobj->includeMeshes)
			{
				// Get the root node
				INode *root=pData->eproc->ip->GetRootNode ();

				// View all selected objects
				for (uint nNode=0; nNode<(uint)root->NumberOfChildren(); nNode++)
				{
					// Get the node
					INode* pNode=root->GetChildNode (nNode);

					// It is a zone ?
					if (RPO::isZone (*pNode, pData->T))
					{
					}
					// Try to export a mesh
					else if (CExportNel::isMesh (*pNode, pData->T))
					{
						// Build skined ?
						bool skined=false;
						
						// Export the shape
						IShape *pShape;
						pShape=export_.buildShape (*pNode, pData->T, NULL, true);

						// Export successful ?
						if (pShape)
						{
							// Add the shape to the view
							CNELU::ShapeBank->add (CExportNel::getName (*pNode), pShape);

							// Create an instance
							CTransformShape *tShape=CNELU::Scene->createInstance (CExportNel::getName (*pNode));

							// Big hack to sort
							TheLand->clipAddChild(tShape);
						}
					}
				}

				// Setup ambient light
				CNELU::Driver->setAmbientColor (export_.getAmbientColor (pData->T));

				// Build light vector
				std::vector<CLight> vectLight;
				export_.getLights (vectLight, pData->T);

				// Insert each lights
				for (uint light=0; light<vectLight.size(); light++)
					CNELU::Driver->setLight (light, vectLight[light]);
			}

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

			// Init the camera
			CMatrix	mat;
			mat.identity();
			CVector	I,J,K,P;
			
			Matrix3 matInvert;
			matInvert.SetRow (0, Point3(1.f, 0.f, 0.f));
			matInvert.SetRow (1, Point3(0.f, 0.f, 1.f));
			matInvert.SetRow (2, Point3(0.f, -1.f, 0.f));
			matInvert.SetRow (3, Point3(0.f, 0.f, 0.f));
			matInvert.Invert();
			affineTM.Invert();
			affineTM=matInvert*affineTM;

			I.x= affineTM.GetRow(0).x;
			I.y= affineTM.GetRow(0).y;
			I.z= affineTM.GetRow(0).z;
			J.x= affineTM.GetRow(1).x;
			J.y= affineTM.GetRow(1).y;
			J.z= affineTM.GetRow(1).z;
			K.x= affineTM.GetRow(2).x;
			K.y= affineTM.GetRow(2).y;
			K.z= affineTM.GetRow(2).z;

			P.x= affineTM.GetTrans().x;
			P.y= affineTM.GetTrans().y;
			P.z= affineTM.GetTrans().z;
			mat.setRot(I, J, K);
			mat.setPos(P);
			CNELU::Camera->setTransformMode (ITransformable::DirectMatrix);
			CNELU::Camera->setMatrix (mat);
			CNELU::Camera->setPerspective( 75.f*(float)Pi/180.f/*vp->GetFOV()*/, 1.33f, 0.1f, 1000.f);

			// Resize the sym vector
			symVector.resize (pData->VectMesh.size());

			// Form each zone
			uint i;
			for (i = 0; i <(int)pData->VectMesh.size(); i++)
			{
				// Get pointers
				PaintPatchData *patchData = pData->VectMesh[i].PatchData;
				RPatchMesh *rpatch = pData->VectMesh[i].RMesh;
				PatchMesh *patch = pData->VectMesh[i].PMesh;
				if ((!patchData)||(!patch)||(!rpatch))
					continue;

				// Get the symmetry flag
				CLigoConfig config;
				if (!loadLigoConfigFile (config, *pData->eproc->ip))
				{
					config.CellSize = 100;
					config.Snap = 1;
					config.ZoneSnapShotRes = 128;
				}

				// Create the zone..
				CZone	zone;
				if (rpatch->exportZone (pData->VectMesh[i].Node, patch, zone, symVector[i], i, config.CellSize, config.Snap, true))
				{
					// Smooth corner
					CZoneCornerSmoother cornerSmoother;
					std::vector<CZone*> emptyVector;
					cornerSmoother.computeAllCornerSmoothFlags (&zone, emptyVector);

					// Add the zone
					TheLand->Landscape.addZone (zone);
				}
				else
				{
					char message[512];
					smprintf (message, 512, "Can't build the zone named %s", pData->VectMesh[i].Node->GetName());
					MessageBox (pData->eproc->ip->GetMAXHWnd(), message, "NeL Painter", MB_OK|MB_ICONEXCLAMATION);
				}
			}

			// Check zones
	#ifdef NL_DEBUG
			TheLand->Landscape.checkBinds();
	#endif // NL_DEBUG

			// Refine les zones
			TheLand->Landscape.setRefineMode (true);

			// Go.
			//========
			CEvent3dMouseListener	mouseListener;
			MouseListener			listener (pData->eproc->ip, CNELU::Camera, &viewport, pData->pobj, pData->eproc, &TheLand->Landscape, 
				&CNELU::AsyncListener, &mouseListener, pData->VectMesh, pData->T);

			// Mouse listener
			CNELU::EventServer.addListener (EventMouseMoveId, &listener);
			CNELU::EventServer.addListener (EventMouseDownId, &listener);
			CNELU::EventServer.addListener (EventMouseUpId, &listener);
			CNELU::EventServer.addListener (EventMouseDblClkId, &listener);
			CNELU::EventServer.addListener (EventDestroyWindowId, &listener);
			CNELU::EventServer.addListener (EventKeyDownId, &listener);

			// Camera position

			// Mouse listener
			mouseListener.setMatrix (CNELU::Camera->getMatrix());
			mouseListener.setFrustrum (CNELU::Camera->getFrustum());
			mouseListener.setViewport (viewport);
			mouseListener.setHotSpot (pData->center);
			mouseListener.setMouseMode (CEvent3dMouseListener::edit3d);

			mouseListener.addToServer(CNELU::EventServer);

			// *** Flush all selected tileset...
			if (pData->pobj->preloadTiles)
			{
				// For all the tileset selected
				for (sint tss=0; tss<(sint)tileSetSelector.getTileCount (); tss++)
				{			
					// Get the tileset index
					sint ts=tileSetSelector.getTileSet (tss);

					// Get the tileset pointer
					CTileSet *tileSet=bank.getTileSet (ts);
					nlassert (tileSet);

					// Flush all its 128x128 tiles
					sint tl;
					for (tl=0; tl<tileSet->getNumTile128(); tl++)
						TheLand->Landscape.flushTiles (CNELU::Scene->getDriver(), (uint16)tileSet->getTile128(tl), 1);

					// Flush all its 256x256 tiles
					for (tl=0; tl<tileSet->getNumTile256(); tl++)
						TheLand->Landscape.flushTiles (CNELU::Scene->getDriver(), (uint16)tileSet->getTile256(tl), 1);

					// Flush all its transisitons tiles
					for (tl=0; tl<CTileSet::count; tl++)
						TheLand->Landscape.flushTiles (CNELU::Scene->getDriver(), (uint16)tileSet->getTransition(tl)->getTile (), 1);
				}
			}

			// Setup lights
			CPaintLight lights;
			lights.build (*pData->eproc->ip);
			lights.setup (TheLand->Landscape, *CNELU::Scene);

			// MAIN LOOP
			do
			{
				// Pump events
				CNELU::EventServer.pump();

				// Call the proc
				mainproc(*CNELU::Scene, CNELU::AsyncListener, mouseListener, *TheLand, *CNELU::Scene->getDriver(), pData, listener.PaintColor);
			}
			while (!CNELU::AsyncListener.isKeyPushed(KeyESCAPE)&&listener.WindowActive);

			// Release the emitter from the server
			mouseListener.removeFromServer (CNELU::EventServer);

			CNELU::Scene->getDriver()->release ();

			// Mouse listener
			CNELU::EventServer.removeListener (EventMouseMoveId, &listener);
			CNELU::EventServer.removeListener (EventMouseDownId, &listener);
			CNELU::EventServer.removeListener (EventMouseUpId, &listener);
			CNELU::EventServer.removeListener (EventMouseDblClkId, &listener);
			CNELU::EventServer.removeListener (EventKeyDownId, &listener);
			CNELU::EventServer.removeListener (EventDestroyWindowId, &listener);

			// End.
			//========
			CNELU::release();
		}
		catch (EDru& druExcept)
		{
			MessageBox (NULL, druExcept.what(), "NeL driver utility", MB_OK|MB_ICONEXCLAMATION);
		}

		delete pData;
	}
	catch (Exception& e)
	{
		MessageBox (NULL, e.what(), "NeL Painter", MB_OK|MB_ICONEXCLAMATION);
	}

	return 0;
}

/*-------------------------------------------------------------------*/

void EPM_PaintCMode::ExitMode()
{
	pobj->channelModified=EDITPAT_CHANNELS;
	if (pobj->hOpsPanel)
	{
		ICustButton *but = GetICustButton(GetDlgItem(pobj->hOpsPanel, IDC_PAINT));
		but->SetCheck(FALSE);
		ReleaseICustButton(but);

		// Build paint tile infos..
		nlassert (eproc.ip);
	}
}

/*-------------------------------------------------------------------*/

class NelPatchHitData : public HitData
{
public:
	NelPatchHitData (int index, int type, int mesh)
	{
		Index=index;
		Type=type;
		Mesh=mesh;
	}
	int Index;
	int Type;
	int Mesh;
};

BOOL EPM_PaintMouseProc::HitATile(ViewExp *vpt, IPoint2 *p, int *tile, int *mesh, TimeValue t, std::vector<EPM_Mesh>& vectMesh, CVector &hit, CVector &topVector)
{
	// Get a world ray with the mouse 2d point
	Ray ray;
	vpt->MapScreenToWorldRay((float)p->x,  (float)p->y, ray);

	// Select tree's node with the world ray
	quadTreeSelect.clearSelection ();
	quadTreeSelect.selectRay (CVector (ray.p.x, ray.p.y, ray.p.z), CVector (ray.dir.x, ray.dir.y, ray.dir.z));

	// Get selected nodes..
	CQuadTree<EPM_PaintTile*>::CIterator it=quadTreeSelect.begin();
	while (it!=quadTreeSelect.end())
	{
		// Check if the ray intersect the tile..
		if ((*it)->intersect (ray, vectMesh, t, hit, topVector))
		{
			*tile = (*it)->tile;
			*mesh = (*it)->Mesh;
			return TRUE;
		}
		it++;
	}

	return FALSE;
}

BOOL EPM_PaintMouseProc::HitATile(const CViewport& viewport, const CCamera& camera, float x, float y, int *tile, int *mesh, TimeValue t, 
								  std::vector<EPM_Mesh>& vectMesh, NLMISC::CVector& hit, NLMISC::CVector &topVector)
{
	// Get a world ray with the mouse 2d point
	CVector pos, dir;
	viewport.getRayWithPoint (x, y, pos, dir, camera.getMatrix(), camera.getFrustum());

	// Select tree's node with the world ray
	quadTreeSelect.clearSelection ();
	quadTreeSelect.selectRay (pos, dir);

	// Get selected nodes..
	CQuadTree<EPM_PaintTile*>::CIterator it=quadTreeSelect.begin();

	BOOL bRet=FALSE;

	float fMin=FLT_MAX;
	while (it!=quadTreeSelect.end())
	{
		// Check if the ray intersect the tile..

		Ray ray;
		ray.p.x=pos.x;
		ray.p.y=pos.y;
		ray.p.z=pos.z;
		ray.dir.x=dir.x;
		ray.dir.y=dir.y;
		ray.dir.z=dir.z;
		CVector hit2;
		if ((*it)->intersect (ray, vectMesh, t, hit2, topVector))
		{
			float newDist=(hit2-camera.getMatrix().getPos()).norm();
			if (newDist<fMin)
			{
				*tile = (*it)->tile;
				*mesh = (*it)->Mesh;
				fMin=newDist;
				hit=hit2;
				bRet=TRUE;
			}
		}
		it++;
	}

	return bRet;
}

/*-------------------------------------------------------------------*/

bool CheckTri (const Point3& pos0, const Point3& pos1, const Point3& pos2, const Ray& ray, CVector& hit)
{
	// Vectors in Nel format
	CVector v0 (pos0.x, pos0.y, pos0.z);
	CVector v1 (pos1.x, pos1.y, pos1.z);
	CVector v2 (pos2.x, pos2.y, pos2.z);
	CVector pos (ray.p.x, ray.p.y, ray.p.z);
	CVector dir (ray.dir.x, ray.dir.y, ray.dir.z);
	CVector center=v0+v1+v2;
	center/=3.f;
	dir.normalize ();

	// A second point on the ray
	hit=pos+dir;

	// Plane of the tri
	CPlane plane;
	plane.make (v0, v1, v2);

	// Normale
	CVector	normal=plane.getNormal();

	// Devant ?
	if ((plane*pos)<0.f)
		return false;

	// Derrière ?
	if ((dir*(center-pos))<0.f)
		return false;

	// Point on the plane
	hit=plane.intersect (pos, pos+dir); //(D*p/(D-d))*dir+pos;

	// Check the point...
	bool positive=(((v0-hit)^(v1-hit))*normal>0.f);

	if ((((v1-hit)^(v2-hit))*normal>0.f)!=positive)
		return false;
	return ((((v2-hit)^(v0-hit))*normal>0.f)==positive);
}

/*-------------------------------------------------------------------*/

bool EPM_PaintTile::intersect (const Ray& ray, std::vector<EPM_Mesh>& vectMesh, TimeValue t, CVector& hit, CVector& topVector)
{
	// Pointer on the patch mesh
	PatchMesh *patchPtr=vectMesh[Mesh].PMesh;
	RPatchMesh *rpatch=vectMesh[Mesh].RMesh;
	INode *node=vectMesh[Mesh].Node;

	// Nb tile in this patch
	int nU=1<<rpatch->getUIPatch (patch).NbTilesU;
	int nV=1<<rpatch->getUIPatch (patch).NbTilesV;

	// 4 corners
	Point3 pos[4];
	pos[0]=patchPtr->patches[patch].interp (patchPtr, (float)u/(float)(nU), (float)v/(float)(nV));
	pos[0]=pos[0]*(node->GetObjectTM (t));
	pos[1]=patchPtr->patches[patch].interp (patchPtr, (float)u/(float)(nU), (float)(v+1)/(float)(nV));
	pos[1]=pos[1]*(node->GetObjectTM (t));
	pos[2]=patchPtr->patches[patch].interp (patchPtr, (float)(u+1)/(float)(nU), (float)(v+1)/(float)(nV));
	pos[2]=pos[2]*(node->GetObjectTM (t));
	pos[3]=patchPtr->patches[patch].interp (patchPtr, (float)(u+1)/(float)(nU), (float)v/(float)(nV));
	pos[3]=pos[3]*(node->GetObjectTM (t));

	// Symmetry ?
	if (vectMesh[Mesh].Symmetry)
	{
		Point3 tmp = pos[0];
		pos[0] = pos[3];
		pos[3] = tmp;
		tmp = pos[1];
		pos[1] = pos[2];
		pos[2] = tmp;
	}

	// Get the normal
	Point3 up = (pos[1]-pos[0]) ^ (pos[2]-pos[0]);
	topVector.x = up.x;
	topVector.y = up.y;
	topVector.z = up.z;
	topVector.normalize ();

	// Check first tri
	if (CheckTri (pos[0], pos[1], pos[3], ray, hit))
		return true;

	// Check second tri
	if (CheckTri (pos[1], pos[2], pos[3], ray, hit))
		return true;

	// No intersection
	return false;
}

/*-------------------------------------------------------------------*/

int EPM_PaintMouseProc::proc(
			HWND hwnd, 
			int msg, 
			int point, 
			int flags, 
			IPoint2 m)
{
	ViewExp *vpt = ip->GetViewport(hwnd);	
	int res = TRUE;
	static PatchMesh *shape1 = NULL;
	static int poly1, tile1, tile2, mesh1, mesh2, seg1;
	static bool pressed=false;
	static IPoint2 anchor, lastPoint;

	switch (msg)
	{
		case MOUSE_PROPCLICK:
			ip->SetStdCommandMode(CID_OBJMOVE);
			break;

		case MOUSE_POINT:
			if (point)
				PaintPatchMod::paintMode->DoPaint ();
			break;

		case MOUSE_MOVE:
			break;
					
		case MOUSE_FREEMOVE:
			break;
		
		case MOUSE_ABORT:
			ip->SetStdCommandMode(CID_OBJMOVE);
			break;
	}

	if (vpt)
		ip->ReleaseViewport(vpt);

	return res;
}

/*-------------------------------------------------------------------*/