// 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/>.

// Precompiled header
#include "stdafx.h"

#include "export_nel.h"
#include <vector>

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

#include "calc_lm_plane.h"

// -----------------------------------------------------------------------------------------------
SLMPlane::SLMPlane ()
{ 
	nNbLayerUsed = 1;
	x = y = 0; w = h = 1; msk.resize(1); msk[0] = 0; 
	col.resize(1); 
	col[0].R = col[0].G = col[0].B = col[0].A = 0.0f;
	ray.resize(1);
	ray[0] = 0;
}

// -----------------------------------------------------------------------------------------------
void SLMPlane::newLayer ()
{
	col.resize( w*h*(nNbLayerUsed+1), CRGBAF(0.0f,0.0f,0.0f,0.0f) );
	nNbLayerUsed += 1;
}

// -----------------------------------------------------------------------------------------------
bool SLMPlane::isAllBlack (uint8 nLayerNb)
{
	for( uint32 i = 0; i < w*h; ++i )
		if( (col[i+w*h*nLayerNb].R > 0.06f) || // around 15/255
			(col[i+w*h*nLayerNb].G > 0.06f) ||
			(col[i+w*h*nLayerNb].B > 0.06f) )
			return false; // Not all is black
	return true;
}

// -----------------------------------------------------------------------------------------------
void SLMPlane::copyColToBitmap8x2 (CBitmap* pImage, uint32 nLayerNb, CRGBAF lA, CRGBAF lD)
{
	if( nLayerNb >= nNbLayerUsed )
		return;
	
	if( ( pImage->getWidth() != w ) ||
		( pImage->getHeight() != h ) )
	{
		pImage->resize(w,h);
	}
	
	/* 
		We want to compress the RGBA lightmap L32 into a (lA,lD,L8) lightmap, where lA and lD are constants.

		lA and lD are given, so we have to compute L8.

		In the standard 32 bits Lightmap shader, for a single lightmap, the final formula is:
			O= L32*F*T
			where:
				O:		output
				L32:	the lightmap (actually in 16 bits RGB)
				F:		the lightmap factor (for light animation or activation)
				T:		the diffuse texture

		In the "8bits *2" Lightmap shader, for a single lightmap, the final formula is:
			O= (mA+L8*mD)*F*T*2
			where:
				L8:		the 8 bits lightmap
				mA:		Material Lightmap Ambient term. equal to lA/2, for convenience, and avoid too much "ambient clamping"
				mD:		Material Lightmap Diffuse term. equal to lD.
				*2:		the pixel shader multiplyBy2, to allow some TextureDiffuse burn.

		Hence, we have to solve the simple equation for L8:
			(lA/2+L8*lD)*2 = L32

		which result into:

			L8= ((L32-lA) / lD) * 0.5

		We define Vector0/Vector1 operation as the projection operation:  
			scalar= Vector0*Vector1 / sqrnorm(Vector1).
	*/

	// the dir vector lD
	CVector		vDir(lD.R, lD.G, lD.B);
	float		OOSqrNorm= 0;
	if(!vDir.isNull())
		OOSqrNorm= 1.0f / vDir.sqrnorm();

	// for all pixel of the layer
	CObjectVector<uint8> &vBitmap = pImage->getPixels();
	for( uint32 i = 0; i < w*h; ++i )
	{
		const CRGBAF	&srcCol= col[i+w*h*nLayerNb];

		// find the factor f, such that f= (L32-lA)/lD
		float	f;
		f= vDir * CVector(srcCol.R - lA.R, srcCol.G - lA.G, srcCol.B - lA.B);
		f*= OOSqrNorm;

		// we are in multiply x2 => compress to 8 bits from 0 to 127
		const float fMult = 127.0f;
		
		f*= fMult;
		clamp(f, 0.f, 255.0f);
		uint8	f8= (uint8)f;

		vBitmap[4*i+0] = f8;
		vBitmap[4*i+1] = f8;
		vBitmap[4*i+2] = f8;
		
		if (msk[i] != 0)
			vBitmap[4*i+3] = 255;
		else
			vBitmap[4*i+3] = 0;
	}
}

// -----------------------------------------------------------------------------------------------
void SLMPlane::copyColToBitmap32 (CBitmap* pImage, uint32 nLayerNb)
{
	if( nLayerNb >= nNbLayerUsed )
		return;
	if( ( pImage->getWidth() != w ) ||
		( pImage->getHeight() != h ) )
	{
		pImage->resize(w,h);
	}

	CObjectVector<uint8> &vBitmap = pImage->getPixels();

	for( uint32 i = 0; i < w*h; ++i )
	{
		// if we are in multiply x2 we have to set the following value to 127.0 else set to 255.0
		// By default we are in multiply x2 in Lightmap 8 bits mode but not in 32 bits mode
		const float fMult = 255.0;
		
		if( (fMult*col[i+w*h*nLayerNb].R) > 255.0 )
			vBitmap[4*i+0] = 255;
		else
			vBitmap[4*i+0] = (uint8)(fMult*col[i+w*h*nLayerNb].R);

		if( (fMult*col[i+w*h*nLayerNb].G) > 255.0 )
			vBitmap[4*i+1] = 255;
		else
			vBitmap[4*i+1] = (uint8)(fMult*col[i+w*h*nLayerNb].G);
		if( (fMult*col[i+w*h*nLayerNb].B) > 255.0 )
			vBitmap[4*i+2] = 255;
		else
			vBitmap[4*i+2] = (uint8)(fMult*col[i+w*h*nLayerNb].B);
		// Mask go into alpha channel
		if (msk[i] != 0)
			vBitmap[4*i+3] = 255;
		else
			vBitmap[4*i+3] = 0;
	}
}

// -----------------------------------------------------------------------------------------------
// Put me in the plane Dst (copy the col and mask or mask only)
void SLMPlane::putIn (SLMPlane &Dst, bool bMaskOnly)
{
	uint32 a, b, c;

	while (this->nNbLayerUsed > Dst.nNbLayerUsed)
		Dst.newLayer();

	if( ( (this->w + this->x) > Dst.w ) || ( (this->h + this->y) > Dst.h ) )
	{
		a = 0; b = 0;
	}
	for( b = 0; b < this->h; ++b )
	for( a = 0; a < this->w; ++a )
		if( this->msk[a+b*this->w] != 0 )
		{
			Dst.msk[(this->x+a)+(this->y+b)*Dst.w] = this->msk[a+b*this->w];
			if( bMaskOnly == false )
				for( c = 0; c < this->nNbLayerUsed; ++c )
					Dst.col[(this->x+a)+(this->y+b)*Dst.w+Dst.w*Dst.h*c] = this->col[a+b*this->w+w*h*c];
		}
}

// -----------------------------------------------------------------------------------------------
// Test the mask between me and the plane dst (with my decalage)
bool SLMPlane::testIn (SLMPlane &Dst)
{
	uint32 a, b;
	for( b = 0; b < this->h; ++b )
	for( a = 0; a < this->w; ++a )
		if( this->msk[a+b*this->w] != 0 )
			if( Dst.msk[(this->x+a)+(this->y+b)*Dst.w] != 0 )
				return false;
	return true;
}

// -----------------------------------------------------------------------------------------------
// Try all position to put me in the plane dst
bool SLMPlane::tryAllPosToPutIn (SLMPlane &Dst)
{
	uint32 i, j;

	if( this->w > Dst.w ) return false;
	if( this->h > Dst.h ) return false;

	// For all position test if the Src plane can be put in
	for( j = 0; j < (Dst.h-this->h); ++j )
	for( i = 0; i < (Dst.w-this->w); ++i )
	{
		this->x = i; this->y = j;
		if( testIn( Dst ) )
			return true;
	}
	return false;
}

// -----------------------------------------------------------------------------------------------
// Do not stretch the image inside the plane just enlarge and fill with black
void SLMPlane::resize (uint32 nNewSizeX, uint32 nNewSizeY)
{
	vector<uint8> vImgTemp;
	vector<CRGBAF> vImgTemp2;
	uint32 i, j, k;

	// Resize the mask
	vImgTemp.resize(nNewSizeX*nNewSizeY);
	for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
		vImgTemp[i] = 0;

	for( j = 0; j < min(this->h,nNewSizeY); ++j )
	for( i = 0; i < min(this->w,nNewSizeX); ++i )
		vImgTemp[i+j*nNewSizeX] = this->msk[i+j*this->w];

	this->msk.resize(nNewSizeX*nNewSizeY);
	for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
		this->msk[i] = vImgTemp[i];

	// Resize the raytrace information
	for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
		vImgTemp[i] = 0;

	for( j = 0; j < min(this->h,nNewSizeY); ++j )
	for( i = 0; i < min(this->w,nNewSizeX); ++i )
		vImgTemp[i+j*nNewSizeX] = this->ray[i+j*this->w];

	this->ray.resize(nNewSizeX*nNewSizeY);
	for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
		this->ray[i] = vImgTemp[i];

	// The same as the mask but for the bitmap
	vImgTemp2.resize(nNewSizeX*nNewSizeY*nNbLayerUsed);
	for( i = 0; i < nNewSizeX*nNewSizeY*nNbLayerUsed; ++i )
	{ vImgTemp2[i].R = vImgTemp2[i].G = vImgTemp2[i].B = vImgTemp2[i].A = 0.0f; }

	for( k = 0; k < nNbLayerUsed; ++k )
		for( j = 0; j < min(this->h,nNewSizeY); ++j )
		for( i = 0; i < min(this->w,nNewSizeX); ++i )
			vImgTemp2[i+j*nNewSizeX+nNewSizeX*nNewSizeY*k] = this->col[i+j*this->w+w*h*k];

	this->col.resize(nNewSizeX*nNewSizeY*nNbLayerUsed);
	for( i = 0; i < nNewSizeX*nNewSizeY*nNbLayerUsed; ++i )
		this->col[i] = vImgTemp2[i];

	this->w = nNewSizeX;
	this->h = nNewSizeY;
}

// -----------------------------------------------------------------------------------------------
// Stretch a plane by a given factor 4.0 -> multiply its size by 4 and 0.5 -> halves its size
// Take care the decalage is affected by the scaling factor (like homothetie)
void SLMPlane::stretch (double osFactor)
{
	if( osFactor < 0.0 )
		osFactor = 0.0;
	uint32 nNewSizeX = (uint32)(this->w * osFactor);
	uint32 nNewSizeY = (uint32)(this->h * osFactor);
	vector<uint8> vImgTemp;
	vector<uint8> vImgTempRay;
	vector<CRGBAF> vImgTemp2;
	uint32 i, j, k;

	// Reduce the color
	vImgTempRay.resize(nNewSizeX * nNewSizeY);
	for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
		vImgTempRay[i] = 0;	

	vImgTemp2.resize( nNewSizeX * nNewSizeY * nNbLayerUsed );
	for( i = 0; i < nNewSizeX*nNewSizeY*nNbLayerUsed; ++i )
	{ vImgTemp2[i].R = vImgTemp2[i].G = vImgTemp2[i].B = vImgTemp2[i].A = 0.0f; }

	vImgTemp.resize( nNewSizeX * nNewSizeY );
	for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
		vImgTemp[i] = 0;

	double dx, dy, x, y;
	if( osFactor > 1.0 ) // Enlarge the image
	{
		dx = 1.0/osFactor;
		dy = 1.0/osFactor;
		y = 0.0;
		for( j = 0; j < nNewSizeY; ++j )
		{
			x = 0.0;
			for( i = 0; i < nNewSizeX; ++i )
			{
				if( this->msk[((sint32)x)+((sint32)y)*this->w] != 0 )
				{
					vImgTemp[i+j*nNewSizeX] = 1;
				}
				for( k = 0; k < nNbLayerUsed; ++k )
				{
					vImgTemp2[i+j*nNewSizeX+nNewSizeX*nNewSizeY*k].R += col[((sint32)x)+((sint32)y)*w+w*h*k].R;
					vImgTemp2[i+j*nNewSizeX+nNewSizeX*nNewSizeY*k].G += col[((sint32)x)+((sint32)y)*w+w*h*k].G;
					vImgTemp2[i+j*nNewSizeX+nNewSizeX*nNewSizeY*k].B += col[((sint32)x)+((sint32)y)*w+w*h*k].B;
					vImgTemp2[i+j*nNewSizeX+nNewSizeX*nNewSizeY*k].A += 1.0f;
				}
				vImgTempRay[i+j*nNewSizeX] = ray[((sint32)x)+((sint32)y)*w];
				x += dx;
			}
			y += dy;
		}
	}
	else // Reduce image
	{
		dx = osFactor;
		dy = osFactor;
		y = 0.0;
		for( j = 0; j < this->h; ++j )
		{
			x = 0.0;
			for( i = 0; i < this->w; ++i )
			{
				if( this->msk[i+j*this->w] != 0 )
				{
					vImgTemp[((sint32)x)+((sint32)y)*nNewSizeX] = 1;
				}
				for( k = 0; k < nNbLayerUsed; ++k )
				{
					vImgTemp2[((sint32)x)+((sint32)y)*nNewSizeX+nNewSizeX*nNewSizeY*k].R += col[i+j*w+w*h*k].R;
					vImgTemp2[((sint32)x)+((sint32)y)*nNewSizeX+nNewSizeX*nNewSizeY*k].G += col[i+j*w+w*h*k].G;
					vImgTemp2[((sint32)x)+((sint32)y)*nNewSizeX+nNewSizeX*nNewSizeY*k].B += col[i+j*w+w*h*k].B;
					vImgTemp2[((sint32)x)+((sint32)y)*nNewSizeX+nNewSizeX*nNewSizeY*k].A += 1.0f;
				}
				vImgTempRay[((sint32)x)+((sint32)y)*nNewSizeX] = ray[i+j*w];
				x += dx;
			}
			y += dy;
		}
	}

	for( k = 0; k < nNbLayerUsed; ++k )
	for( j = 0; j < nNewSizeY; ++j )
	for( i = 0; i < nNewSizeX; ++i )
	if( vImgTemp2[i+j*nNewSizeX+nNewSizeX*nNewSizeY*k].A > 1.0f )
	{
		vImgTemp2[i+j*nNewSizeX+nNewSizeX*nNewSizeY*k].R /= vImgTemp2[i+j*nNewSizeX+nNewSizeX*nNewSizeY*k].A;
		vImgTemp2[i+j*nNewSizeX+nNewSizeX*nNewSizeY*k].G /= vImgTemp2[i+j*nNewSizeX+nNewSizeX*nNewSizeY*k].A;
		vImgTemp2[i+j*nNewSizeX+nNewSizeX*nNewSizeY*k].B /= vImgTemp2[i+j*nNewSizeX+nNewSizeX*nNewSizeY*k].A;
		vImgTemp2[i+j*nNewSizeX+nNewSizeX*nNewSizeY*k].A = 1.0f;
	}

	col.resize( nNewSizeX * nNewSizeY * nNbLayerUsed );
	for( i = 0; i < nNewSizeX*nNewSizeY*nNbLayerUsed; ++i )
		col[i] = vImgTemp2[i];

	msk.resize( nNewSizeX * nNewSizeY );
	for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
		msk[i] = vImgTemp[i];

	ray.resize( nNewSizeX * nNewSizeY );
	for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
		ray[i] = vImgTempRay[i];

	this->w = nNewSizeX;
	this->h = nNewSizeY;
	this->x = (sint32)(this->x * osFactor);
	this->y = (sint32)(this->y * osFactor);
}

// -----------------------------------------------------------------------------------------------
void SLMPlane::createFromPlane (SLMPlane &Src)
{
	uint i;
	// Resize to the same size
	resize(Src.w,Src.h);
	x = Src.x;
	y = Src.y;
	// Copy the mask
	for( i = 0; i < Src.w*Src.h; ++i )
		msk[i] = Src.msk[i];
	// Copy the faces
	faces.resize(Src.faces.size());
	for( i = 0; i < Src.faces.size(); ++i )
		faces[i] = Src.faces[i];
}

// -----------------------------------------------------------------------------------------------
void SLMPlane::copyFirstLayerTo (SLMPlane &Dst, uint8 nDstLayer)
{
	uint i;

	if( ( Dst.w != w ) || ( Dst.h != h ) )
		Dst.resize( w, h );

	while( nDstLayer >= Dst.nNbLayerUsed )
		Dst.newLayer();

	for( i = 0; i < w*h; ++i )
		Dst.col[i+w*h*nDstLayer] = col[i];
}

// -----------------------------------------------------------------------------------------------
void SLMPlane::contourDetect ()
{
	uint i, j;
	vector<uint8> vImgTemp;
	vImgTemp.resize(w*h);
	for( i = 0; i < w*h; ++i )
		vImgTemp[i] = 0;

	for( j = 0; j < h; ++j )
	for( i = 0; i < w; ++i )
	{
		if( i > 0 )
		if( ray[i+j*w] != ray[i-1+j*w] )
			vImgTemp[i+j*w] = 1;
		if( i < (w-1) )
		if( ray[i+j*w] != ray[i+1+j*w] )
			vImgTemp[i+j*w] = 1;
		if( j > 0 )
		if( ray[i+j*w] != ray[i+(j-1)*w] )
			vImgTemp[i+j*w] = 1;
		if( j < (h-1) )
		if( ray[i+j*w] != ray[i+(j+1)*w] )
			vImgTemp[i+j*w] = 1;

		if( ray[i+j*w] == 255 )
			vImgTemp[i+j*w] = 1;
	}

	for( i = 0; i < w*h; ++i )
		ray[i] = vImgTemp[i];


	/*{
		CBitmap b;
		COFile f( "c:\\temp\\gloup.tga" );
		b.resize(w,h);
		CObjectVector<uint8>&bits = b.getPixels();
		for( i = 0; i < w*h; ++i )
		{
			bits[i*4+0] = bits[i*4+1] = bits[i*4+2] = bits[i*4+3] = ray[i]*255;
		}

		b.writeTGA( f, 32 );
	}*/
}

// -----------------------------------------------------------------------------------------------
void SLMPlane::andRayWidthMask ()
{
	for( uint i = 0; i < w*h; ++i )
	if( ray[i] == 0 ) 
		msk[i] = 0;
}

// -----------------------------------------------------------------------------------------------
bool SLMPlane::isInTriangleOrEdge(	double x, double y, 
									double xt1, double yt1, 
									double xt2, double yt2, 
									double xt3, double yt3)
{
	// Test vector T1X and T1T2
	double sign1 = ((xt2-xt1)*(y-yt1) - (yt2-yt1)*(x-xt1));
	// Test vector T2X and T2T3
	double sign2 = ((xt3-xt2)*(y-yt2) - (yt3-yt2)*(x-xt2));
	// Test vector T3X and T3T1
	double sign3 = ((xt1-xt3)*(y-yt3) - (yt1-yt3)*(x-xt3));
	if( (sign1 <= 0.0)&&(sign2 <= 0.0)&&(sign3 <= 0.0) )
		return true;
	if( (sign1 >= 0.0)&&(sign2 >= 0.0)&&(sign3 >= 0.0) )
		return true;
	return false;
}

// -----------------------------------------------------------------------------------------------
bool SLMPlane::segmentIntersection(	double x1, double y1,
									double x2, double y2, 
									double x3, double y3, 
									double x4, double y4)
{
	double denominator = (y4-y3)*(x2-x1) - (x4-x3)*(y2-y1);
	if( denominator == 0.0 )
		return false; // The segment are colinear
	double k = ((x4-x3)*(y1-y3) - (y4-y3)*(x1-x3) ) / denominator;
	if( (k<=0.0) || (k>=1.0) ) return false;
	k = ( (x2-x1)*(y1-y3) - (y2-y1)*(x1-x3) ) / denominator;
	if( (k<=0.0) || (k>=1.0) ) return false;
	return true;
}

// -----------------------------------------------------------------------------------------------
void SLMPlane::createFromFace (CMesh::CFace *pF)
{
	double	lumx1 = pF->Corner[0].Uvws[1].U, lumy1 = pF->Corner[0].Uvws[1].V, 
			lumx2 = pF->Corner[1].Uvws[1].U, lumy2 = pF->Corner[1].Uvws[1].V, 
			lumx3 = pF->Corner[2].Uvws[1].U, lumy3 = pF->Corner[2].Uvws[1].V;
	double minx, miny;
	double maxx, maxy;
	sint32 j, k;

	minx = lumx1;
	if( minx > lumx2 ) minx = lumx2;
	if( minx > lumx3 ) minx = lumx3;
	maxx = lumx1;
	if( maxx < lumx2 ) maxx = lumx2;
	if( maxx < lumx3 ) maxx = lumx3;
	miny = lumy1;
	if( miny > lumy2 ) miny = lumy2;
	if( miny > lumy3 ) miny = lumy3;
	maxy = lumy1;
	if( maxy < lumy2 ) maxy = lumy2;
	if( maxy < lumy3 ) maxy = lumy3;

	// Put the piece in the new basis (nPosX,nPosY)
	sint32 decalX = ((sint32)floor(minx-0.5)) - x;
	sint32 decalY = ((sint32)floor(miny-0.5)) - y;
	sint32 sizeX = 1 + ((sint32)floor(maxx+0.5)) - ((sint32)floor(minx-0.5));
	sint32 sizeY = 1 + ((sint32)floor(maxy+0.5)) - ((sint32)floor(miny-0.5));

	lumx1 -= x; lumy1 -= y;
	lumx2 -= x; lumy2 -= y;
	lumx3 -= x;	lumy3 -= y;

	// The square interact with the triangle if an edge of the square is cut by an edge of the triangle
	// Or the square is in the triangle
	
	for (j = decalY; j < (decalY+sizeY-1); ++j)
	for (k = decalX; k < (decalX+sizeX-1); ++k)
	{
		// Is the square (j,k) is interacting with the triangle
		// This means : The square contains a point of the triangle (can be done for the 3 points)
		//              The triangle contains a point of the square
		// If so then we have to turn on all the 4 pixels of the square
		if( isInTriangleOrEdge(k+0.5,j+0.5,lumx1,lumy1,lumx2,lumy2,lumx3,lumy3) ||
			isInTriangleOrEdge(k+1.5,j+0.5,lumx1,lumy1,lumx2,lumy2,lumx3,lumy3) ||
			isInTriangleOrEdge(k+0.5,j+1.5,lumx1,lumy1,lumx2,lumy2,lumx3,lumy3) ||
			isInTriangleOrEdge(k+1.5,j+1.5,lumx1,lumy1,lumx2,lumy2,lumx3,lumy3) )
		{
			msk[k   + j    *w] = 1;
			msk[1+k + j    *w] = 1;
			msk[k   + (1+j)*w] = 1;
			msk[1+k + (1+j)*w] = 1;
		}
		else
		if( segmentIntersection(k+0.5, j+0.5, k+1.5, j+0.5, lumx1, lumy1, lumx2, lumy2) ||
			segmentIntersection(k+0.5, j+0.5, k+1.5, j+0.5, lumx2, lumy2, lumx3, lumy3) ||
			segmentIntersection(k+0.5, j+0.5, k+1.5, j+0.5, lumx3, lumy3, lumx1, lumy1) ||

			segmentIntersection(k+0.5, j+0.5, k+0.5, j+1.5, lumx1, lumy1, lumx2, lumy2) ||
			segmentIntersection(k+0.5, j+0.5, k+0.5, j+1.5, lumx2, lumy2, lumx3, lumy3) ||
			segmentIntersection(k+0.5, j+0.5, k+0.5, j+1.5, lumx3, lumy3, lumx1, lumy1) ||

			segmentIntersection(k+1.5, j+1.5, k+1.5, j+0.5, lumx1, lumy1, lumx2, lumy2) ||
			segmentIntersection(k+1.5, j+1.5, k+1.5, j+0.5, lumx2, lumy2, lumx3, lumy3) ||
			segmentIntersection(k+1.5, j+1.5, k+1.5, j+0.5, lumx3, lumy3, lumx1, lumy1) ||

			segmentIntersection(k+1.5, j+1.5, k+0.5, j+1.5, lumx1, lumy1, lumx2, lumy2) ||
			segmentIntersection(k+1.5, j+1.5, k+0.5, j+1.5, lumx2, lumy2, lumx3, lumy3) ||
			segmentIntersection(k+1.5, j+1.5, k+0.5, j+1.5, lumx3, lumy3, lumx1, lumy1) )
		{
			msk[k   + j    *w] = 1;
			msk[1+k + j    *w] = 1;
			msk[k   + (1+j)*w] = 1;
			msk[1+k + (1+j)*w] = 1;
		}

	}
	
	// For all the points of the triangle update the square
	msk[((sint32)(lumx1-0.5))   + ((sint32)(lumy1-0.5))    *w] = 1;
	msk[1+((sint32)(lumx1-0.5)) + ((sint32)(lumy1-0.5))    *w] = 1;
	msk[((sint32)(lumx1-0.5))   + (1+((sint32)(lumy1-0.5)))*w] = 1;
	msk[1+((sint32)(lumx1-0.5)) + (1+((sint32)(lumy1-0.5)))*w] = 1;

	msk[((sint32)(lumx2-0.5))   + ((sint32)(lumy2-0.5))    *w] = 1;
	msk[1+((sint32)(lumx2-0.5)) + ((sint32)(lumy2-0.5))    *w] = 1;
	msk[((sint32)(lumx2-0.5))   + (1+((sint32)(lumy2-0.5)))*w] = 1;
	msk[1+((sint32)(lumx2-0.5)) + (1+((sint32)(lumy2-0.5)))*w] = 1;
	
	msk[((sint32)(lumx3-0.5))   + ((sint32)(lumy3-0.5))    *w] = 1;
	msk[1+((sint32)(lumx3-0.5)) + ((sint32)(lumy3-0.5))    *w] = 1;
	msk[((sint32)(lumx3-0.5))   + (1+((sint32)(lumy3-0.5)))*w] = 1;
	msk[1+((sint32)(lumx3-0.5)) + (1+((sint32)(lumy3-0.5)))*w] = 1;
}

// -----------------------------------------------------------------------------------------------
void SLMPlane::createFromFaceGroup (vector<CMesh::CFace*>::iterator ItFace, uint32 nNbFace)
{
	uint32 i, j;
	double rMinU = 1000000.0, rMaxU = -1000000.0, rMinV = 1000000.0, rMaxV = -1000000.0;
	vector<CMesh::CFace*>::iterator ItParseI = ItFace;
	CMesh::CFace *pF;

	faces.resize( nNbFace );

	for( i = 0; i < nNbFace; ++i )
	{
		pF = *ItParseI;
		for( j = 0; j < 3; ++j )
		{
			if( rMinU > pF->Corner[j].Uvws[1].U ) rMinU = pF->Corner[j].Uvws[1].U;
			if( rMaxU < pF->Corner[j].Uvws[1].U ) rMaxU = pF->Corner[j].Uvws[1].U;
			if( rMinV > pF->Corner[j].Uvws[1].V ) rMinV = pF->Corner[j].Uvws[1].V;
			if( rMaxV < pF->Corner[j].Uvws[1].V ) rMaxV = pF->Corner[j].Uvws[1].V;
		}
		faces[i] = pF;
		++ItParseI;
	}

	uint32 w = ( 1 + ((sint32)floor( rMaxU + 0.5 )) - ((sint32)floor( rMinU - 0.5 )) );
	uint32 h = ( 1 + ((sint32)floor( rMaxV + 0.5 )) - ((sint32)floor( rMinV - 0.5 )) );
	resize( w, h );
	x = ( ((sint32)floor( rMinU - 0.5 )) );
	y = ( ((sint32)floor( rMinV - 0.5 )) );
	for( j = 0; j < w*h; ++j )
		msk[j] = 0;

	ItParseI = ItFace;
	for( i = 0; i < nNbFace; ++i )
	{
		pF = *ItParseI;

		// Create Mask
		createFromFace (pF);

		++ItParseI;
	}
}

// -----------------------------------------------------------------------------------------------
CRGBAF SLMPlane::getAverageColor (uint8 nLayerNb)
{
	uint32 a, b, c, nNbPixel = 0;
	CRGBAF ret (0.0f, 0.0f, 0.0f, 0.0f);

	if (nLayerNb > nNbLayerUsed)
		return ret;

	c = nLayerNb;
	for( b = 0; b < this->h; ++b )
	for( a = 0; a < this->w; ++a )
		if( this->msk[a+b*this->w] != 0 )
		{
			ret += this->col[a+b*this->w+w*h*c];
			++nNbPixel;
		}
	if (nNbPixel > 0)
	{
		ret.R = ret.R / (float)nNbPixel;
		ret.G = ret.G / (float)nNbPixel;
		ret.B = ret.B / (float)nNbPixel;
		ret.A = ret.A / (float)nNbPixel;
	}
	return ret;
}

// -----------------------------------------------------------------------------------------------
bool SLMPlane::isSameColorAs (uint8 nLayerNb, CRGBAF color, float precision)
{
	uint32 a, b, c;

	if (nLayerNb > nNbLayerUsed)
		return false;

	c = nLayerNb;
	for( b = 0; b < this->h; ++b )
	for( a = 0; a < this->w; ++a )
		if( this->msk[a+b*this->w] != 0 )
		{
			CRGBAF lc = this->col[a+b*this->w+w*h*c];

			if ((fabsf(lc.R-color.R) > precision) ||
				(fabsf(lc.G-color.G) > precision) ||
				(fabsf(lc.B-color.B) > precision))
				return false;
		}
	return true;
}