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

#include "screenshot_islands.h"

#include <game_share/scenario_entry_points.h>

#include <game_share/season.h>
#include <game_share/dir_light_setup.h>
#include <game_share/bmp4image.h>

#include <nel/misc/path.h>
#include <nel/misc/file.h>
#include <nel/misc/config_file.h>
#include <nel/misc/big_file.h>
#include <nel/misc/i18n.h>
#include <nel/misc/progress_callback.h>
#include <nel/misc/random.h>
#include <nel/misc/common.h>
#include <nel/3d/u_material.h>

#include <nel/3d/u_driver.h>
#include <nel/3d/u_scene.h>
#include <nel/3d/u_landscape.h>
#include <nel/3d/u_camera.h>
#include <nel/3d/landscapeig_manager.h>
#include <nel/3d/u_material.h>

#include <nel/georges/u_form_loader.h>
#include <nel/georges/u_form.h>
#include <nel/georges/u_form_elm.h>

// AI share
#include <ai_share/world_map.h>

#include <nel/3d/material.h>

#include <math.h>
#include <limits>

using namespace NLMISC;
using namespace NL3D;
using namespace std;
using namespace EGSPD;
using namespace NLGEORGES;
using namespace RYAI_MAP_CRUNCH;


// The 3d driver
UDriver        *driver = NULL;
CLandscapeIGManager		LandscapeIGManager;

uint			ScreenShotWidth;	
uint			ScreenShotHeight;

UMaterial sceneMaterial;

namespace R2
{

const TBufferEntry InteriorValue = std::numeric_limits<TBufferEntry>::max()-1;
const TBufferEntry ValueBorder = std::numeric_limits<TBufferEntry>::max()-2;
const uint32 BigValue= 15*5;
const float limitValue = 200.0;

//-------------------------------------------------------------------------------------------------
CScreenshotIslands::CScreenshotIslands()
{
	_BackColor = CRGBA(255, 255, 255, 255);
}

//-------------------------------------------------------------------------------------------------
void CScreenshotIslands::init()
{
	// Create a driver
	driver = UDriver::createDriver(0, true);
	nlassert(driver);

	sceneMaterial = driver->createMaterial();
	sceneMaterial.getObjectPtr()->setLighting(true);
	sceneMaterial.getObjectPtr()->setSpecular(CRGBA(255, 255, 255, 255));
	sceneMaterial.getObjectPtr()->setShininess(50);
	sceneMaterial.getObjectPtr()->setDiffuse(CRGBA(100, 100, 100, 255));
	sceneMaterial.getObjectPtr()->setEmissive(CRGBA(25, 25, 25, 255));

	// load and parse the configfile
	CConfigFile cf;
	cf.load("island_screenshots.cfg");

	// get the value of searchPaths
	CConfigFile::CVar * searchPaths = cf.getVarPtr("SearchPaths");
	if(searchPaths)
	{
		for(int i = 0; i < searchPaths->size(); i++)
		{
 			CPath::addSearchPath(searchPaths->asString(i).c_str(), true, false);
		}
	}
	CPath::remapExtension("dds", "tga", true);
	CPath::remapExtension("dds", "png", true);

	// get the scenario entry points file
	CConfigFile::CVar * epFile = cf.getVarPtr("CompleteIslandsFile");
	if(epFile)
	{
		_CompleteIslandsFile = epFile->asString();
	}

	// get the out directory path
	CConfigFile::CVar * outDir = cf.getVarPtr("OutDir");
	if(outDir)
	{
		_OutDirectory = outDir->asString();
	}

	// get the vegetation option
	CConfigFile::CVar * veget = cf.getVarPtr("Vegetation");
	if(veget)
	{
		_Vegetation = veget->asBool();
	}

	// get the vegetation option
	CConfigFile::CVar * inverseZTest = cf.getVarPtr("InverseZTest");
	if(inverseZTest)
	{
		_InverseZTest = inverseZTest->asBool();
	}

	// get list of continents
	CConfigFile::CVar * continents = cf.getVarPtr("Continents");
	vector<string> continentsName(continents->size());
	for(int i = 0; i < continents->size(); i++)
	{
 		continentsName[i] = continents->asString(i);	
	}
	
	// get continents data (light, coarseMesh,...)
	UFormLoader * formLoader;
	for(uint i=0; i<continentsName.size(); i++)
	{
		string georgeFileName = continentsName[i]+".continent";

		formLoader = UFormLoader::createLoader();
		CSmartPtr<UForm> form = formLoader->loadForm(CPath::lookup(georgeFileName).c_str());
		if(form)
		{
			CContinentData continentData;

			UFormElm &formRoot = form->getRootNode();

			const UFormElm *elm;
			if(formRoot.getNodeByName(&elm, "LightLandscapeDay") && elm)
			{
				CDirLightSetup	landscapeLightDay;
				landscapeLightDay.build(*elm);
				continentData.Ambiant = landscapeLightDay.Ambiant;
				continentData.Diffuse = landscapeLightDay.Diffuse;

				if(continentsName[i]=="r2_jungle" || continentsName[i]=="r2_forest" || continentsName[i]=="r2_roots")
				{
					continentData.Ambiant = CRGBA(255, 255, 255, 255);
					continentData.Diffuse = CRGBA(255, 255, 255, 255);
				}
			}

			formRoot.getValueByName(continentData.IGFile, "LandscapeIG");
			string zoneMin, zoneMax;
			formRoot.getValueByName(zoneMin, "ZoneMin");
			formRoot.getValueByName(zoneMax, "ZoneMax");

			getPosFromZoneName(zoneMin, continentData.ZoneMin);
			getPosFromZoneName(zoneMax, continentData.ZoneMax);

			string filename;
			if(formRoot.getValueByName(filename, "Ecosystem"))
			{
				UFormLoader *formLoaderEco = UFormLoader::createLoader();
				if(formLoaderEco)
				{		
					// Load the form
					CSmartPtr<UForm> formEco = formLoaderEco->loadForm(filename.c_str());

					if(formEco)
					{
						// Root node
						UFormElm &formRootEco = formEco->getRootNode();

						// Small bank.
						formRootEco.getValueByName(continentData.SmallBank, "SmallBank");

						// Far bank.
						formRootEco.getValueByName(continentData.FarBank, "FarBank");

						// Coarse mesh texture.
						formRootEco.getValueByName(continentData.CoarseMeshMap, "CoarseMeshMap");
					}
					else 
					{
						nlwarning("CScreenshotIslands::init : Can't load form %s.", filename.c_str());
					}
					UFormLoader::releaseLoader(formLoaderEco);
				}		
			}

			_ContinentsData[continentsName[i]] = continentData;
		}
		UFormLoader::releaseLoader(formLoader);
	}
	

	// load islands
	loadIslands();

	searchIslandsBorders();

	// get seasons
	CConfigFile::CVar * seasonSuffixes = cf.getVarPtr("SeasonSuffixes");
	if(seasonSuffixes)
	{
		for(uint i = 0; i < (uint)seasonSuffixes->size(); i++)
		{
 			_SeasonSuffixes.push_back(seasonSuffixes->asString(i));
		}
	}
	
	// get the meter size in pixels
	CConfigFile::CVar * meterSize = cf.getVarPtr("MeterPixelSize");
	if(meterSize)
	{
		_MeterPixelSize = meterSize->asInt();
	}
}

//-------------------------------------------------------------------------------------------------
bool CScreenshotIslands::getPosFromZoneName(const std::string &name, NLMISC::CVector2f &dest)
{
	if(name.empty())
	{
		nlwarning ("getPosFromZoneName(): empty name, can't getPosFromZoneName");
		return false;
	}

	static std::string zoneName;
	static string xStr, yStr;
	xStr.clear();
	yStr.clear();
	zoneName = CFile::getFilenameWithoutExtension(name);
	uint32 i = 0;
	while(zoneName[i] != '_')
	{
		if(!::isdigit(zoneName[i])) return false;
		yStr += zoneName[i]; ++i;
		if(i == zoneName.size())
			return false;
	}	
	++i;
	while(i < zoneName.size())
	{
		if(!::isalpha(zoneName[i])) return false;
		xStr += (char) ::toupper(zoneName[i]); ++i;
	}
	if(xStr.size() != 2) return false;
	dest.x = 160.f * ((xStr[0] - 'A') * 26 + (xStr[1] - 'A'));
	dest.y = 160.f * -atoi(yStr.c_str());
	return true;
}

//-------------------------------------------------------------------------------------------------
void CScreenshotIslands::searchIslandsBorders()
{
	vector<string> filenames;
	list<string> zonelFiles;

	map< CVector2f, bool> islandsMap;
	
	TContinentsData::iterator itCont(_ContinentsData.begin()), lastCont(_ContinentsData.end());
	for( ; itCont != lastCont ; ++itCont)
	{
		// for each continent we recover a map of zonel files whith position of 
		// left/bottom point of each zone for keys
		filenames.clear();
		zonelFiles.clear();

		string bnpFileName = itCont->first + ".bnp";
		CBigFile::getInstance().list(bnpFileName.c_str(), filenames);

		for(uint i=0; i<filenames.size(); i++)
		{
			if(CFile::getExtension(filenames[i]) == "zonel")
			{
				zonelFiles.push_back(filenames[i]);
			}
		}

		list<string>::iterator itZonel(zonelFiles.begin()), lastZonel(zonelFiles.end());
		for( ; itZonel != lastZonel ; ++itZonel)
		{	
			CVector2f position;
			getPosFromZoneName(*itZonel, position);
			
			islandsMap[position] = true;
		}

		// search for island borders
		CContinentData & continent = itCont->second;
		list< string >::const_iterator itIsland(continent.Islands.begin()), lastIsland(continent.Islands.end());
		for( ; itIsland != lastIsland ; ++itIsland)
		{
			if(_IslandsData.find(itIsland->c_str()) != _IslandsData.end())
			{
				const CProximityZone & islandData = _IslandsData[itIsland->c_str()];

				sint32 xmin = islandData.getBoundXMin();
				sint32 xmax = islandData.getBoundXMax();
				sint32 ymin = islandData.getBoundYMin();
				sint32 ymax = islandData.getBoundYMax();

				sint32 width = xmax-xmin;
				sint32 height = ymax-ymin;

				sint32 zonelXMin = ((uint)(xmin/160)) * 160;
				sint32 zonelYMin = ((uint)(ymin/160) - 1) * 160;
				sint32 zonelXMax = ((uint)(xmax/160)) * 160;
				sint32 zonelYMax = ((uint)(ymax/160) - 1) * 160;

				list< CVector2f > leftBorders, rightBorders, bottomBorders, topBorders;
				
				// search for left and right borders on lines
				for(sint32 y = zonelYMin; y<=zonelYMax; y+=160 )
				{
					sint32 x=zonelXMin;
					CVector2f vec((float)x, (float)y);
					bool lastZoneFull = (islandsMap.find(vec) != islandsMap.end());
					bool currentZoneFull;

					while(x<=zonelXMax)
					{
						vec = CVector2f((float)x, (float)y);
						currentZoneFull = (islandsMap.find(vec) != islandsMap.end());
						
						if(lastZoneFull && !currentZoneFull && vec.x-1 >= xmin)
						{
							rightBorders.push_back(CVector2f(vec.x-1, vec.y));
						}
						else if(!lastZoneFull && currentZoneFull)
						{
							leftBorders.push_back(vec);
						}
						x += 160;
						lastZoneFull = currentZoneFull;
					}
				}

				// search for bottom and top borders on columns
				for(sint32 x = zonelXMin; x<=zonelXMax; x+=160 )
				{
					sint32 y=zonelYMin;
					CVector2f vec((float)x, (float)y);
					bool lastZoneFull = (islandsMap.find(vec) != islandsMap.end());
					bool currentZoneFull;

					while(y<=zonelYMax)
					{
						vec = CVector2f((float)x, (float)y);
						currentZoneFull = (islandsMap.find(vec) != islandsMap.end());
						
						if(lastZoneFull && !currentZoneFull && vec.y-1 >= ymin)
						{
							topBorders.push_back(CVector2f(vec.x, vec.y-1));
						}
						else if(!lastZoneFull && currentZoneFull)
						{
							bottomBorders.push_back(vec);
						}
						y += 160;
						lastZoneFull = currentZoneFull;
					}
				}

				_BorderIslands[*itIsland + "/right"] = rightBorders;
				_BorderIslands[*itIsland + "/left"] = leftBorders;
				_BorderIslands[*itIsland + "/bottom"] = bottomBorders;
				_BorderIslands[*itIsland + "/top"] = topBorders;
			}
		}
	}
}

//-------------------------------------------------------------------------------------------------
void CScreenshotIslands::attenuateIslandBorders(const std::string & islandName, CBitmap & islandBitmap,
												const CProximityZone & islandData)
{
	list< CVector2f > leftBorders, rightBorders, bottomBorders, topBorders;
	rightBorders = _BorderIslands[islandName + "/right"];
	leftBorders = _BorderIslands[islandName + "/left"];
	bottomBorders = _BorderIslands[islandName + "/bottom"];
	topBorders = _BorderIslands[islandName + "/top"];

	sint32 xmin = islandData.getBoundXMin();
	sint32 xmax = islandData.getBoundXMax();
	sint32 ymin = islandData.getBoundYMin();
	sint32 ymax = islandData.getBoundYMax();

	sint32 width = xmax-xmin;
	sint32 height = ymax-ymin;
	uint8 *dest	= &(islandBitmap.getPixels(0)[0]);

	list< CVector2f >::iterator itBorder;

	for(itBorder=leftBorders.begin(); itBorder!=leftBorders.end(); itBorder++)
	{
		const CVector2f initPoint = *itBorder;
		sint32 x = (sint32)initPoint.x - xmin;
		sint32 y = (sint32)initPoint.y - ymin;
		sint32 maxBorder = 160;
		if(y<0)
		{
			maxBorder += y;
			y = 0;
		}
		sint32 inity = y;

		while(y<(inity+maxBorder) && y<(sint32)height)
		{
			double noiseValue = (1+cos(((y-inity)*2*Pi)/maxBorder))*5;
			double evalNoise = 10 + noiseValue;
			double diffAlpha = 255/evalNoise;

			CRGBA color = islandBitmap.getPixelColor(x, height-y-1);
			sint32 currentX = x-1;

			while((currentX>=x-evalNoise) && currentX>=0)
			{
				uint8 *pixel = &(islandBitmap.getPixels(0)[((height-y-1)*width + currentX)*4]);
				uint alpha = (uint)(255-diffAlpha*(x-currentX));
				uint invAlpha = 255-alpha;

				*pixel = (uint8) (((invAlpha * *pixel)		+ (alpha * color.R)) >> 8);
				*(pixel + 1) = (uint8) (((invAlpha * *(pixel + 1)) + (alpha * color.G)) >> 8);
				*(pixel + 2) = (uint8) (((invAlpha * *(pixel + 2)) + (alpha * color.B)) >> 8);
				*(pixel + 3)  = (uint8) 255;

				currentX--;
			}
			y++;
		}
	}

	for(itBorder=rightBorders.begin(); itBorder!=rightBorders.end(); itBorder++)
	{
		const CVector2f initPoint = *itBorder;
		sint32 x = (sint32)initPoint.x - xmin;
		sint32 y = (sint32)initPoint.y - ymin;
		sint32 maxBorder = 160;
		if(y<0)
		{
			maxBorder += y;
			y = 0;
		}
		sint32 inity = y;

		while(y<(inity+maxBorder) && y<(sint32)height)
		{
			double noiseValue = (1+cos(((y-inity)*2*Pi)/maxBorder))*5;
			double evalNoise = 10 + noiseValue;
			double diffAlpha = 255/evalNoise;

			CRGBA color = islandBitmap.getPixelColor(x, height-y-1);
			sint32 currentX = x+1;

			while((currentX<=x+evalNoise) && currentX<width)
			{
				uint8 *pixel = &(islandBitmap.getPixels(0)[((height-y-1)*width + currentX)*4]);
				uint alpha = (uint)(255-diffAlpha*(currentX-x));
				uint invAlpha = 255-alpha;

				*pixel = (uint8) (((invAlpha * *pixel)		+ (alpha * color.R)) >> 8);
				*(pixel + 1) = (uint8) (((invAlpha * *(pixel + 1)) + (alpha * color.G)) >> 8);
				*(pixel + 2) = (uint8) (((invAlpha * *(pixel + 2)) + (alpha * color.B)) >> 8);
				*(pixel + 3)  = (uint8) 255;

				currentX++;
			}

			y++;
		}
	}
	
	for(itBorder=bottomBorders.begin(); itBorder!=bottomBorders.end(); itBorder++)
	{
		const CVector2f initPoint = *itBorder;
		sint32 x = (sint32)initPoint.x - xmin;
		sint32 y = (sint32)initPoint.y - ymin;
		sint32 maxBorder = 160;
		if(x<0)
		{
			maxBorder += x;
			x = 0;
		}
		sint32 initx = x;
		
		while(x<(initx+maxBorder) && x<(sint32)width)
		{
			double noiseValue = (1+cos(((x-initx)*2*Pi)/maxBorder))*5;
			double evalNoise = 10 + noiseValue;
			double diffAlpha = 255/evalNoise;

			CRGBA color = islandBitmap.getPixelColor(x, height-y-1);
			sint32 currentY = y-1;

			while((currentY>=y-evalNoise) && currentY>=0)
			{
				uint8 *pixel = &(islandBitmap.getPixels(0)[((height-currentY-1)*width + x)*4]);
				uint alpha = (uint)(255-diffAlpha*(y-currentY));
				uint invAlpha = 255-alpha;

				*pixel = (uint8) (((invAlpha * *pixel)		+ (alpha * color.R)) >> 8);
				*(pixel + 1) = (uint8) (((invAlpha * *(pixel + 1)) + (alpha * color.G)) >> 8);
				*(pixel + 2) = (uint8) (((invAlpha * *(pixel + 2)) + (alpha * color.B)) >> 8);
				*(pixel + 3)  = (uint8) 255;

				currentY--;
			}

			x++;
		}
	}

	for(itBorder=topBorders.begin(); itBorder!=topBorders.end(); itBorder++)
	{
		const CVector2f initPoint = *itBorder;
		sint32 x = (sint32)initPoint.x - xmin;
		sint32 y = (sint32)initPoint.y - ymin;
		sint32 maxBorder = 160;
		if(x<0)
		{
			maxBorder += x;
			x = 0;
		}
		sint32 initx = x;
		
		while(x<(initx+maxBorder) && x<(sint32)width)
		{
			double noiseValue = (1+cos(((x-initx)*2*Pi)/maxBorder))*5;
			double evalNoise = 10 + noiseValue;
			double diffAlpha = 255/evalNoise;

			CRGBA color = islandBitmap.getPixelColor(x, height-y-1);
			sint32 currentY = y+1;

			while((currentY<=y+evalNoise) && currentY<height)
			{
				uint8 *pixel = &(islandBitmap.getPixels(0)[((height-currentY-1)*width + x)*4]);
				uint alpha = (uint)(255-diffAlpha*(currentY-y));
				uint invAlpha = 255-alpha;

				*pixel = (uint8) (((invAlpha * *pixel)		+ (alpha * color.R)) >> 8);
				*(pixel + 1) = (uint8) (((invAlpha * *(pixel + 1)) + (alpha * color.G)) >> 8);
				*(pixel + 2) = (uint8) (((invAlpha * *(pixel + 2)) + (alpha * color.B)) >> 8);
				*(pixel + 3)  = (uint8) 255;

				currentY++;
			}

			x++;
		}
	}
}

//-------------------------------------------------------------------------------------------------
void CScreenshotIslands::buildScreenshots()
{
	init();
	buildIslandsTextures();
}

//-------------------------------------------------------------------------------------------------
void CScreenshotIslands::writeProximityBufferToTgaFile(const std::string& fileName,const TBuffer& buffer,uint32 scanWidth,uint32 scanHeight)
{
	uint	imageWidth = (scanWidth); // (scanWidth+15)&~15;
	uint	imageHeight = (scanHeight);

	CTGAImageGrey tgaImage;
	tgaImage.setup((uint16)imageWidth, (uint16)imageHeight, fileName, 0, 0);
	for (uint32 y=0;y<scanHeight;++y)
	{
		for (uint32 x=0; x<scanWidth; ++x)
		{
			uint32 value= buffer[y*scanWidth+x];
			tgaImage.set(x, (value>255*5)?255:value/5);
		}
		tgaImage.writeLine();
	}
}

//-------------------------------------------------------------------------------------------------
void CScreenshotIslands::processProximityBuffer(TBuffer & inputBuffer, uint32 lineLength, TBuffer& resultBuffer)
{
	// a couple of constants to control the range over which our degressive filter is to be applied
	const uint32 smallValue= 2*5;

	float a = 5*((255.0 - limitValue)/(float(100-BigValue)));
	float b = (float)(limitValue*5 - a*BigValue);

	// determine numer of lines in the buffer...
	uint32 numLines= inputBuffer.size()/ lineLength;

	// clear out the result buffer and reset all values to 5*255, remembering that this is the correct value for the image edges
	resultBuffer.clear();
	resultBuffer.resize(inputBuffer.size(),(TBufferEntry)5*255);

	for (uint32 y=1;y<numLines-1;++y)
	{
		uint32 lineOffset= y* lineLength;
		for (uint32 x=1;x<lineLength-1;++x)
		{
			uint32 offset= lineOffset+x;
			
			uint32 value=(uint32)inputBuffer[offset];

			// apply a clip and cosine function
			/*
			if (value<smallValue) value=0;
			else if (value>BigValue) value=5*255;
			else value= (uint32)(((1.0-cos(Pi*(float(value-smallValue)/(float)(BigValue-smallValue))))/2.0)*float(5*255));
			*/

			if (value==ValueBorder);
			else if ((value>=0) && (value<smallValue)) value=0;
			else if (value>BigValue) 
			{
				if(value==InteriorValue) 
				{
					value = (uint)(5*limitValue);	
				}
				else
				{
					value = (uint)(a*value+b);
					if(value > 5*255) value = 5*255; 
				}
			}
			else if((value>=smallValue) && (value<=BigValue))
			{
				value= (uint32)(((1.0-cos(Pi*(float(value-smallValue)/(float)(BigValue-smallValue))))/2.0)*float(5*limitValue));
			}

			// store the value into the result buffer
			resultBuffer[offset]= (TBufferEntry)value;
		}
	}

	// modify inputBuffer to store "bigValue" limit
	for (uint32 y=1;y<numLines-1;++y)
	{
		uint32 lineOffset= y* lineLength;
		for (uint32 x=1;x<lineLength-1;++x)
		{
			uint32 offset= lineOffset+x;

			uint32 value=(uint32)inputBuffer[offset];

			if(value==BigValue) value = 255*5;
			else value = 0;
			
			inputBuffer[offset]= (TBufferEntry)value;
		}
	}

	/*
	// lines
	for (uint32 y=0;y<numLines;++y)
	{
		uint32 lineOffset= y* lineLength;

		for (uint32 x=0;x<lineLength;++x)
		{
			uint32 offset = lineOffset+x;
			uint16 value = resultBuffer[offset];
			
			if(value==ValueBorder)
			{
				resultBuffer[offset]= (TBufferEntry)(5*limitValue);
				
				// increase x
				if(x+1<lineLength-1)
				{
					uint16 nextValue = resultBuffer[offset+1];
					uint16 prevValue = (TBufferEntry)(5*limitValue);
					if(nextValue!=(TBufferEntry)(5*limitValue))
					{
						uint32 count = x+1;	
						while((count<x+7) && (count<lineLength-1) && ((nextValue=resultBuffer[lineOffset+count])!=0) 
							&& nextValue!=(TBufferEntry)(5*limitValue) && (nextValue!=ValueBorder))
						{
							uint16 newValue = (TBufferEntry)(prevValue+5*7);
							if(newValue < nextValue)
							{
								resultBuffer[lineOffset+count] = newValue;
							}
							
							prevValue = newValue;
							count++;
						}

						x = count-1;
						break;
					}
				}

				// decrease x
				if(x-1>0)
				{
					uint16 nextValue = resultBuffer[offset-1];
					uint16 prevValue = (TBufferEntry)(5*limitValue);
					if(nextValue!=(TBufferEntry)(5*limitValue))
					{
						uint32 count = x-1;	
						while((count>x-7) && (count>0) && ((nextValue=resultBuffer[lineOffset+count])!=0) 
							&& nextValue!=(TBufferEntry)(5*limitValue) && (nextValue!=ValueBorder))
						{
							uint16 newValue = (TBufferEntry)(prevValue+5*7);
							if(newValue < nextValue)
							{
								resultBuffer[lineOffset+count] = newValue;
							}
							
							prevValue = newValue;
							count--;
						}
					}
				}
			}
		}
	}

	//columns
	for (uint32 x=0;x<lineLength;++x)
	{
		// setup start and end offsets marking first and last 'zero' value pixels in the column
		uint32 startOffset=x, endOffset=x+(numLines-1)*lineLength;
	
		for (uint32 offset=startOffset; offset<=endOffset; offset+=lineLength)
		{
			uint16 value = resultBuffer[offset];
			
			if(value==ValueBorder)
			{
				resultBuffer[offset]= (TBufferEntry)(5*limitValue);

				// increase y
				if(offset+lineLength<=endOffset)
				{
					uint16 nextValue = resultBuffer[offset+lineLength];
					uint16 prevValue = (TBufferEntry)(5*limitValue);
					if(nextValue!=(TBufferEntry)(5*limitValue))
					{
						uint32 count = offset+lineLength;	
						while((count<offset+7*lineLength) && (count<=endOffset) && 
							((nextValue=resultBuffer[count])!=0) && nextValue!=(TBufferEntry)(5*limitValue) && (nextValue!=ValueBorder))
						{
							uint16 newValue = (TBufferEntry)(prevValue+5*7);
							if(newValue < nextValue)
							{
								resultBuffer[count] = newValue;
							}
							
							prevValue = newValue;
							count += lineLength;
						}

						offset = count-lineLength;
						break;
					}
				}

				// decrease y
				if(offset-lineLength>=startOffset)
				{
					uint16 nextValue = resultBuffer[offset-lineLength];
					uint16 prevValue = (TBufferEntry)(5*limitValue);
					if(nextValue!=(TBufferEntry)(5*limitValue))
					{
						uint32 count = offset-lineLength;	
						while((count>offset-7*lineLength) && (count>=startOffset) && 
							((nextValue=resultBuffer[count])!=0) && nextValue!=(TBufferEntry)(5*limitValue) && (nextValue!=ValueBorder))
						{
							uint16 newValue = (TBufferEntry)(prevValue+5*7);
							if(newValue < nextValue)
							{
								resultBuffer[count] = newValue;
							}
							
							prevValue = newValue;
							count -= lineLength;
						}
					}
				}
			}
		}
	}
	*/

	//-----------------------------------------------------------------------------
	// search for pixels of borders
	map< CVector2f, bool > bordersPixels;
	for (uint32 y=0;y<numLines;++y)
	{
		uint32 lineOffset= y* lineLength;

		for (uint32 x=0;x<lineLength;++x)
		{
			uint32 offset = lineOffset+x;
			uint16 value = resultBuffer[offset];
			
			if(value==ValueBorder)
			{
				bordersPixels[CVector2f((float)x, (float)y)] = true;
				resultBuffer[offset] = (TBufferEntry)(5*limitValue);
			}
		}
	}

	//-----------------------------------------------------------------------------
	// search for global borders
	// search on lines for top and bottom borders
	map< CVector2f, uint32 > leftBorders, rightBorders, bottomBorders, topBorders;
	for (uint32 y=0;y<numLines;++y)
	{
		uint32 lineOffset= y* lineLength;

		bool lastValue = false;
		CVector2f firstPixelBorder;
		firstPixelBorder.set(0.f, 0.f);
		uint32 nbPixelsBorder = 0;

		for (uint32 x=0;x<lineLength;++x)
		{
			bool value = (bordersPixels.find(CVector2f((float)x, (float)y))!=bordersPixels.end());
			
			if(value)
			{
				if(!lastValue)
				{
					firstPixelBorder = CVector2f((float)x, (float)y);
				}
				nbPixelsBorder ++;
			}
			else if(lastValue)
			{
				// store border line
				if(nbPixelsBorder !=1) //column instead of line
				{
					bool top=false, bottom=false;
					if(y>0)
					{
						for(uint32 xc=(uint32)firstPixelBorder.x; xc<(uint32)(firstPixelBorder.x+nbPixelsBorder); xc++)
						{
							if(resultBuffer[(y-1)*lineLength+xc]==(TBufferEntry)(5*255))
							{
								bottom = true;
								break;
							}				
						}
					}

					if(y+1<numLines)
					{
						for(uint32 xc=(uint32)firstPixelBorder.x; xc<(uint32)(firstPixelBorder.x+nbPixelsBorder); xc++)
						{
							if(resultBuffer[(y+1)*lineLength+xc]==(TBufferEntry)(5*255))
							{
								top = true;
								break;
							}				
						}
					}

					// TOP
					if(top)
						topBorders[firstPixelBorder] =nbPixelsBorder;
					
					// BOTTOM
					if(bottom)
						bottomBorders[firstPixelBorder] =nbPixelsBorder;
				}
				nbPixelsBorder =0;
			}
			lastValue = value;
		}
	}

	// search on columns for left and right borders
	for (uint32 x=0;x<lineLength;++x)
	{
		bool lastValue = false;
		CVector2f firstPixelBorder;
		firstPixelBorder.set(0.f, 0.f);
		uint32 nbPixelsBorder = 0;
	
		for(uint32 y=0; y<numLines; y++)
		{
			bool value = (bordersPixels.find(CVector2f((float)x, (float)y))!=bordersPixels.end());
			
			if(value)
			{
				if(!lastValue)
				{
					firstPixelBorder = CVector2f((float)x, (float)y);
				}
				nbPixelsBorder ++;
			}
			else if(lastValue)
			{
				// store border line
				if(nbPixelsBorder !=1) //line instead of column
				{
					bool left = false;
					bool right = false;

					if(x>0)
					{
						for(uint32 yc=(uint32)firstPixelBorder.y; yc<(uint32)(firstPixelBorder.y+nbPixelsBorder); yc++)
						{
							if(resultBuffer[yc*lineLength+x-1]==(TBufferEntry)(5*255))
							{
								left = true;
								break;				
							}
						}
					}

					if(x+1<lineLength)
					{
						for(uint32 yc=(uint32)firstPixelBorder.y; yc<(uint32)(firstPixelBorder.y+nbPixelsBorder); yc++)
						{
							if(resultBuffer[yc*lineLength+x+1]==(TBufferEntry)(5*255))
							{
								right = true;
								break;								
							}
						}
					}

					// LEFT
					if(left)
						leftBorders[firstPixelBorder] =nbPixelsBorder;

					// RIGHT
					if(right)
						rightBorders[firstPixelBorder] =nbPixelsBorder;
				}
				nbPixelsBorder =0;
			}
			lastValue = value;
		}
	}

	//-----------------------------------------------------------------------------
	// attenuate borders
	// bottom and top borders (lines)
	for (uint32 y=0;y<numLines;++y)
	{
		uint32 lineOffset= y* lineLength;
		
		for (uint32 x=0;x<lineLength;++x)
		{
			uint32 offset = lineOffset+x;
			CVector2f firstPixelBorder((float)x, (float)y);

			// BOTTOM
			if(bottomBorders.find(CVector2f((float)x, (float)y))!=bottomBorders.end())
			{
				uint32 nbPixelsBorder = bottomBorders[firstPixelBorder];
				uint32 xc;
				for(xc=(uint32)firstPixelBorder.x; xc<(uint32)(firstPixelBorder.x+nbPixelsBorder); xc++)
				{
					uint nbZones = (uint)(nbPixelsBorder/160)+1;
					uint period = (uint)(nbPixelsBorder/(2*nbZones));
					double noiseValue = (1-cos(((xc-firstPixelBorder.x)*Pi)/period))*5;
					double evalNoise = 7 + noiseValue;
					double diffAlpha = (255.0-limitValue)/evalNoise;

					uint32 yc = y-1;
					while((yc>=(uint32)(y-evalNoise)) && yc>=0)
					{
						uint16 newValue = (TBufferEntry)(5*(limitValue + diffAlpha*(y-yc)));
						uint16 currentValue = (TBufferEntry)resultBuffer[yc*lineLength+xc];
						if(newValue<currentValue)
							resultBuffer[yc*lineLength+xc] = (TBufferEntry)(5*(limitValue + diffAlpha*(y-yc)));
						yc--;
					}
				}
				x=xc;
			}

			// TOP
			if(topBorders.find(CVector2f((float)x, (float)y))!=topBorders.end())
			{
				uint32 nbPixelsBorder = topBorders[firstPixelBorder];
				uint32 xc;
				for(xc=(uint32)firstPixelBorder.x; xc<=(uint32)(firstPixelBorder.x+nbPixelsBorder); xc++)
				{
					uint nbZones = (uint)(nbPixelsBorder/160)+1;
					uint period = (uint)(nbPixelsBorder/(2*nbZones));
					double noiseValue = (1-cos(((xc-firstPixelBorder.x)*Pi)/period))*5;
					double evalNoise = 7 + noiseValue;
					double diffAlpha = (255.0-limitValue)/evalNoise;

					uint32 yc = y+1;
					while((yc<=(uint32)(y+evalNoise)) && yc<numLines)
					{
						uint16 newValue = (TBufferEntry)(5*(limitValue + diffAlpha*(yc-y)));
						uint16 currentValue = (TBufferEntry)resultBuffer[yc*lineLength+xc];
						if(newValue<currentValue)
							resultBuffer[yc*lineLength+xc] = (TBufferEntry)(5*(limitValue + diffAlpha*(yc-y)));
						yc++;
					}
				}
				x=xc;
			}
		}
	}

	// left and right borders (columns)
	for (uint32 x=0;x<lineLength;++x)
	{
		for (uint32 y=0; y<numLines; y++)
		{
			CVector2f firstPixelBorder((float)x, (float)y);

			// LEFT
			if(leftBorders.find(CVector2f((float)x, (float)y))!=leftBorders.end())
			{
				uint32 nbPixelsBorder = leftBorders[firstPixelBorder];
				uint32 yc;
				for(yc=(uint32)firstPixelBorder.y; yc<(uint32)(firstPixelBorder.y+nbPixelsBorder); yc++)
				{
					uint nbZones = (uint)(nbPixelsBorder/160)+1;
					uint period = (uint)(nbPixelsBorder/(2*nbZones));
					double noiseValue = (1-cos(((yc-firstPixelBorder.y)*Pi)/period))*5;
					double evalNoise = 7 + noiseValue;
					double diffAlpha = (255.0-limitValue)/evalNoise;

					uint32 xc = x-1;
					while((xc>=(uint32)(x-evalNoise)) && xc>=0)
					{
						uint16 newValue = (TBufferEntry)(5*(limitValue + diffAlpha*(x-xc)));
						uint16 currentValue = (TBufferEntry)resultBuffer[yc*lineLength+xc];
						if(newValue<currentValue)
							resultBuffer[yc*lineLength+xc] = (TBufferEntry)(5*(limitValue + diffAlpha*(x-xc)));
						xc--;
					}
				}
				y=yc;
			}

			// RIGHT
			if(rightBorders.find(CVector2f((float)x, (float)y))!=rightBorders.end())
			{
				uint32 nbPixelsBorder = rightBorders[firstPixelBorder];
				uint32 yc;
				for(yc=(uint32)firstPixelBorder.y; yc<=(uint32)(firstPixelBorder.y+nbPixelsBorder); yc++)
				{
					uint nbZones = (uint)(nbPixelsBorder/160)+1;
					uint period = (uint)(nbPixelsBorder/(2*nbZones));
					double noiseValue = (1-cos(((yc-firstPixelBorder.y)*Pi)/period))*5;
					double evalNoise = 7 + noiseValue;
					double diffAlpha = (255.0-limitValue)/evalNoise;

					uint32 xc = x+1;
					while((xc<=(uint32)(x+evalNoise)) && xc<lineLength)
					{
						uint16 newValue = (TBufferEntry)(5*(limitValue + diffAlpha*(xc-x)));
						uint16 currentValue = (TBufferEntry)resultBuffer[yc*lineLength+xc];
						if(newValue<currentValue)
							resultBuffer[yc*lineLength+xc] = (TBufferEntry)(5*(limitValue + diffAlpha*(xc-x)));
						xc++;
					}
				}
				y=yc;
			}
		}
	}
}

//--------------------------------------------------------------------------------
void CScreenshotIslands::loadIslands()
{
	// load entryPoints
	map< string, CVector2f > islands;
	CScenarioEntryPoints scenarioEntryPoints = CScenarioEntryPoints::getInstance();

	scenarioEntryPoints.loadFromFile();
	const CScenarioEntryPoints::TEntryPoints& entryPoints =  scenarioEntryPoints.getEntryPoints();

	CScenarioEntryPoints::TEntryPoints::const_iterator entry(entryPoints.begin()), entryPoint(entryPoints.end());
	for( ; entry != entryPoint ; ++entry)
	{	
		islands[entry->Island] = CVector2f((float)entry->X, (float)entry->Y);
	}

	// search islands of each continent
	map< string, CVector2f >::iterator itIsland(islands.begin()), lastIsland(islands.end());
	for( ; itIsland != lastIsland ; ++itIsland)
	{	
		const CVector2f & entryPoint = itIsland->second;

		// search continent of this island
		TContinentsData::iterator itCont(_ContinentsData.begin()), lastCont(_ContinentsData.end());
		for( ; itCont != lastCont ; ++itCont)
		{
			CContinentData & continent = itCont->second;
			CVector2f zoneMax = continent.ZoneMax;
			CVector2f zoneMin = continent.ZoneMin;

			if((zoneMin.x <= entryPoint.x) && (entryPoint.x <= zoneMax.x)
				&& (zoneMax.y <= entryPoint.y) && (entryPoint.y <= zoneMin.y))
			{
				continent.Islands.push_back(itIsland->first);
				break;
			}
		}
	}

	// search data of each island
	TContinentsData::iterator itCont(_ContinentsData.begin()), lastCont(_ContinentsData.end());
	for( ; itCont != lastCont ; ++itCont)
	{
		string aiFileName = itCont->first+"_0.cwmap2";

		const CContinentData & continent = itCont->second;

		CProximityMapBuffer continentBuffer;
		continentBuffer.load(CPath::lookup(aiFileName));

		CProximityMapBuffer::TZones zones;
		continentBuffer.calculateZones(zones);

		for (uint32 i=0;i<zones.size();++i)
		{
			TBuffer zoneBuffer;
			continentBuffer.generateZoneProximityMap(zones[i], zoneBuffer); 

			TBuffer cleanBuffer;
			processProximityBuffer(zoneBuffer, zones[i].getZoneWidth(), cleanBuffer);

			string fileName = string("");
			list< string >::const_iterator itIsland(continent.Islands.begin()), lastIsland(continent.Islands.end());
			for( ; itIsland != lastIsland ; ++itIsland)
			{
				const CVector2f & entryPoint = islands[*itIsland];
				sint32 xmin = zones[i].getBoundXMin();
				sint32 xmax = zones[i].getBoundXMax();
				sint32 ymin = zones[i].getBoundYMin();
				sint32 ymax = zones[i].getBoundYMax();

				if((xmin <= entryPoint.x) && (entryPoint.x <= xmax)
					&& (ymin <= entryPoint.y) && (entryPoint.y <= ymax))
				{
					fileName = _OutDirectory + "/" + *itIsland + "_prox.tga";
					_IslandsData[*itIsland] = zones[i];
					break;
				}
			}
		
			// write the processed proximity map to an output file
			if(fileName != "")
			{
				writeProximityBufferToTgaFile(fileName, cleanBuffer, zones[i].getZoneWidth(), zones[i].getZoneHeight());
				_TempFileNames.push_back(fileName);

				fileName = _OutDirectory + "/" + *itIsland + "_limit.tga";
				writeProximityBufferToTgaFile(fileName, zoneBuffer, zones[i].getZoneWidth(), zones[i].getZoneHeight());
				_TempFileNames.push_back(fileName);
			}
			else
			{
				nlinfo("Zone of island not found, tga not build");
			}
		}
	}


	CScenarioEntryPoints::TCompleteIslands completeIslands(entryPoints.size());

	uint completeIslandsNb = 0;
	for(uint e=0; e<entryPoints.size(); e++)
	{	
		const CScenarioEntryPoints::CEntryPoint & entry = entryPoints[e];

		CScenarioEntryPoints::CCompleteIsland completeIsland;
		completeIsland.Island = entry.Island;
		completeIsland.Package = entry.Package;

		for(itCont=_ContinentsData.begin(); itCont!=_ContinentsData.end(); ++itCont)
		{
			list< string >::const_iterator itIsland(itCont->second.Islands.begin()), lastIsland(itCont->second.Islands.end());
			for( ; itIsland != lastIsland ; ++itIsland)
			{
				if(*itIsland == entry.Island)
				{
					completeIsland.Continent = CSString(itCont->first);
					if(_IslandsData.find(entry.Island)!=_IslandsData.end())
					{
						completeIsland.XMin = _IslandsData[entry.Island].getBoundXMin();
						completeIsland.YMin = _IslandsData[entry.Island].getBoundYMin();
						completeIsland.XMax = _IslandsData[entry.Island].getBoundXMax();
						completeIsland.YMax = _IslandsData[entry.Island].getBoundYMax();
						completeIslands[completeIslandsNb] = completeIsland;
						completeIslandsNb++;
					}
					break;
				}
			}
		}
	}
	completeIslands.resize(completeIslandsNb);
	
	CScenarioEntryPoints::getInstance().saveXMLFile(completeIslands, _CompleteIslandsFile);
}

//--------------------------------------------------------------------------------

void CScreenshotIslands::getBuffer(UScene * scene, ULandscape * landscape, CBitmap &btm)
{		
	//
	if (ScreenShotWidth && ScreenShotHeight)
	{		
		UCamera camera = scene->getCam();

		// Destination image
		CBitmap dest;
		btm.resize(ScreenShotWidth, ScreenShotHeight, CBitmap::RGBA);

		uint windowWidth = driver->getWindowWidth();
		uint windowHeight = driver->getWindowHeight();
		
		uint top;
		uint bottom = min(windowHeight, ScreenShotHeight);
		for (top=0; top<ScreenShotHeight; top+=windowHeight)
		{
			uint left;
			uint right = std::min(windowWidth, ScreenShotWidth);
			for(left=0; left<ScreenShotWidth; left+=windowWidth)
			{
				driver->clearBuffers(_BackColor);
				
				// store initial frustum and viewport
				CFrustum Frustum = scene->getCam().getFrustum();
				CViewport Viewport = scene->getViewport();

				// Build a new frustum
				CFrustum frustumPart;
				frustumPart.Left = Frustum.Left+(Frustum.Right-Frustum.Left)*((float)left/(float)ScreenShotWidth);
				frustumPart.Right = Frustum.Left+(Frustum.Right-Frustum.Left)*((float)right/(float)ScreenShotWidth);
				frustumPart.Top = ceil(Frustum.Top+(Frustum.Bottom-Frustum.Top)*((float)top/(float)ScreenShotHeight));
				frustumPart.Bottom = ceil(Frustum.Top+(Frustum.Bottom-Frustum.Top)*((float)bottom/(float)ScreenShotHeight));
				frustumPart.Near = Frustum.Near;
				frustumPart.Far = Frustum.Far;
				frustumPart.Perspective = Frustum.Perspective;

				// Build a new viewport
				CViewport viewport;
				viewport.init(0, 0, (float)(right-left)/windowWidth, 
					(float)(bottom-top)/windowHeight);
				
				// Activate all this
				scene->getCam().setFrustum(frustumPart);
				scene->setViewport(viewport);
				
				scene->setMaxSkeletonsInNotCLodForm(1000000);
				scene->setPolygonBalancingMode(UScene::PolygonBalancingOff);

				if(_InverseZTest)
				{
					// render scene with inversed ZBuffer test (keep greater distances)
					driver->setColorMask(false, false, false, false);
					sceneMaterial.setZFunc(UMaterial::less);

					// initialize ZBuffer with leak value
					driver->setMatrixMode2D11();
					CQuad quad;
					quad.V0 = CVector(0.0, 0.0, 0.0);
					quad.V1 = CVector(1.0, 0.0, 0.0);
					quad.V2 = CVector(1.0, 1.0, 0.0);
					quad.V3 = CVector(0.0, 1.0, 0.0);

					driver->drawQuad(quad, sceneMaterial);
					driver->setMatrixMode3D(camera);
					driver->setColorMask(true, true, true, true);

					scene->enableElementRender(UScene::FilterWater, false);
				}
				
				scene->render();
				
				// display vegetables with normal ZBuffer test
				if(_InverseZTest && _Vegetation)
				{
					scene->enableElementRender(UScene::FilterWater, false);
					scene->enableElementRender(UScene::FilterLandscape, false);
					scene->enableElementRender(UScene::FilterWater, true);
					scene->render();
					scene->enableElementRender(UScene::FilterLandscape, true);
				}

				// Get the bitmap
				driver->getBuffer(dest);
				btm.blit(dest, 0, windowHeight-(bottom-top), right-left, bottom-top, left, top);

				// restore camera
				scene->getCam().setFrustum(Frustum);
				scene->setViewport(Viewport);

				driver->flush();
				driver->swapBuffers();	

				// Next
				right = std::min(right+windowWidth, ScreenShotWidth);
			}

			// Next
			bottom = std::min(bottom+windowHeight, ScreenShotHeight);
		}
	}
	else
	{		
		driver->getBuffer(btm);
	}
}



void CScreenshotIslands::buildIslandsTextures()
{
	int loop = 0;
	int maxLoop = 6;

	// Create the window with config file values
	driver->setDisplay(UDriver::CMode(512, 512, 32, true));

	// Create a scene
	UScene	* scene = driver->createScene(true);
	scene->animate(CTime::ticksToSecond(CTime::getPerformanceTime()));
	scene->setMaxSkeletonsInNotCLodForm(1000000);
	scene->setPolygonBalancingMode(UScene::PolygonBalancingOff);
	
	// Create a camera
	UCamera camera = scene->getCam();
	camera.setTransformMode(UTransformable::DirectMatrix);

	// Create and load landscape
	ULandscape * landscape = scene->createLandscape();
	landscape->setThreshold(0.0005);
	if(_InverseZTest)
	{
		landscape->setZFunc(UMaterial::greaterequal);
	}
	else
	{
		landscape->setZFunc(UMaterial::less);
	}
	
	//Iteration on seasons
	list< string >::iterator itSeason(_SeasonSuffixes.begin()), lastSeason(_SeasonSuffixes.end());
	for( ; itSeason != lastSeason ; ++itSeason)
	{
		string seasonSuffix = *itSeason;

		sint season = -1;

		if (seasonSuffix == "_sp") season = CSeason::Spring;
		else if (seasonSuffix == "_su") season = CSeason::Summer;
		else if (seasonSuffix == "_au") season = CSeason::Autumn;
		else if (seasonSuffix == "_wi") season = CSeason::Winter;

		if (season == -1)
		{
			nlwarning("Unknown season suffix %s, skipping...", seasonSuffix.c_str());
			continue;
		}

		// Iterations on Continents
		TContinentsData::iterator itCont(_ContinentsData.begin()), lastCont(_ContinentsData.end());
		for( ; itCont != lastCont ; ++itCont)
		{	
			const CContinentData & continent = itCont->second;

			// Light init
			landscape->setupStaticLight(continent.Diffuse, continent.Ambiant, 1.0f);

			string coarseMeshFile = continent.CoarseMeshMap;
			string coarseMeshWithoutExt = CFile::getFilenameWithoutExtension(coarseMeshFile);
			string coarseMeshExt = CFile::getExtension(coarseMeshFile);
			coarseMeshFile = coarseMeshWithoutExt + seasonSuffix + "." + coarseMeshExt;
			nldebug("Coarse mesh texture: '%s'", coarseMeshFile.c_str());
			scene->setCoarseMeshManagerTexture(coarseMeshFile.c_str()); 

			// Load the landscape	
			string farBank = continent.FarBank;
			string farBankWithoutExt = CFile::getFilenameWithoutExtension(farBank);
			string farBankExt = CFile::getExtension(farBank);
			farBank = farBankWithoutExt + seasonSuffix + "." + farBankExt;
			landscape->loadBankFiles(continent.SmallBank, farBank);

			// Load vegatables
			LandscapeIGManager.initIG(scene, continent.IGFile, driver, season, NULL);
		
			// Iterations on Islands
			list< string >::const_iterator itIsland(continent.Islands.begin()), lastIsland(continent.Islands.end());
			for( ; itIsland != lastIsland ; ++itIsland)
			{
				loop = 0;

				if(_IslandsData.find(itIsland->c_str()) != _IslandsData.end())
				{
					const CProximityZone & islandData = _IslandsData[itIsland->c_str()];

					sint32 xmin = islandData.getBoundXMin();
					sint32 xmax = islandData.getBoundXMax();
					sint32 ymin = islandData.getBoundYMin();
					sint32 ymax = islandData.getBoundYMax();

					float width = (float)(xmax-xmin);
					float height = (float)(ymax-ymin);
					ScreenShotWidth = (uint)(width*_MeterPixelSize);	
					ScreenShotHeight = (uint)(height*_MeterPixelSize);

					// position in island center
					float posx = ((float)(xmax+xmin))/2;
					float posy = ((float)(ymax+ymin))/2;
					CVector entryPos(posx, posy, 400);
					
					// Setup camera
					CMatrix startCamMatrix;
					startCamMatrix.setPos(entryPos);
					startCamMatrix.rotateX(-(float)Pi/2);
					camera.setMatrix(startCamMatrix);
					camera.setFrustum(width, height, -10000.0f, 10000.0f, false);
					
					// init lanscape
					landscape->postfixTileFilename(seasonSuffix.c_str());
					
					while(loop<maxLoop)
					{
						// refresh lanscape
						vector<string>		zonesAdded;
						vector<string>		zonesRemoved;
						IProgressCallback progress;
						landscape->refreshAllZonesAround(camera.getMatrix().getPos(), 1000, zonesAdded, zonesRemoved, progress);
						if(_Vegetation)
						{
							LandscapeIGManager.unloadArrayZoneIG(zonesRemoved);
							LandscapeIGManager.loadArrayZoneIG(zonesAdded);
						
							vector<string>::iterator itName(zonesAdded.begin()), lastName(zonesAdded.end());
							for( ; itName != lastName ; ++itName)
							{
								UInstanceGroup	* instanceGr = LandscapeIGManager.getIG(*itName);
								if(instanceGr)
								{
									uint nbInst = instanceGr->getNumInstance();
									for(uint i=0; i<instanceGr->getNumInstance(); i++)
									{
										instanceGr->setCoarseMeshDist(i, 100000);
										instanceGr->setDistMax(i, 100000);
									}
								}
							}
						}
						scene->animate(CTime::ticksToSecond(CTime::getPerformanceTime()));
						
						// Clear all buffers
						driver->clearBuffers(_BackColor);

						if(_InverseZTest)
						{
							// render scene with inversed ZBuffer test (keep greater distances)
							driver->setColorMask(false, false, false, false);
							sceneMaterial.setZFunc(UMaterial::less);

							// initialize ZBuffer with leak value
							driver->setMatrixMode2D11();
							CQuad quad;
							quad.V0 = CVector(0.0, 0.0, 0.0);
							quad.V1 = CVector(1.0, 0.0, 0.0);
							quad.V2 = CVector(1.0, 1.0, 0.0);
							quad.V3 = CVector(0.0, 1.0, 0.0);

							driver->drawQuad(quad, sceneMaterial);
							driver->setMatrixMode3D(camera);
							driver->setColorMask(true, true, true, true);

							scene->enableElementRender(UScene::FilterWater, false);
						}

						scene->render();

						// display vegetables with normal ZBuffer test
						if(_InverseZTest && _Vegetation)
						{
							scene->enableElementRender(UScene::FilterLandscape, false);
							scene->enableElementRender(UScene::FilterWater, true);
							scene->render();
							scene->enableElementRender(UScene::FilterLandscape, true);
						}
						
						// Swap 3d buffers
						driver->flush();
						driver->swapBuffers();

						// Pump user input messages
						driver->EventServer.pump();

						loop += 1;

						// Screenshot
						if(loop==maxLoop-1)
						{
							CBitmap islandBitmap;
							getBuffer(scene, landscape, islandBitmap);
						
							buildBackTextureHLS(*itIsland, islandBitmap);
						}
						if(loop==maxLoop)
						{
							// create srcennshot bitmap of full island
							CBitmap islandBitmap;
							getBuffer(scene, landscape, islandBitmap);

							attenuateIslandBorders(*itIsland, islandBitmap, islandData);

							// load proximity bitmap
							CBitmap proxBitmap;
							std::string proxFileName = _OutDirectory + "/" + *itIsland + "_prox.tga";
							CIFile proxFS(proxFileName.c_str());
							proxBitmap.load(proxFS);

							// resize proximity bitmap
							CBitmap tempBitmap;
							int newWidth = islandBitmap.getWidth();
							int newHeight = islandBitmap.getHeight();
							tempBitmap.resize(newWidth, newHeight, islandBitmap.PixelFormat);
							// blit src bitmap
							//tempBitmap.blit(proxBitmap, 0, 0, newWidth, newHeight, 0, 0);
							{
								const uint8 *prox = &(proxBitmap.getPixels(0)[0]);
								uint8 *temp = &(tempBitmap.getPixels(0)[0]);
								for (uint y = 0; y < newHeight; ++y)
									for (uint x = 0; x < newWidth; ++x)
								{
									uint ys = (y * proxBitmap.getHeight()) / newHeight;
									uint xs = (x * proxBitmap.getWidth()) / newWidth;
									uint addr = ((y * newWidth) + x) * 4;
									uint addrs = ((ys * proxBitmap.getWidth()) + xs) * 4;
									temp[addr] = prox[addrs];
									temp[addr+1] = prox[addrs+1];
									temp[addr+2] = prox[addrs+2];
									temp[addr+3] = prox[addrs+3];
								}
							}

							// swap them
							proxBitmap.resize(newWidth, newHeight, proxBitmap.PixelFormat);
							proxBitmap.swap(tempBitmap);

							//proxBitmap.resample(newWidth, newHeight);


							// create final bitmap
							CBitmap bitmapDest;
							bitmapDest.resize(islandBitmap.getWidth(), islandBitmap.getHeight(), islandBitmap.PixelFormat);

							
							// mix black and full island bitmaps with blend factor of proximity bitmap pixels
							uint numPix = islandBitmap.getWidth() * islandBitmap.getHeight(); 

							const uint8 *alphaProx = &(proxBitmap.getPixels(0)[0]);
							const uint8 *srcIsland		= &(islandBitmap.getPixels(0)[0]);
							uint8 *dest					= &(bitmapDest.getPixels(0)[0]);


							const uint8 *srcBack		= &(_BackBitmap.getPixels(0)[0]);
							
							uint8 *endDest = dest + (numPix << 2);

							do
							{
								uint invblendFact = (uint) alphaProx[0];
								uint blendFact    = 256 - invblendFact;
								
								// blend 4 component at each pass
								*dest = (uint8) (((blendFact * *srcIsland)		+ (invblendFact * *srcBack)) >> 8);
								*(dest + 1) = (uint8) (((blendFact * *(srcIsland + 1)) + (invblendFact * *(srcBack + 1))) >> 8);
								*(dest + 2) = (uint8) (((blendFact * *(srcIsland + 2)) + (invblendFact * *(srcBack + 2))) >> 8);
								*(dest + 3)  = (uint8) 255;

								alphaProx = alphaProx + 4;
								srcIsland = srcIsland + 4;
								dest = dest + 4;

								srcBack = srcBack + 4;
							}
							while(dest != endDest);
							
							
							// create tga file of avoidable place in island
							string textureName = _OutDirectory + "/" + *itIsland + seasonSuffix + ".tga";

							CBitmap bitmapLittle;
							bitmapLittle.resize(bitmapDest.getWidth(), bitmapDest.getHeight(), bitmapDest.PixelFormat);
							bitmapLittle = bitmapDest;
							if(!isPowerOf2(bitmapDest.getWidth()) || !isPowerOf2(bitmapDest.getHeight()) )
							{
								uint pow2w = NLMISC::raiseToNextPowerOf2(bitmapDest.getWidth());
								uint pow2h = NLMISC::raiseToNextPowerOf2(bitmapDest.getHeight());
								CBitmap enlargedBitmap;
								enlargedBitmap.resize(pow2w, pow2h, bitmapDest.PixelFormat);
								// blit src bitmap
								enlargedBitmap.blit(&bitmapDest, 0, 0);
								// swap them
								bitmapDest.swap(enlargedBitmap);
							}

							COFile fsDest(textureName.c_str());
							bitmapDest.writeTGA(fsDest,32);


							// little tga
							bitmapLittle.resample(bitmapLittle.getWidth()/10, bitmapLittle.getHeight()/10);
							if(!isPowerOf2(bitmapLittle.getWidth()) || !isPowerOf2(bitmapLittle.getHeight()) )
							{
								uint pow2w = NLMISC::raiseToNextPowerOf2(bitmapLittle.getWidth());
								uint pow2h = NLMISC::raiseToNextPowerOf2(bitmapLittle.getHeight());
								CBitmap enlargedBitmap;
								enlargedBitmap.resize(pow2w, pow2h, bitmapLittle.PixelFormat);
								// blit src bitmap
								enlargedBitmap.blit(&bitmapLittle, 0, 0);
								// swap them
								bitmapLittle.swap(enlargedBitmap);
							}

							textureName = _OutDirectory + "/" + *itIsland + seasonSuffix + "_little.tga";
							COFile fsLittle(textureName.c_str());
							bitmapLittle.writeTGA(fsLittle,32);

							_BackColor = CRGBA(255, 255, 255, 255);
						}
					}
				}
			}

			LandscapeIGManager.reset();
			landscape->removeAllZones();
		}
	}

	// remove proximity tga
	list<string>::iterator itProx(_TempFileNames.begin()), lastProx(_TempFileNames.end());
	for( ; itProx != lastProx ; ++itProx)
	{
		CFile::deleteFile(*itProx);
	};
}

//--------------------------------------------------------------------------------
inline bool RGB2HSV(const CRGBA & rgba, uint & Hue, uint & Sat, uint & Val)
{
	double Min_, Max_, Delta, H, S, V;
	
	Min_ = min(min(rgba.R, rgba.G), rgba.B);
	Max_ = max(max(rgba.R, rgba.G), rgba.B);
	Delta = ( Max_ - Min_);

	if(Max_ != 0.0)
	{
		S = 255.0*Delta/Max_;
	}
	else
	{
		Hue = 0;
		Sat = 0;
		Val = 0;
		return false;
	}

	H = 0.0;
	V = Max_;

	if(rgba.R == Max_) 
	{
		H = (rgba.G - rgba.B) / Delta;
	}
	else if(rgba.G == Max_)
	{
		H = 2.0 + (rgba.B - rgba.R) / Delta;
	}
	else 
	{
		H = 4.0 + (rgba.R - rgba.G) / Delta;
	}

	H = H * 60;
	if(H < 0.0)
	{
		H = H + 360.0;
	}

	Hue = (uint)H ;             // Hue -> 0..360
	Sat = (uint)S * 100 / 255; // Saturation -> 0..100 %
	Val = (uint)V * 100 / 255; // Value - > 0..100 %

	return true;
}

//-------------------------------------------------------------------------------------------------
inline bool infHLS(const CRGBA & rgba1, const CRGBA & rgba2)
{
	uint h1, s1, v1, h2, s2, v2;
	RGB2HSV(rgba1, h1, s1, v1);  
	RGB2HSV(rgba2, h2, s2, v2);  
	
	if(h1 != h2)
	{
		return (h1 < h2);
	}
	else if(s1 != s2)
	{
		return (s1 < s2);
	}
	else 
	{
		return (v1 < v2);
	}
}

//-------------------------------------------------------------------------------------------------
void CScreenshotIslands::buildBackTextureHLS(const std::string & islandName, const CBitmap & islandBitmap)
{
	// load limit bitmap
	CBitmap limBitmap;
	std::string limFileName = _OutDirectory + "/" + islandName + "_limit.tga";

	CIFile limFS(limFileName.c_str());
	limBitmap.load(limFS);

	list< CRGBA > limitPixels;

	// search for colors of limit pixels
	for(uint x=0; x<islandBitmap.getWidth(); x++)
	{
		for(uint y=0; y<islandBitmap.getHeight(); y++)
		{
			CRGBA lim = limBitmap.getPixelColor(x, y);
			if((lim == CRGBA::White) && (islandBitmap.getPixelColor(x, y)!=CRGBA::White))
			{
				limitPixels.push_back(islandBitmap.getPixelColor(x, y));	
			}
		}
	}

	// HLS order
	list< CRGBA > sortedHLS;
	list< CRGBA >::iterator itCol, itHLS;
	bool inserted = false;
	for(itCol=limitPixels.begin(); itCol!=limitPixels.end(); itCol++)
	{
		inserted = false;
		for(itHLS=sortedHLS.begin(); itHLS!=sortedHLS.end(); ++itHLS)
		{
			if(infHLS(*itCol, *itHLS))
			{
				sortedHLS.insert(itHLS, *itCol);
				inserted = true;
				break;
			}
		}
		if(inserted==false) sortedHLS.push_back(*itCol);
	}


	// keep more filled eighth of circle
	nlassert(!sortedHLS.empty()); // If it crashes here, you may be missing .zonel's.
	itHLS = sortedHLS.begin();
	uint h, s, v;
	RGB2HSV(*itHLS, h, s, v);
	list< CRGBA > currentList, maxList;

	for(uint i=0; i<8; i++)
	{
		while(itHLS!=sortedHLS.end() && h<i*45)
		{
			currentList.push_back(*itHLS);
			RGB2HSV(*itHLS, h, s, v);
			++itHLS;
		}

		if(currentList.size() > maxList.size())
		{
			maxList.clear();
			maxList = currentList;
			currentList.clear();
		}
	}

	vector< CRGBA > sortedColors(maxList.size());
	uint colorsNb = 0;
	CRGBA lastColor(0, 0, 0, 0);
	CRGBA maxColor;
	uint maxColorNb = 0;
	uint currentColorNb = 0;
	for(itHLS=maxList.begin(); itHLS!=maxList.end(); ++itHLS)
	{
		if(lastColor==*itHLS)
		{
			currentColorNb++;	
		}
		else
		{
			currentColorNb = 1;
		}

		if(currentColorNb>maxColorNb)
		{
			maxColorNb = currentColorNb;
			maxColor = *itHLS;
		}
		
		lastColor = *itHLS;

		RGB2HSV(*itHLS, h, s, v); 
		if(v>25 && v<75 && s>25 && s<75)
		{
			sortedColors[colorsNb] = *itHLS;
			colorsNb++;
		}
	}

	if(colorsNb < 5)
	{
		colorsNb = 0;
		for(itHLS=maxList.begin(); itHLS!=maxList.end(); ++itHLS)
		{
			sortedColors[colorsNb] = *itHLS;
			colorsNb++;
		}			
	}

	sortedColors.resize(colorsNb);

	_BackBitmap.resize(islandBitmap.getWidth(), islandBitmap.getHeight(), islandBitmap.PixelFormat);

	if(sortedColors.size()!=0)
	{
		_BackColor = maxColor;

		CRandom	randomGenerator;

		uint8 * backPixels = &(_BackBitmap.getPixels(0)[0]);

		for(uint x=0; x<_BackBitmap.getWidth(); x++)
		{
			for(uint y=0; y<_BackBitmap.getHeight(); y++)
			{
				sint32 randomVal = randomGenerator.rand(colorsNb-1);
				const CRGBA & color = sortedColors[randomVal];

				*backPixels = (uint8) color.R;
				*(backPixels + 1) = (uint8) color.G;
				*(backPixels + 2) = (uint8) color.B;
				*(backPixels + 3)  = (uint8) 255;
				
				backPixels = backPixels+4;
			}
		}
	}

	/*
	//TEST
	CBitmap HLSBitmap;
	HLSBitmap.resize(640, sortedColors.size()*4, islandBitmap.PixelFormat);

	uint8 * hlsPixels = &(HLSBitmap.getPixels(0)[0]);

	for(uint i=0; i < sortedColors.size(); i++)
	{
		uint count = 0;
		while(count<640*4)
		{
			*hlsPixels = (uint8) sortedColors[i].R;
			*(hlsPixels + 1) = (uint8) sortedColors[i].G;
			*(hlsPixels + 2) = (uint8) sortedColors[i].B;
			*(hlsPixels + 3)  = (uint8) sortedColors[i].A;
			
			hlsPixels = hlsPixels+4;
			count++;
		}
	}


	string textureName = _OutDirectory + "/" + islandName + "_HLS2.tga";
	COFile fsHLS(textureName.c_str());
	HLSBitmap.writeTGA(fsHLS,32);
	*/
}


//--------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------------
// methods CProximityMapBuffer
//-------------------------------------------------------------------------------------------------

void CProximityMapBuffer::load(const std::string& name)
{
	// load the AI collision map file
	CWorldMap worldMap;
	CIFile	f(name);
	f.serial(worldMap);

	// lookup the map bounds
	CMapPosition	min, max;
	worldMap.getBounds(min, max);

	// calculate a handful of constants relating to the bounds of the image...
	_ScanWidth = max.x()-min.x();
	_ScanHeight = max.y()-min.y();
	_XOffset= min.x();
	_YOffset= (sint16)min.y();

	// redimension buffer to correct size
	_Buffer.resize(_ScanWidth*_ScanHeight);

	// setup a position variable to mark the start point of each line
	CMapPosition	scanpos(min.x(),min.y());

	// iterate over the scan area looking for points that are accessible
	for (uint32 y=0; y<_ScanHeight; ++y, scanpos = scanpos.getStepN())
	{
		CMapPosition pos(scanpos);

		// scan a line of the map
		for (uint32 x=0; x<_ScanWidth; ++x, pos = pos.getStepE())
		{
			bool isAccessible= false;
			// if the cell pointer is NULL it means that the 16x16 cell in question is inaccessible
			if (worldMap.getRootCellCst(pos) != NULL)
			{
				// run through the surfaces in the cell looking for a match for this position (may be as many as 3 surfaces per cell max)
				for (uint32 ns=0; ns<3; ++ns)
				{
					isAccessible |= worldMap.getSafeWorldPosition(pos, CSlot(ns)).isValid();
				}
			}
			// setup the next pixel in the output buffers...
			_Buffer[y*_ScanWidth+x]= (isAccessible? 0:std::numeric_limits<TBufferEntry>::max());
		}
	}
}

//-------------------------------------------------------------------------------------------------
void CProximityMapBuffer::calculateZones(TZones& zones)
{
	// clear out the result buffer before starting work
	zones.clear();

	// setup a container to hold the accessible points within this buffer
	typedef std::set<uint32> TAccessiblePoints;
	TAccessiblePoints accessiblePoints;

	// start by building the set of all accessible points
	for (uint32 i=0;i<_Buffer.size();++i)
	{
		if (_Buffer[i]==0)
			accessiblePoints.insert(i);
	}

	// while there are still points remaining in the set we must have another zone to process
	while (!accessiblePoints.empty())
	{
		// append a new zone to the zones vector and get a refference to it
		zones.push_back( CProximityZone(_ScanWidth,_ScanHeight,_XOffset,_YOffset) );
		CProximityZone& theZone= zones.back();

		// setup a todo list representing points that are part of the surface that we are dealing with
		// that haven't yet been treated to check for neighbours, etc
		std::vector<uint32> todo;

		// get hold of the first point in the accessilbe points set and push it onto the todo list
		todo.push_back(*accessiblePoints.begin());
		accessiblePoints.erase(todo.back());

		// while we have more points to deal with ...
		while (!todo.empty())
		{
			// pop the next point off the todo list
			uint32 thePoint= todo.back();
			todo.pop_back();

			// add the point to the zone
			theZone.add(thePoint);

			// a little macro for the code to perform for each movement test...
			#define TEST_MOVE(xoffs,yoffs)\
				{\
					TAccessiblePoints::iterator it= accessiblePoints.find(thePoint+xoffs+_ScanWidth*yoffs);\
					if (it!=accessiblePoints.end())\
					{\
						todo.push_back(*it);\
						accessiblePoints.erase(it);\
					}\
				}

			// N, S, W, E moves
			TEST_MOVE( 0, 1);
			TEST_MOVE( 0,-1);
			TEST_MOVE( 1, 0);
			TEST_MOVE(-1, 0);

			// NW, NE, WS, SE moves
			TEST_MOVE( 1, 1);
			TEST_MOVE(-1, 1);
			TEST_MOVE( 1,-1);
			TEST_MOVE(-1,-1);

			#undef TEST_MOVE
		}
	}

	nlinfo("Found %u zones",zones.size());
}

//-------------------------------------------------------------------------------------------------
void CProximityMapBuffer::_prepareBufferForZoneProximityMap(const CProximityZone& zone,TBuffer& zoneBuffer,TOffsetsVector& accessiblePoints)
{
	// the length of runs that we consider too short to deal with...
	const uint32 shortRunLength=5;

	// redimention and initialise the zone buffer
	uint32 zoneWidth= zone.getZoneWidth();
	uint32 zoneHeight= zone.getZoneHeight();
	zoneBuffer.clear();
	zoneBuffer.resize(zoneWidth*zoneHeight, std::numeric_limits<TBufferEntry>::max());

	// setup the buffer's accessible points and prime vects[0] with the set of accessible points in the zone buffer
	for (uint32 i=0;i<zone.getOffsets().size();++i)
	{
		// lookup the next offset in the zone's offsets vector and remap to a zone-relative offset
		uint32 zoneOffset= zone.remapOffset(zone.getOffsets()[i]);
		// flag the appropriate entry in the zoneBuffer as 'distance=0'
		zoneBuffer[zoneOffset]= 0;
		// add the zone offset to the accessible points vector
		accessiblePoints.push_back(zoneOffset);
	}

	// run through the zone buffer looking for points that are surrounded that we can just throw out...
	// start by flagging all points that belong to a short run in the y direction
	for (uint32 i=0;i<zoneWidth;++i)
	{
		// setup start and end offsets marking first and last 'zero' value pixels in the column
		uint32 startOffset=i, endOffset=i+(zoneHeight-1)*zoneWidth;
		for (; startOffset<endOffset && zoneBuffer[startOffset]!=0; startOffset+= zoneWidth) {}
		for (; endOffset>startOffset && zoneBuffer[endOffset]!=0;   endOffset-= zoneWidth) {}

		for (uint32 offset=startOffset, marker=startOffset;offset<=endOffset;offset+=zoneWidth)
		{
			// see if this is an accessible position 
			if (zoneBuffer[offset]!=0)
			{
				zoneBuffer[offset]= InteriorValue;

				if(offset-1>=startOffset && zoneBuffer[offset-1] == std::numeric_limits<TBufferEntry>::max())
				{
					zoneBuffer[offset-1] = ValueBorder;
				}
				if(offset+1<=endOffset && zoneBuffer[offset+1] == std::numeric_limits<TBufferEntry>::max())
				{
					zoneBuffer[offset+1] = ValueBorder;
				}
			}
		}
	}

	// continue by dealing with all points that belong to a short run in the x direction
	for (uint32 i=0;i<zoneHeight;++i)
	{
		// setup start and end offsets marking first and last 'zero' value pixels in the column
		uint32 startOffset= i*zoneWidth;
		uint32 endOffset= startOffset+zoneWidth-1;

		uint32 startOffsetInit = startOffset;
		uint32 endOffsetInit = endOffset;

		for (; startOffset<endOffset && zoneBuffer[startOffset]!=0; ++startOffset) {}
		for (; endOffset>startOffset && zoneBuffer[endOffset]!=0; --endOffset) {}

		for (uint32 offset=startOffset, marker=startOffset;offset<=endOffset;++offset)
		{
			// see if this is an accessible position 
			if (zoneBuffer[offset]!=0)
			{
				zoneBuffer[offset]= InteriorValue;

				if(offset>zoneWidth && zoneBuffer[offset-zoneWidth] == std::numeric_limits<TBufferEntry>::max())
				{
					zoneBuffer[offset-zoneWidth] = ValueBorder;
				}
				if(offset+zoneWidth<zoneHeight*zoneWidth && zoneBuffer[offset+zoneWidth] == std::numeric_limits<TBufferEntry>::max())
				{
					zoneBuffer[offset+zoneWidth] = ValueBorder;
				}
			}
		}
	}
}

//-------------------------------------------------------------------------------------------------
void CProximityMapBuffer::generateZoneProximityMap(const CProximityZone& zone,TBuffer& zoneBuffer)
{
	// a set of vectors to hold sets of points that need to be treated
	TOffsetsVector vects[16];
	// a counter that should always contain sum of all vects[i].size()
	uint32 entriesToTreat= 0;

	// setup the buffer's accessible points and prime vects[0] with the set of accessible points in the zone buffer
	_prepareBufferForZoneProximityMap(zone, zoneBuffer, vects[0]);
	entriesToTreat= vects[0].size();

	// lookup the buffer dimentions
	uint32 zoneWidth= zone.getZoneWidth();
	uint32 zoneHeight= zone.getZoneHeight();

	// for dist=0 to ? treat points with distance 'dist' from centre, iterating until all vects are empty
	for (TBufferEntry dist=0; entriesToTreat!=0; ++dist)
	{
		// setup refference to the vector that we are supposed to be iterating over for this dist
		TOffsetsVector &vect= vects[dist&15];

		// iterate over contents of points for this distance, treating NSWE neighbours
		for(TOffsetsVector::iterator it=vect.begin(); it!=vect.end(); ++it)
		{
			uint32 val=(*it);

			// deal with the case where this point has already been refferenced via a better route
			if (zoneBuffer[val]<dist || (zoneBuffer[val]==InteriorValue && dist > BigValue) 
				|| (zoneBuffer[val]==ValueBorder && dist > BigValue))
				continue;

			// write the new distance into this buffer entry
			zoneBuffer[val]=dist;

			// decompose into x and y in order to manage identification of neighbour cells correctly
			uint32 x= val % zoneWidth;
			uint32 y= val / zoneWidth;

			#define TEST_MOVE(xoffs,yoffs,newDist)\
				{\
					if (((uint32)(x+xoffs)<zoneWidth) && ((uint32)(y+yoffs)<zoneHeight))\
					{\
						uint32 newVal= val+xoffs+(yoffs*zoneWidth);\
						bool isInterior = ((zoneBuffer[newVal] == InteriorValue && newDist > BigValue) || (zoneBuffer[newVal] == ValueBorder && newDist > BigValue));\
						if (zoneBuffer[newVal] > newDist && !isInterior)\
						{\
							zoneBuffer[newVal] = newDist;\
							vects[newDist & 15].push_back(newVal);\
							++entriesToTreat;\
						}\
					}\
				}

			// N, S, W, E moves
			TEST_MOVE( 0, 1,dist+5);
			TEST_MOVE( 0,-1,dist+5);
			TEST_MOVE( 1, 0,dist+5);
			TEST_MOVE(-1, 0,dist+5);

			// NW, NE, WS, SE moves
			TEST_MOVE( 1, 1,dist+7);
			TEST_MOVE(-1, 1,dist+7);
			TEST_MOVE( 1,-1,dist+7);
			TEST_MOVE(-1,-1,dist+7);

			// NNW, NNE, SSW, SSE moves
			TEST_MOVE( 1, 2,dist+11);
			TEST_MOVE(-1, 2,dist+11);
			TEST_MOVE( 1,-2,dist+11);
			TEST_MOVE(-1,-2,dist+11);

			// WNW, WSW, ENE, ESE moves
			TEST_MOVE( 2, 1,dist+11);
			TEST_MOVE(-2, 1,dist+11);
			TEST_MOVE( 2,-1,dist+11);
			TEST_MOVE(-2,-1,dist+11);

			#undef TEST_MOVE
		}

		// clear out the vector
		entriesToTreat-= vect.size();
		vect.clear();
	}
}

//-------------------------------------------------------------------------------------------------
const TBuffer& CProximityMapBuffer::getBuffer() const
{
	return _Buffer;
}

//-------------------------------------------------------------------------------------------------
uint32 CProximityMapBuffer::getScanHeight() const
{
	return _ScanHeight;
}

//-------------------------------------------------------------------------------------------------
uint32 CProximityMapBuffer::getScanWidth() const
{
	return _ScanWidth;
}

//-----------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------------
// methods CProximityZone
//-------------------------------------------------------------------------------------------------

CProximityZone::CProximityZone(uint32 scanWidth,uint32 scanHeight,sint32 xOffset, sint32 yOffset)
{
	_ScanWidth	= scanWidth;
	_ScanHeight	= scanHeight;
	_XOffset	= xOffset;
	_YOffset	= yOffset;

	_MaxOffset	= scanWidth * scanHeight -1;

	_XMin = std::numeric_limits<uint32>::max();
	_YMin = std::numeric_limits<uint32>::max();
	_XMax = 0;
	_YMax = 0;

	_BorderPixels = 30;
}

//-------------------------------------------------------------------------------------------------
bool CProximityZone::add(uint32 offset)
{
	// make sure the requested point is in the zone
	if (offset>_MaxOffset)
		return false;

	// calculate the x and y coordinates of the point
	uint32 y= offset/ _ScanWidth;
	uint32 x= offset% _ScanWidth;

	// update the bounding coordinates for this zone
	if (x<_XMin) _XMin= x;
	if (x>_XMax) _XMax= x;
	if (y<_YMin) _YMin= y;
	if (y>_YMax) _YMax= y;
			 
	// add the point to the vector of points
	_Offsets.push_back(offset);
	return true;
}

//-------------------------------------------------------------------------------------------------
const CProximityZone::TOffsets& CProximityZone::getOffsets() const
{
	return _Offsets;
}

//-------------------------------------------------------------------------------------------------
uint32 CProximityZone::getZoneWidth() const
{
	return getZoneXMax()- getZoneXMin() +1;
}

//-------------------------------------------------------------------------------------------------
uint32 CProximityZone::getZoneHeight() const
{
	return getZoneYMax()- getZoneYMin() +1;
}

//-------------------------------------------------------------------------------------------------
sint32 CProximityZone::getZoneXMin() const
{
	return _XMin-_BorderPixels;
}

//-------------------------------------------------------------------------------------------------
sint32 CProximityZone::getZoneYMin() const
{
	return _YMin-_BorderPixels;
}

//-------------------------------------------------------------------------------------------------
uint32 CProximityZone::getZoneXMax() const
{
	return _XMax+_BorderPixels;
}

//-------------------------------------------------------------------------------------------------
uint32 CProximityZone::getZoneYMax() const
{
	return _YMax+_BorderPixels;
}

//-------------------------------------------------------------------------------------------------
uint32 CProximityZone::getBoundXMin() const
{
	return _XMin+_XOffset-_BorderPixels;
}

//-------------------------------------------------------------------------------------------------
uint32 CProximityZone::getBoundYMin() const
{
	return _YMin+_YOffset-_BorderPixels;
}

//-------------------------------------------------------------------------------------------------
uint32 CProximityZone::getBoundXMax() const
{
	return _XMax+_XOffset+_BorderPixels;
}

//-------------------------------------------------------------------------------------------------
uint32 CProximityZone::getBoundYMax() const
{
	return _YMax+_YOffset+_BorderPixels;
}

//-------------------------------------------------------------------------------------------------
uint32 CProximityZone::remapOffset(uint32 bufferOffset) const
{
	// decompose input coordinates into x and y parts
	uint32 bufferX= bufferOffset% _ScanWidth;
	uint32 bufferY= bufferOffset/ _ScanWidth;

	// remap the offset from a _Buffer-relative offset to a zone-relative offset
	return bufferX-getZoneXMin()+ (bufferY-getZoneYMin())*getZoneWidth();
}

}