#pragma once
#include "Greeble.h"
#include "intrin.h"
#ifdef EXTRACODE
#include "greebledata.h"
#else
#include "greeblearrays.h"
#endif
#include "globals.h"

Greeble g_Greeble;

float Greeble::GetFloatParam( int iBank, int iOffset )
{
	return g_GreebleParam[ iBank * 4 + iOffset ];
}

void Greeble::AddToScene( float fCurTime, int iObject, int iObjDesc )
{
	iObjID= iObject;
	pObj= g_GreebleObj + iObjDesc;
	fTime= fCurTime;
	PrepMesh();
}

void Greeble::CreateFloatFieldPlasma( int ParamBank, float* pFloat, float fStepX, int iStepsX, float fStepY, int iStepsY, float fTime )
{
	const float fAmplifyX= GetFloatParam( ParamBank, 0 );
	const float fAmplifyY= GetFloatParam( ParamBank, 1 );
	const float fBaseValue= GetFloatParam( ParamBank, 2 );

	const float fStretchAmplify= GetFloatParam( ParamBank, 3 );

	const float fStretchX=	GetFloatParam( ParamBank + 1, 0 );
	const float fStretchX2=	GetFloatParam( ParamBank + 1, 1 );
	const float fSpeedX=	GetFloatParam( ParamBank + 1, 2 );
	const float fSpeedX2=	GetFloatParam( ParamBank + 1, 3 );

	const float fStretchY=	GetFloatParam( ParamBank + 2, 0 );
	const float fStretchY2=	GetFloatParam( ParamBank + 2, 1 );
	const float fSpeedY=	GetFloatParam( ParamBank + 2, 2 );
	const float fSpeedY2=	GetFloatParam( ParamBank + 2, 3 );

	const float fStartX= 0.0f;
	const float fStartY= 0.0f;

	float fY= fStartY;
	for( int iY= 0; iY < iStepsY; ++iY, fY+= fStepY )
	{
		float fX= fStartX;
		for( int iX= 0; iX < iStepsX; ++iX, fX+= fStepX )
		{
			float fVal= fBaseValue +
				fAmplifyX * sin(	fX * fStretchX + 
				fSpeedX * fTime + 
				fStretchAmplify * sin( fStretchX2 * fY + fTime * fSpeedX2 ) ) + 
				fAmplifyY * sin(	fY * fStretchY + 
				fSpeedY * fTime + 
				fStretchAmplify * sin( fStretchY2 * fX + fTime * fSpeedY2 ) );

			int iOffset= iY * iStepsX + iX;
			pFloat[ iOffset ]= fVal;
		}
	}
}

void Greeble::CreateTwistedBow( int ParamBank, float* pFloat, float fStepX, int iStepsX, float fStepY, int iStepsY, float fTime )
{
	const float fStrength= GetFloatParam( ParamBank, 0 );
	const float fAmpliHorz= GetFloatParam( ParamBank, 1 );
	const float fRepHorz= GetFloatParam( ParamBank, 2 );
	const float fSpeedHorz= GetFloatParam( ParamBank, 3 );

	const float fTwistVert= GetFloatParam( ParamBank + 1, 0 );
	const float fAmpliVert= GetFloatParam( ParamBank + 1, 1 );
	const float fRepVert= GetFloatParam( ParamBank + 1, 2 );
	const float fSpeedVert= GetFloatParam( ParamBank + 1, 3 );

	const float fStartX= 0.0f;
	const float fStartY= 0.0f;

	float fY= fStartY;
	for( int iY= 0; iY < iStepsY; ++iY, fY+= fStepY )
	{
		float fX= fStartX;
		for( int iX= 0; iX < iStepsX; ++iX, fX+= fStepX )
		{
			float fBow= sin( 0.5f * fY );
			float fVal= fStrength + 
				fAmpliHorz * sin( fSpeedHorz * fTime + fRepHorz * fY ) +
				fAmpliVert * sin( fSpeedVert * fTime + fRepVert * fX + fTwistVert * fY );

			fVal*= fBow;

			int iOffset= iY * iStepsX + iX;
			pFloat[ iOffset ]= fVal;
		}
	}
}

void Greeble::Create3DMeshPlane( float* pFloat, float fStartX, float fStepX, int iStepsX, float fStartY, float fStepY, int iStepsY )
{
	float fY= fStartY;
	for( int iY= 0; iY < iStepsY; ++iY, fY+= fStepY )
	{
		float fX= fStartX;
		for( int iX= 0; iX < iStepsX; ++iX, fX+= fStepX )
		{
			int iOffset= iY * iStepsX + iX;
			PreMesh[ iOffset ].Pos().x= fX;
			PreMesh[ iOffset ].Pos().y= pFloat[ iOffset ];
			PreMesh[ iOffset ].Pos().z= fY;
		}
	}
}

void Greeble::Create3DMeshCylinder( float* pFloat, float fBaseRadiusX, float fBaseRadiusZ, int iStepsX, float fStartY, float fStepY, int iStepsY )
{
	const float fStepX= c_2PI / (float)( iStepsX - 1 );

	float fY= fStartY;
	for( int iY= 0; iY < iStepsY; ++iY, fY+= fStepY )
	{
		float fX= 0.0f;
		for( int iX= 0; iX < iStepsX; ++iX, fX+= fStepX )
		{
			int iOffset= iY * iStepsX + iX;
			float fR= pFloat[ iOffset ];
			PreMesh[ iOffset ].Pos().x= sin( fX ) * ( fR + fBaseRadiusX );
			PreMesh[ iOffset ].Pos().y= fY; 
			PreMesh[ iOffset ].Pos().z= cos( fX ) * ( fR + fBaseRadiusZ );
		}
	}
}

void Greeble::Create3DMeshSphere( float* pFloat, float fBaseRadiusX, float fBaseRadiusY, float fBaseRadiusZ, int iStepsX, int iStepsY )
{
	const float fStepX= c_2PI / (float)( iStepsX - 1 );
	const float Length= c_PI - 0.01f;
	const float fStepY= Length / (float)( iStepsY - 1 );

	float fY= ( c_PI - Length )* 0.5f;
	for( int iY= 0; iY < iStepsY; ++iY, fY+= fStepY )
	{
		float SinY= sin( fY );
		float CosY= cos( fY );

		float fX= 0.0f;
		for( int iX= 0; iX < iStepsX; ++iX, fX+= fStepX )
		{
			int iOffset= iY * iStepsX + iX;
			float fR= pFloat[ iOffset ] * SinY;
			PreMesh[ iOffset ].Pos().x= SinY * sin( fX ) * ( fR + fBaseRadiusX );
			PreMesh[ iOffset ].Pos().y= CosY * ( fR + fBaseRadiusY ); 
			PreMesh[ iOffset ].Pos().z= SinY * cos( fX ) * ( fR + fBaseRadiusZ );
		}
	}
}

void Greeble::Create3DMeshTorus( float* pFloat, float fBaseRadiusX, float fBaseRadiusZ, float fInnerRadiusXZ, float fInnerRadiusY, int iStepsX, int iStepsY )
{
	const float fStepX= c_2PI / (float)( iStepsX - 1 );
	const float fStepY= c_2PI / (float)( iStepsY - 1 );

	float fY= 0.0f;
	for( int iY= 0; iY < iStepsY; ++iY, fY+= fStepY )
	{
		float SinY= sin( fY );
		float CosY= cos( fY );

		float fX= 0.0f;
		for( int iX= 0; iX < iStepsX; ++iX, fX+= fStepX )
		{
			int iOffset= iY * iStepsX + iX;
			float fR= pFloat[ iOffset ];
			float SinX= sin( fX );
			float CosX= cos( fX );

			PreMesh[ iOffset ].Pos().x= SinY * ( fBaseRadiusX + CosX * fInnerRadiusXZ + fR);
			PreMesh[ iOffset ].Pos().y= SinX * ( fInnerRadiusY + fR ); 
			PreMesh[ iOffset ].Pos().z= CosY * ( fBaseRadiusZ + CosX * fInnerRadiusXZ + fR );
		}
	}
}

void Greeble::CreateNormals( int iStepsX, int iStepsY )
{
	for( int iY= 0; iY < iStepsY; ++iY )
	{
		for( int iX= 0; iX < iStepsX; ++iX )
		{
			int iOffset= iY * iStepsX + iX;
			int iOffsetLeft= iY * iStepsX + ( iX + 1 ) % iStepsX;
			int iOffsetRight= iY * iStepsX + ( iX + iStepsX - 1 ) % iStepsX;
			int iOffsetBottom= ( ( iY + 1 ) % iStepsY ) * iStepsX + iX;
			int iOffsetTop= ( ( iY + iStepsY - 1 ) % iStepsY ) * iStepsX + iX;

			D3DXVECTOR3 vec3V( 
				PreMesh[ iOffsetLeft ].Pos() - PreMesh[ iOffsetRight ].Pos() );
			D3DXVECTOR3 vec3H( 
				PreMesh[ iOffsetTop ].Pos() - PreMesh[ iOffsetBottom ].Pos() );
			D3DXVec3Cross( &PreMesh[ iOffset ].Normal(), &vec3V, &vec3H );
			D3DXVec3Normalize( &PreMesh[ iOffset ].Normal(), &PreMesh[ iOffset ].Normal() );
		}
	}
}

void Greeble::CreateNormalsBreakXY( int iStepsX, int iStepsY )
{
	for( int iY= 0; iY < iStepsY; ++iY )
	{
		for( int iX= 0; iX < iStepsX; ++iX )
		{
			int iOffset= iY * iStepsX + iX;
			int iOffsetLeft= iY * iStepsX + ( iX + 1 ) % iStepsX;
			int iOffsetRight= iY * iStepsX + ( iX + iStepsX - 1 ) % iStepsX;
			int iOffsetBottom= ( ( iY + 1 ) % iStepsY ) * iStepsX + iX;
			int iOffsetTop= ( ( iY + iStepsY - 1 ) % iStepsY ) * iStepsX + iX;

			if( iX == 0 )
			{
				iOffsetRight= iOffset;
			}
			if( iX == iStepsX - 1 )
			{
				iOffsetLeft= iOffset;
			}
			if( iY == 0 )
			{
				iOffsetTop= iOffset;
			}
			if( iY == iStepsY - 1 )
			{
				iOffsetBottom= iOffset;
			}

			D3DXVECTOR3 vec3V( 
				PreMesh[ iOffsetLeft ].Pos() - PreMesh[ iOffsetRight ].Pos() );
			D3DXVECTOR3 vec3H( 
				PreMesh[ iOffsetTop ].Pos() - PreMesh[ iOffsetBottom ].Pos() );
			D3DXVec3Cross( &PreMesh[ iOffset ].Normal(), &vec3V, &vec3H );
			D3DXVec3Normalize( &PreMesh[ iOffset ].Normal(), &PreMesh[ iOffset ].Normal() );
		}
	}
}

void Greeble::CreateNormalsBreakX( int iStepsX, int iStepsY )
{
	for( int iY= 0; iY < iStepsY; ++iY )
	{
		for( int iX= 0; iX < iStepsX; ++iX )
		{
			int iOffset= iY * iStepsX + iX;
			int iOffsetLeft= iY * iStepsX + ( iX + 1 ) % iStepsX;
			int iOffsetRight= iY * iStepsX + ( iX + iStepsX - 1 ) % iStepsX;
			int iOffsetBottom= ( ( iY + 1 ) % iStepsY ) * iStepsX + iX;
			int iOffsetTop= ( ( iY + iStepsY - 1 ) % iStepsY ) * iStepsX + iX;

			if( iX == 0 )
			{
				iOffsetRight= iOffset;
			}
			if( iX == iStepsX - 1 )
			{
				iOffsetLeft= iOffset;
			}

			D3DXVECTOR3 vec3V( 
				PreMesh[ iOffsetLeft ].Pos() - PreMesh[ iOffsetRight ].Pos() );
			D3DXVECTOR3 vec3H( 
				PreMesh[ iOffsetTop ].Pos() - PreMesh[ iOffsetBottom ].Pos() );
			D3DXVec3Cross( &PreMesh[ iOffset ].Normal(), &vec3V, &vec3H );
			D3DXVec3Normalize( &PreMesh[ iOffset ].Normal(), &PreMesh[ iOffset ].Normal() );
		}
	}
}

void Greeble::CreateNormalsBreakY( int iStepsX, int iStepsY )
{
	for( int iY= 0; iY < iStepsY; ++iY )
	{
		for( int iX= 0; iX < iStepsX; ++iX )
		{
			int iOffset= iY * iStepsX + iX;
			int iOffsetLeft= iY * iStepsX + ( iX + 1 ) % iStepsX;
			int iOffsetRight= iY * iStepsX + ( iX + iStepsX - 1 ) % iStepsX;
			int iOffsetBottom= ( ( iY + 1 ) % iStepsY ) * iStepsX + iX;
			int iOffsetTop= ( ( iY + iStepsY - 1 ) % iStepsY ) * iStepsX + iX;

			if( iY == 0 )
			{
				iOffsetTop= iOffset;
			}
			if( iY == iStepsY - 1 )
			{
				iOffsetBottom= iOffset;
			}

			D3DXVECTOR3 vec3V( 
				PreMesh[ iOffsetLeft ].Pos() - PreMesh[ iOffsetRight ].Pos() );
			D3DXVECTOR3 vec3H( 
				PreMesh[ iOffsetTop ].Pos() - PreMesh[ iOffsetBottom ].Pos() );
			D3DXVec3Cross( &PreMesh[ iOffset ].Normal(), &vec3V, &vec3H );
			D3DXVec3Normalize( &PreMesh[ iOffset ].Normal(), &PreMesh[ iOffset ].Normal() );
		}
	}
}

void Greeble::PrepAO( int iStepsX, int iStepsY, float* pFloatHeight, float* pFloatCenterMix, float* pFloatAOVert, float* pFloatAOVHorz, float* pFloatAOIntermediate )
{
	const float fBase= 1.0f / 2.0f;
	for( int iY= 0; iY < iStepsY; ++iY )
	{
		for( int iX= 0; iX < iStepsX; ++iX )
		{
			int iOffset= iY * iStepsX + iX;
			float fHeight= pFloatHeight[ iOffset ];
			float fMix= pFloatCenterMix[ iOffset ];

			if( fHeight > 0.01f )
			{
				pFloatAOIntermediate[ iOffset ]= minimum( ( fMix ) * sqrt( fBase / fHeight ), 0.5f );
			}
			else
			{
				pFloatAOIntermediate[ iOffset ]= 0.5f;
			}
		}
	}
	for( int iY= 0; iY < iStepsY; ++iY )
	{
		for( int iX= 0; iX < iStepsX; ++iX )
		{
			int iOffset= iY * iStepsX + iX;
			int iOffsetRight= iY * iStepsX + ( iX + iStepsX - 1 ) % iStepsX;
			int iOffsetTop= ( ( iY + iStepsY - 1 ) % iStepsY ) * iStepsX + iX;

			pFloatAOVHorz[ iOffset ]= pFloatAOIntermediate[ iOffset ] + pFloatAOIntermediate[ iOffsetRight ];
			pFloatAOVert[ iOffset ]= pFloatAOIntermediate[ iOffset ] + pFloatAOIntermediate[ iOffsetTop ];
		}
	}
}

DWORD ShadeColor( DWORD dwBaseColor, float fShade )
{
	DWORD dwRGB[3]=
	{	
		( dwBaseColor & 0xff0000 ) >> 16, 
		( dwBaseColor & 0xff00 ) >> 8,
		( dwBaseColor & 0xff ) 
	};
	dwRGB[0]= (int)( (float)dwRGB[0] * fShade );
	dwRGB[1]= (int)( (float)dwRGB[1] * fShade );
	dwRGB[2]= (int)( (float)dwRGB[2] * fShade );
	return dwRGB[0] << 16 | dwRGB[1] << 8 | dwRGB[2] | ( 0xff000000 & dwBaseColor );
}

void Greeble::CreateFinal3DMesh( int iStepsX, int iStepsY, float* pFloatHeight, float* pFloatCenterMix, float* pFloatAOVert, float* pFloatAOVHorz, DWORD dwBaseColor )
{
	g_Objects[ iObjID ].Lock();
	const int QuadsPerStep= 5;
	for( int iY= 0; iY < iStepsY - 1; ++iY )
	{
		for( int iX= 0; iX < iStepsX - 1; ++iX )
		{
			int iOffsetVert[ 4 ]=
			{	
				iY * iStepsX + iX,
				iY * iStepsX + iX + 1,
				iY * iStepsX + iX + iStepsX + 1,
				iY * iStepsX + iX + iStepsX 
			};

			float fHeight= pFloatHeight[ iOffsetVert[ 0 ] ];
			float fMix= pFloatCenterMix[ iOffsetVert[ 0 ] ];

			D3DXVECTOR3 v[ 8 ]=
			{
				PreMesh[ iOffsetVert[ 0 ] ].Pos(),
				PreMesh[ iOffsetVert[ 1 ] ].Pos(),
				PreMesh[ iOffsetVert[ 2 ] ].Pos(),
				PreMesh[ iOffsetVert[ 3 ] ].Pos(),
				PreMesh[ iOffsetVert[ 0 ] ].Pos() + PreMesh[ iOffsetVert[ 0 ] ].Normal() * fHeight,
				PreMesh[ iOffsetVert[ 1 ] ].Pos() + PreMesh[ iOffsetVert[ 1 ] ].Normal() * fHeight,
				PreMesh[ iOffsetVert[ 2 ] ].Pos() + PreMesh[ iOffsetVert[ 2 ] ].Normal() * fHeight,
				PreMesh[ iOffsetVert[ 3 ] ].Pos() + PreMesh[ iOffsetVert[ 3 ] ].Normal() * fHeight,
			};


			D3DXVECTOR3 vCenter= 0.25f * ( v[4] + v[5] + v[6] + v[7] );

			D3DXVec3Lerp( &v[4], &v[4], &vCenter, fMix );
			D3DXVec3Lerp( &v[5], &v[5], &vCenter, fMix );
			D3DXVec3Lerp( &v[6], &v[6], &vCenter, fMix );
			D3DXVec3Lerp( &v[7], &v[7], &vCenter, fMix );

			D3DXVECTOR3 n[8]=
			{
				PreMesh[ iOffsetVert[ 0 ] ].Normal(),
				PreMesh[ iOffsetVert[ 1 ] ].Normal(),
				PreMesh[ iOffsetVert[ 2 ] ].Normal(),
				PreMesh[ iOffsetVert[ 3 ] ].Normal(),
			};
			{
				D3DXVECTOR3 v1= PreMesh[ iOffsetVert[ 1 ] ].Pos() - PreMesh[ iOffsetVert[ 0 ] ].Pos();
				D3DXVECTOR3 v2= v[4] - PreMesh[ iOffsetVert[ 0 ] ].Pos();
				D3DXVec3Cross( &n[4], &v2, &v1 );
				D3DXVec3Normalize( &n[4], &n[4] );
			}
			{
				D3DXVECTOR3 v1= PreMesh[ iOffsetVert[ 2 ] ].Pos() - PreMesh[ iOffsetVert[ 1 ] ].Pos();
				D3DXVECTOR3 v2= v[5] - PreMesh[ iOffsetVert[ 1 ] ].Pos();
				D3DXVec3Cross( &n[5], &v2, &v1 );
				D3DXVec3Normalize( &n[5], &n[5] );
			}
			{
				D3DXVECTOR3 v1= PreMesh[ iOffsetVert[ 3 ] ].Pos() - PreMesh[ iOffsetVert[ 2 ] ].Pos();
				D3DXVECTOR3 v2= v[6] - PreMesh[ iOffsetVert[ 2 ] ].Pos();
				D3DXVec3Cross( &n[6], &v2, &v1 );
				D3DXVec3Normalize( &n[6], &n[6] );
			}
			{
				D3DXVECTOR3 v1= PreMesh[ iOffsetVert[ 0 ] ].Pos() - PreMesh[ iOffsetVert[ 3 ] ].Pos();
				D3DXVECTOR3 v2= v[7] - PreMesh[ iOffsetVert[ 3 ] ].Pos();
				D3DXVec3Cross( &n[7], &v2, &v1 );
				D3DXVec3Normalize( &n[7], &n[7] );
			}


			/*int iFinalOffset= iY * ( iStepsX - 1 )+ iX;
			iFinalOffset*= VertsPerStep;*/

			float AOLeft= pFloatAOVHorz[ iOffsetVert[ 0 ] ];
			float AORight= pFloatAOVHorz[ iOffsetVert[ 1 ] ];
			float AOTop= pFloatAOVert[ iOffsetVert[ 0 ] ];
			float AOBottom= pFloatAOVert[ iOffsetVert[ 3 ] ];

			DWORD dwColor[ 5 ]= 
			{ 
				ShadeColor( dwBaseColor, 1.0f ),
				ShadeColor( dwBaseColor, AOTop ),
				ShadeColor( dwBaseColor, AORight ),
				ShadeColor( dwBaseColor, AOBottom ),
				ShadeColor( dwBaseColor, AOLeft ),
			};

			/*dwColor[ 1 ]= (int)( 255.4f * AOTop );
			dwColor[ 2 ]= (int)( 255.4f * AORight );
			dwColor[ 3 ]= (int)( 255.4f * AOBottom );
			dwColor[ 4 ]= (int)( 255.4f * AOLeft );

			dwColor[ 1 ]= dwColor[ 1 ] << 16 | dwColor[ 1 ] << 8 | dwColor[ 1 ] | 0xff000000;
			dwColor[ 2 ]= dwColor[ 2 ] << 16 | dwColor[ 2 ] << 8 | dwColor[ 2 ] | 0xff000000;
			dwColor[ 3 ]= dwColor[ 3 ] << 16 | dwColor[ 3 ] << 8 | dwColor[ 3 ] | 0xff000000;
			dwColor[ 4 ]= dwColor[ 4 ] << 16 | dwColor[ 4 ] << 8 | dwColor[ 4 ] | 0xff000000;*/

			int iQuadOffsets[]=
			{
				4,	0,	0,	// Deckel
				5,	1,	0,
				7,	3,	0,
				6,	2,	0,

				0,	4,	1,	// Flanke oben
				1,	4,	1,
				4,	4,	0,
				5,	4,	0,

				1,	5,	2,	// Flanke rechts
				2,	5,	2,
				5,	5,	0,
				6,	5,	0,

				2,	6,	3,	// Flanke unten
				3,	6,	3,
				6,	6,	0,
				7,	6,	0,

				3,	7,	4,	// Flanke links
				0,	7,	4,
				7,	7,	0,
				4,	7,	0,
			};

			for( int i= 0; i < QuadsPerStep * 4; ++i )
			{
				Renderjob::SVertex V;
				V.Pos()= v[ iQuadOffsets[ i * 3 ] ]; 
				V.Normal()= n[ iQuadOffsets[ i * 3 + 1 ] ];
				V.dwColor= dwColor[ iQuadOffsets[ i * 3 + 2 ] ];
				V.tu= 0.0f;
				V.tv= 0.0f;
				g_Objects[ iObjID ].AddVertex( V );
			}
		}
	}

	int iV= 0;
	for( int i= 0; i < QuadsPerStep * ( iStepsX - 1 ) * ( iStepsY - 1 ); ++i )
	{
		g_Objects[ iObjID ].AddIndex( iV + 2);
		g_Objects[ iObjID ].AddIndex( iV + 1);
		g_Objects[ iObjID ].AddIndex( iV + 0);
		
		g_Objects[ iObjID ].AddIndex( iV + 3);
		g_Objects[ iObjID ].AddIndex( iV + 1);
		g_Objects[ iObjID ].AddIndex( iV + 2);

		iV+= 4;
		assert( iV <= g_Objects[ iObjID ].GetVertCount() );
	}

	g_Objects[ iObjID ].Unlock();
}

void Greeble::Create2DFunc( int FuncType, int iParamBank, float* pFloat, int iSizeX, int iSizeY, float fTime )
{
	switch( FuncType )
	{
	case -1:
		{
			for( int i= 0; i < iSizeX * iSizeY; ++i )
			{
				pFloat[ i ]= 0.0f;
			}
		}
		break;
	case 0:
	case 1:
	case 2:
	case 3:
		{
			for( int i= 0; i < iSizeX * iSizeY; ++i )
			{
				pFloat[ i ]= GetFloatParam( iParamBank, FuncType );
			}
		}
		break;
	case 4:
		{
			const float fPiX= c_2PI / (float)( iSizeX - 1 );
			const float fPiY= c_2PI / (float)( iSizeY - 1 );

			CreateFloatFieldPlasma(
				iParamBank,	// ParamBank,
				pFloat,					// pFloat, 
				fPiX,					// fStepX
				iSizeX,					// iStepsX,
				fPiY,					// fStepY
				iSizeY,					// iStepsY
				fTime );
		}
		break;
	case 5:
		{
			const float fPiX= c_2PI / (float)( iSizeX - 1 );
			const float fPiY= c_2PI / (float)( iSizeY - 1 );

			CreateTwistedBow(
				iParamBank,	// ParamBank,
				pFloat,					// pFloat, 
				fPiX,					// fStepX
				iSizeX,					// iStepsX,
				fPiY,					// fStepY
				iSizeY,					// iStepsY
				fTime );
		}
		break;
	}
}

void Greeble::PrepMesh()
{
	const int iSizeX= pObj->m_iSizeX;
	const int iSizeY= pObj->m_iSizeY;

	Create2DFunc( 
		pObj->m_iOffsetFunc,
		pObj->m_iOffsetBank,
		PreFloats,
		iSizeX,
		iSizeY,
		fTime);

	/*const float fPiX= c_2PI / (float)( iSizeX - 1 );
	const float fPiY= c_2PI / (float)( iSizeY - 1 );

	CreateFloatFieldPlasma(
	pObj->m_iOffsetBank,	// ParamBank,
	PreFloats,				// pFloat, 
	fPiX,					// fStepX
	iSizeX,					// iStepsX,
	fPiY,					// fStepY
	iSizeY					// iStepsY
	);*/

	switch( pObj->m_iBaseMeshType )
	{
	case 0:
		{
			const float fPlaneSizeX= GetFloatParam( pObj->m_iBaseBank, 0 );
			const float fPlaneSizeY= GetFloatParam( pObj->m_iBaseBank, 1 );

			float fPlaneStepX= 2.0f * fPlaneSizeX / (float)( iSizeX - 1 );
			float fPlaneStepY= 2.0f * fPlaneSizeY / (float)( iSizeY - 1 );

			Create3DMeshPlane(
				PreFloats,		// pFloat, 
				-fPlaneSizeX,	// fStartX
				fPlaneStepX,	// fStepX
				iSizeX,			// iStepsX,
				-fPlaneSizeY,	// fStartY
				fPlaneStepY,	// fStepY
				iSizeY			// iStepsY
				);

			CreateNormalsBreakXY(
				iSizeX,
				iSizeY 
				);
		}
		break;
	case 1:
		{
			const float fBaseRadiusX= GetFloatParam( pObj->m_iBaseBank, 0 );
			const float fBaseRadiusZ= GetFloatParam( pObj->m_iBaseBank, 1 );
			const float fCylinderSizeY= GetFloatParam( pObj->m_iBaseBank, 2 );

			float fCylinderStepY= 2.0f * fCylinderSizeY / (float)( iSizeY - 1 );

			Create3DMeshCylinder(
				PreFloats,			// float* pFloat, 
				fBaseRadiusX,		// float fBaseRadiusX, 
				fBaseRadiusZ,		// float fBaseRadiusZ, 
				iSizeX,				// int iStepsX,
				-fCylinderSizeY,	// float fStartY, 
				fCylinderStepY,		// float fStepY, 
				iSizeY				// int iStepsY
				);
			CreateNormalsBreakY(
				iSizeX,
				iSizeY 
				);
		}
		break;
	case 2:
		{
			const float fBaseRadiusX= GetFloatParam( pObj->m_iBaseBank, 0 );
			const float fBaseRadiusY= GetFloatParam( pObj->m_iBaseBank, 1 );
			const float fBaseRadiusZ= GetFloatParam( pObj->m_iBaseBank, 2 );

			Create3DMeshSphere(
				PreFloats,			// float* pFloat, 
				fBaseRadiusX,		// fBaseRadiusX
				fBaseRadiusY,		// fBaseRadiusY
				fBaseRadiusZ,		// fBaseRadiusZ
				iSizeX,				// int iStepsX,
				iSizeY				// int iStepsY,
				);
			CreateNormalsBreakY(
				iSizeX,
				iSizeY 
				);
		}
		break;
	case 3:
		{
			Create3DMeshTorus(
				PreFloats,			// float* pFloat, 
				GetFloatParam( pObj->m_iBaseBank, 0 ),
				GetFloatParam( pObj->m_iBaseBank, 1 ),
				GetFloatParam( pObj->m_iBaseBank, 2 ),
				GetFloatParam( pObj->m_iBaseBank, 3 ),
				iSizeX,				// int iStepsX,
				iSizeY				// int iStepsY,
				);
			CreateNormals(
				iSizeX,
				iSizeY 
				);
		}
		break;
	}

	Create2DFunc( 
		pObj->m_iHeightFunc,
		pObj->m_iHeightBank,
		PreFloat(1),
		iSizeX,
		iSizeY,
		fTime );

	Create2DFunc( 
		pObj->m_iMixFunc,
		pObj->m_iMixBank,
		PreFloat(2),
		iSizeX,
		iSizeY,
		fTime );

	/*W
	CreateFloatFieldPlasma(
	pObj->m_iHeightBank,	// ParamBank,
	PreFloat(1),			// pFloat, 
	fPiX,					// fStepX
	iSizeX,					// iStepsX,
	fPiY,					// fStepY
	iSizeY					// iStepsY
	);

	CreateFloatFieldPlasma(
	pObj->m_iMixBank,		// ParamBank,
	PreFloat(2),			// pFloat, 
	fPiX,					// fStepX
	iSizeX,					// iStepsX,
	fPiY,					// fStepY
	iSizeY					// iStepsY
	);
	*/

	PrepAO(
		iSizeX,
		iSizeY ,
		PreFloat(1),	// pFloatHeight,
		PreFloat(2),	// pFloatCenterMix,
		PreFloat(3),		// pFloatAOVert,
		PreFloat(4),		// pFloatAOVHorz
		PreFloat(5)			// Intermediate
		);

	CreateFinal3DMesh(
		iSizeX,
		iSizeY ,
		PreFloat(1),	// pFloatHeight,
		PreFloat(2),	// pFloatCenterMix,
		PreFloat(3),		// pFloatAOVert,
		PreFloat(4),		// pFloatAOVHorz
		pObj->m_dwColor
		);
}

/*void Greeble::CreateInterpolationMatrix( D3DXMATRIX* pMat, int iBank, float fTime )
{
	D3DXVECTOR3 vecPos( 
		GetFloatParam( iBank, 0 ),
		GetFloatParam( iBank, 1 ),
		GetFloatParam( iBank, 2 ) );
	D3DXVECTOR3 vecPos2( 
		GetFloatParam( iBank + 1, 0 ),
		GetFloatParam( iBank + 1, 1 ),
		GetFloatParam( iBank + 1, 2 ) );
	D3DXVECTOR3 vecRot( 
		GetFloatParam( iBank + 2, 0 ),
		GetFloatParam( iBank + 2, 1 ),
		GetFloatParam( iBank + 2, 2 ) );
	D3DXVECTOR3 vecRot2( 
		GetFloatParam( iBank + 3, 0 ),
		GetFloatParam( iBank + 3, 1 ),
		GetFloatParam( iBank + 3, 2 ) );
	vecPos+= vecPos2 * fTime * GetFloatParam( iBank + 1, 3 );
	vecRot+= vecRot2 * fTime * GetFloatParam( iBank + 3, 3 );
	vecRot*= c_2PI;

	D3DXMATRIX matPos;
	D3DXMatrixTranslation( &matPos, vecPos.x, vecPos.y, vecPos.z );

	D3DXMATRIX matRot;
	D3DXMatrixRotationYawPitchRoll( &matRot, vecRot.x, vecRot.y, vecRot.z );

	*pMat= matRot * matPos;
}

void Greeble::RenderMesh( SObjectDescription* pObj, float fTime )
{
	g_d3d_device->SetRenderState( D3DRS_LIGHTING,       TRUE );

	g_d3d_device->SetLight( 0, &d3dLight[ 0 ] );
	g_d3d_device->LightEnable( 0, TRUE );
	g_d3d_device->SetLight( 1, &d3dLight[ 1 ] );
	g_d3d_device->LightEnable( 1, TRUE );
	g_d3d_device->SetLight( 2, &d3dLight[ 2 ] );
	g_d3d_device->LightEnable( 2, TRUE );


	g_d3d_device->SetRenderState( D3DRS_ZENABLE,		TRUE );

	g_d3d_device->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );
	g_d3d_device->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );

	g_d3d_device->SetRenderState( D3DRS_CULLMODE,  D3DCULL_CW );

	g_d3d_device->SetRenderState( D3DRS_TEXTUREFACTOR, pObj->m_dwColor );

	g_d3d_device->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE );
	g_d3d_device->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
	g_d3d_device->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TFACTOR );

	//g_d3d_device->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
	//g_d3d_device->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );


	D3DXMATRIX mat;

	float zf= 400.0f;
	float zn= 0.125f;
	float xScale = 1.0f;
	float yScale= xScale / (float)c_iScreenSizeY * (float)c_iScreenSizeX;

	mat._11= xScale;	mat._12= 0;			mat._13= 0;				mat._14= 0;
	mat._21= 0;			mat._22= yScale;	mat._23= 0;				mat._24= 0;
	mat._31= 0;			mat._32= 0;			mat._33= zf/(zf-zn);	mat._34= 1;
	mat._41= 0;         mat._42= 0;			mat._43= -zn*zf/(zf-zn);mat._44= 0;

	g_d3d_device->SetTransform( D3DTS_PROJECTION, &mat );

	D3DXMatrixIdentity( &mat );
	g_d3d_device->SetTransform( D3DTS_WORLD, &mat );

	SetTransformation( pObj, fTime );

	{
		g_d3d_device->SetFVF( c_dwFVFMesh );

		int iPrimCount= PrepMesh( pObj, fTime );
		SVertexMesh* pVertices= FinalMesh;
		while( iPrimCount > 0 )
		{
			int iActPrimCount= iPrimCount;
			if( iActPrimCount > 16384 )
			{
				iActPrimCount= 16384;
			}
			g_d3d_device->DrawPrimitiveUP(
				D3DPT_TRIANGLELIST,
				iActPrimCount,
				pVertices,
				sizeof( SVertexMesh ) 
				);
			pVertices+= iActPrimCount * 3;
			iPrimCount-= iActPrimCount;
		}
	}
}*/