khanat-opennel-code/code/nel/src/3d/zone_lighter.cpp

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

#include "std3d.h"

#include "nel/3d/zone_lighter.h"
#include "nel/3d/landscape.h"
#include "nel/3d/patchuv_locator.h"
#include "nel/3d/shape.h"
#include "nel/3d/mesh.h"
#include "nel/3d/mesh_multi_lod.h"
#include "nel/3d/mesh_mrm.h"
#include "nel/3d/transform_shape.h"
#include "nel/3d/water_shape.h"
#include "nel/3d/texture_file.h"

#include "nel/misc/common.h"
#include "nel/misc/thread.h"
#include "nel/misc/path.h"
#include "nel/misc/file.h"
#include "nel/misc/aabbox.h"
#include "nel/misc/algo.h"


#ifdef NL_OS_WINDOWS
#	define WIN32_LEAN_AND_MEAN
#	define NOMINMAX
#	include <windows.h>
#	include <winbase.h>
#endif // NL_OS_WINDOWS

using namespace NLMISC;
using namespace NL3D;
using namespace std;

// Define this to render the zbuffers into a bitmap zbuffer and save it into a jpeg
// #define SAVE_ZBUFFER "c:/temp"

#define DEFAULT_JITTER 0.4f
#define DEFAULT_ZBUFFER_LANDSCAPE_SIZE 32768
#define DEFAULT_ZBUFFER_OBJECT_SIZE (32768*3)
#define DEFAULT_SUN_DISTANCE 50000
#define DEFAULT_SUN_FOV (NLMISC::Pi/6)
#define DEFAULT_SUN_CENTER (CVector (0, 0, 0))
#define DEFAULT_SUN_RADIUS 5000
#define DEFAULT_SUN_SRQT_SAMPLES 4

// Bad coded: don't set too big else it allocates too much memory.
#define NL3D_ZONE_LIGHTER_CUBE_GRID_SIZE 16

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

Documentation:


	To light a zone, you must first adding shadow caster triangles using the addTriangle() methods.
	Triangles can come from landscape zones or IG meshes. Then call the lighting process with ligth().

	addTriangle ()
		- Add landscape triangles to shadow caster triangle list
			- Tesselate the landscape to shadow accuracy (2 meters)
		- Add others triangles to shadow caster triangle list  (trees, building)
			- AlphaTest textures can be used here

	light ()
		The lighting process uses a software zbuffers render to compute shadow attenuation of the zone.
		CRenderZBuffer () (multithread)
			- Render shadow caster triangles into the light zbuffers for shadows. Each z value is tested and
			written in the pixel and in the 8 neighbor pixels.
			- There is a zbuffer per landscape softshadow sample and an additionnal zbuffer for objects. So
			landscape triangles cast softshadows and object (trees and building) cast antialiased shadows.

		- Render shadow caster triangles into a heightfield used for radiosity

		buildZoneInformation ()

			- Tesselate the landscape to shadow accuracy (2 meters)

			- Compute lumel positions.
				Lumel position is the average of lumel triangles center overlapping
				the lumel but using the shadow accuracy triangle position because
				we need the same triangles than shadow caster polygons.
				Border lumel position are extended to fit the patch border.

			- Tesselate to lumel accuracy (0.5 meter)

			- Compute lumel normal
				- Lumel normal is the average of lumel triangles normals. The normals
				comes from the lumel accuracy to get more precise lighting. So normals
				are interpolated from the center of the lumel but they will be rendered
				on the patch border. Unlike the position, we can extand the normal to the
				border without loosing normal precision because normal interpolation is
				aligned with the tesselation. So we need some border normal smoothing.

			- Border normal smoothing
				- Normals on the border of the patches are smoothed with neighbor normals.

		CLightRunnable () (multithread)

			- For each patches and for each lumels

				attenuation ()
					- Compute shadow attenuation
						- Get an antialised attenuation value in each lansdcape softshadow zbuffer.
						Average it with jitter.
						- Get an antialised attenuation value from the object zbuffer.
						- Return the smaller value of the both.

				- Compute sun lighting (dot product)

				getSkyContribution ()
					- Compute sky lighting (radiosity)
						- Algorithm
							- Get the lumel position in the heightfield
							- Lookup in the 8 2d directions for max height
							- Compute an approximation of the sky surface visible from
							the lumel position
				- Store final lumel luminosity

*/

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

inline float easineasout(float x)
{
 float y;
 // cubic tq f(0)=0, f'(0)=0, f(1)=1, f'(1)=0.
 float x2=x*x;
 float x3=x2*x;
 y= -2*x3 + 3*x2;
 return y;
}

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

inline void transformVectorToZBuffer (const CZoneLighter::CZBuffer& zbuffer, const CVector &world, CVector &projected)
{
	projected = zbuffer.WorldToZBuffer * world;
	float temp = projected.z;
	projected.z = projected.y;
	projected.y = -temp;
	projected = zbuffer.WorldToZBufferFrustum.project (projected);

	// Scale to zbuffer size
	projected.x *= zbuffer.ZBufferPixelSize;
	projected.y *= zbuffer.ZBufferPixelSize;
	projected.z = temp;
}

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

static const sint DeltaZ[9][2]=
{
	{0, 0},
	{-1, 0},
	{1, 0},
	{0, -1},
	{0, 1},
	{-1, -1},
	{1, 1},
	{1, -1},
	{-1, 1},
};

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

inline float testZPercentageCloserFilter (float x, float y, float z, CZoneLighter::CZBuffer &zbuffer, const CZoneLighter::CLightDesc &description, bool &zBufferOverflowFlag)
{
	// See "Rendering Antialiased Shadows With Depth Maps" Reeves, Salesint, Cook, ACM 1987

	// Bilinear filtering

	float biliValues[2][2];

	float ix = (float)floor (x-0.5f);
	float factorX = x - (ix+0.5f);
	nlassert (factorX>=0);
	nlassert (factorX<=1);

	float iy = (float)floor (y-0.5f);
	float factorY = y - (iy+0.5f);
	nlassert (factorY>=0);
	nlassert (factorY<=1);

	sint dx, dy;
	for (dy=0; dy<2; dy++)
	for (dx=0; dx<2; dx++)
	{
		const sint fx = dx + (sint)ix;
		const sint fy = dy + (sint)iy;
		if ((fx >= 0) && (fx < zbuffer.LocalZBufferWidth) && (fy >= 0) && (fy < zbuffer.LocalZBufferHeight))
		{
			const float zRed = zbuffer.Pixels[fx + (zbuffer.LocalZBufferHeight - 1 - fy) * zbuffer.LocalZBufferWidth];

			biliValues[dx][dy] = (zRed < (-z)) ? 0.f : 1.f;
		}
		else
		{
			biliValues[dx][dy] = 1;
			zBufferOverflowFlag = true;
		}
	}

	// Bilinear
	return (biliValues[0][0] * (1 - factorX) + biliValues[1][0] * factorX) * (1 - factorY) +
		(biliValues[0][1] * (1 - factorX) + biliValues[1][1] * factorX) * factorY;
}

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

CZoneLighter::CZoneLighter () : _PatchComputed ("PatchComputed")
{
}

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

void CZoneLighter::init ()
{
	// Precalc some values
	for (uint i=0; i<8; i++)
	{
		// Precalc sinP and cosP
		float sinP=(float)(sin((Pi/4)*(i+0.5))-sin((Pi/4)*(i-0.5)));
		float cosP=(float)(cos((Pi/4)*(i-0.5))-cos((Pi/4)*(i+0.5)));

		for (uint phi=0; phi<256; phi++)
		{
			// Real phi
			float fPhi=(float)((Pi/2)*phi/256.0);

			// Tmp result
			float tmp0=(float)(fPhi-sin(2*fPhi)/2);
			float tmp1=(float)sin(fPhi);

			// Calc K
			_K[phi][i].set (tmp0*sinP, tmp0*cosP, (float)((Pi/4)*tmp1*tmp1));
		}
	}

	// Init some containers
	_ZBufferOverflow = false;
	_Bitmaps.clear ();
}

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

// N - NW - W - SW - S - SE - E - NE
static const sint deltaDirection[8][2]=
{
	{1, 0},
	{1, 1},
	{0, 1},
	{-1, 1},
	{-1, 0},
	{-1, -1},
	{0, -1},
	{1, -1},
};

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

float CZoneLighter::calcSkyContribution (sint s, sint t, float height, float skyIntensity, const CVector& normal) const
{
	// Sky contribution
	float skyContribution;

	// Calc k
	CVector k (0, 0, 0);

	// For the height direction
	for (uint i=0; i<8; i++)
	{
		// Get phi for this point
		uint8 phi=getMaxPhi (s, t, deltaDirection[i][0], deltaDirection[i][1], height);

		// Add to k
		k+=_K[phi][i];
	}

	// Finalize sky contribution
	skyContribution=(float)(skyIntensity*(normal*k)/(2*Pi));
	skyContribution=(float)(skyIntensity*(normal*k)/(2*Pi));
	clamp (skyContribution, 0.f, 1.f);
	return skyContribution;
}

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

void NEL3DCalcBase (CVector &direction, CMatrix& matrix)
{
	direction.normalize();
	CVector		K=-direction;
	CVector		I=CVector::K^K;
	CVector		J=K^I;
	J.normalize();
	I=J^K;
	I.normalize();
	matrix.identity();
	matrix.setRot(I,J,K, true);
}

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

void setCPUMask (IThread *thread, uint process)
{
	// Set the processor mask
	uint64 mask = IProcess::getCurrentProcess()->getCPUMask ();

	// Mask must not be NULL
	nlassert (mask != 0);

	if (mask != 0)
	{
		uint i=0;
		uint count = 0;
		for(;;)
		{
			if (mask & (UINT64_CONSTANT(1)<<i))
			{
				if (count == process)
					break;
				count++;
			}
			i++;
			if (i==64)
				i = 0;
		}

		// Set the CPU mask
		thread->setCPUMask (1<<i);
	}
}

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

class NL3D::CLightRunnable : public IRunnable
{
	// Members
	uint			_Process;
	CZoneLighter	*_ZoneLighter;
	const CZoneLighter::CLightDesc	*_Description;

public:
	IThread			*Thread;

public:
	// Ctor
	CLightRunnable (uint process, CZoneLighter *zoneLighter, const CZoneLighter::CLightDesc *description)
	{
		_ZoneLighter = zoneLighter;
		_Process = process;
		_Description = description;
	}

	// Run method
	void run()
	{
		// Set the CPU mask
		setCPUMask (Thread, _Process);

		_ZoneLighter->processCalc (_Process, *_Description);
		_ZoneLighter->_ProcessExited++;
	}
};


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

class NL3D::CRenderZBuffer : public IRunnable
{
	// Members
	uint			_Process;
	CZoneLighter	*_ZoneLighter;

	// The lighting decription
	const CZoneLighter::CLightDesc	*_Description;

	// Triangles to render
	uint			_FirstTriangle;
	uint			_NumTriangle;
	const vector<CZoneLighter::CTriangle>		*_Triangles;

public:
	IThread			*Thread;

public:
	// Ctor
	CRenderZBuffer (uint process, CZoneLighter *zoneLighter, const CZoneLighter::CLightDesc	*description, uint firstTriangle, uint numTriangle, const vector<CZoneLighter::CTriangle> *triangles)
	{
		_ZoneLighter = zoneLighter;
		_Description = description;
		_Process = process;
		_FirstTriangle = firstTriangle;
		_NumTriangle = numTriangle;
		_Triangles = triangles;
	}

	// Run method
	virtual void run ();
};

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

#define CLIPPED_TOP 1
#define CLIPPED_BOTTOM 2
#define CLIPPED_RIGHT 3
#define CLIPPED_LEFT 4
#define CLIPPED_ALL (CLIPPED_TOP|CLIPPED_BOTTOM|CLIPPED_LEFT|CLIPPED_RIGHT)

void RenderTriangle (const CZoneLighter::CTriangle &triangle, const CZoneLighter::CLightDesc &description, CPolygon2D::TRasterVect &borders,
					CFastMutex &mutex, CZoneLighter::CZBuffer &zbuffer, uint radius)
{
	// *** Transform it in the zbuffer basis

	// 2d polygon used for rasteriation
	CPolygon2D zBasis;
	zBasis.Vertices.resize (3);

	// 3d polygon used for the gradient
	NLMISC::CTriangle gradientTriangle;

	// One over z value
	float	ooz[3];

	// Clipping
	uint8 in = 0;

	// For each vertex
	for (uint j=0; j<3; j++)
	{
		// Pointer on the vector
		const CVector *pt = (&triangle.Triangle.V0)+j;
		CVector *ptDest = (&gradientTriangle.V0)+j;

		// Transform it in the zbuffer basis
		transformVectorToZBuffer (zbuffer, *pt, *ptDest);

		// Clip
		if (ptDest->x >= zbuffer.LocalZBufferXMin)
			in |= CLIPPED_LEFT;
		if (ptDest->x <= zbuffer.LocalZBufferXMax)
			in |= CLIPPED_RIGHT;
		if (ptDest->y >= zbuffer.LocalZBufferYMin)
			in |= CLIPPED_TOP;
		if (ptDest->y <= zbuffer.LocalZBufferYMax)
			in |= CLIPPED_BOTTOM;

		// Set the 2d points
		zBasis.Vertices[j].x = ptDest->x - (float)zbuffer.LocalZBufferXMin;
		zBasis.Vertices[j].y = ptDest->y - (float)zbuffer.LocalZBufferYMin;
		ooz[j] = 1.f / ptDest->z;

		// No z
		ptDest->z = 0;
	}

	// Not clipped ?
	if (in == CLIPPED_ALL)
	{
		// Rasterise
		sint minimumY;
		borders.clear ();
		zBasis.computeBorders (borders, minimumY);

		// Compute the gradient for one over z
		CVector ozzGradient;
		gradientTriangle.computeGradient (ooz[0], ooz[1], ooz[2], ozzGradient);

		// Need uv ?
		bool needUV = triangle.Texture != NULL;

		// Compute the gradient for uv
		CVector uGradient;
		CVector vGradient;
		if (needUV)
		{
			gradientTriangle.computeGradient (triangle.U[0], triangle.U[1], triangle.U[2], uGradient);
			gradientTriangle.computeGradient (triangle.V[0], triangle.V[1], triangle.V[2], vGradient);
		}

		// Texture information
		uint width=0;
		uint height=0;
		const CObjectVector<uint8> *pixels = 0;
		if (needUV)
		{
			// Get pixels
			pixels = &triangle.Texture->getPixels ();

			// Get width and height
			width = triangle.Texture->getWidth ();
			height = triangle.Texture->getHeight ();
		}

		// For each scanlines
		sint y = std::max (minimumY, 0);
		sint yMax = std::min ((sint)(minimumY+borders.size ()), zbuffer.LocalZBufferHeight);
		for (; y<yMax; y++)
		{
			// Ref on the raster
			const CPolygon2D::TRaster &raster = borders[y-minimumY];

			// Gradient y for ooz, u and v
			const float deltaY = (float)y - zBasis.Vertices[0].y;
			const float oozGradientY = deltaY * ozzGradient.y;
			float uGradientY=0.0f;
			float vGradientY=0.0f;
			if (needUV)
			{
				uGradientY = deltaY * uGradient.y;
				vGradientY = deltaY * vGradient.y;
			}

			// Clip it
			sint x = std::max (raster.first, 0);
			sint xMax = std::min (raster.second+1, zbuffer.LocalZBufferWidth);
			for (; x<xMax; x++)
			{
				// Gradient x for ooz, u and v
				const float deltaX = (float)x - zBasis.Vertices[0].x;
				const float oozGradientX = deltaX * ozzGradient.x;
				float uGradientX=0.0f;
				float vGradientX=0.0f;
				if (needUV)
				{
					uGradientX = deltaX * uGradient.x;
					vGradientX = deltaX * vGradient.x;
				}

				// Calc z
				float z = - 1.f / (ooz[0] + oozGradientX + oozGradientY);

				// Calc u & v
				float u;
				float v;
				bool alphaTest = true;
				if (needUV)
				{
					// Compute uv
					u = triangle.U[0] + uGradientX + uGradientY;
					v = triangle.V[0] + vGradientX + vGradientY;

					// Clamp or wrap ?
					if (triangle.Flags & CZoneLighter::CTriangle::ClampU)
						clamp (u, 0.f, 1.f);
					else
						u -= (float)floor (u);
					if (triangle.Flags & CZoneLighter::CTriangle::ClampV)
						clamp (v, 0.f, 1.f);
					else
						v -= (float)floor (v);

					// Lookup in the texture
					u *= width;
					v *= height;
					clamp (u, 0, width-1);
					clamp (v, 0, height-1);
					uint8 alpha = ((const CRGBA*)&((*pixels)[(((uint)u)+((uint)v)*width)*sizeof (CRGBA)]))->A;

					// Alpha test
					alphaTest = alpha >= triangle.AlphaTestThreshold;
				}

				// Good alpha test ?
				if (alphaTest)
				{
					// Enter the mutex
					mutex.enter ();

					// Write Z around
					uint d;
					for (d=0; d<radius; d++)
					{
						// Ref in the zbuffer
						sint fx = x + DeltaZ[d][0];
						sint fy = y + DeltaZ[d][1];
						if ( (fx >= 0) && (fx < zbuffer.LocalZBufferWidth) && (fy >= 0) && (fy < zbuffer.LocalZBufferHeight) )
						{
							float &zValue = zbuffer.Pixels[fx+(zbuffer.LocalZBufferHeight-fy-1)*zbuffer.LocalZBufferWidth];

							// Z test
							if (z < zValue)
							{
								// Render z in zbuffer
								zValue = z;
							}
						}
					}

					// Leave the mutex
					mutex.leave ();
				}
			}
		}
	}
}


void NL3D::CRenderZBuffer::run()
{
	// Set the CPU mask
	setCPUMask (Thread, _Process);

	// Span array
	CPolygon2D::TRasterVect borders;

	// For each triangles
	uint i;
	for (i=_FirstTriangle; i<_FirstTriangle+_NumTriangle; i++)
	{
		// Triangle reference
		const CZoneLighter::CTriangle &triangle = (*_Triangles)[i];

		// Keep backface and doublesided polygons
		if ((triangle.Flags & CZoneLighter::CTriangle::DoubleSided) || ((triangle.getPlane ().getNormal() * _ZoneLighter->_SunDirection) > 0))
		{
			// Landscape triangle ?
			if (triangle.Flags & CZoneLighter::CTriangle::Landscape)
			{
				// For each landscape zbuffer
				uint sample;
				const uint samples = _Description->SoftShadowSamplesSqrt*_Description->SoftShadowSamplesSqrt;
				for (sample=0; sample<samples; sample++)
				{
					RenderTriangle (triangle, *_Description, borders, _ZoneLighter->_Mutex, _ZoneLighter->_ZBufferLandscape[sample], 9);
				}
			}
			else
			{
				// Render in a high resolution zbuffer
				RenderTriangle (triangle, *_Description, borders, _ZoneLighter->_Mutex, _ZoneLighter->_ZBufferObject, 1);
			}
		}
		_ZoneLighter->_NumberOfPatchComputed++;
	}

	// Exit
	_ZoneLighter->_ProcessExited++;
}

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

class NL3D::CCalcLightableShapeRunnable : public IRunnable
{
public:
	CCalcLightableShapeRunnable(uint process,
								CZoneLighter *zoneLighter,
								const CZoneLighter::CLightDesc *description,
								CZoneLighter::TShapeVect *shapeToLit,
								uint firstShape,
								uint lastShape
								)
		:
		  _ZoneLighter(zoneLighter),
		  _Description(description),
		  _ShapesToLit(shapeToLit),
		  _FirstShape(firstShape),
		  _LastShape(lastShape),
		  _Process(process)
	{
	}
	void run()
	{
		_ZoneLighter->processLightableShapeCalc(_Process, _ShapesToLit, _FirstShape, _LastShape, *_Description);
		_ZoneLighter->_ProcessExited++;
	}
private:
	CZoneLighter						*_ZoneLighter;
	const CZoneLighter::CLightDesc		*_Description;
	CZoneLighter::TShapeVect	*_ShapesToLit;
	uint								_FirstShape, _LastShape;
	uint								_Process;

};

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

void draw2dLine (CBitmap &bitmap, float x0, float y0, float x1, float y1, const CRGBA &color)
{
	static vector< std::pair<sint, sint> > lines;
	drawFullLine (x0, y0, x1, y1, lines);

	// Bitmap pixels
	CRGBA *pixels = (CRGBA*)&(bitmap.getPixels ()[0]);

	// Bitmap size
	sint width = (sint)bitmap.getWidth ();
	sint height = (sint)bitmap.getHeight ();

	// Draw the line
	uint i;
	for (i=0; i<lines.size (); i++)
	{
		sint x = lines[i].first;
		sint y = lines[i].second;

		// Clip
		if ( (x >= 0) && (x < width) && (y >= 0) && (y < height) )
		{
			pixels[x+(height-y-1)*width] = color;
		}
	}
}

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

void InitZBuffer (CZoneLighter::CZBuffer &zbuffer, const CVector &SunPosition, const CMatrix &rayBasis, const CAABBoxExt &zoneBB, uint zBufferPixelSize, const CZoneLighter::CLightDesc& description)
{
	// Clac the zbuffer world size
	const float zBufferWorldSize = (float)(tan (description.SunFOV/2)*description.SunDistance*2);

	// ** Compute the zbuffer basis
	zbuffer.WorldToZBuffer.identity ();

	zbuffer.WorldToZBuffer = rayBasis;
	zbuffer.WorldToZBuffer.setPos (SunPosition);
	zbuffer.WorldToZBuffer.invert ();
	zbuffer.WorldToZBufferFrustum.init ((float)zBufferWorldSize, (float)zBufferWorldSize, description.SunDistance, description.SunDistance*2);

	// Zbuffer size
	zbuffer.ZBufferPixelSize = zBufferPixelSize;

	// Evaluate the size of the local zbuffer

	// The zone bounding box
	CVector bMin = zoneBB.getMin ();
	CVector bMax = zoneBB.getMax ();
	transformVectorToZBuffer (zbuffer, CVector (bMin.x, bMax.y, bMin.z), zbuffer.BoundingBoxVectors[0]);
	transformVectorToZBuffer (zbuffer, CVector (bMin.x, bMin.y, bMin.z), zbuffer.BoundingBoxVectors[1]);
	transformVectorToZBuffer (zbuffer, CVector (bMax.x, bMin.y, bMin.z), zbuffer.BoundingBoxVectors[2]);
	transformVectorToZBuffer (zbuffer, CVector (bMax.x, bMax.y, bMin.z), zbuffer.BoundingBoxVectors[3]);
	transformVectorToZBuffer (zbuffer, CVector (bMin.x, bMax.y, bMax.z), zbuffer.BoundingBoxVectors[4]);
	transformVectorToZBuffer (zbuffer, CVector (bMin.x, bMin.y, bMax.z), zbuffer.BoundingBoxVectors[5]);
	transformVectorToZBuffer (zbuffer, CVector (bMax.x, bMin.y, bMax.z), zbuffer.BoundingBoxVectors[6]);
	transformVectorToZBuffer (zbuffer, CVector (bMax.x, bMax.y, bMax.z), zbuffer.BoundingBoxVectors[7]);

	// Get the min and max
	zbuffer.LocalZBufferXMin = 0x7fffffff;
	zbuffer.LocalZBufferYMin = 0x7fffffff;
	zbuffer.LocalZBufferXMax = 0x80000000;
	zbuffer.LocalZBufferYMax = 0x80000000;
	zbuffer.LocalZBufferZMin = FLT_MAX;
	zbuffer.LocalZBufferZMax = -FLT_MAX;
	uint j;
	for (j=0; j<8; j++)
	{
		sint minX = (sint)floor (zbuffer.BoundingBoxVectors[j].x);
		sint maxX = (sint)ceil (zbuffer.BoundingBoxVectors[j].x);
		sint minY = (sint)floor (zbuffer.BoundingBoxVectors[j].y);
		sint maxY = (sint)ceil (zbuffer.BoundingBoxVectors[j].y);
		if (minX<zbuffer.LocalZBufferXMin)
			zbuffer.LocalZBufferXMin = minX;
		if (maxX>zbuffer.LocalZBufferXMax)
			zbuffer.LocalZBufferXMax = maxX;
		if (minY<zbuffer.LocalZBufferYMin)
			zbuffer.LocalZBufferYMin = minY;
		if (maxY>zbuffer.LocalZBufferYMax)
			zbuffer.LocalZBufferYMax = maxY;
		if ((-zbuffer.BoundingBoxVectors[j].z)<zbuffer.LocalZBufferZMin)
			zbuffer.LocalZBufferZMin = -zbuffer.BoundingBoxVectors[j].z;
		if ((-zbuffer.BoundingBoxVectors[j].z)>zbuffer.LocalZBufferZMax)
			zbuffer.LocalZBufferZMax = -zbuffer.BoundingBoxVectors[j].z;
	}

	// Expand the zbuffer
	zbuffer.LocalZBufferXMax++;
	zbuffer.LocalZBufferXMin--;
	zbuffer.LocalZBufferYMax++;
	zbuffer.LocalZBufferYMin--;

	zbuffer.LocalZBufferWidth = zbuffer.LocalZBufferXMax-zbuffer.LocalZBufferXMin;
	zbuffer.LocalZBufferHeight = zbuffer.LocalZBufferYMax-zbuffer.LocalZBufferYMin;

	// Resize and clear the zbuffer
	zbuffer.Pixels.resize (0);
	zbuffer.Pixels.resize (zbuffer.LocalZBufferWidth*zbuffer.LocalZBufferHeight, FLT_MAX);
}

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

#ifdef SAVE_ZBUFFER
void SaveZBuffer (CZoneLighter::CZBuffer &zbuffer, const char *filename)
{
	// Resize the bitmap
	CBitmap bitmap;
	bitmap.resize (zbuffer.LocalZBufferWidth, zbuffer.LocalZBufferHeight, CBitmap::Luminance);

	// Get pixels
	CObjectVector<uint8> &pixels = bitmap.getPixels ();

	// Draw it
	uint samples = zbuffer.LocalZBufferWidth*zbuffer.LocalZBufferHeight;
	for (uint i=0; i<samples; i++)
	{
		// Get the value
		float value = (zbuffer.Pixels[i] - zbuffer.LocalZBufferZMin) * 255 / (zbuffer.LocalZBufferZMax - zbuffer.LocalZBufferZMin);
		clamp (value, 0, 255);
		pixels[i] = (uint8)value;
	}

	// Convert to RGBA
	bitmap.convertToType (CBitmap::RGBA);

	// Draw some red lines
	draw2dLine (bitmap, zbuffer.BoundingBoxVectors[0].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[0].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[1].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[1].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
	draw2dLine (bitmap, zbuffer.BoundingBoxVectors[0].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[0].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[3].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[3].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
	draw2dLine (bitmap, zbuffer.BoundingBoxVectors[2].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[2].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[1].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[1].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
	draw2dLine (bitmap, zbuffer.BoundingBoxVectors[2].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[2].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[3].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[3].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
	draw2dLine (bitmap, zbuffer.BoundingBoxVectors[4].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[4].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[5].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[5].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
	draw2dLine (bitmap, zbuffer.BoundingBoxVectors[4].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[4].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[7].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[7].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
	draw2dLine (bitmap, zbuffer.BoundingBoxVectors[6].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[6].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[5].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[5].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
	draw2dLine (bitmap, zbuffer.BoundingBoxVectors[6].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[6].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[7].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[7].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
	draw2dLine (bitmap, zbuffer.BoundingBoxVectors[0].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[0].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[4].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[4].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
	draw2dLine (bitmap, zbuffer.BoundingBoxVectors[1].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[1].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[5].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[5].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
	draw2dLine (bitmap, zbuffer.BoundingBoxVectors[2].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[2].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[6].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[6].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);
	draw2dLine (bitmap, zbuffer.BoundingBoxVectors[3].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[3].y-(float)zbuffer.LocalZBufferYMin, zbuffer.BoundingBoxVectors[7].x-(float)zbuffer.LocalZBufferXMin, zbuffer.BoundingBoxVectors[7].y-(float)zbuffer.LocalZBufferYMin, CRGBA::Red);

	// Render it
	COFile outputZFile;

	// Open it
	if (outputZFile.open (filename))
	{
		// Save the new zone
		try
		{
			// Convert to RGBA
			bitmap.convertToType (CBitmap::RGBA);

			// Save it
			bitmap.writeJPG (outputZFile, 128);
		}
		catch (const Exception& except)
		{
			// Error message
			nlwarning ("ERROR writing %s: %s\n", filename, except.what());
		}
	}
	else
	{
		// Error can't open the file
		nlwarning ("ERROR Can't open %s for writing\n", filename);
	}
}
#endif // SAVE_ZBUFFER

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

void FilterZBuffer (CZoneLighter::CZBuffer &zbuffer, uint filterRadius)
{
	// Resize the temp buffer
	static std::vector<float> tempPixels;
	tempPixels = zbuffer.Pixels;

	sint x, y;
	for (y=0; y<zbuffer.LocalZBufferHeight; y++)
	for (x=0; x<zbuffer.LocalZBufferWidth; x++)
	{
		// The Value
		float &newValue = tempPixels[x+y*zbuffer.LocalZBufferWidth];

		uint n;
		for (n=1; n<filterRadius; n++)
		{
			const sint fx = x + DeltaZ[n][0];
			const sint fy = y + DeltaZ[n][1];

			// Clip
			if ( (fx>=0) && (fx < zbuffer.LocalZBufferWidth) && (fy>=0) && (fy < zbuffer.LocalZBufferHeight) )
			{
				const float &testValue = zbuffer.Pixels[fx+fy*zbuffer.LocalZBufferWidth];
				if (testValue < newValue)
					newValue = testValue;
			}
		}

	}

	// Copy the new zbuffer
	zbuffer.Pixels = tempPixels;
}

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

void CZoneLighter::light (CLandscape &landscape, CZone& output, uint zoneToLight, const CLightDesc& description, std::vector<CTriangle>& obstacles, vector<uint> &listZone)
{
	/*
	 * Lighting algorithm
	 * ------------------
	 *
	 * - Create a quad grid to store shadow casting triangles
	 * - Create a heightfield used for global illumination. Cells are initialized with -FLT_MAX
	 * - Insert each shadow casting triangles in the quad grid and fill the heightfield's cells overlapped by the bounding box of the triangle with
	 * the max height of the triangle if its height is > than the current height in the heightfield's cell.
	 * -
	 */

	// Backup thread mask
	IThread *currentThread = IThread::getCurrentThread ();
	uint64 threadMask = currentThread->getCPUMask();
	currentThread->setCPUMask (1);

	// Calc the ray basis
	_SunDirection=description.SunDirection;
	NEL3DCalcBase (_SunDirection, _RayBasis);

	// Zone to light
	_ZoneToLight=zoneToLight;

	// Landscape
	_Landscape=&landscape;

	// Process count
	_ProcessCount=description.NumCPU;
	if (_ProcessCount==0)
	{
		// Create a doomy thread
		IProcess *pProcess=IProcess::getCurrentProcess ();
		_CPUMask = pProcess->getCPUMask();
		_ProcessCount = 0;
		uint64 i;
		for (i=0; i<64; i++)
		{
			if (_CPUMask&((uint64)1<<i))
				_ProcessCount++;
		}
	}
	if (_ProcessCount>MAX_CPU_PROCESS)
		_ProcessCount=MAX_CPU_PROCESS;

	// Number of obstacle polygones
	nlinfo ("Obstacle polygones : %u", (uint)obstacles.size ());

	// Number of CPUS used
	nlinfo ("Number of CPU used: %u", _ProcessCount);

	// Zone pointer
	CZone *pZone=landscape.getZone (_ZoneToLight);
	if (pZone)
	{
		// *** Compute center of the object

		// Get the zone bounding box
		const CAABBoxExt &zoneBB=pZone->getZoneBB();

		// Get the center
		CVector center = zoneBB.getCenter ();

		// *** Compute planes
		const uint size=(uint)obstacles.size();
		uint triangleId;
		for (triangleId=0; triangleId<size; triangleId++)
		{
			// Triangle ref
			CZoneLighter::CTriangle& triangle=obstacles[triangleId];

			// Calc the plane
			triangle._Plane.make (triangle.Triangle.V0, triangle.Triangle.V1, triangle.Triangle.V2);
		}

		// Create landscape zbuffers
		_ZBufferLandscape.resize (description.SoftShadowSamplesSqrt*description.SoftShadowSamplesSqrt);

		uint sampleX;
		uint sampleY;
		for (sampleY=0; sampleY<description.SoftShadowSamplesSqrt; sampleY++)
		for (sampleX=0; sampleX<description.SoftShadowSamplesSqrt; sampleX++)
		{
			// *** Render the light zbuffer
			CZBuffer &zbuffer = _ZBufferLandscape[sampleX + sampleY*description.SoftShadowSamplesSqrt];

			// Delta pos for area light
			float deltaX = ( (float)sampleX + 0.5f  - (float)description.SoftShadowSamplesSqrt / 2.f) / (float)description.SoftShadowSamplesSqrt;
			float deltaY = ( (float)sampleY + 0.5f  - (float)description.SoftShadowSamplesSqrt / 2.f) / (float)description.SoftShadowSamplesSqrt;
			CVector lightPos = _RayBasis.getI () * ((float)description.SunRadius * deltaX) + _RayBasis.getJ () * ((float)description.SunRadius * deltaY);
			lightPos = description.SunCenter - (description.SunDirection * description.SunDistance) + lightPos;

			InitZBuffer (zbuffer, lightPos, _RayBasis, zoneBB, description.ZBufferLandscapeSize, description);
			nlinfo ("Zbuffer %d size : %d x %d", sampleX+sampleY*description.SoftShadowSamplesSqrt, zbuffer.LocalZBufferWidth, zbuffer.LocalZBufferHeight);
		}


		// *** Init the zbuffer for the vegetation
		CVector lightPos = description.SunCenter - (description.SunDirection * description.SunDistance);
		InitZBuffer (_ZBufferObject, lightPos, _RayBasis, zoneBB, description.ZBufferObjectSize, description);
		nlinfo ("Zbuffer object size : %d x %d", _ZBufferObject.LocalZBufferWidth, _ZBufferObject.LocalZBufferHeight);


		// Compute the zbuffer in multi thread
		_ProcessExited = 0;

		// Number of triangle to render per thread
		uint numTriangle = ((uint)obstacles.size () / _ProcessCount) + 1;

		// First triangle for the thread
		uint firstTriangle = 0;

		// Count
		_NumberOfPatchComputed = 0;

		for (uint process=0; process<_ProcessCount; process++)
		{
			// Get list of triangles to render
			uint lastTriangle=firstTriangle+numTriangle;
			if (lastTriangle>obstacles.size ())
				lastTriangle=(uint)obstacles.size ();

			// Create a thread
			CRenderZBuffer *runnable = new CRenderZBuffer (process, this, &description, firstTriangle, lastTriangle - firstTriangle, &obstacles);
			IThread *pThread=IThread::create (runnable);
			runnable->Thread = pThread;

			// New first patch
			firstTriangle = lastTriangle;

			// Launch
			pThread->start();
		}

		// Wait for others processes
		while (_ProcessExited!=_ProcessCount)
		{
			nlSleep (1000);

			// Call the progress callback
			progress ("Render triangles", (float)_NumberOfPatchComputed/(float)obstacles.size());
		}

		// * Save the zbuffer
		uint sample;
		const uint samples = description.SoftShadowSamplesSqrt*description.SoftShadowSamplesSqrt;
#ifdef SAVE_ZBUFFER
		for (sample=0; sample<samples; sample++)
		{
			// *** The zbuffer
			CZBuffer &zbuffer = _ZBufferLandscape[sample];

			string zbufferFilename = SAVE_ZBUFFER"/zbuffer_landscape_" + toString (sample) + ".jpg";

			SaveZBuffer (zbuffer, zbufferFilename.c_str ());
		}

		// Save the object zbuffer
		SaveZBuffer (_ZBufferObject, SAVE_ZBUFFER"/zbuffer_object.jpg");
#endif // SAVE_ZBUFFER

		// *** Filter the zbuffer
		for (sample=0; sample<samples; sample++)
		{
			// For landscape zbuffer, expand the z to neighbor
			FilterZBuffer (_ZBufferLandscape[sample], 5);
		}

		// Change the quadGrid basis
		CMatrix invRayBasis=_RayBasis;
		invRayBasis.invert ();

		// Init the heightfield
		_HeightfieldCellSize=description.HeightfieldCellSize;
		_HeightFieldCellCount=(sint)(description.HeightfieldSize/_HeightfieldCellSize);
		nlassert (_HeightFieldCellCount!=0);
		_OrigineHeightField=zoneBB.getCenter ()-CVector (description.HeightfieldSize/2, description.HeightfieldSize/2, 0);
		_HeightField.resize (_HeightFieldCellCount*_HeightFieldCellCount, -FLT_MAX);

		// Fill the quadGrid and the heightField
		for (triangleId=0; triangleId<size; triangleId++)
		{
			// Progress bar
			if ( (triangleId&0xff) == 0)
				progress ("Build quadtree and heightfield", (float)triangleId/(float)size);

			// Triangle ref
			CZoneLighter::CTriangle& triangle=obstacles[triangleId];

			// Look for the min coordinate, in World Basis
			CVector minv;
			minv.minof (triangle.Triangle.V0, triangle.Triangle.V1);
			minv.minof (minv, triangle.Triangle.V2);

			// Look for the max coordinate, in World Basis
			CVector maxv;
			maxv.maxof (triangle.Triangle.V0, triangle.Triangle.V1);
			maxv.maxof (maxv, triangle.Triangle.V2);

			// Lanscape tri ?
			if (triangle.Flags & CTriangle::Landscape)
			{
				// Fill the heightfield
				sint minX=std::max (0, (sint)floor (0.5f+(minv.x-_OrigineHeightField.x)/_HeightfieldCellSize));
				sint maxX=std::min (_HeightFieldCellCount, (sint)floor (0.5f+(maxv.x-_OrigineHeightField.x)/_HeightfieldCellSize));
				sint minY=std::max (0, (sint)floor (0.5f+(minv.y-_OrigineHeightField.y)/_HeightfieldCellSize));
				sint maxY=std::min (_HeightFieldCellCount, (sint)floor (0.5f+(maxv.y-_OrigineHeightField.y)/_HeightfieldCellSize));

				// Calc position in the heightfield
				for (sint y=minY; y<maxY; y++)
				for (sint x=minX; x<maxX; x++)
				{
					// Valid position, try to insert it
					if (maxv.z>_HeightField[x+y*_HeightFieldCellCount])
					{
						// New height in this cell
						_HeightField[x+y*_HeightFieldCellCount]=maxv.z;
					}
				}
			}
		}

		// Retrieve the zone to fill its shaded value
		pZone->retrieve (_PatchInfo, _BorderVertices);

		// Number of patch
		uint patchCount=(uint)_PatchInfo.size();

		// Bit array to know if the lumel is shadowed
		if (description.Shadow)
			_ShadowArray.resize (patchCount);

		// A lumel vector by patch
		vector<vector<CLumelDescriptor>	> lumels;
		lumels.resize (patchCount);

		// Build zone information
		buildZoneInformation (landscape,
							  listZone,
							  description);

	}

	// Number of patch
	uint patchCount=(uint)_PatchInfo.size();

	// Reset patch count
	{
		CSynchronized<std::vector<bool> >::CAccessor access (&_PatchComputed);
		access.value().resize (0);
		access.value().resize (patchCount, false);
	}

	// Patch by thread
	uint patchCountByThread = patchCount/_ProcessCount;
	patchCountByThread++;

	// Patch to allocate
	uint firstPatch=0;
	_NumberOfPatchComputed = 0;

	// Reset exited process
	_ProcessExited=0;

	// Set the thread state
	_LastPatchComputed.resize (_ProcessCount);

	// Launch threads
	uint process;
	for (process=0; process<_ProcessCount; process++)
	{
		// Last patch
		uint lastPatch=firstPatch+patchCountByThread;
		if (lastPatch>patchCount)
			lastPatch=patchCount;

		// Last patch computed
		_LastPatchComputed[process] = firstPatch;

		// Create a thread
		CLightRunnable *runnable = new CLightRunnable (process, this, &description);
		IThread *pThread=IThread::create (runnable);
		runnable->Thread = pThread;

		// New first patch
		firstPatch=lastPatch;

		// Launch
		pThread->start();
	}

	// Wait for others processes
	while (_ProcessExited!=_ProcessCount)
	{
		nlSleep (1000);

		// Call the progress callback
		progress ("Lighting patches", (float)_NumberOfPatchComputed/(float)_PatchInfo.size());
	}

	// Reset old thread mask
	currentThread->setCPUMask (threadMask);

	// overflow ?
	if (_ZBufferOverflow)
		nlwarning ("Error : zbuffer overflow");

	// Progress bar
	progress ("Compute Influences of PointLights", 0.f);

	// Compute PointLight influences on zone.
	// Some precalc.
	compilePointLightRT(description.GridSize, description.GridCellSize, obstacles, description.Shadow);
	// Influence patchs and get light list of interest
	std::vector<CPointLightNamed>	listPointLight;
	processZonePointLightRT(listPointLight);


	// Rebuild the zone

	// Progress bar
	progress ("Compress the lightmap", 0.6f);

	// Build, with list of lights.
	CZoneInfo	zinfo;
	zinfo.ZoneId= _ZoneToLight;
	zinfo.Patchs= _PatchInfo;
	zinfo.BorderVertices= _BorderVertices;
	zinfo.PointLights= listPointLight;
	output.build (zinfo);

	/// copy the tiles flags from the zone to light to the output zone
	copyTileFlags(output, *(landscape.getZone(zoneToLight)));

	/// Perform lightning of some ig's of the current zone (if any)
	lightShapes(zoneToLight, description);
}


// *************************************************************************************
void CZoneLighter::copyTileFlags(CZone &destZone, const CZone &srcZone)
{
	nlassert(destZone.getZoneId() == srcZone.getZoneId());
	nlassert(destZone.getNumPatchs() == srcZone.getNumPatchs());
	for (sint k = 0; k < srcZone.getNumPatchs(); ++k)
	{
		destZone.copyTilesFlags(k, srcZone.getPatch(k));
	}
}

// ***************************************************************************
float CZoneLighter::getSkyContribution(const CVector &pos, const CVector &normal, float skyIntensity) const
{
	float s=(pos.x-_OrigineHeightField.x)/_HeightfieldCellSize;
	float t=(pos.y-_OrigineHeightField.y)/_HeightfieldCellSize;
	sint sInt=(sint)(floor (s+0.5f));
	sint tInt=(sint)(floor (t+0.5f));

	// Bilinear
	float skyContributionTab[2][2];
	skyContributionTab[0][0] = calcSkyContribution (sInt-1, tInt-1, pos.z, skyIntensity, normal);
	skyContributionTab[1][0] = calcSkyContribution (sInt, tInt-1, pos.z, skyIntensity, normal);
	skyContributionTab[1][1] = calcSkyContribution (sInt, tInt, pos.z, skyIntensity, normal);
	skyContributionTab[0][1] = calcSkyContribution (sInt-1, tInt, pos.z, skyIntensity, normal);

	float sFact=s+0.5f-sInt;
	float tFact=t+0.5f-tInt;
	return (skyContributionTab[0][0]*(1.f-sFact) + skyContributionTab[1][0]*sFact)*(1.f-tFact) +
		(skyContributionTab[0][1]*(1.f-sFact) + skyContributionTab[1][1]*sFact)*tFact;
}


// ***************************************************************************
void CZoneLighter::processCalc (uint process, const CLightDesc& description)
{
	// *** Raytrace each patches

	// Get a patch
	uint patch = getAPatch (process);
	while (patch != 0xffffffff)
	{
		// For each patch
		if (description.Shadow)
		{
			// Lumels
			std::vector<CLumelDescriptor> &lumels=_Lumels[patch];

			// Lumel count
			uint lumelCount=(uint)lumels.size();
			CPatchInfo &patchInfo=_PatchInfo[patch];
			nlassert (patchInfo.Lumels.size()==lumelCount);

			// Resize shadow array
			_ShadowArray[patch].resize (lumelCount);

			// For each lumel
			for (uint lumel=0; lumel<lumelCount; lumel++)
			{
				float factor=0;
				factor = attenuation (lumels[lumel].Position, description);
				patchInfo.Lumels[lumel]=(uint)(factor*255);
			}
		}
		else
		{
			// Lumels
			std::vector<CLumelDescriptor> &lumels=_Lumels[patch];

			// Lumel count
			uint lumelCount=(uint)lumels.size();
			CPatchInfo &patchInfo=_PatchInfo[patch];
			nlassert (patchInfo.Lumels.size()==lumelCount);

			// For each lumel
			for (uint lumel=0; lumel<lumelCount; lumel++)
			{
				// Not shadowed
				patchInfo.Lumels[lumel]=255;
			}
		}

		// *** Lighting

		// Get the patch info
		CPatchInfo &patchInfo=_PatchInfo[patch];

		// ** Pointer on arries
		std::vector<CLumelDescriptor> &lumels=_Lumels[patch];

		// Go for light each lumel
		for (uint lumel=0; lumel<lumels.size(); lumel++)
		{
			// Sky contribution
			float skyContribution;

			if (description.SkyContribution)
			{
				skyContribution = getSkyContribution(lumels[lumel].Position, lumels[lumel].Normal, description.SkyIntensity);
			}
			else
			{
				skyContribution = 0.f;
			}

			// Sun contribution
			float sunContribution;
			if (description.SunContribution)
			{
				sunContribution=(-lumels[lumel].Normal*_SunDirection)-skyContribution;
				clamp (sunContribution, 0.f, 1.f);
			}
			else
				sunContribution=0;

			// Final lighting
			sint finalLighting=(sint)(255.f*(((float)patchInfo.Lumels[lumel])*sunContribution/255.f+skyContribution));
			clamp (finalLighting, 0, 255);
			patchInfo.Lumels[lumel]=finalLighting;
		}

		// Next patch
		patch = getAPatch (process);
	}
}

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

uint8 CZoneLighter::getMaxPhi (sint s, sint t, sint deltaS, sint deltaT, float heightPos) const
{
	// Start position
	s+=deltaS;
	t+=deltaT;

	// Distance increment
	float stepDistance=CVector (deltaS*_HeightfieldCellSize, deltaT*_HeightfieldCellSize,0).norm ();

	// Current distance
	float distance=stepDistance;

	// Max height
	float maxHeight=0;
	float maxTanTeta=0;

	// For all the line
	while ((s<_HeightFieldCellCount)&&(t<_HeightFieldCellCount)&&(s>=0)&&(t>=0))
	{
		// Get height
		float height=_HeightField[s+t*_HeightFieldCellCount];
		height-=heightPos;

		// Better ?
		if (height>maxHeight)
		{
			// Calc sin teta
			float tanTeta=height/distance;
			nlassert (tanTeta>=0);

			// Better ?
			if (tanTeta>maxTanTeta)
			{
				// New max height
				maxHeight=height;
				maxTanTeta=tanTeta;
			}
		}
		s+=deltaS;
		t+=deltaT;
		distance+=stepDistance;
	}

	// return phi
	float teta=(float)atan (maxTanTeta);
	nlassert (teta>=0);
	nlassert (teta<=Pi/2);
	clamp (teta, 0.f, (float)Pi/2);
	sint res=(sint)((Pi/2-teta)*256/(Pi/2));
	clamp (res, 0, 255);
	return (uint8)res;
}

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

#define AllFront 0
#define AllBack 1
#define Clipped 2

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

bool CZoneLighter::isLumelOnEdgeMustBeOversample (uint patch, uint edge, sint s, sint t, const vector<bool> &binded,
												  const vector<bool> &oversampleEdges, vector<CPatchUVLocator> &locator,
												  uint8 shadowed, vector<vector<uint8> >& shadowBuffer)
{
	// Must force oversampling of this edge ?
	if (oversampleEdges[edge])
		return true;
	else
	{
		// binded ?
		if (binded[edge])
		{
			// Lumel coord
			CVector2f lumelCoord (((float)(s+_GetNormalDeltaS[edge])+0.5f)/4.f, ((float)(t+_GetNormalDeltaT[edge])+0.5f)/4.f);
			uint otherPatch=locator[edge].selectPatch(lumelCoord);

			// Get uv
			CVector2f neighborUV;
			CPatch *patchOut;
			locator[edge].locateUV (lumelCoord, otherPatch, patchOut, neighborUV);

			// Is the same shadowed flag ?
			sint ss=(sint)(neighborUV.x*4.f);
			sint tt=(sint)(neighborUV.y*4.f);
			return (shadowBuffer[patchOut->getPatchId()][ss+(patchOut->getOrderS()<<2)*tt]!=shadowed);
		}
		else
		{
			// Not oversample if not binded
			return false;
		}
	}
}

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

float easineasoutC2(float x)
{
 float y;
 // 5-nome tq f(0)=0, f'(0)=0, f''(0)=0, f(1)=1, f'(1)=0, f''(1)=0.
 float x3=x*x*x;
 float x4=x3*x;
 float x5=x4*x;
 y= 6*x5 -15*x4 +10*x3;
 return y;
}

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


sint16 CZoneLighter::_GetNormalDeltaS[4]={ -1, 0, 1, 0 };
sint16 CZoneLighter::_GetNormalDeltaT[4]={ 0, 1, 0, -1 };

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

void CZoneLighter::getNormal (const CPatch *pPatch, sint16 lumelS, sint16 lumelT, vector<CPatchUVLocator> &locator,
								 const vector<CPatch::CBindInfo> &bindInfo, const vector<bool> &binded, set<uint64>& visited,
								 float deltaS, float deltaT, uint rotation, const CBezierPatch &bezierPatch, uint lastEdge)
{
	// Build a desc srructure
	uint64 id=(uint64)lumelS|(((uint64)lumelT)<<16)|(((uint64)pPatch->getPatchId())<<32)|(((uint64)pPatch->getZone()->getZoneId())<<48);

	// Insert it
	if (visited.insert (id).second)
	{
		// Clip
		float sqDist=deltaS*deltaS+deltaT*deltaT;
		if ( sqDist < 1 )
		{
			// Continue...

			sint orderSx4=pPatch->getOrderS()<<2;
			sint orderTx4=pPatch->getOrderT()<<2;

			sint16 _GetNormalBorderS[4]={ 0, -10, 1, -10 };
			sint16 _GetNormalBorderT[4]={ -10, 1, -10, 0 };
			_GetNormalBorderS[2]=orderSx4-1;
			_GetNormalBorderT[1]=orderTx4-1;

			// Add normal
			_GetNormalNormal+=bezierPatch.evalNormal ( ((float)lumelS+0.5f)/(float)orderSx4, ((float)lumelT+0.5f)/(float)orderTx4 );

			// For the four neighbors
			for (uint edge=0; edge<4; edge++)
			{
				// Not last edge ?
				if (edge!=lastEdge)
				{
					// Direction
					uint globalDirection=(edge+(4-rotation))&0x3;

					// Neighbor
					if ( (lumelS==_GetNormalBorderS[edge]) || (lumelT==_GetNormalBorderT[edge]) )
					{
						// Binded ?
						bool bind=binded[edge];
						bool smooth=pPatch->getSmoothFlag (edge);
						if (bind&&smooth)
						{
							// Lumel coord
							CVector2f lumelCoord ( ((float)(lumelS+_GetNormalDeltaS[edge])+0.5f)/4,
								((float)(lumelT+_GetNormalDeltaT[edge])+0.5f)/4 );

							// Get neighbor pixel
							uint otherPatch=locator[edge].selectPatch(lumelCoord);

							// Get uv
							CVector2f neighborUV;
							CPatch *patchOut;
							locator[edge].locateUV (lumelCoord, otherPatch, patchOut, neighborUV);

							// New coordinates
							sint16 newLumelS=(sint16)(4.f*neighborUV.x);
							sint16 newLumelT=(sint16)(4.f*neighborUV.y);

							// Zone id
							uint16 patchId=patchOut->getPatchId();
							uint16 zoneId=_ZoneId[patchOut->getZone()->getZoneId ()];

							// Get edge
							uint newEdge=0;
							uint i;
							for (i=0; i<=(uint)bindInfo[edge].NPatchs; i++)
							{
								// Good patch ?
								if (bindInfo[edge].Next[i]==patchOut)
								{
									// Get its edge
									newEdge=bindInfo[edge].Edge[i];
									break;
								}
							}

							// Rotation
							uint newRotation=(2-edge+rotation+newEdge)&0x3;

							// Must found it
							nlassert (i!=(uint)bindInfo[edge].NPatchs);

							// Get the bezier patch
							CBezierPatch &NewBezierPatch=_BezierPatch[zoneId][patchId];

							// Next lumel
							getNormal (patchOut, newLumelS, newLumelT, _Locator[zoneId][patchId], _BindInfo[zoneId][patchId],
								_Binded[zoneId][patchId], visited, deltaS+_GetNormalDeltaS[globalDirection],
								deltaT+_GetNormalDeltaT[globalDirection], newRotation, NewBezierPatch, newEdge);
						}
					}
					else
					{
						// Left internal
						getNormal (pPatch, lumelS+_GetNormalDeltaS[edge], lumelT+_GetNormalDeltaT[edge], locator, bindInfo, binded, visited,
							deltaS+_GetNormalDeltaS[globalDirection], deltaT+_GetNormalDeltaT[globalDirection], rotation, bezierPatch, (edge+2)&0x3);
					}
				}
			}
		}
	}
}

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

void CZoneLighter::addTriangles (CLandscape &landscape, vector<uint> &listZone, uint order, std::vector<CTriangle>& triangleArray)
{
	// Set all to refine
	excludeAllPatchFromRefineAll (landscape, listZone, false);

	// Setup the landscape
	landscape.setThreshold (0);
	landscape.setTileMaxSubdivision (order);

	// Refine it
	landscape.refineAll (CVector (0, 0, 0));

	// Dump tesselated triangles
	std::vector<const CTessFace*> leaves;
	landscape.getTessellationLeaves(leaves);

	// Number of leaves
	uint leavesCount=(uint)leaves.size();

	// Reserve the array
	triangleArray.reserve (triangleArray.size()+leavesCount);

	// Scan each leaves
	for (uint leave=0; leave<leavesCount; leave++)
	{
		// Leave
		const CTessFace *face=leaves[leave];

		// Add a triangle
		triangleArray.push_back (CTriangle (NLMISC::CTriangle (face->VBase->EndPos, face->VLeft->EndPos, face->VRight->EndPos)));
	}

	// Setup the landscape
	landscape.setThreshold (1000);
	landscape.setTileMaxSubdivision (0);

	// Remove all triangles
	landscape.refineAll (CVector (0, 0, 0));
	landscape.refineAll (CVector (0, 0, 0));
	landscape.refineAll (CVector (0, 0, 0));
	landscape.refineAll (CVector (0, 0, 0));
	landscape.refineAll (CVector (0, 0, 0));
	landscape.refineAll (CVector (0, 0, 0));
	landscape.refineAll (CVector (0, 0, 0));
	landscape.refineAll (CVector (0, 0, 0));
	landscape.refineAll (CVector (0, 0, 0));
	landscape.refineAll (CVector (0, 0, 0));
}

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

void CZoneLighter::addTriangles (const IShape &shape, const CMatrix& modelMT, std::vector<CTriangle>& triangleArray)
{
	// Cast to CMesh
	const CMesh *mesh=dynamic_cast<const CMesh*>(&shape);

	// Cast to CMeshMultiLod
	const CMeshMultiLod *meshMulti=dynamic_cast<const CMeshMultiLod*>(&shape);

	// Cast to CMeshMultiLod
	const CMeshMRM *meshMRM=dynamic_cast<const CMeshMRM*>(&shape);

	// It is a mesh ?
	if (mesh)
	{
		// Add its triangles
		addTriangles (*mesh, mesh->getMeshGeom (), modelMT, triangleArray);
	}
	// It is a CMeshMultiLod ?
	else if (meshMulti)
	{
		// Get the first geommesh
		const IMeshGeom *meshGeom=&meshMulti->getMeshGeom (0);

		// Dynamic cast
		const CMeshGeom *geomMesh=dynamic_cast<const CMeshGeom*>(meshGeom);
		if (geomMesh)
		{
			addTriangles (*meshMulti, *geomMesh, modelMT, triangleArray);
		}

		// Dynamic cast
		const CMeshMRMGeom *mrmGeomMesh=dynamic_cast<const CMeshMRMGeom*>(meshGeom);
		if (mrmGeomMesh)
		{
			addTriangles (*meshMulti, *mrmGeomMesh, modelMT, triangleArray);
		}
	}
	// It is a CMeshMultiLod ?
	else if (meshMRM)
	{
		// Get the first lod mesh geom
		addTriangles (*meshMRM, meshMRM->getMeshGeom (), modelMT, triangleArray);
	}
}

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

void CZoneLighter::addTriangles (const CMeshBase &meshBase, const CMeshGeom &meshGeom, const CMatrix& modelMT, std::vector<CTriangle>& triangleArray)
{
	// Get the vertex buffer
	const CVertexBuffer &vb=meshGeom.getVertexBuffer();
	CVertexBufferRead vba;
	vb.lock (vba);

	// For each matrix block
	uint numBlock=meshGeom.getNbMatrixBlock();
	for (uint block=0; block<numBlock; block++)
	{
		// For each render pass
		uint numRenderPass=meshGeom.getNbRdrPass(block);
		for (uint pass=0; pass<numRenderPass; pass++)
		{
			// Get the primitive block
			const CIndexBuffer &primitive=meshGeom.getRdrPassPrimitiveBlock ( block, pass);

			// Get the material
			const CMaterial &material = meshBase.getMaterial (meshGeom.getRdrPassMaterial ( block, pass));

			// ** Get the bitmap

			// Texture information, not NULL only if texture is used for alpha test
			CBitmap *texture;
			bool clampU;
			bool clampV;
			uint8 alphaTestThreshold;
			bool doubleSided;
			if (getTexture (material, texture, clampU, clampV, alphaTestThreshold, doubleSided))
			{
				// Dump triangles
				CIndexBufferRead iba;
				primitive.lock (iba);
				if (iba.getFormat() == CIndexBuffer::Indices32)
				{
					const uint32* triIndex= (const uint32*) iba.getPtr ();
					uint numTri=primitive.getNumIndexes ()/3;
					uint tri;
					for (tri=0; tri<numTri; tri++)
					{
						// Vertex
						CVector v0=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3]));
						CVector v1=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3+1]));
						CVector v2=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3+2]));

						// UV
						float u[3] = { 0.f };
						float v[3] = { 0.f };
						for (uint i=0; i<3; i++)
						{
							// Get UV coordinates
							const float *uv = (const float*)vba.getTexCoordPointer (triIndex[tri*3+i], 0);
							if (uv)
							{
								// Copy it
								u[i] = uv[0];
								v[i] = uv[1];
							}
						}

						// Make a triangle
						triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v1, v2), doubleSided, texture, clampU, clampV, u, v,
							alphaTestThreshold));
					}
				}
				else
				{
					const uint16* triIndex=(const uint16*)iba.getPtr ();
					uint numTri=primitive.getNumIndexes ()/3;
					uint tri;
					for (tri=0; tri<numTri; tri++)
					{
						// Vertex
						CVector v0=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3]));
						CVector v1=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3+1]));
						CVector v2=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3+2]));

						// UV
						float u[3] = { 0.f };
						float v[3] = { 0.f };
						for (uint i=0; i<3; i++)
						{
							// Get UV coordinates
							const float *uv = (const float*)vba.getTexCoordPointer (triIndex[tri*3+i], 0);
							if (uv)
							{
								// Copy it
								u[i] = uv[0];
								v[i] = uv[1];
							}
						}

						// Make a triangle
						triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v1, v2), doubleSided, texture, clampU, clampV, u, v,
							alphaTestThreshold));
					}
				}
			}
		}
	}
}

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

bool CZoneLighter::getTexture (const CMaterial &material, CBitmap *&result, bool &clampU, bool &clampV, uint8 &alphaTestThreshold, bool &doubleSided)
{
	// Texture information, not NULL only if texture is used for alpha test
	result = NULL;
	clampU = false;
	clampV = false;

	// Alpha test threashold
	float alphaTestThresholdF = material.getAlphaTestThreshold () * 255;
	clamp (alphaTestThresholdF, 0.f, 255.f);
	alphaTestThreshold = (uint8)alphaTestThresholdF;

	// Drawable material ?
	if (material.getBlend ())
		return false;

	// Use alpha test ?
	if (material.getAlphaTest ())
	{
		// Get the texture
		ITexture *texture = material.getTexture (0);

		// Is texture shared ?
		if (texture && texture->supportSharing ())
		{
			// Share name
			string name = texture->getShareName();

			// Texture exist ?
			std::map<string, NLMISC::CBitmap>::iterator ite = _Bitmaps.find (name);
			if (ite != _Bitmaps.end ())
			{
				// Yes
				result = &(ite->second);
			}
			else
			{
				// No, add it
				ite = _Bitmaps.insert (std::map<string, NLMISC::CBitmap>::value_type (name, CBitmap())).first;
				result = &(ite->second);

				// Generate the texture
				texture->generate ();

				// Convert to RGBA
				texture->convertToType (CBitmap::RGBA);

				// Copy it
				*result = *texture;

				// Release the texture
				texture->release ();
			}

			// Wrap flags
			clampU = texture->getWrapS () == ITexture::Clamp;
			clampV = texture->getWrapT () == ITexture::Clamp;
		}
	}

	// Get double sided flag
	doubleSided = material.getDoubleSided ();
	return true;
}

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

void CZoneLighter::addTriangles (const CMeshBase &meshBase, const CMeshMRMGeom &meshGeom, const CMatrix& modelMT, std::vector<CTriangle>& triangleArray)
{
	// Get the vertex buffer
	const CVertexBuffer &vb=meshGeom.getVertexBuffer();
	CVertexBufferRead vba;
	vb.lock (vba);

	// For each render pass
	uint numRenderPass=meshGeom.getNbRdrPass(0);
	for (uint pass=0; pass<numRenderPass; pass++)
	{
		// Get the primitive block
		const CIndexBuffer &primitive=meshGeom.getRdrPassPrimitiveBlock ( 0, pass);

		// Get the material
		const CMaterial &material = meshBase.getMaterial (meshGeom.getRdrPassMaterial (0, pass));

		// ** Get the bitmap

		// Texture information, not NULL only if texture is used for alpha test
		CBitmap *texture;
		bool clampU;
		bool clampV;
		uint8 alphaTestThreshold;
		bool doubleSided;
		if (getTexture (material, texture, clampU, clampV, alphaTestThreshold, doubleSided))
		{
			// Dump triangles
			CIndexBufferRead iba;
			primitive.lock (iba);
			const uint32* triIndex= (const uint32 *) iba.getPtr ();
			uint numTri=primitive.getNumIndexes ()/3;
			uint tri;
			for (tri=0; tri<numTri; tri++)
			{
				// Vertex
				CVector v0=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3]));
				CVector v1=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3+1]));
				CVector v2=modelMT*(*vba.getVertexCoordPointer (triIndex[tri*3+2]));

				// UV
				float u[3] = { 0.f };
				float v[3] = { 0.f };
				for (uint i=0; i<3; i++)
				{
					// Get UV coordinates
					float *uv = (float*)vba.getTexCoordPointer (triIndex[tri*3+i], 0);
					if (uv)
					{
						// Copy it
						u[i] = uv[0];
						v[i] = uv[1];
					}
				}

				// Make a triangle
				triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v1, v2), doubleSided, texture, clampU, clampV, u, v,
					alphaTestThreshold));
			}
		}
	}
}

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

void CZoneLighter::excludeAllPatchFromRefineAll (CLandscape &landscape, vector<uint> &listZone, bool exclude)
{
	// For each zone
	for (uint zone=0; zone<listZone.size(); zone++)
	{
		// Get num patches
		uint patchCount=landscape.getZone(listZone[zone])->getNumPatchs();

		// For each patches
		for (uint patch=0; patch<patchCount; patch++)
		{
			// Exclude all the patches from refine all
			landscape.excludePatchFromRefineAll (listZone[zone], patch, exclude);
		}
	}
}

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

const sint8 CZoneLighter::TriangleIndexes[10][2][3] =
{
	{{0, 11, 6}, {0, 6, 9}},
	{{9, 6, 4}, {4, 6, 14}},
	{{4, 14, 8}, {4, 8, 10}},
	{{10, 8, 1}, {-1, -1, -1}},
	{{11, 5, 6}, {5, 13, 6}},
	{{6, 13, 3}, {6, 3, 14}},
	{{3, 8, 14}, {-1, -1, -1}},
	{{5, 12, 7}, {5, 7, 13}},
	{{7, 3, 13}, {-1, -1, -1}},
	{{12, 2, 7}, {-1, -1, -1}}
};

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

// lumel vertex ID, tesselation edge ID (0 for base<->right, 1 for base<->left), tesselation edge vertex 0, tesselation edge vertex 1
const sint8 CZoneLighter::VertexThanCanBeSnappedOnABorder[8][4] =
{
	{0, 0, 0, 9},
	{1, 0, 9, 4},
	{2, 0, 4, 10},
	{3, 0, 10, 1},
	{0, 1, 0, 11},
	{4, 1, 11, 5},
	{7, 1, 5, 12},
	{9, 1, 12, 2},
};

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

// lumel vertex ID, tesselation corner vertex
const sint8 CZoneLighter::VertexThanCanBeSnappedOnACorner[3][2] =
{
	{0, 0},
	{3, 1},
	{9, 2},
};

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

void CZoneLighter::buildZoneInformation (CLandscape &landscape, const vector<uint> &listZone, const CLightDesc &lightDesc)
{
	// Bool visit
	vector<vector<uint> > visited;

	// Zone count
	uint zoneCount=(uint)listZone.size();

	// Resize arries
	_Locator.resize (zoneCount);
	_Binded.resize (zoneCount);
	_BindInfo.resize (zoneCount);
	_BezierPatch.resize (zoneCount);

	// For each zone
	for (uint zone=0; zone<zoneCount; zone++)
	{
		// Get num patches
		uint patchCount=landscape.getZone(listZone[zone])->getNumPatchs();

		// Insert zone id
		_ZoneId.insert (map<uint, uint>::value_type (listZone[zone], zone));

		// This is the zone to light ?
		if (listZone[zone]==_ZoneToLight)
		{
			// Resize the arraies
			_Lumels.resize(patchCount);
//			_LumelCorners.resize(patchCount);
//			_BezierPatch.resize(patchCount);
			_OversampleEdges.resize(patchCount);
			visited.resize(patchCount);
		}

		// Common arries
		_Locator[zone].resize(patchCount);
		_Binded[zone].resize(patchCount);
		_BindInfo[zone].resize(patchCount);
		_BezierPatch[zone].resize(patchCount);

		// For each patch
		uint patch;
		for (patch=0; patch<patchCount; patch++)
		{
			// Get a patch pointer
			const CPatch* pPatch=(const_cast<const CZone*>(landscape.getZone(listZone[zone])))->getPatch (patch);

			// Progress bar
			progress ("Scan all patches", (float)patch/(float)patchCount);

			// Get pointer on arries
			vector<bool> &binded=_Binded[zone][patch];
			vector<CPatch::CBindInfo> &bindInfo=_BindInfo[zone][patch];
			vector<CPatchUVLocator> &locator=_Locator[zone][patch];
			CBezierPatch &bezierPatch=_BezierPatch[zone][patch];
			binded.resize (4, false);
			bindInfo.resize (4);
			locator.resize (4);

			// Contruct the patch
			bezierPatch=*pPatch->unpackIntoCache();

			// Same zone ?
			if (listZone[zone]==_ZoneToLight)
			{
				// oversample this edge
				_OversampleEdges[patch].resize (4, false);
			}

			// *** Build bind info

			// *** Build neighboorhood information
			uint edge;
			for (edge=0; edge<4; edge++)
			{
				// Bond neighbor
				pPatch->getBindNeighbor (edge, bindInfo[edge]);

				// Patch binded
				if (bindInfo[edge].NPatchs>0)
				{
					// This edeg is binded
					binded[edge]=true;

					// Same zone ?
					if ((listZone[zone]==_ZoneToLight)&&(bindInfo[edge].Zone->getZoneId()!=_ZoneToLight))
					{
						// oversample this edge
						_OversampleEdges[patch][edge]=true;
					}
					locator[edge].build (pPatch, edge, bindInfo[edge]);
				}
				else
				{
					if (listZone[zone]==_ZoneToLight)
					{
						// oversample this edge
						_OversampleEdges[patch][edge]=true;
					}
				}
			}

			// This is the zone to light ?
			if (listZone[zone]==_ZoneToLight)
			{
				// *** Resize lumel array for this patch

				// Get patch order
				uint orderS=pPatch->getOrderS();
				uint orderT=pPatch->getOrderT();

				// Number of lumels
				uint lumelCount = orderS*orderT*16;

				// Resize the lumel descriptor
				CLumelDescriptor descriptor;
				descriptor.Normal.set (0,0,0);
				descriptor.Position.set (0,0,0);
				descriptor.S=0;
				descriptor.T=0;
				_Lumels[patch].resize (lumelCount, descriptor);
				visited[patch].resize (lumelCount, 0);
//				_LumelCorners[patch].resize (lumelCornerCount);


				// *** Unexclude this patch

				// Exclude all the patches from refine all
				landscape.excludePatchFromRefineAll (listZone[zone], patch, false);
			}
			else
			{
				// Exclude all the patches from refine all
				landscape.excludePatchFromRefineAll (listZone[zone], patch, true);
			}
		}
	}

	// *** Now tesselate this zone to shadow casters accuracy

	// Setup the landscape
	landscape.setThreshold (0);
	landscape.setTileMaxSubdivision (0);

	// Refine all
	progress ("Refine landscape to shadow accuracy", 0.5f);
	landscape.refineAll (CVector (0, 0, 0));

	// Get tesselated faces
	std::vector<const CTessFace*> leaves;
	landscape.getTessellationLeaves(leaves);




	if (_WaterShapes.size() != 0) // any water shape in this zone ?
	{
		/// make a quad grid of each water shape
		makeQuadGridFromWaterShapes(landscape.getZone(_ZoneToLight)->getZoneBB().getAABBox());

		/// check for each tile if it is above / below water
		computeTileFlagsForPositionTowardWater(lightDesc, leaves);
	}
	else
	{
		setTileFlagsToDefault(leaves);
	}


	// Id of this zone in the array
	uint zoneNumber=_ZoneId[_ZoneToLight];

	// Scan each leaves
	uint leavesCount=(uint)leaves.size();
	uint leave;
	for (leave=0; leave<leavesCount; leave++)
	{
		// Progress bar
		if ( (leave&0xff) == 0)
			progress ("Precompute lumel position", (float)leave/(float)leavesCount);

		// Leave
		const CTessFace *face=leaves[leave];

		// Get zone id
		if (face->Patch->getZone()->getZoneId()==_ZoneToLight)
		{
			// Get a patch pointer
			const CPatch* pPatch=face->Patch;

			// Get order
			uint orderS=pPatch->getOrderS();
			uint orderT=pPatch->getOrderT();

			// *** Base Coordinates

			CVector pos[15];
			pos[0]=face->VBase->EndPos;		// p0
			pos[1]=face->VRight->EndPos;
			pos[2]=face->VLeft->EndPos;		// p2
			pos[3]=(pos[1]+pos[2])/2;
			pos[4]=(pos[0]+pos[1])/2;				// p4
			pos[5]=(pos[0]+pos[2])/2;
			pos[6]=(pos[0]+pos[3])/2;				// p6
			pos[7]=(pos[2]+pos[3])/2;
			pos[8]=(pos[1]+pos[3])/2;				// p8
			pos[9]=(pos[0]+pos[4])/2;
			pos[10]=(pos[1]+pos[4])/2;				// p10
			pos[11]=(pos[0]+pos[5])/2;
			pos[12]=(pos[2]+pos[5])/2;				// p12
			pos[13]=(pos[3]+pos[5])/2;
			pos[14]=(pos[3]+pos[4])/2;				// p14

			float s0=face->PVBase.getS();
			float s1=face->PVRight.getS();
			float s2=face->PVLeft.getS();
			float s3=(s1+s2)/2;
			float s4=(s0+s1)/2;
			float s5=(s0+s2)/2;
			float s6=(s4+s5)/2;
			float s7=(s2+s3)/2;
			float s8=(s1+s3)/2;

			float t0=face->PVBase.getT();
			float t1=face->PVRight.getT();
			float t2=face->PVLeft.getT();
			float t3=(t1+t2)/2;
			float t4=(t0+t1)/2;
			float t5=(t0+t2)/2;
			float t6=(t4+t5)/2;
			float t7=(t2+t3)/2;
			float t8=(t1+t3)/2;

			// *** Interpolated value
			CVector interpolatedP[10]=
			{
				(pos[0]+pos[6])/2,
				(pos[4]+pos[6])/2,
				(pos[4]+pos[8])/2,
				(pos[1]+pos[8])/2,
				(pos[5]+pos[6])/2,
				(pos[3]+pos[6])/2,
				(pos[3]+pos[8])/2,
				(pos[5]+pos[7])/2,
				(pos[3]+pos[7])/2,
				(pos[2]+pos[7])/2,
			};

			// Does the border are snapped ?
			uint sBase = (uint)floor ((float)orderS * face->PVBase.getS() + 0.5);
			uint tBase = (uint)floor ((float)orderT * face->PVBase.getT() + 0.5);
			uint sLeft = (uint)floor ((float)orderS * face->PVLeft.getS() + 0.5);
			uint tLeft = (uint)floor ((float)orderT * face->PVLeft.getT() + 0.5);
			uint sRight = (uint)floor ((float)orderS * face->PVRight.getS() + 0.5);
			uint tRight = (uint)floor ((float)orderT * face->PVRight.getT() + 0.5);
			bool snapedLeft[2]=
			{
				(sBase == 0) && (sRight == 0),
				(sBase == 0) && (sLeft == 0),
			};
			bool snapedRight[2]=
			{
				(sBase == orderS) && (sRight == orderS),
				(sBase == orderS) && (sLeft == orderS),
			};
			bool snapedTop[2]=
			{
				(tBase == 0) && (tRight == 0),
				(tBase == 0) && (tLeft == 0),
			};
			bool snapedBottom[2]=
			{
				(tBase == orderT) && (tRight == orderT),
				(tBase == orderT) && (tLeft == orderT),
			};
			bool snapedBorder[2]=
			{
				snapedLeft[0]||snapedRight[0]||snapedTop[0]||snapedBottom[0],
				snapedLeft[1]||snapedRight[1]||snapedTop[1]||snapedBottom[1],
			};

			bool snapedCorner[3]=
			{
				((sBase == 0) && ((tBase == 0) || (tBase == orderT))) ||
				((sBase == orderS) && ((tBase == 0) || (tBase == orderT))),
				((sRight == 0) && ((tRight == 0) || (tRight == orderT))) ||
				((sRight == orderS) && ((tRight == 0) || (tRight == orderT))),
				((sLeft == 0) && ((tLeft == 0) || (tLeft == orderT))) ||
				((sLeft == orderS) && ((tLeft == 0) || (tLeft == orderT))),
			};

			// Snap on the border
			uint i;
			for (i=0; i<8; i++)
			{
				// Snaped on left ?
				if (snapedBorder[VertexThanCanBeSnappedOnABorder[i][1]])
				{
					// Compute the border vertex
					interpolatedP[VertexThanCanBeSnappedOnABorder[i][0]] = (pos[VertexThanCanBeSnappedOnABorder[i][2]]
						+ pos[VertexThanCanBeSnappedOnABorder[i][3]])/2;
				}
			}

			// Snap on the corner
			for (i=0; i<3; i++)
			{
				// Snaped on a corner ?
				uint tesselCornerIndex = VertexThanCanBeSnappedOnACorner[i][1];
				if ( snapedCorner[tesselCornerIndex] )
				{
					// Compute the border vertex
					interpolatedP[VertexThanCanBeSnappedOnACorner[i][0]] = pos[tesselCornerIndex];
				}
			}

			float interpolatedS[10]=
			{
				(s0+s6)/2,
				(s4+s6)/2,
				(s4+s8)/2,
				(s1+s8)/2,
				(s5+s6)/2,
				(s3+s6)/2,
				(s3+s8)/2,
				(s5+s7)/2,
				(s3+s7)/2,
				(s2+s7)/2,
			};

			float interpolatedT[10]=
			{
				(t0+t6)/2,
				(t4+t6)/2,
				(t4+t8)/2,
				(t1+t8)/2,
				(t5+t6)/2,
				(t3+t6)/2,
				(t3+t8)/2,
				(t5+t7)/2,
				(t3+t7)/2,
				(t2+t7)/2,
			};

			for (i=0; i<10; i++)
			{
				sint s=(sint)((float)orderS*4*interpolatedS[i]);
				sint t=(sint)((float)orderT*4*interpolatedT[i]);

				if ((s>=0)&&(s<(sint)orderS*4)&&(t>=0)&&(t<(sint)orderT*4))
				{
					// Triangle index
					uint index=s+t*orderS*4;

					// Ge tthe patch id
					uint patchId=pPatch->getPatchId();

					// Get lumel array
					vector<CLumelDescriptor> &lumels=_Lumels[patchId];

					// Visited
					visited[patchId][index]++;

					// Position
					lumels[index].Position+=interpolatedP[i];
				}
			}
		}
	}

	// *** Now, finalise patch information for shadow source positions

	// For each patches
	uint patchCount=landscape.getZone(_ZoneToLight)->getNumPatchs();
	uint patch;
	for (patch=0; patch<patchCount; patch++)
	{
		// Info
		progress ("Finalize lumel positions", (float)patch/(float)patchCount);

		// *** Resize lumel array for this patch

		// Get a patch pointer
		const CPatch* pPatch=(const_cast<const CZone*>(landscape.getZone(_ZoneToLight)))->getPatch (patch);
		uint orderS=pPatch->getOrderS();
		uint orderT=pPatch->getOrderT();

		// Get lumel array
		vector<CLumelDescriptor> &lumels=_Lumels[patch];

		// *** Average position

		// Renormalize
		nlassert (isPowerOf2 (orderS));
		nlassert (isPowerOf2 (orderT));
		uint lumelS=4<<getPowerOf2 (orderS);
		uint lumelT=4<<getPowerOf2 (orderT);

		for (uint t=0; t<lumelT; t++)
		for (uint s=0; s<lumelS; s++)
		{
			// Lumel index
			uint lumelIndex=s+t*lumelS;

			// *** Number of visit
			uint visitedCount=visited[patch][lumelIndex];

			// If visited, renormalise other values
			if (visitedCount)
			{
				// Normalise position
				lumels[lumelIndex].Position/=(float)visitedCount;
			}

			// Not visited for next pass
			visited[patch][lumelIndex]=false;
		}
	}

	// *** Now tesselate this zone to shadow receivers accuracy

	// Setup the landscape
	landscape.setThreshold (0);
	landscape.setTileMaxSubdivision (4);

	// Refine all
	progress ("Refine landscape to lumels", 0.5f);
	landscape.refineAll (CVector (0, 0, 0));

	// Get tesselated faces
	leaves.clear ();
	landscape.getTessellationLeaves(leaves);

	// Scan each leaves
	leavesCount=(uint)leaves.size();
	for (leave=0; leave<leavesCount; leave++)
	{
		// Progress bar
		if ( (leave&0xff) == 0)
			progress ("Precompute tesselation", (float)leave/(float)leavesCount);

		// Leave
		const CTessFace *face=leaves[leave];

		// Get zone id
		if (face->Patch->getZone()->getZoneId()==_ZoneToLight)
		{
			// Get a patch pointer
			const CPatch* pPatch=face->Patch;

			// Get order
			uint orderS=pPatch->getOrderS();
			uint orderT=pPatch->getOrderT();

			// Coordinates
			float fS=(face->PVBase.getS()+face->PVLeft.getS()+face->PVRight.getS())/3.f;
			float fT=(face->PVBase.getT()+face->PVLeft.getT()+face->PVRight.getT())/3.f;
			uint s=(uint)((float)orderS*4*fS);
			uint t=(uint)((float)orderT*4*fT);
			//nlassert (s>=0);
			nlassert (s<orderS*4);
			//nlassert (t>=0);
			nlassert (t<orderT*4);

			// Triangle index
			uint index=s+t*orderS*4;

			// Ge tthe patch id
			uint patchId=pPatch->getPatchId();

			// Get lumel array
			vector<CLumelDescriptor> &lumels=_Lumels[patchId];

			// Visited
			visited[patchId][index]++;

			// Lumel s and t
			lumels[index].S+=fS;
			lumels[index].T+=fT;

			// Normal
			CPlane plane;
			plane.make (face->VBase->EndPos, face->VLeft->EndPos, face->VRight->EndPos);
			lumels[index].Normal+=plane.getNormal();
		}
	}

	// *** Now, finalise patch information

	// For each patches
	patchCount=landscape.getZone(_ZoneToLight)->getNumPatchs();
	for (patch=0; patch<patchCount; patch++)
	{
		// Info
		progress ("Finalize patches", (float)patch/(float)patchCount);

		// *** Resize lumel array for this patch

		// Get a patch pointer
		const CPatch* pPatch=(const_cast<const CZone*>(landscape.getZone(_ZoneToLight)))->getPatch (patch);
		uint orderS=pPatch->getOrderS();
		uint orderT=pPatch->getOrderT();

		// Get lumel array
		vector<CLumelDescriptor> &lumels=_Lumels[patch];

		// *** Compute an interpolated normal

		// Get pointer on arries
		vector<bool> &binded=_Binded[zoneNumber][patch];
		vector<CPatchUVLocator> &locator=_Locator[zoneNumber][patch];
		vector<CPatch::CBindInfo> &bindInfo=_BindInfo[zoneNumber][patch];
		CBezierPatch &bezierPatch=_BezierPatch[zoneNumber][patch];

		// Renormalize
		nlassert (isPowerOf2 (orderS));
		nlassert (isPowerOf2 (orderT));
		uint powerS=getPowerOf2 (orderS);
		uint powerT=getPowerOf2 (orderT);
		uint lumelS=4<<powerS;
		uint lumelT=4<<powerT;

		// Sample edge normal
		CVector normals[NL_MAX_TILES_BY_PATCH_EDGE*NL_LUMEL_BY_TILE+1][4];
		uint sFixed[4] = { 0, 0xffffffff, lumelS-1, 0xffffffff };
		uint tFixed[4] = { 0xffffffff, lumelT-1, 0xffffffff, 0 };
		float sOri[4] = { 0, -1, (float)lumelS, -1 };
		float tOri[4] = { -1, (float)lumelT, -1, 0 };
		for (uint edge=0; edge<4; edge++)
		{
			// s and t
			uint count=(edge&1)?lumelS:lumelT;
			for (uint lumel=0; lumel<=count; lumel++)
			{
				// Start coordinates
				float origineS;
				float origineT;
				uint startS;
				uint startT;
				if (edge&1)
				{
					if (lumel==count)
						startS=count-1;
					else
						startS=lumel;
					startT=tFixed[edge];
					origineS=(float)lumel;
					origineT=tOri[edge];
				}
				else
				{
					if (lumel==count)
						startT=count-1;
					else
						startT=lumel;
					startS=sFixed[edge];
					origineT=(float)lumel;
					origineS=sOri[edge];
				}
				_GetNormalNormal=CVector::Null;
				set<uint64> visitedLumels;
				getNormal (pPatch, startS, startT, locator, bindInfo, binded, visitedLumels,
					startS+0.5f-origineS, startT+0.5f-origineT, 0, bezierPatch);
				_GetNormalNormal.normalize ();
				normals[lumel][edge]=_GetNormalNormal;
			}

			// Smooth the corners
#define BLUR_SIZE 4
			for (uint i=1; i<BLUR_SIZE; i++)
			{
				float value=(float)i/BLUR_SIZE;
				value=easineasout(value);
				normals[i][edge]=normals[0][edge]*(1-value)+normals[i][edge]*value;
				normals[i][edge].normalize();
				normals[count-i][edge]=normals[count][edge]*(1-value)+normals[count-i][edge]*value;
				normals[count-i][edge].normalize();
			}
		}

		for (uint t=0; t<lumelT; t++)
		for (uint s=0; s<lumelS; s++)
		{
			// Lumel index
			uint lumelIndex=s+t*lumelS;

			// *** Calc the smoothed normal

			// For each edge
			CVector normalS=bezierPatch.evalNormal (((float)s+0.5f)/(float)lumelS, ((float)t+0.5f)/(float)lumelT);
			float sFactor=0;
			CVector normalT=normalS;
			float tFactor=0;
			bool sGood=false, tGood=false;
			if (s<BLUR_SIZE)
			{
				sGood=true;
				// Average the two normals
				CVector average=normals[t][0];
				average+=normals[t+1][0];
				average/=2;

				// Blend
				float value=s+0.5f;
				sFactor=BLUR_SIZE-value;
				value/=BLUR_SIZE;
				value=easineasout(value);
				normalS=(normalS*value+average*(1-value));
				normalS.normalize();
			}
			if (s>=lumelS-BLUR_SIZE)
			{
				sGood=true;
				// Average the two normals
				CVector average=normals[t][2];
				average+=normals[t+1][2];
				average/=2;

				// Blend
				float value=s+0.5f;
				sFactor=BLUR_SIZE-(lumelS-value);
				value=(lumelS-value)/BLUR_SIZE;
				value=easineasout(value);
				normalS=(normalS*value+average*(1-value));
				normalS.normalize();
			}
			if (t<BLUR_SIZE)
			{
				tGood=true;
				// Average the two normals
				CVector average=normals[s][3];
				average+=normals[s+1][3];
				average/=2;

				// Blend
				float value=t+0.5f;
				tFactor=BLUR_SIZE-value;
				value/=BLUR_SIZE;
				value=easineasout(value);
				normalT=(normalT*value+average*(1-value));
				normalT.normalize();
			}
			if (t>=lumelT-BLUR_SIZE)
			{
				tGood=true;
				// Average the two normals
				CVector average=normals[s][1];
				average+=normals[s+1][1];
				average/=2;

				// Blend
				float value=t+0.5f;
				tFactor=BLUR_SIZE-(lumelT-value);
				value=((lumelT)-value)/BLUR_SIZE;
				value=easineasout(value);
				normalT=(normalT*value+average*(1-value));
				normalT.normalize();
			}

			// The smooth normal
			CVector smoothNormal;

			if ((sGood)&&(tGood))
			{
				if ((sFactor!=BLUR_SIZE)||(tFactor!=BLUR_SIZE))
					smoothNormal=normalS*(BLUR_SIZE-tFactor)+normalT*(BLUR_SIZE-sFactor);
				else
					smoothNormal=normalS+normalT;
			}
			else if (sGood)
				smoothNormal=normalS;
			else
				smoothNormal=normalT;

			// Normalize it
			smoothNormal.normalize();

			// The pure normal
			CVector purNormal=bezierPatch.evalNormal (((float)s+0.5f)/(float)lumelS, ((float)t+0.5f)/(float)lumelT);

			// Normalize the noisy normal
			lumels[lumelIndex].Normal.normalize();

			// Final normal
			lumels[lumelIndex].Normal=lumels[lumelIndex].Normal-purNormal+smoothNormal;
			lumels[lumelIndex].Normal.normalize ();

			// *** Number of visit
			uint visitedCount=visited[patch][lumelIndex];

			// Some lumel have not been found in tesselation
			//nlassert (visitedCount==2);

			// If visited, renormalise other values
			if (visitedCount)
			{
				// Normalise position
				lumels[lumelIndex].S/=(float)visitedCount;
				lumels[lumelIndex].T/=(float)visitedCount;
			}
		}
	}
}

// ***************************************************************************
void CZoneLighter::computeTileFlagsOnly (CLandscape &landscape, CZone& output, uint zoneToLight, const CLightDesc& description,
						   std::vector<uint> &listZone)
{
	// Zone to light
	_ZoneToLight=zoneToLight;

	// Landscape
	_Landscape=&landscape;


	// Zone count
	uint zoneCount=(uint)listZone.size();

	// For each zone
	for (uint zone=0; zone<zoneCount; zone++)
	{
		// Get num patches
		uint patchCount=landscape.getZone(listZone[zone])->getNumPatchs();

		// Insert zone id
		_ZoneId.insert (map<uint, uint>::value_type (listZone[zone], zone));

		// For each patch
		uint patch;
		for (patch=0; patch<patchCount; patch++)
		{
			// Progress bar
			progress ("Scan all patches", (float)patch/(float)patchCount);

			// This is the zone to light ?
			if (listZone[zone]==_ZoneToLight)
			{
				// unExclude all the patches from refine all
				landscape.excludePatchFromRefineAll (listZone[zone], patch, false);
			}
			else
			{
				// Exclude all the patches from refine all
				landscape.excludePatchFromRefineAll (listZone[zone], patch, true);
			}
		}
	}

	// *** Now tesselate this zone to max accuracy

	// Setup the landscape
	landscape.setThreshold (0);
	landscape.setTileMaxSubdivision (0);

	// Refine all
	progress ("Refine landscape to maximum", 0.5f);
	landscape.refineAll (CVector (0, 0, 0));

	// Get tesselated faces
	std::vector<const CTessFace*> leaves;
	landscape.getTessellationLeaves(leaves);


	// compute only the water states
	if (_WaterShapes.size() != 0) // any water shape in this zone ?
	{
		/// make a quad grid of each water shape
		makeQuadGridFromWaterShapes(landscape.getZone(_ZoneToLight)->getZoneBB().getAABBox());

		/// check for each tile if it is above / below water
		computeTileFlagsForPositionTowardWater(description, leaves);
	}
	else
	{
		setTileFlagsToDefault(leaves);
	}

	/// verify that the zonew and the zonel (output) are compatible
	bool	ok= true;
	CZone	&zonew= *(landscape.getZone(zoneToLight));
	if(zonew.getNumPatchs() == output.getNumPatchs())
	{
		// verify for each patch that the tile array are same
		for(uint i=0;i<(uint)zonew.getNumPatchs();i++)
		{
			const CPatch	&p0= *const_cast<const CZone&>(zonew).getPatch(i);
			const CPatch	&p1= *const_cast<const CZone&>(output).getPatch(i);
			if( p0.getOrderS()!=p1.getOrderS() || p0.getOrderT()!=p1.getOrderT() )
			{
				ok= false;
				break;
			}
		}
	}
	else
		ok= false;

	// can't copy tile flags
	if(!ok)
		throw Exception("The input zonew, and ouput zonel are too different: not same patchs!!");

	/// copy the tiles flags from the zone to light to the output zone
	copyTileFlags(output, zonew);
}

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

CZoneLighter::CLightDesc::CLightDesc ()
{
	SunDirection.set (1, 1, -1);
	GridSize=512;
	GridCellSize=4;
	HeightfieldSize=200;
	HeightfieldCellSize=20;
	SkyContribution=true;
	SkyIntensity=0.25;

	ZBufferLandscapeSize = DEFAULT_ZBUFFER_LANDSCAPE_SIZE;
	ZBufferObjectSize = DEFAULT_ZBUFFER_OBJECT_SIZE;
	SoftShadowJitter = DEFAULT_JITTER;
	SunDistance = DEFAULT_SUN_DISTANCE;
	SunFOV = (float)DEFAULT_SUN_FOV;
	SunCenter = DEFAULT_SUN_CENTER;
	SunRadius = DEFAULT_SUN_RADIUS;
	SoftShadowSamplesSqrt = DEFAULT_SUN_SRQT_SAMPLES;
}

// ***************************************************************************
void CZoneLighter::addLightableShape(IShape *shape, const NLMISC::CMatrix& MT)
{
	CShapeInfo lsi;
	lsi.MT = MT;
	lsi.Shape = shape;
	_LightableShapes.push_back(lsi);
}


// ***************************************************************************
bool CZoneLighter::isLightableShape(IShape &shape)
{
	/// for now, the only shape that we lit are water shapes
	if (dynamic_cast<CWaterShape *>(&shape) != NULL)
	{
		// check that this water surface has a diffuse map that is a CTextureFile (we must be able to save it !)
		CWaterShape *ws = static_cast<CWaterShape *>(&shape);
		const ITexture *tex = ws->getColorMap();
		if (dynamic_cast<const CTextureFile *>(tex) != NULL)
		{
			return ws->isLightMappingEnabled();
		}
	}
	return false;
}

// ***************************************************************************
void CZoneLighter::lightShapes(uint zoneID, const CLightDesc& description)
{
	/// compute light for the lightable shapes in the given zone
	if (_LightableShapes.size() == 0) return;

	uint numShapePerThread = 1 + ((uint)_LightableShapes.size() / _ProcessCount);
	uint currShapeIndex = 0;
	uint process = 0;
	_ProcessExited = 0;

	_NumLightableShapesProcessed = 0;


	progress("Processing lightable shapes", 0);

	for (uint k = 0; k < _LightableShapes.size(); ++k, ++process)
	{
		uint lastShapeIndex = currShapeIndex + numShapePerThread;
		lastShapeIndex = std::min((uint)_LightableShapes.size(), lastShapeIndex);
		IThread *pThread = IThread::create (new CCalcLightableShapeRunnable(process, this, &description, &_LightableShapes, currShapeIndex, lastShapeIndex));
		pThread->start();
		currShapeIndex = lastShapeIndex;
	}

	/// wait for other process
	while (_ProcessExited != _ProcessCount)
	{
		nlSleep (10);
	}

}



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

void CZoneLighter::processLightableShapeCalc (uint process,
											  TShapeVect *shapesToLit,
											  uint firstShape,
											  uint lastShape,
											  const CLightDesc& description)
{
	// for each lightable shape
	for (uint k = firstShape; k < lastShape; ++k)
	{
		nlassert(isLightableShape(* (*shapesToLit)[k].Shape)); // make sure it is a lightable shape
		lightSingleShape((*shapesToLit)[k], description, process);
	}
}


// ***************************************************************************
void CZoneLighter::lightSingleShape(CShapeInfo &si, const CLightDesc& description, uint cpu)
{
	/// we compute the lighting for one single shape
	if (dynamic_cast<CWaterShape *>(si.Shape))
	{
		lightWater(* static_cast<CWaterShape *>(si.Shape), si.MT, description, cpu);
	}
	++_NumLightableShapesProcessed;
	progress("Processing lightable shapes", (float) _NumLightableShapesProcessed / _LightableShapes.size());
	return;
}



// ***************************************************************************
// utility function to get the directory of a fileName
static std::string getDir (const std::string& path)
{
	char tmpPath[512];
	strcpy (tmpPath, path.c_str());
	char* slash=strrchr (tmpPath, '/');
	if (!slash)
	{
		slash=strrchr (tmpPath, '\\');
	}

	if (!slash)
		return "";

	slash++;
	*slash=0;
	return tmpPath;
}


// ***************************************************************************
// utility function to get a file name fdrom a path
static std::string getName (const std::string& path)
{
	std::string dir=getDir (path);

	char tmpPath[512];
	strcpy (tmpPath, path.c_str());

	char *name=tmpPath;
	nlassert (dir.length()<=strlen(tmpPath));
	name+=dir.length();

	char* point=strrchr (name, '.');
	if (point)
		*point=0;

	return name;
}


// ***************************************************************************
// utility function to get the extension of a fileName
static std::string getExt (const std::string& path)
{
	std::string dir = getDir (path);
	std::string name = getName (path);

	char tmpPath[512];
	strcpy (tmpPath, path.c_str());

	char *ext=tmpPath;
	nlassert (dir.length()+name.length()<=strlen(tmpPath));
	ext+=dir.length()+name.length();

	return ext;
}


// ***************************************************************************
void CZoneLighter::lightWater(CWaterShape &ws, const CMatrix &MT, const CLightDesc& description, uint cpu)
{
	try
	{
		/// get the diffuse map
		CTextureFile *diffuseTex = NLMISC::safe_cast<CTextureFile *>(ws.getColorMap());
		std::string texFileName = CPath::lookup(diffuseTex->getFileName());
		diffuseTex->generate();
		const uint width = diffuseTex->getWidth();
		const uint height = diffuseTex->getHeight();

		/// build a matrix to convert from water space to uv space
		NLMISC::CMatrix worldSpaceToUVs;
		NLMISC::CVector2f col0, col1, pos;
		ws.getColorMapMat(col0, col1, pos);
		worldSpaceToUVs.setRot(NLMISC::CVector(col0.x * width, col0.y * height, 0),
							   NLMISC::CVector(col1.x * width, col1.y * height, 0),
							   NLMISC::CVector::K);
		worldSpaceToUVs.setPos(NLMISC::CVector(pos.x * width, pos.y * height, 0));

		/// get min and max uvs
		NLMISC::CPolygon p;
		ws.getShapeInWorldSpace(p);

		float minU, maxU;
		float minV, maxV;

		NLMISC::CVector uvs = worldSpaceToUVs * p.Vertices[0];
		minU = maxU = uvs.x;
		minV = maxV = uvs.y;


		for (uint k = 1; k < (uint) p.getNumVertices(); ++k)
		{
			uvs = worldSpaceToUVs * p.Vertices[k];
			minU = std::min(uvs.x, minU);
			minV = std::min(uvs.y, minV);
			maxU = std::max(uvs.x, maxU);
			maxV = std::max(uvs.y, maxV);
		}




		sint iMinU = (sint) minU;
		sint iMaxU = (sint) maxU;
		sint iMinV = (sint) minV;
		sint iMaxV = (sint) maxV;

		NLMISC::clamp(iMinU, 0, (sint) width);
		NLMISC::clamp(iMaxU, 0, (sint) width);
		NLMISC::clamp(iMinV, 0, (sint) height);
		NLMISC::clamp(iMaxV, 0, (sint) height);

		// matrix to go from uv space to worldspace
		NLMISC::CMatrix UVSpaceToWorldSpace = worldSpaceToUVs.inverted();

		CObjectVector<uint8> &pixs8 = diffuseTex->getPixels();
		NLMISC::CRGBA *rgbPixs = (NLMISC::CRGBA *) &pixs8[0];


		/// raytrace each texel
		for (sint x = iMinU; x < iMaxU; ++x)
		{
			for (sint y = iMinV; y < iMaxV; ++y)
			{
				float factor;
				NLMISC::CVector pos = UVSpaceToWorldSpace * NLMISC::CVector( x + 0.5f, y + 0.5f, 0 )
					+ description.WaterShadowBias * NLMISC::CVector::K;
				if (description.Shadow)
				{
					factor = attenuation (pos, description);
				}
				else
				{
					factor = - NLMISC::CVector::K * description.SunDirection;
				}
				clamp(factor, 0.f, 1.f);
				factor = factor * description.WaterDiffuse + description.WaterAmbient;
				if (description.SkyContributionForWater)
				{
					factor += getSkyContribution(pos, NLMISC::CVector::K, description.SkyIntensity);
				}
				clamp(factor, 0.f, 1.f);
				uint intensity = (uint8) (255 * factor);
				NLMISC::CRGBA srcCol(intensity,
									 intensity,
									 intensity,
									  255);

				if (!description.ModulateWaterColor)
				{
					rgbPixs[x + y * width] = srcCol;
				}
				else
				{
					NLMISC::CRGBA &col = rgbPixs[x + y * width];
					col.modulateFromColor(col, srcCol);
				}
			}
		}

		/// now, save the result
		if (getExt(texFileName) != ".tga")
		{
			nlwarning("Zone lighter : error when lighting a water surface : input bitmap is not a tga file");
		}
		else
		{
			try
			{
				COFile of;
				of.open(texFileName);
				diffuseTex->writeTGA(of, 24);
				of.close();
			}
			catch (const NLMISC::Exception &)
			{
				nlwarning("Zone lighter : while lighting a water shape, writing %s failed! ", texFileName.c_str());
			}
		}
	}
	catch(const NLMISC::Exception &e)
	{
		nlwarning("Water shape lighting failed !");
		nlwarning(e.what());
	}
}

// ***********************************************************
void CZoneLighter::addWaterShape(CWaterShape *shape, const NLMISC::CMatrix &MT)
{
	/// make sure it hasn't been inserted twice
	CShapeInfo ci;
	ci.Shape = shape;
	ci.MT = MT;
	_WaterShapes.push_back(ci);
}

// ***********************************************************
void CZoneLighter::makeQuadGridFromWaterShapes(NLMISC::CAABBox zoneBBox)
{
	if (!_WaterShapes.size()) return;

	NLMISC::CAABBox tmpBox;

	/// the number of cells we want in the quad grid
	const uint numCells = 16;

	/// get the dimension
	float width  = zoneBBox.getMax().x - zoneBBox.getMin().x;
	float height = zoneBBox.getMax().y - zoneBBox.getMin().y;

	float dim = std::max(width, height);


	/// init the quad grid
	_WaterShapeQuadGrid.create(numCells, dim / numCells);


	uint count = 0, totalCount = (uint)_WaterShapes.size();

	/// now, insert all water shapes
	for (TShapeVect::iterator it = _WaterShapes.begin(); it != _WaterShapes.end(); ++it, ++count)
	{
		/// get the current shape bbox in the world
		it->Shape->getAABBox(tmpBox);
		NLMISC::CAABBox currBB = NLMISC::CAABBox::transformAABBox(it->MT, tmpBox);

		/// test if it intesect the zone bbox
		if (zoneBBox.intersect(currBB))
		{
			_WaterShapeQuadGrid.insert(currBB.getMin(), currBB.getMax(), *it);
		}
		progress("Building quadtree from water surfaces", (float) count / totalCount);
	}

	/// free the vector of water shapes
	NLMISC::contReset(_WaterShapes);
}


//==================================================================

/// a struct that helps us to know which tile we've processed
struct CTileOfPatch
{
	uint8		TileId;
	CPatch		*Patch;
	CTileOfPatch();
	CTileOfPatch(uint8 tileId, CPatch *patch) : TileId(tileId), Patch(patch)
	{
	}
};



// ***************************************************************************
// ***************************************************************************
// Static point lights.
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
CZoneLighter::CPointLightRT::CPointLightRT()
{
	RefCount= 0;
}


// ***************************************************************************
bool	CZoneLighter::CPointLightRT::testRaytrace(const CVector &v)
{
	CVector	dummy;

	if(!BSphere.include(v))
		return false;

	// If Ambient light, just skip
	if(PointLight.getType()== CPointLight::AmbientLight)
		return false;

	// If SpotLight verify in angle radius.
	if(PointLight.getType()== CPointLight::SpotLight)
	{
		float	att= PointLight.computeLinearAttenuation(v);
		if (att==0)
			return false;
	}

	// Select in the cubeGrid
	FaceCubeGrid.select(v);
	// For all faces selected
	while(!FaceCubeGrid.isEndSel())
	{
		const CTriangle	*tri= FaceCubeGrid.getSel();

		// If intersect, the point is occluded.
		if( tri->Triangle.intersect(BSphere.Center, v, dummy, tri->getPlane()) )
			return false;

		// next
		FaceCubeGrid.nextSel();
	}

	// Ok the point is visilbe from the light
	return true;
}


// ***************************************************************************
void			CZoneLighter::addStaticPointLight(const CPointLightNamed &pln)
{
	// build the plRT.
	CPointLightRT	plRT;
	plRT.PointLight= pln;
	// compute plRT.OODeltaAttenuation
	plRT.OODeltaAttenuation= pln.getAttenuationEnd() - pln.getAttenuationBegin();
	if(plRT.OODeltaAttenuation <=0 )
		plRT.OODeltaAttenuation= 0;
	else
		plRT.OODeltaAttenuation= 1.0f / plRT.OODeltaAttenuation;
	// compute plRT.BSphere
	plRT.BSphere.Center= pln.getPosition();
	plRT.BSphere.Radius= pln.getAttenuationEnd();
	// NB: FaceCubeGrid will be computed during light()

	// add the plRT
	_StaticPointLights.push_back(plRT);

}


// ***************************************************************************
void			CZoneLighter::compilePointLightRT(uint gridSize, float gridCellSize, std::vector<CTriangle>& obstacles, bool doShadow)
{
	uint	i;

	// Fill the quadGrid of Lights.
	// ===========
	_StaticPointLightQuadGrid.create(gridSize, gridCellSize);
	for(i=0; i<_StaticPointLights.size();i++)
	{
		CPointLightRT	&plRT= _StaticPointLights[i];

		// Compute the bbox of the light
		CAABBox		bbox;
		bbox.setCenter(plRT.BSphere.Center);
		float	hl= plRT.BSphere.Radius;
		bbox.setHalfSize(CVector(hl,hl,hl));

		// Insert the pointLight in the quadGrid.
		_StaticPointLightQuadGrid.insert(bbox.getMin(), bbox.getMax(), &plRT);
	}


	// Append triangles to cubeGrid ??
	if(doShadow)
	{
		// Point lights ?
		if (!_StaticPointLights.empty ())
		{
			// For all obstacles, Fill a quadGrid.
			// ===========
			CQuadGrid<CTriangle*>	obstacleGrid;
			obstacleGrid.create(gridSize, gridCellSize);
			uint	size= (uint)obstacles.size();
			for(i=0; i<size; i++)
			{
				// bbox of triangle
				CAABBox	bbox;
				bbox.setCenter(obstacles[i].Triangle.V0);
				bbox.extend(obstacles[i].Triangle.V1);
				bbox.extend(obstacles[i].Triangle.V2);
				// insert triangle in quadGrid.
				obstacleGrid.insert(bbox.getMin(), bbox.getMax(), &obstacles[i]);
			}


			// For all PointLights, fill his CubeGrid
			// ===========
			for(i=0; i<_StaticPointLights.size();i++)
			{
				// progress
				progress ("Compute Influences of PointLights", 0.5f*i / (float)(_StaticPointLights.size()-1));

				CPointLightRT	&plRT= _StaticPointLights[i];
				// Create the cubeGrid
				plRT.FaceCubeGrid.create(plRT.PointLight.getPosition(), NL3D_ZONE_LIGHTER_CUBE_GRID_SIZE);

				// AmbiantLIghts: do nothing.
				if(plRT.PointLight.getType()!=CPointLight::AmbientLight)
				{
					// Select only obstacle Faces around the light. Other are not useful
					CAABBox	bbox;
					bbox.setCenter(plRT.PointLight.getPosition());
					float	hl= plRT.PointLight.getAttenuationEnd();
					bbox.setHalfSize(CVector(hl,hl,hl));
					obstacleGrid.select(bbox.getMin(), bbox.getMax());

					// For all faces, fill the cubeGrid.
					CQuadGrid<CTriangle*>::CIterator	itObstacle;
					itObstacle= obstacleGrid.begin();
					while( itObstacle!=obstacleGrid.end() )
					{
						CTriangle	&tri= *(*itObstacle);

						// Triangle bounding box
						CAABBox	triBbox;
						triBbox.setCenter (tri.Triangle.V0);
						triBbox.extend (tri.Triangle.V1);
						triBbox.extend (tri.Triangle.V2);

						// Triangle in the light
						if (triBbox.intersect (bbox))
						{
							// Test BackFace culling. Only faces which are BackFace the point light are inserted.
							// This is to avoid AutoOccluding problems
							if( tri.getPlane() * plRT.BSphere.Center < 0)
							{
								// Insert the triangle in the CubeGrid
								plRT.FaceCubeGrid.insert( tri.Triangle, &tri);
							}
						}

						itObstacle++;
					}
				}

				// Compile the CubeGrid.
				plRT.FaceCubeGrid.compile();

				// And Reset RefCount.
				plRT.RefCount= 0;
			}
		}
	}
	// else, just build empty grid
	else
	{
		for(i=0; i<_StaticPointLights.size();i++)
		{
			// progress
			progress ("Compute Influences of PointLights", 0.5f*i / (float)(_StaticPointLights.size()-1));

			CPointLightRT	&plRT= _StaticPointLights[i];
			// Create a dummy empty cubeGrid => no rayTrace :)
			plRT.FaceCubeGrid.create(plRT.PointLight.getPosition(), 4);

			// Compile the CubeGrid.
			plRT.FaceCubeGrid.compile();

			// And Reset RefCount.
			plRT.RefCount= 0;
		}
	}

}


// ***************************************************************************
bool	CZoneLighter::CPredPointLightToPoint::operator() (CPointLightRT *pla, CPointLightRT *plb) const
{
	float	ra= (pla->BSphere.Center - Point).norm();
	float	rb= (plb->BSphere.Center - Point).norm();
	float	infA= (pla->PointLight.getAttenuationEnd() - ra) * pla->OODeltaAttenuation;
	float	infB= (plb->PointLight.getAttenuationEnd() - rb) * plb->OODeltaAttenuation;
	// return which light impact the most.
	// If same impact
	if(infA==infB)
		// return nearest
		return ra < rb;
	else
		// return better impact
		return  infA > infB;
}

// ***************************************************************************
void			CZoneLighter::processZonePointLightRT(vector<CPointLightNamed> &listPointLight)
{
	uint	i;
	vector<CPointLightRT*>		lightInfs;
	lightInfs.reserve(1024);

	// clear result list
	listPointLight.clear();

	// zoneToLight
	CZone	*zoneToLight= _Landscape->getZone(_ZoneToLight);
	if(!zoneToLight)
		return;

	// Build patchForPLs
	//===========
	vector<CPatchForPL>		patchForPLs;
	patchForPLs.resize(_PatchInfo.size());
	for(i=0; i<patchForPLs.size(); i++)
	{
		// Get OrderS/OrderT
		patchForPLs[i].OrderS= _PatchInfo[i].OrderS;
		patchForPLs[i].OrderT= _PatchInfo[i].OrderT;
		// resize TileLightInfluences
		uint	w= patchForPLs[i].WidthTLI= patchForPLs[i].OrderS/2 +1 ;
		uint	h= patchForPLs[i].HeightTLI= patchForPLs[i].OrderT/2 +1;
		patchForPLs[i].TileLightInfluences.resize(w*h);
	}


	// compute each TileLightInfluence
	//===========
	for(i=0; i<patchForPLs.size(); i++)
	{
		// progress
		progress ("Compute Influences of PointLights", 0.5f + 0.5f*i / (float)patchForPLs.size());

		CPatchForPL		&pfpl= patchForPLs[i];
		const CPatch	*patch= const_cast<const CZone*>(zoneToLight)->getPatch(i);

		uint	x, y;
		for(y= 0; y<pfpl.HeightTLI; y++)
		{
			for(x= 0; x<pfpl.WidthTLI; x++)
			{
				// compute the point and normal (normalized) where the TLI lies.
				//---------
				CVector		pos, normal;
				float		s, t;
				s= (float)x / (pfpl.WidthTLI-1);
				t= (float)y / (pfpl.HeightTLI-1);
				// Compute the Vertex, with Noise information (important for accurate raytracing).
				pos= patch->computeVertex(s, t);
				// Use UnNoised normal from BezierPatch, because the lighting does not need to be so precise.
				CBezierPatch	*bp= patch->unpackIntoCache();
				normal= bp->evalNormal(s, t);


				// Compute Which light influences him.
				//---------
				lightInfs.clear();
				// Search possible lights around the position.
				_StaticPointLightQuadGrid.select(pos, pos);
				// For all of them, get the ones which touch this point.
				CQuadGrid<CPointLightRT*>::CIterator	it= _StaticPointLightQuadGrid.begin();
				while(it != _StaticPointLightQuadGrid.end())
				{
					CPointLightRT	*pl= *it;

					// a light influence a TLI only if this one is FrontFaced to the light !!
					if( ( pl->BSphere.Center - pos ) * normal > 0)
					{
						// Add 5cm else it fails in some case where ( pl->BSphere.Center - pos ) * normal is
						// nearly 0 and the point should be occluded.
						const float	deltaY= 0.05f;
						CVector	posToRT= pos + normal * deltaY;
						// Test if really in the radius of the light, if no occlusion, and if in SpotAngle
						if( pl->testRaytrace(posToRT) )
						{
							// Ok, add the light to the lights which influence the TLI
							lightInfs.push_back(pl);
						}
					}

					// next
					it++;
				}

				// Choose the Best ones.
				//---------
				CPredPointLightToPoint	predPLTP;
				predPLTP.Point= pos;
				// sort.
				sort(lightInfs.begin(), lightInfs.end(), predPLTP);
				// truncate.
				lightInfs.resize( min((uint)lightInfs.size(), (uint)CTileLightInfluence::NumLightPerCorner) );


				// For each of them, fill TLI
				//---------
				CTileLightInfUnpack		tli;
				uint					lightInfId;
				for(lightInfId=0; lightInfId<lightInfs.size(); lightInfId++)
				{
					CPointLightRT	*pl= lightInfs[lightInfId];

					// copy light.
					tli.Light[lightInfId]= pl;
					// Compute light Diffuse factor.
					CVector		dir= pl->BSphere.Center - pos;
					dir.normalize();
					tli.LightFactor[lightInfId]= dir * normal;
					clamp(tli.LightFactor[lightInfId], 0.f, 1.f);
					// modulate by light attenuation.
					tli.LightFactor[lightInfId]*= pl->PointLight.computeLinearAttenuation(pos);

					// Inc RefCount of the light.
					pl->RefCount++;
				}
				// Reset any empty slot to NULL.
				for(; lightInfId<CTileLightInfluence::NumLightPerCorner; lightInfId++)
				{
					tli.Light[lightInfId]= NULL;
				}


				// Set TLI in patch.
				//---------
				pfpl.TileLightInfluences[y*pfpl.WidthTLI + x]= tli;
			}
		}
	}


	// compress and setup _PatchInfo with compressed data.
	//===========
	uint	plId= 0;
	// Process each pointLights
	for(i=0; i<_StaticPointLights.size(); i++)
	{
		CPointLightRT	&plRT= _StaticPointLights[i];
		// If this light is used.
		if(plRT.RefCount > 0)
		{
			// Must Copy it into Zone.
			listPointLight.push_back(plRT.PointLight);
			plRT.DstId= plId++;
			// If index >= 255, too many lights (NB: => because 255 is a NULL code).
			if(plId>=0xFF)
			{
				throw Exception("Too many Static Point Lights influence the zone!!");
			}
		}
	}

	// For each patch, compress TLI in PatchInfo.
	for(i=0; i<patchForPLs.size(); i++)
	{
		CPatchForPL		&pfpl= patchForPLs[i];
		CPatchInfo		&pInfo= _PatchInfo[i];

		uint	w= pfpl.WidthTLI;
		uint	h= pfpl.HeightTLI;

		// Fill  pInfo.TileLightInfluences
		pInfo.TileLightInfluences.resize(w*h);
		uint	x, y;
		for(y= 0; y<h; y++)
		{
			for(x= 0; x<w; x++)
			{
				uint	tliId= y*w + x;
				// For all light slot
				for(uint lightId= 0; lightId<CTileLightInfluence::NumLightPerCorner; lightId++)
				{
					CTileLightInfUnpack		&tliSrc= pfpl.TileLightInfluences[tliId];
					CTileLightInfluence		&tliDst= pInfo.TileLightInfluences[tliId];
					if(tliSrc.Light[lightId] == NULL)
					{
						// Mark as unused.
						tliDst.Light[lightId]= 0xFF;
					}
					else
					{
						// Get index.
						tliDst.Light[lightId]= tliSrc.Light[lightId]->DstId;
						// Get Diffuse Factor.
						tliDst.setDiffuseLightFactor(lightId, (uint8)(tliSrc.LightFactor[lightId]*255));
					}
				}
			}
		}

	}

}

// ***********************************************************
// ***********************************************************
// TileFlagsForPositionTowardWater
// ***********************************************************
// ***********************************************************


//==================================================================
/// for map insertion of CTileOfPatch structs
static inline bool operator < (const CTileOfPatch &lhs, const CTileOfPatch &rhs)
{
	return lhs.Patch == rhs.Patch  ?
		   lhs.TileId < rhs.TileId :
		   lhs.Patch  < rhs.Patch;
};

/// A set of tiles from patch and their bbox
typedef std::map<CTileOfPatch, NLMISC::CAABBox> TTileOfPatchMap;

// ***********************************************************
void CZoneLighter::computeTileFlagsForPositionTowardWater(const CLightDesc &lightDesc,
														  std::vector<const CTessFace*> &tessFaces
														  )
{
	uint numTileAbove     = 0;
	uint numTileBelow     = 0;
	uint numTileIntersect = 0;

	/// the tiles that we have setupped so far...
	TTileOfPatchMap tiles;

	///////////////////////////////////////////
	//  First, build the bbox for all tiles  //
	///////////////////////////////////////////

	uint triCount = 0, totalTriCount = (uint)tessFaces.size();

	nlinfo("Dealing with %d tessFaces", tessFaces.size());
	for (std::vector<const CTessFace*>::iterator it = tessFaces.begin(); it != tessFaces.end(); ++it, ++triCount)
	{
		/// does the face belong to the zone to light ?
		if ((*it)->Patch->getZone()->getZoneId() != _ZoneToLight) continue;
		/// if the tile flags say that micro vegetation is disabled, just skip that
		if ((*it)->Patch->Tiles[(*it)->TileId].getVegetableState() == CTileElement::VegetableDisabled)
			continue;

		CTileOfPatch top((*it)->TileId, (*it)->Patch);
		TTileOfPatchMap::iterator tileIt = tiles.find(top);

		/// test whether we've seen face(s) from this tile before
		if (tileIt == tiles.end()) // first time ?
		{
			/// build a bbox for this face
			NLMISC::CAABBox b;
			b.setMinMax((*it)->VBase->EndPos, (*it)->VLeft->EndPos);
			b.extend((*it)->VRight->EndPos);
			b.extend(b.getMax() + lightDesc.VegetableHeight * NLMISC::CVector::K); // adds vegetable height
			tiles[top] = b;
		}
		else // extends the bbox with the given face
		{
			NLMISC::CAABBox &b = tileIt->second;
			b.extend((*it)->VBase->EndPos);
			b.extend((*it)->VRight->EndPos);
			b.extend((*it)->VLeft->EndPos);
		}

		if ((triCount % 100) == 0)
		{
			progress("Building bbox from tiles", (float) triCount / totalTriCount);
		}
	}

	progress("Building bbox from tiles", 1.f);



	////////////////////////////////////////////////////
	// Now, check each tile bbox against water shapes //
	////////////////////////////////////////////////////
	NLMISC::CPolygon   waterPoly;
	NLMISC::CPolygon2D tilePoly;
	tilePoly.Vertices.resize(4);

	uint tileCount = 0, totalTileCount = (uint)tiles.size();

	for (TTileOfPatchMap::iterator tileIt = tiles.begin(); tileIt != tiles.end(); ++tileIt, ++tileCount)
	{
		const NLMISC::CVector v0 = tileIt->second.getMin();
		const NLMISC::CVector v1 = tileIt->second.getMax();

		/// build a top view from the bbox
		tilePoly.Vertices[0].set(v0.x, v0.y);
		tilePoly.Vertices[1].set(v1.x, v0.y);
		tilePoly.Vertices[2].set(v1.x, v1.y);
		tilePoly.Vertices[3].set(v0.x, v1.y);

		/// Select the candidate water shape from the quad grid
		_WaterShapeQuadGrid.clearSelection();
		_WaterShapeQuadGrid.select(tileIt->second.getMin(), tileIt->second.getMax());

		CTileElement &te = tileIt->first.Patch->Tiles[tileIt->first.TileId]; // alias to the current tile element

		/// test more accurate intersection for each water shape
		TWaterShapeQuadGrid::CIterator qgIt;
		for (qgIt = _WaterShapeQuadGrid.begin(); qgIt != _WaterShapeQuadGrid.end(); ++qgIt)
		{
			CWaterShape		*waterShape= safe_cast<CWaterShape*>((*qgIt).Shape);
			waterShape->getShapeInWorldSpace(waterPoly, (*qgIt).MT);
			NLMISC::CPolygon2D poly(waterPoly);
			if (poly.intersect(tilePoly)) // above or below a water surface ?
			{
				/// height of water
				float waterHeight = waterPoly.Vertices[0].z;

				if (v1.z < waterHeight)
				{
					// below
					te.setVegetableState(CTileElement::UnderWater);
					//nlassert(te.getVegetableState() == CTileElement::UnderWater);
					++ numTileBelow;
				}
				else if (v0. z > waterHeight)
				{
					// above
					te.setVegetableState(CTileElement::AboveWater);
					//nlassert(te.getVegetableState() == CTileElement::AboveWater);
					++ numTileAbove;
				}
				else
				{
					// intersect water
					te.setVegetableState(CTileElement::IntersectWater);
					//nlassert(te.getVegetableState() == CTileElement::IntersectWater);
					++ numTileIntersect;
				}
				break;
			}
		}

		if (qgIt == _WaterShapeQuadGrid.end()) // no intersection found ? if yes it's above water
		{
			te.setVegetableState(CTileElement::AboveWater);
			//nlassert(te.getVegetableState() == CTileElement::AboveWater);
			++ numTileAbove;
		}

		if ((tileCount % 50) == 0)
		{
			progress("Computing tile position towards water", (float) tileCount / totalTileCount);
		}
	}

	progress("Computing tile position towards water", 1.f);

	nlinfo(" %d tiles are above water.", numTileAbove);
	nlinfo(" %d tiles are below water.", numTileBelow);
	nlinfo(" %d tiles intersect water.", numTileIntersect);



	/// delete the quadgrid now
	NLMISC::contReset(_WaterShapeQuadGrid);
}

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

void CZoneLighter::setTileFlagsToDefault(std::vector<const CTessFace*> &tessFaces)
{
	/// We may setup a tile several time, but this doesn't matter here...
	for (std::vector<const CTessFace*>::iterator it = tessFaces.begin(); it != tessFaces.end(); ++it)
	{
		if ((*it)->Patch->getZone()->getZoneId() != _ZoneToLight) continue;
		CTileElement &te = (*it)->Patch->Tiles[(*it)->TileId];
		if (te.getVegetableState() != CTileElement::VegetableDisabled)
		{
			te.setVegetableState(CTileElement::AboveWater);
		}
	}
}

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

uint CZoneLighter::getAPatch (uint process)
{
	// Accessor
	CSynchronized<std::vector<bool> >::CAccessor access (&_PatchComputed);

	// Current index
	uint index = _LastPatchComputed[process];
	uint firstIndex = index;

	if (access.value().size() == 0)
		// no more patches
		return 0xffffffff;

	while (access.value()[index])
	{
		// Next patch
		index++;

		// Last patch ?
		if (index == _PatchInfo.size())
			index = 0;

		// First ?
		if (firstIndex == index)
			// no more patches
			return 0xffffffff;
	}

	// Visited
	access.value()[index] = true;

	// Last index
	_LastPatchComputed[process] = index;
	_NumberOfPatchComputed++;

	// Return the index
	return index;
}

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

float CZoneLighter::attenuation (const CVector &pos, const CZoneLighter::CLightDesc &description)
{
	// Clipped ?

	// *** Landscape attenuation

	// Current value
	float averageAttenuation = 0;
	float randomSum = 0;

	// For each sample
	uint sample;
	const uint samples = description.SoftShadowSamplesSqrt*description.SoftShadowSamplesSqrt;
	for (sample=0; sample<samples; sample++)
	{
		// The zbuffer
		CZBuffer &zbuffer = _ZBufferLandscape[sample];

		// Get position in z buffer
		CVector zPos;
		transformVectorToZBuffer (zbuffer, pos, zPos);

		// Get the z
		float random = (float)_Random.rand () * description.SoftShadowJitter + _Random.RandMax * (1.f - description.SoftShadowJitter);
		averageAttenuation += random * testZPercentageCloserFilter (zPos.x-(float)zbuffer.LocalZBufferXMin, zPos.y-(float)zbuffer.LocalZBufferYMin, zPos.z, zbuffer, description, _ZBufferOverflow);
		randomSum += random;
	}

	// Average landscape attenuation
	averageAttenuation /= randomSum;



	// *** Attenuation in the object zbuffer

	// Get position in z buffer
	CVector zPos;
	transformVectorToZBuffer (_ZBufferObject, pos, zPos);

	const float objectAttenuation = testZPercentageCloserFilter (zPos.x-(float)_ZBufferObject.LocalZBufferXMin, zPos.y-(float)_ZBufferObject.LocalZBufferYMin, zPos.z, _ZBufferObject, description, _ZBufferOverflow);


	// *** Return the min of the both
	return std::min (objectAttenuation, averageAttenuation);
}

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