#include <MLR\MLRHeaders.hpp>

#if !defined(HFSLIMMZ0P3_HPP)
	#include "HFSlimMZ0p3.hpp"
	#include "terra\terra.hpp"
#endif

const Scalar One_Over_Three = 1.0f/3.0f;

extern FILE *analyzeFile;

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	ToDrawTriangle::GetSurfaceAreaAndCentroid()
{
	//
	//---------------------
	// Set up the variables
	//---------------------
	//
	Point3D
		position_a = Point3D::Identity,
		position_b,
		position_c = Point3D::Identity;
	Vector3D
		leg_1,
		leg_2 = Vector3D::Identity;

	//
	//-----------------------------------
	// Spin through, testing the vertices
	//-----------------------------------
	//
	area = 0.0f;
	center = Point3D::Identity;

	//
	//-----------------------------------------------
	// Generate all the information on the first pass
	//-----------------------------------------------
	//
	position_a = v[0];
	position_b = v[1];
	position_c = v[2];

	leg_1.Subtract(position_b, position_a);
	leg_2.Subtract(position_c, position_a);

	//
	//-----------------------------------------------------------------
	// Compute the cross-product of the two legs to get the area of the
	// triangle
	//-----------------------------------------------------------------
	//
	Vector3D vcp;
	vcp.Cross(leg_1, leg_2);

	//
	//-------------------------------------------------------------------
	// Add the three triangle points together and multiply by the area of
	// the triangle to give a weighted sum for the polygon centroid
	//-------------------------------------------------------------------
	//
	Point3D centroid;
	centroid.Add(position_a, position_b);
	centroid += position_c;

	Scalar wedge_area = vcp.GetLength() * 0.5f;

	if (area <= SMALL)
	{
		if (wedge_area > SMALL)
		{
			area += wedge_area;
			centroid *= wedge_area;
		}
		center = centroid;
	}
	else
	{
		if (wedge_area > SMALL)
		{
			area += wedge_area;
			centroid *= wedge_area;
			center += centroid;
		}
	}

	plane.normal.x = 0.0f;
	plane.normal.y = 0.0f;
	plane.normal.z = 1.0f;
	plane.offset = 0.0f;

	if(area > SMALL)
	{
		plane.BuildPlane(
			v[0],
			v[2],
			v[1]
		);

		center *= (One_Over_Three/area);
	}
	else
	{
		center *= One_Over_Three;
	}
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
HFSlimMZ0p3::HFSlimMZ0p3()
{
	X = (int)0.0f;
	Z = (int)0.0f;
	
	dX = 2.0f;
	dY = 0.15f;
	dZ = 2.0f;

	xOffset = 0.0f;
	zOffset = 0.0f;

	Offset = 0.0f;
	visHeight = 0;

	simpleTerrainGroup.SetLength(0);

	borderPixelFun = 0.0f;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
HFSlimMZ0p3::~HFSlimMZ0p3()
{
	for(int i=0;i<simpleTerrainGroup.GetLength();i++)
	{
		Unregister_Object(simpleTerrainGroup[i]);
		delete simpleTerrainGroup[i];
		simpleTerrainGroup[i] = NULL;
	}
	simpleTerrainGroup.SetLength(0);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
Stuff::ExtentBox
	HFSlimMZ0p3::GetExtents()
{
	Stuff::ExtentBox ebox;

	ebox.minX = GetX(0);
	ebox.minZ = GetZ(0);

	ebox.maxX = GetX(X-1);
	ebox.maxZ = GetZ(Z-1);

	int i, j;
	Scalar h;
	ebox.maxY = ebox.minY = GetHeight(0, 0);

	for (j=1;j<Z;j++)
		for (i=1;i<X;i++)
		{
			h = GetHeight(i, j);
			if(ebox.maxY < h)
			{
				ebox.maxY = h;
			}
			if(ebox.minY > h)
			{
				ebox.minY = h;
			}
		}

	return ebox;
}

//---------------------------------------------------------------------------
void
	HFSlimMZ0p3::Blur2D (int smooth)
{

    // Precondition for stability:  0 < scale < exp(0.25)
    // Good choice for iterative blurring is scale = exp(0.125)
	float scale = static_cast<float>(exp(0.125));
	float** temp = new float*[Z];
	int x, y;
	for (y = 0; y < Z; y++)
		temp[y] = new float[X];

	for(int i=0;i<smooth;i++)
	{
		float logscale = float(log(scale));

		for (y = 0; y < Z; y++) 
		{
			float ryp = y+scale, rym = y-scale;
			int yp = (int) floor(ryp), ym = (int) ceil(rym);

			for (x = 0; x < X; x++) 
			{
				float rxp = x+scale, rxm = x-scale;
				int xp = (int) floor(rxp), xm = (int) ceil(rxm);

				// x portion of second central difference
				float xsum = -2*field[y*X+x];
				if ( xp >= X-1 )  // use boundary value
					xsum += field[y*X+X-1];
				else  // linearly interpolate
					xsum += field[y*X+xp]+(rxp-xp)*(field[y*X+xp+1]-field[y*X+xp]);
				if ( xm <= 0 )  // use boundary value
					xsum += field[y*X+0];
				else  // linearly interpolate
					xsum += field[y*X+xm]+(rxm-xm)*(field[y*X+xm]-field[y*X+xm-1]);

				// y portion of second central difference
				float ysum = -2*field[y*X+x];
				if ( yp >= Z-1 )  // use boundary value
					ysum += field[(Z-1)*X+x];
				else  // linearly interpolate
					ysum += field[yp*X+x]+(ryp-yp)*(field[(yp+1)*X+x]-field[yp*X+x]);
				if ( ym <= 0 )  // use boundary value
					ysum += field[0*X+x];
				else  // linearly interpolate
					ysum += field[ym*X+x]+(rym-ym)*(field[ym*X+x]-field[(ym-1)*X+x]);

				temp[y][x] = field[y*X+x]+logscale*(xsum+ysum);
			}
		}

		for (y = 0; y < Z; y++)
			for (x = 0; x < X; x++)
				field[y*X+x] = temp[y][x];
	}

    for (y = 0; y < Z; y++)
        delete[] temp[y];
    delete[] temp;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	HFSlimMZ0p3::FillFromImage(Image &image, int smooth)
{
	X = image.GetWidth()+1;
	Z = image.GetHeight()+1;

	Verify(((X-1)%256 == 0) && ((Z-1)%256 == 0));
	xDim = image.GetWidth()/256;
	zDim = image.GetHeight()/256;
	
	Verify(image.GetBpp()==8);
	
	field.SetLength(X*Z);
	
	unsigned char *ptr;
	ptr=(unsigned char *)image.Lock();

	int i, j;
	for(i=0;i<Z-1;i++)
	{
		for(j=0;j<X-1;j++)
		{
			field[i*X+j] = ptr[(image.GetHeight()-i-1)*(X-1)+image.GetWidth()-j-1];
		}
		field[i*X+j] = field[i*X+j-1];
	}
	for(j=0;j<X-1;j++)
	{
		field[i*X+j] = field[(i-1)*X+j];
	}
	field[i*X+j] = field[i*X+j-1];

	image.UnLock();

	Blur2D(smooth);
}

int triangleCounter = 0;

Scalar xGridSize, zGridSize;
int tX, tY;

void GetFacesCB(Triangle &tri,void *cbp)
{
	ToDrawTriangle *tdtrilist = (ToDrawTriangle *)cbp;
	tdtrilist[triangleCounter].SetPoint(0,(float)tri.point1()[0],0.0f,(float)tri.point1()[1]);
	tdtrilist[triangleCounter].SetPoint(1,(float)tri.point2()[0],0.0f,(float)tri.point2()[1]);
	tdtrilist[triangleCounter].SetPoint(2,(float)tri.point3()[0],0.0f,(float)tri.point3()[1]);

	triangleCounter++;
}

#define TERRAIN2_TEST

Point3D center;
Scalar maxRadius;

bool
	HFSlimMZ0p3::CreateMesh(
		MLR_Terrain2 *erf_mesh,
		DynamicArrayOf<ToDrawTriangle*>& tdtrilist,
		ExtentBox *uvFrame
	)
{
	int polygon_count = tdtrilist.GetLength();
	if(polygon_count==0 || polygon_count*3 >= Limits::Max_Number_Vertices_Per_Mesh)
	{
		return NULL;
	}

    DynamicArrayOf<int> vert_id(X*Z);
	memset(vert_id.GetData(), 0, vert_id.GetSize());
	
	int i, j, x, z, point_count = 0;
	
	int minX[2]={0,0},
		maxX[2]={0,0},
		minY[2]={0,0},
		maxY[2]={0,0},
		minZ[2]={0,0},
		maxZ[2]={0,0};
	Scalar
		minx=tdtrilist[0]->v[0].x,
		maxx=tdtrilist[0]->v[0].x,
		miny=tdtrilist[0]->v[0].y,
		maxy=tdtrilist[0]->v[0].y,
		minz=tdtrilist[0]->v[0].z,
		maxz=tdtrilist[0]->v[0].z;

	Point3D
		center0 = Point3D::Identity,
		center1 = Point3D::Identity,
		center2 = Point3D::Identity,
		center3 = Point3D::Identity;

	for(i=0;i<polygon_count;++i)
	{
		center3 += tdtrilist[i]->center;

		if(tdtrilist[i]->v[0].x < minx)
		{
			minX[0] = i;
			minX[1] = 0;
			minx = tdtrilist[i]->v[0].x;
		} else if(tdtrilist[i]->v[0].x > maxx)
		{
			maxX[0] = i;
			maxX[1] = 0;
			maxx = tdtrilist[i]->v[0].x;
		}
		if(tdtrilist[i]->v[0].y < miny)
		{
			minY[0] = i;
			minY[1] = 0;
			miny = tdtrilist[i]->v[0].y;
		} else if(tdtrilist[i]->v[0].y > maxy)
		{
			maxY[0] = i;
			maxY[1] = 0;
			maxy = tdtrilist[i]->v[0].y;
		}
		if(tdtrilist[i]->v[0].z < minz)
		{
			minZ[0] = i;
			minZ[1] = 0;
			minz = tdtrilist[i]->v[0].z;
		} else if(tdtrilist[i]->v[0].z > maxz)
		{
			maxZ[0] = i;
			maxZ[1] = 0;
			maxz = tdtrilist[i]->v[0].z;
		}
		
		x = (int)(tdtrilist[i]->v[0].x/dX);
		z = (int)(tdtrilist[i]->v[0].z/dZ);

		vert_id[x + X*z]++;
		if(vert_id[x + X*z]==1)
		{
			center0 += tdtrilist[i]->v[0];
			point_count++;
		}

		if(tdtrilist[i]->v[2].x < minx)
		{
			minX[0] = i;
			minX[1] = 2;
			minx = tdtrilist[i]->v[2].x;
		} else if(tdtrilist[i]->v[2].x > maxx)
		{
			maxX[0] = i;
			maxX[1] = 2;
			maxx = tdtrilist[i]->v[2].x;
		}
		if(tdtrilist[i]->v[2].y < miny)
		{
			minY[0] = i;
			minY[1] = 2;
			miny = tdtrilist[i]->v[2].y;
		} else if(tdtrilist[i]->v[2].y > maxy)
		{
			maxY[0] = i;
			maxY[1] = 2;
			maxy = tdtrilist[i]->v[2].y;
		}
		if(tdtrilist[i]->v[2].z < minz)
		{
			minZ[0] = i;
			minZ[1] = 2;
			minz = tdtrilist[i]->v[2].z;
		} else if(tdtrilist[i]->v[2].z > maxz)
		{
			maxZ[0] = i;
			maxZ[1] = 2;
			maxz = tdtrilist[i]->v[2].z;
		}
		x = (int)(tdtrilist[i]->v[2].x/dX);
		z = (int)(tdtrilist[i]->v[2].z/dZ);
		vert_id[x + X*z]++;
		if(vert_id[x + X*z]==1)
		{
			center0 += tdtrilist[i]->v[1];
			point_count++;
		}
		
		if(tdtrilist[i]->v[1].x < minx)
		{
			minX[0] = i;
			minX[1] = 0;
			minx = tdtrilist[i]->v[1].x;
		} else if(tdtrilist[i]->v[1].x > maxx)
		{
			maxX[0] = i;
			maxX[1] = 1;
			maxx = tdtrilist[i]->v[1].x;
		}
		if(tdtrilist[i]->v[1].y < miny)
		{
			minY[0] = i;
			minY[1] = 1;
			miny = tdtrilist[i]->v[1].y;
		} else if(tdtrilist[i]->v[1].y > maxy)
		{
			maxY[0] = i;
			maxY[1] = 1;
			maxy = tdtrilist[i]->v[1].y;
		}
		if(tdtrilist[i]->v[1].z < minz)
		{
			minZ[0] = i;
			minZ[1] = 1;
			minz = tdtrilist[i]->v[1].z;
		} else if(tdtrilist[i]->v[1].z > maxz)
		{
			maxZ[0] = i;
			maxZ[1] = 1;
			maxz = tdtrilist[i]->v[1].z;
		}
		x = (int)(tdtrilist[i]->v[1].x/dX);
		z = (int)(tdtrilist[i]->v[1].z/dZ);
		vert_id[x + X*z]++;
		if(vert_id[x + X*z]==1)
		{
			center0 += tdtrilist[i]->v[2];
			point_count++;
		}
	}

	center0 *= 1.0f/point_count;
	center0.x = GetX(center0.x);
	center0.y += Offset;
	center0.z = GetZ(center0.z);

	center3 *= 1.0f/polygon_count;
	center3.x = GetX(center3.x);
	center3.y += Offset;
	center3.z = GetZ(center3.z);

	Vector3D v3;
	Scalar d[3];

	v3.Subtract(tdtrilist[maxX[0]]->v[maxX[1]], tdtrilist[minX[0]]->v[minX[1]]);
	d[0] = v3.GetLengthSquared();

	v3.Subtract(tdtrilist[maxY[0]]->v[maxY[1]], tdtrilist[minY[0]]->v[minY[1]]);
	d[1] = v3.GetLengthSquared();

	v3.Subtract(tdtrilist[maxZ[0]]->v[maxZ[1]], tdtrilist[minZ[0]]->v[minZ[1]]);
	d[2] = v3.GetLengthSquared();

	if(d[0] > d[1])
	{
		if(d[0]>d[2])
		{
			center1 = tdtrilist[maxX[0]]->v[maxX[1]];
			center1 += tdtrilist[minX[0]]->v[minX[1]];
			center1 *= 0.5f;
		}
		else
		{
			center1 = tdtrilist[maxZ[0]]->v[maxZ[1]];
			center1 += tdtrilist[minZ[0]]->v[minZ[1]];
			center1 *= 0.5f;
		}
	}
	else
	{
		if(d[1]>d[2])
		{
			center1 = tdtrilist[maxY[0]]->v[maxY[1]];
			center1 += tdtrilist[minY[0]]->v[minY[1]];
			center1 *= 0.5f;
		}
		else
		{
			center1 = tdtrilist[maxZ[0]]->v[maxZ[1]];
			center1 += tdtrilist[minZ[0]]->v[minZ[1]];
			center1 *= 0.5f;
		}
	}

	center1.x = GetX(center1.x);
	center1.y += Offset;
	center1.z = GetZ(center1.z);

	center2.x = GetX((maxx+minx)*0.5f);
	center2.y = (maxy+miny)*0.5f;
	center2.z = GetZ((maxz+minz)*0.5f);

	center2.y += Offset;

	Point3D *coords = new Point3D [point_count];
	Vector2DScalar *texCoords = new Vector2DScalar[point_count];
	
	UnitVector3D sun;
	sun = Vector3D(-1.0f, -1.0f, 0.0f);

    int nrOfPoints = 0;
	Scalar radiusSquared, 
		maxRadius0 = 0.0f,
		maxRadius1 = 0.0f,
		maxRadius2 = 0.0f,
		maxRadius3 = 0.0f;

	for(z=0;z<Z;z++)
		for(x=0;x<X;x++)
		{
			if( vert_id[x + X*z] > 0 )
			{
				Verify(nrOfPoints<point_count);
				vert_id[z*X+x] = nrOfPoints;

				Verify(GetX(x)<=uvFrame->maxX && GetX(x)>=uvFrame->minX);
				Verify(GetZ(z)<=uvFrame->maxZ && GetZ(z)>=uvFrame->minZ);

				coords[nrOfPoints].x = GetX(x);
				coords[nrOfPoints].y = GetHeight(x, z);
				coords[nrOfPoints].z = GetZ(z);

				v3.Subtract(coords[nrOfPoints], center0);

				radiusSquared = v3.GetLengthSquared();
				maxRadius0 = radiusSquared>maxRadius0 ? radiusSquared:maxRadius0;

				v3.Subtract(coords[nrOfPoints], center1);

				radiusSquared = v3.GetLengthSquared();
				maxRadius1 = radiusSquared>maxRadius1 ? radiusSquared:maxRadius1;

				v3.Subtract(coords[nrOfPoints], center2);

				radiusSquared = v3.GetLengthSquared();
				maxRadius2 = radiusSquared>maxRadius2 ? radiusSquared:maxRadius2;

				v3.Subtract(coords[nrOfPoints], center3);

				radiusSquared = v3.GetLengthSquared();
				maxRadius3 = radiusSquared>maxRadius3 ? radiusSquared:maxRadius3;

#ifndef TERRAIN2_TEST
				texCoords[nrOfPoints][0] = 
					borderPixelFun + (1.0f-2*borderPixelFun)*((uvFrame->maxX - coords[nrOfPoints].x)/(uvFrame->maxX-uvFrame->minX));
				texCoords[nrOfPoints][1] =
					borderPixelFun + (1.0f-2*borderPixelFun)*((uvFrame->maxZ - coords[nrOfPoints].z)/(uvFrame->maxZ-uvFrame->minZ));
#endif
				nrOfPoints++;
			}
			else
				vert_id[z*X+x] = -1;
		}

	maxRadius0 = static_cast<Scalar>(sqrt(maxRadius0));
	maxRadius1 = static_cast<Scalar>(sqrt(maxRadius1));
	maxRadius2 = static_cast<Scalar>(sqrt(maxRadius2));
	maxRadius3 = static_cast<Scalar>(sqrt(maxRadius3));

	if(maxRadius0<maxRadius1)
	{
		if(maxRadius0<maxRadius2)
		{
			if(maxRadius0<maxRadius3)
			{
				maxRadius = maxRadius0;
				center = center0;
			}
			else
			{
				maxRadius = maxRadius3;
				center = center3;
			}
		}
		else
		{
			if(maxRadius2<maxRadius3)
			{
				maxRadius = maxRadius2;
				center = center2;
			}
			else
			{
				maxRadius = maxRadius3;
				center = center3;
			}
		}
	}
	else
	{
		if(maxRadius1<maxRadius2)
		{
			if(maxRadius1<maxRadius3)
			{
				maxRadius = maxRadius1;
				center = center1;
			}
			else
			{
				maxRadius = maxRadius3;
				center = center3;
			}
		}
		else
		{
			if(maxRadius2<maxRadius3)
			{
				maxRadius = maxRadius2;
				center = center2;
			}
			else
			{
				maxRadius = maxRadius3;
				center = center3;
			}
		}
	}

	unsigned short	*index = new unsigned short [polygon_count*3];

	int k, l;

	for(i=0,l=0;i<polygon_count;i++)
	{
		k = 0;

		x = (int)(tdtrilist[i]->v[0].x/dX);
		z = (int)(tdtrilist[i]->v[0].z/dZ);
		j = x + X*z;
		Verify(vert_id[j]>=0);
		index[l++] = vert_id[j];

		if(z==Z-1)
			k++;

		x = (int)(tdtrilist[i]->v[2].x/dX);
		z = (int)(tdtrilist[i]->v[2].z/dZ);
		j = x + X*z;
		Verify(vert_id[j]>=0);
		index[l++] = vert_id[j];
		if(z==Z-1)
			k++;
		
		x = (int)(tdtrilist[i]->v[1].x/dX);
		z = (int)(tdtrilist[i]->v[1].z/dZ);
		j = x + X*z;
		Verify(vert_id[j]>=0);
		index[l++] = vert_id[j];
		if(z==Z-1)
			k++;

		if(k>=2)
		{
			j = 0;
		}

		if(
			index[l-3]==index[l-2] ||
			index[l-2]==index[l-1] ||
			index[l-1]==index[l-3]
		)
		{
			l-=3;
			continue;
		}

		Vector3D vCross;
		vCross.Cross(
			coords[index[l-1]],
			coords[index[l-2]],
			coords[index[l-3]]
		);

		if(Small_Enough(vCross) || vCross.y<=SMALL)
		{
			l-=3;
			continue;
		}
	}

	gos_PushCurrentHeap(MidLevelRenderer::Heap);
	erf_mesh->SetSubprimitiveLengths(NULL, l/3);

#ifdef _ARMOR
	for(i=0;i<nrOfPoints;i++)
	{
		for(j=0;j<8;j++)
		{
			Verify(coords[i].x>=erf_mesh->GetFrame(j, 0) && coords[i].x<=erf_mesh->GetFrame(j, 2) );
			Verify(coords[i].z>=erf_mesh->GetFrame(j, 1) && coords[i].z<=erf_mesh->GetFrame(j, 3) );
		}
	}
#endif

	erf_mesh->SetCoordData(coords, nrOfPoints);

#ifdef TERRAIN2_TEST
	erf_mesh->SetFrame(0, xOffset, zOffset, xOffset+8*xGridSize,  zOffset+8*zGridSize);
	erf_mesh->SetCurrentDepth(0);
#else
	erf_mesh->SetTexCoordData(texCoords, nrOfPoints);
#endif

	erf_mesh->SetIndexData(index, l);
	gos_PopCurrentHeap();
	erf_mesh->FindFacePlanes();

	delete [] coords;
	delete [] texCoords;
	delete [] index;


	return true;
}

int
	primCounter, maxPrims;

void
	HFSlimMZ0p3::OptimizeHField(int depth, int binSize)
{
	if(X*Z == 0)
	{
		return;
	}
	fprintf(stdout, "Going to optimize the terrain: MaxNr.Of Points: %d BinSize: %d\n", depth, binSize);

	tdtrilist.SetLength((X-1)*(Z-1));
	DirectMap<real> map(X,Z);

	int i, j;

	float maxY = 0;
	for(j=0;j<Z;j++)
		for(i=0;i<X;i++)
		{
			map.ref(i,j) = field[j*X + i];
		}
	Offset = 0.0;

	MASK = new ImportMask;
	MASK->width=X;
	MASK->height=Z;
	
	GreedySubdivision mesh(&map);
	point_limit=1024;

	point_limit = depth;

	triangleCounter = 0;
	int count=1;
	while(mesh.pointCount()<point_limit && mesh.maxError() > error_threshold)
	{
		mesh.greedyInsert();
	}
	fprintf(stdout, "The mesh was greedy.\n");

	mesh.overFaces(GetFacesCB, tdtrilist.GetData());
	for(i=0;i<triangleCounter;i++)
	{
		tdtrilist[i].v[0].y = Offset + static_cast<float>(dY*mesh.eval(
			(int)(tdtrilist[i].v[0].x),
			(int)(tdtrilist[i].v[0].z)
		));

		tdtrilist[i].v[1].y = Offset + static_cast<float>(dY*mesh.eval(
			(int)(tdtrilist[i].v[1].x),
			(int)(tdtrilist[i].v[1].z)
		));

		tdtrilist[i].v[2].y = Offset + static_cast<float>(dY*mesh.eval(
			(int)(tdtrilist[i].v[2].x),
			(int)(tdtrilist[i].v[2].z)
		));

		tdtrilist[i].v[0].x *= dX;
		tdtrilist[i].v[0].z *= dZ;

		tdtrilist[i].v[1].x *= dX;
		tdtrilist[i].v[1].z *= dZ;

		tdtrilist[i].v[2].x *= dX;
		tdtrilist[i].v[2].z *= dZ;

		tdtrilist[i].GetSurfaceAreaAndCentroid();
	}

	OptPolyCount = triangleCounter;

	if(triangleCounter == 0 || mesh.pointCount() == 0)
	{
		return;
	}

	toSortTriangles.SetLength(triangleCounter);

	for(i=0,j=0;i<triangleCounter;++i)
	{
		if(! (tdtrilist[i].plane.normal.y > Stuff::SMALL) )
		{
			STOP(("Danger Danger !"));
		}

/*
		if(	!(tdtrilist[i].GetV0().x==0.0f && tdtrilist[i].GetV0().z==GetZinM()) &&
			!(tdtrilist[i].GetV1().x==0.0f && tdtrilist[i].GetV1().z==GetZinM()) &&
			!(tdtrilist[i].GetV2().x==0.0f && tdtrilist[i].GetV2().z==GetZinM())
		)
*/
		{
			toSortTriangles[j++] = &tdtrilist[i];
		}
	}
	toSortTriangles.SetLength(j);

	fprintf(stdout, "optimized to %d triangles.\n", j);
}

int brokenTriangles;

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	AnalyzeThis(
		DynamicArrayOf<ToDrawTriangle*> &tempTrianglesPtr,
		Scalar x0,
		Scalar z0,
		Scalar x1,
		Scalar z1
	)
{
	int i, j, k, l, len = tempTrianglesPtr.GetLength();
	int divide = 2;
	Scalar x0n, z0n, x1n, z1n;

	fprintf(analyzeFile, "%d	", len);

	int in, out;

	for(i=0;i<divide;i++)
	{
		for(j=0;j<divide;j++)
		{
			x0n = x0 + j*(x1-x0)/divide;
			x1n = x0 + (j+1)*(x1-x0)/divide;
			z0n = z0 + i*(z1-z0)/divide;
			z1n = z0 + (i+1)*(z1-z0)/divide;

			in = 0;
			out = 0;
			for(k=0;k<len;k++)
			{
				l = 0;
				if(	tempTrianglesPtr[k]->GetV0().x >= x0n && tempTrianglesPtr[k]->GetV0().x <= x1n &&
					tempTrianglesPtr[k]->GetV0().z >= z0n && tempTrianglesPtr[k]->GetV0().z < z1n
					)
				{
					l++;
				}
				if(	tempTrianglesPtr[k]->GetV1().x >= x0n && tempTrianglesPtr[k]->GetV1().x <= x1n &&
					tempTrianglesPtr[k]->GetV1().z >= z0n && tempTrianglesPtr[k]->GetV1().z <= z1n
					)
				{
					l++;
				}
				if(	tempTrianglesPtr[k]->GetV2().x >= x0n && tempTrianglesPtr[k]->GetV2().x <= x1n &&
					tempTrianglesPtr[k]->GetV2().z >= z0n && tempTrianglesPtr[k]->GetV2().z <= z1n
					)
				{
					l++;
				}

				if(l==3)
				{
					in++;
				}
				else if(l>0)
				{
					if(	tempTrianglesPtr[k]->center.x >= x0n && tempTrianglesPtr[k]->center.x <= x1n &&
						tempTrianglesPtr[k]->center.z >= z0n && tempTrianglesPtr[k]->center.z <= z1n
						)
					{
						out++;
					}
				}
			}

			fprintf(analyzeFile, "%d	%d	", in, out);

		}
	}

	
	fprintf(analyzeFile, "\n");
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
bool
	HFSlimMZ0p3::BuildTile(
		MLR_Terrain2 *erf_mesh,
		DynamicArrayOf<unsigned char>& onOffPoints,
		int maxNumOfTrianglesPerMesh,
		Scalar x0,
		Scalar z0,
		Scalar x1,
		Scalar z1
	)
{
	int numOfTriangles = toSortTriangles.GetLength();

	DynamicArrayOf<ToDrawTriangle*> tempTrianglesPtr(numOfTriangles);
	DynamicArrayOf<ToDrawTriangle> tempTriangles(numOfTriangles);

	int i, j, inCount, newCount = 0, extraTriangles = 0;
	int k, l, m;

	for(i=0,j=0;i<numOfTriangles;j+=3,++i)
	{
		Verify(i<numOfTriangles);
		Verify(j<3*numOfTriangles);
		if(onOffPoints[i] == 0)
		{
			inCount = 0;
			int clipIt[3] = {0, 0, 0}, orIt = 0, addIt = 0xf;

			if(toSortTriangles[i]->GetV0().x < x0)
			{
				clipIt[0] |= 1;
			}
			if(toSortTriangles[i]->GetV0().x > x1)
			{
				clipIt[0] |= 4;
			}
			if(toSortTriangles[i]->GetV0().z < z0)
			{
				clipIt[0] |= 8;
			}
			if(toSortTriangles[i]->GetV0().z > z1)
			{
				clipIt[0] |= 2;
			}

			orIt |= clipIt[0];
			addIt &= clipIt[0];

			if(toSortTriangles[i]->GetV1().x < x0)
			{
				clipIt[1] |= 1;
			}
			if(toSortTriangles[i]->GetV1().x > x1)
			{
				clipIt[1] |= 4;
			}
			if(toSortTriangles[i]->GetV1().z < z0)
			{
				clipIt[1] |= 8;
			}
			if(toSortTriangles[i]->GetV1().z > z1)
			{
				clipIt[1] |= 2;
			}

			orIt |= clipIt[1];
			addIt &= clipIt[1];

			if(toSortTriangles[i]->GetV2().x < x0)
			{
				clipIt[2] |= 1;
			}
			if(toSortTriangles[i]->GetV2().x > x1)
			{
				clipIt[2] |= 4;
			}
			if(toSortTriangles[i]->GetV2().z < z0)
			{
				clipIt[2] |= 8;
			}
			if(toSortTriangles[i]->GetV2().z > z1)
			{
				clipIt[2] |= 2;
			}

			orIt |= clipIt[2];
			addIt &= clipIt[2];

			if(orIt == 0)
			{
				onOffPoints[i] = 1;

				if(toSortTriangles[i]->area > SMALL)
				{
					if(! (toSortTriangles[i]->plane.normal.y > Stuff::SMALL) )
					{
						STOP(("Danger Danger !"));
					}
					tempTrianglesPtr[newCount++] = toSortTriangles[i];
				}
			}
			else if(addIt==0)
			{
				if(orIt==1 || orIt==2 || orIt==4 || orIt==8)
				{
					Point3D triangle[3], clipPoints[6];

					triangle[0].x = toSortTriangles[i]->GetV0().x;
					triangle[0].y = toSortTriangles[i]->GetV0().y;
					triangle[0].z = toSortTriangles[i]->GetV0().z;

					triangle[1].x = toSortTriangles[i]->GetV1().x;
					triangle[1].y = toSortTriangles[i]->GetV1().y;
					triangle[1].z = toSortTriangles[i]->GetV1().z;

					triangle[2].x = toSortTriangles[i]->GetV2().x;
					triangle[2].y = toSortTriangles[i]->GetV2().y;
					triangle[2].z = toSortTriangles[i]->GetV2().z;

					l = 0;
					for(k=0;k<3;k++)
					{
						int next = k+1>2?0:k+1;
						if(clipIt[k]==0)
						{
							clipPoints[l++] = triangle[k];
							if(clipIt[next]==0)
							{
								continue;
							}
						}
						else
						{
							if(clipIt[next]!=0)
							{
								continue;
							}
						}
						//
						//-----------------------------------------------------
						// Find the boundary conditions that match our clipping
						// plane
						//-----------------------------------------------------
						//
						int mask = 1;
						for (m=0; m<4; m++)
						{
							if((clipIt[k] | clipIt[next]) & mask)
							{
								switch(m)
								{
									case 0:
										clipPoints[l].AddScaled(
											triangle[k],
											Vector3D(
												triangle[next].x - triangle[k].x,
												triangle[next].y - triangle[k].y,
												triangle[next].z - triangle[k].z
											),
											(x0-triangle[k].x)/(triangle[next].x-triangle[k].x)
										
										);
										clipPoints[l++].x = x0;
									break;
									case 1:
										clipPoints[l].AddScaled(
											triangle[k],
											Vector3D(
												triangle[next].x - triangle[k].x,
												triangle[next].y - triangle[k].y,
												triangle[next].z - triangle[k].z
											),
											(z1-triangle[k].z)/(triangle[next].z-triangle[k].z)
										);
										clipPoints[l++].z = z1;
									break;
									case 2:
										clipPoints[l].AddScaled(
											triangle[k],
											Vector3D(
												triangle[next].x - triangle[k].x,
												triangle[next].y - triangle[k].y,
												triangle[next].z - triangle[k].z
											),
											(x1-triangle[k].x)/(triangle[next].x-triangle[k].x)
										);
										clipPoints[l++].x = x1;
									break;
									case 3:
										clipPoints[l].AddScaled(
											triangle[k],
											Vector3D(
												triangle[next].x - triangle[k].x,
												triangle[next].y - triangle[k].y,
												triangle[next].z - triangle[k].z
											),
											(z0-triangle[k].z)/(triangle[next].z-triangle[k].z)
										);
										clipPoints[l++].z = z0;
									break;
								}
								break;
							}
							mask <<= 1;
						}
					}
					Verify(l>2);
					for(m=1;m<l-1;m++)
					{
						tempTriangles[extraTriangles].SetPoint(0, clipPoints[0].x, clipPoints[0].y, clipPoints[0].z);
						tempTriangles[extraTriangles].SetPoint(1, clipPoints[m].x, clipPoints[m].y, clipPoints[m].z);
						tempTriangles[extraTriangles].SetPoint(2, clipPoints[m+1].x, clipPoints[m+1].y, clipPoints[m+1].z);

						tempTriangles[extraTriangles].GetSurfaceAreaAndCentroid();

						if(tempTriangles[extraTriangles].area > SMALL)
						{
							if(! (tempTriangles[extraTriangles].plane.normal.y > Stuff::SMALL) )
							{
								STOP(("Danger Danger !"));
							}

							tempTrianglesPtr[newCount++] = &tempTriangles[extraTriangles];
							extraTriangles++;
						}
					}
				}
				else
				{

					int key=0, len[2] = {0, 0};
					Point3D clipPoints[2][6];
					int clipMeToo[2][6];

					clipPoints[key][0].x = toSortTriangles[i]->GetV0().x;
					clipPoints[key][0].y = toSortTriangles[i]->GetV0().y;
					clipPoints[key][0].z = toSortTriangles[i]->GetV0().z;

					clipPoints[key][1].x = toSortTriangles[i]->GetV1().x;
					clipPoints[key][1].y = toSortTriangles[i]->GetV1().y;
					clipPoints[key][1].z = toSortTriangles[i]->GetV1().z;

					clipPoints[key][2].x = toSortTriangles[i]->GetV2().x;
					clipPoints[key][2].y = toSortTriangles[i]->GetV2().y;
					clipPoints[key][2].z = toSortTriangles[i]->GetV2().z;

					clipMeToo[key][0] = clipIt[0];
					clipMeToo[key][1] = clipIt[1];
					clipMeToo[key][2] = clipIt[2];
					
					len[key] = 3;

 					int next, mask = 1;
					for(m=0;m<4;++m)
					{
						if(orIt & mask)
						{
							for(k=0;k<len[key];k++)
							{
								next = (k+1) < len[key] ? k+1 : 0;
					
								if(!(clipMeToo[key][k] & mask))
								{
									clipPoints[!key][len[!key]++] = clipPoints[key][k];
									if(!(clipMeToo[key][next] & mask))
									{
										continue;
									}
								}
								else
								{
									if(clipMeToo[key][next] & mask)
									{
										continue;
									}
								}

								switch(m)
								{
									case 0:
										clipPoints[!key][len[!key]].AddScaled(
											clipPoints[key][k],
											Vector3D(
												clipPoints[key][next].x - clipPoints[key][k].x,
												clipPoints[key][next].y - clipPoints[key][k].y,
												clipPoints[key][next].z - clipPoints[key][k].z
											),
											(x0-clipPoints[key][k].x)/(clipPoints[key][next].x-clipPoints[key][k].x)
										);
										clipPoints[!key][len[!key]++].x = x0;
									break;
									case 1:
										clipPoints[!key][len[!key]].AddScaled(
											clipPoints[key][k],
											Vector3D(
												clipPoints[key][next].x - clipPoints[key][k].x,
												clipPoints[key][next].y - clipPoints[key][k].y,
												clipPoints[key][next].z - clipPoints[key][k].z
											),
											(z1-clipPoints[key][k].z)/(clipPoints[key][next].z-clipPoints[key][k].z)
										);
										clipPoints[!key][len[!key]++].z = z1;
									break;
									case 2:
										clipPoints[!key][len[!key]].AddScaled(
											clipPoints[key][k],
											Vector3D(
												clipPoints[key][next].x - clipPoints[key][k].x,
												clipPoints[key][next].y - clipPoints[key][k].y,
												clipPoints[key][next].z - clipPoints[key][k].z
											),
											(x1-clipPoints[key][k].x)/(clipPoints[key][next].x-clipPoints[key][k].x)
										);
										clipPoints[!key][len[!key]++].x = x1;
									break;
									case 3:
										clipPoints[!key][len[!key]].AddScaled(
											clipPoints[key][k],
											Vector3D(
												clipPoints[key][next].x - clipPoints[key][k].x,
												clipPoints[key][next].y - clipPoints[key][k].y,
												clipPoints[key][next].z - clipPoints[key][k].z
											),
											(z0-clipPoints[key][k].z)/(clipPoints[key][next].z-clipPoints[key][k].z)
										);
										clipPoints[!key][len[!key]++].z = z0;
									break;
								}
							}
							key = !key;
							for(k=0;k<len[key];k++)
							{
								clipMeToo[key][k] = 0;
								if(clipPoints[key][k].x < x0)
								{
									clipMeToo[key][k] |= 1;
								}
								if(clipPoints[key][k].x > x1)
								{
									clipMeToo[key][k] |= 4;
								}
								if(clipPoints[key][k].z < z0)
								{
									clipMeToo[key][k] |= 8;
								}
								if(clipPoints[key][k].z > z1)
								{
									clipMeToo[key][k] |= 2;
								}
							}
							len[!key] = 0;
						}
						mask <<= 1;
					}

					for(m=1;m<len[key]-1;m++)
					{
						tempTriangles[extraTriangles].SetPoint(0, 
							clipPoints[key][0].x, 
							clipPoints[key][0].y, 
							clipPoints[key][0].z
						);
						tempTriangles[extraTriangles].SetPoint(1, 
							clipPoints[key][m].x, 
							clipPoints[key][m].y, 
							clipPoints[key][m].z
						);
						tempTriangles[extraTriangles].SetPoint(2, 
							clipPoints[key][m+1].x, 
							clipPoints[key][m+1].y, 
							clipPoints[key][m+1].z
						);

						tempTriangles[extraTriangles].GetSurfaceAreaAndCentroid();


						if(tempTriangles[extraTriangles].area > SMALL)
						{
							if(! (tempTriangles[extraTriangles].plane.normal.y > Stuff::SMALL) )
							{
								STOP(("Danger Danger !"));
							}
							tempTrianglesPtr[newCount++] = &tempTriangles[extraTriangles];
							extraTriangles++;
						}
					}
				}
			}
		}
	}
//	tempTriangles.SetLength(extraTriangles);
	tempTrianglesPtr.SetLength(newCount);

#if _ARMOR
	for(i=0,j=0;i<newCount;++i)
	{
		if(onOffPoints[i] == 0)
		{
			Verify(tempTrianglesPtr[i]->GetV0().x >= x0);
			Verify(tempTrianglesPtr[i]->GetV0().x <= x1);
			Verify(tempTrianglesPtr[i]->GetV0().z >= z0);
			Verify(tempTrianglesPtr[i]->GetV0().z <= z1);

			Verify(tempTrianglesPtr[i]->GetV1().x >= x0);
			Verify(tempTrianglesPtr[i]->GetV1().x <= x1);
			Verify(tempTrianglesPtr[i]->GetV1().z >= z0);
			Verify(tempTrianglesPtr[i]->GetV1().z <= z1);

			Verify(tempTrianglesPtr[i]->GetV2().x >= x0);
			Verify(tempTrianglesPtr[i]->GetV2().x <= x1);
			Verify(tempTrianglesPtr[i]->GetV2().z >= z0);
			Verify(tempTrianglesPtr[i]->GetV2().z <= z1);
		}
	}
#endif

	MLR_Terrain2 *ret_mesh = NULL;

	if(newCount > 0)
	{
		AnalyzeThis(
			tempTrianglesPtr,
			x0,
			z0,
			x1,
			z1
			);

		Stuff::ExtentBox box;
		box.minX = x0;
		box.maxX = x1;
		box.minY = Offset;
		box.maxY = Offset+256.0f;
		box.minZ = z0;
		box.maxZ = z1;

		if(!CreateMesh(erf_mesh, tempTrianglesPtr, &box))
		{
			PAUSE(("Unstable triangle mesh created!"));
		}
		else
		{
			brokenTriangles += newCount;
		}
	}
	else
	{
		STOP(("Danger Danger !"));
	}

	tempTrianglesPtr.SetLength(0);

	return true;
}


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
bool
	HFSlimMZ0p3::SetMegaTexture(
		int nrOfLevels,
		int bucketSize,
		const char *theName
	)
{
	static char megaBaseName[1024];


	if(detailInfo.name)
	{
/*
		state1.SetBackFaceOn();
		state1.SetDitherOff();
		state1.SetTextureCorrectionOn();
		state1.SetZBufferCompareOn();
		state1.SetZBufferWriteOff();


		state1.SetFilterMode(MLRState::BiLinearFilterMode);

		state1.SetFogMode(MLRState::DisableFogMode);
		state1.SetFogData(
			0xff000000,
			0.0f,
			90.0f,
			100.0f
		);
*/
		state1.SetTextureWrapMode(MLRState::TextureWrap);
		state1.SetAlphaMode(detailInfo.alphaMode);
		state1.SetPriority(MLRState::AlphaPriority);
		MLRTexture *texture = MLRTexturePool::Instance->Add(detailInfo.name);
		state1.SetTextureHandle(texture->GetTextureHandle());
	}

	DynamicArrayOf<unsigned char> onOffTriangles;
	onOffTriangles.AssignValue(0, toSortTriangles.GetLength());

	int i, j, k, l, m, n;
	simpleTerrainGroup.SetLength(xDim*zDim);

	Stuff::ExtentBox allBox;
	allBox = GetExtents();

	int len = 1<<nrOfLevels;

	xGridSize = (allBox.maxX-allBox.minX)/(len*xDim);
	zGridSize = (allBox.maxZ-allBox.minZ)/(len*zDim);

	for(l=0;l<zDim;l++)
	{
		for(k=0;k<xDim;k++)
		{
			brokenTriangles = 0;

			sprintf(megaBaseName, "Maps\\%s\\%c%c\\%s_%c%c", theName, 'A'+l, 'A'+k, theName, 'A'+l, 'A'+k);
			
			xOffset = k*dX*256;
			zOffset = l*dZ*256;
			gos_PushCurrentHeap(ElementRenderer::Heap);
			simpleTerrainGroup[l*xDim+k] = new GridElement(len, len, zOffset, xOffset, dZ*256, dX*256);
			Register_Object(simpleTerrainGroup[l*xDim+k]);
			simpleTerrainGroup[l*xDim+k]->SetName("OptimizedTerrain");
			gos_PopCurrentHeap();


			for(j=0;j<len;j++)
			{
				for(i=0;i<len;i++)
				{
					tX = i;
					tY = j;

					gos_PushCurrentHeap(ElementRenderer::Heap);
					ElementRenderer::GroupElement *group = new GroupElement;
					Register_Object(group);

					simpleTerrainGroup[l*xDim+k]->AttachIndexedChild(j, i, group);

					group->NeedNewBounds();
					group->SetVolumeCullMode();
					ElementRenderer::ListElement *subList = new ListElement;
					Register_Object(subList);
					subList->SetSize(4);
					group->AttachChild(subList);
					subList->NeedNewBounds();
					subList->SetVolumeCullMode();
					gos_PopCurrentHeap();

					for(n=0;n<2;n++)
					{
						for(m=0;m<2;m++)
						{
							MLRState state;


						/*
							state.SetBackFaceOn();
							state.SetDitherOff();
							state.SetTextureCorrectionOn();
							state.SetZBufferCompareOn();
							state.SetZBufferWriteOn();

							state.SetFilterMode(MLRState::BiLinearFilterMode);

							state.SetFogMode(MLRState::OverrideFogMode);
							state.SetFogData(
								0xff9090f0,
								0.0f,
								700.0f,
								1000.0f
							);
						*/
							char textureName[1024];

							state.SetPriority(MLRState::DefaultPriority);

#if 0
							sprintf(textureName, "%s_%1d_%02x%02x", 
								megaBaseName,
								depth,
								(1<<depth) - tileX/(1<<(maxdepth-depth)) - 1,
								(1<<depth) - tileZ/(1<<(maxdepth-depth)) - 1
							);
#else
							sprintf(textureName, "%s_0_0000", megaBaseName);
#endif

							MLRTexture *texture = MLRTexturePool::Instance->Add(textureName);
							texture->SetHint(gosHint_AGPMemory | gosHint_DontShrink);
							state.SetTextureHandle(texture->GetTextureHandle());
							state.SetTextureWrapMode(MLRState::TextureClamp);

							gos_PushCurrentHeap(MidLevelRenderer::Heap);
							MLR_Terrain2 *erf_mesh = new MLR_Terrain2;
							gos_PopCurrentHeap();

							erf_mesh->SetReferenceState(state);
							erf_mesh->SetReferenceState(state1, 1);

							erf_mesh->SetLevelTexture(0, texture->GetTextureHandle());

							Scalar x0, z0, x1, z1;

							if(i<len/2)
							{
								x0 = xOffset;
								x1 = xOffset + (len/2)*xGridSize;
							}
							else
							{
								x0 = xOffset + (len/2)*xGridSize;
								x1 = xOffset + len*xGridSize;
							}
							if(j<len/2)
							{
								z0 = zOffset;
								z1 = zOffset + (len/2)*zGridSize;
							}
							else
							{
								z0 = zOffset + (len/2)*zGridSize;
								z1 = zOffset + len*zGridSize;
							}
							erf_mesh->SetFrame(1, x0, z0, x1, z1);

							x0 = xOffset + i*xGridSize;
							z0 = zOffset + j*zGridSize;
							x1 = x0 + xGridSize;
							z1 = z0 + zGridSize;

							erf_mesh->SetFrame(0, xOffset, zOffset, xOffset+len*xGridSize,  zOffset+len*zGridSize);
	
							erf_mesh->SetFrame(2, x0, z0, x1, z1);
							erf_mesh->SetFrame(3, x0, z0, x1, z1);
							erf_mesh->SetFrame(4, x0, z0, x1, z1);
							erf_mesh->SetFrame(5, x0, z0, x1, z1);
							erf_mesh->SetFrame(6, x0, z0, x1, z1);
							erf_mesh->SetFrame(7, x0, z0, x1, z1);

							erf_mesh->SetDepthData(maxAllDepth, maxAllDepth);
							erf_mesh->SetTileData(tX, tY);
							erf_mesh->SetBorderPixel(borderPixelFun);

							Register_Object(erf_mesh);

							erf_mesh->SetDetailData(
								detailInfo.xOff,
								detailInfo.zOff,
								detailInfo.xFac,
								detailInfo.zFac,
								detailInfo.dStart,
								detailInfo.dEnd
							);

							x0 = xOffset + i*xGridSize + m*xGridSize/2.0f;
							z0 = zOffset + j*zGridSize + n*xGridSize/2.0f;
							x1 = x0 + xGridSize/2.0f;
							z1 = z0 + zGridSize/2.0f;

							BuildTile(erf_mesh, onOffTriangles, bucketSize, x0, z0, x1, z1);


							gos_PushCurrentHeap(ElementRenderer::Heap);
							ShapeElement* Shape = new ShapeElement;
							Register_Object(Shape);
							gos_PopCurrentHeap();

							gos_PushCurrentHeap(MidLevelRenderer::Heap);
							MLRShape *shape = new MLRShape(1);
							Register_Object(shape);
							gos_PopCurrentHeap();

							shape->Add(erf_mesh);
							erf_mesh->DetachReference();

							Shape->SetMLRShape(shape);

							Shape->m_localOBB.localToParent = LinearMatrix4D::Identity;
							Shape->m_localOBB.localToParent.BuildTranslation(center);
							
							Shape->m_localOBB.sphereRadius = maxRadius;
							subList->AttachIndexedChild(2*n+m, Shape);
							Shape->SetVolumeCullMode();


						}
					}

					group->Sync();
					group->LockBounds();
					group->SetNeverCullMode();
					subList->LockBounds();
					subList->SetNeverCullMode();
				}
			}

			simpleTerrainGroup[l*xDim+k]->LockBounds();


			fprintf(stdout, "\"broken\" triangles: %d\n", brokenTriangles);
		}
	}

	return true;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
Scalar
	HFSlimMZ0p3::GetHeight(int x, int z)
{
	if (x<0) x = 0;
	if (x>GetX()-1)
	{
		x = GetX() - 1;
	}
	if (z<0) z = 0;
	if (z>GetZ()-1)
	{
		z = GetZ() - 1;
	}
	return field[z*X + x]*dY + Offset;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void ToDrawTriangle::SetPoint(int idx,float x,float y,float z)
{
	Verify(idx>=0 && idx<3);

	v[idx].x=x;
	v[idx].y=y;
	v[idx].z=z;
}