#pragma once

/*
0                                       1 
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
x xx                         .....  xxx x
x.  xx                  .....     xx    x
x .    xx          .....        xx      x
x  .     xx    ....           xx        x
x   .      xx 4             xx          x
x    .       xxxxxxxxxxxxxxx 5          x
x    .        x         x x   .         x
x     .       x       xx  x    .        x
x      .      x    xxx    x     .       x
x       .     x  xx       x      .      x
x        .    x           x       .     x
x          7 xxxxxxxxxxxxxxx      .     x
x          xx             6 xx     .    x
x        xx           ....    xx    .   x
x      xx        .....          xx   .  x
x    xx     .....                 xx  . x
x xxx  .....                        xxx x
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
3                                       2
*/

/*
struct SVertexMesh
{
		D3DXVECTOR3	Pos;
		D3DXVECTOR3	Normal;
		DWORD	dwColor;
};

const DWORD c_dwFVFMesh= D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_DIFFUSE;

SVertexMesh PreMesh[ 128 * 128 ];
float PreFloats[ 128 * 128 * 16 ];
const int PreFloatBlock= 128 * 128;
float* PreFloat( int i )
{
	return PreFloats + i * PreFloatBlock;
}
SVertexMesh FinalMesh[ 128 * 128 * 32 ];

void 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 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 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 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 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 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 CreateBase3DMesh()
{
}

void 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 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 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 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 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 ];
		}
	}
}

int CreateFinal3DMesh(
	int iStepsX,
	int iStepsY,
	float* pFloatHeight,
	float* pFloatCenterMix,
	float* pFloatAOVert,
	float* pFloatAOVHorz
	)
{
	float fBeat= 1.0f - 0.4f * minimum( 1.0f,( g_vuOffBeat.Get( g_dwSamples / 100 ) ) * 0.5f );

	const int VertsPerStep= 30;
	for( int iY= 0; iY < iStepsY - 1; ++iY )
	{
		for( int iX= 0; iX < iStepsX - 1; ++iX )
		{
			int iOffsetVert0= iY * iStepsX + iX;
			int iOffsetVert1= iY * iStepsX + iX + 1;
			int iOffsetVert2= iY * iStepsX + iX + iStepsX + 1;
			int iOffsetVert3= iY * iStepsX + iX + iStepsX;

			float fHeight= pFloatHeight[ iOffsetVert0 ] * fBeat;
			float fMix= pFloatCenterMix[ iOffsetVert0 ];

			D3DXVECTOR3 v4= PreMesh[ iOffsetVert0 ].Pos + PreMesh[ iOffsetVert0 ].Normal * fHeight;
			D3DXVECTOR3 v5= PreMesh[ iOffsetVert1 ].Pos + PreMesh[ iOffsetVert1 ].Normal * fHeight;
			D3DXVECTOR3 v6= PreMesh[ iOffsetVert2 ].Pos + PreMesh[ iOffsetVert2 ].Normal * fHeight;
			D3DXVECTOR3 v7= PreMesh[ iOffsetVert3 ].Pos + PreMesh[ iOffsetVert3 ].Normal * fHeight;

			D3DXVECTOR3 vCenter= 0.25f * ( v4 + v5 + v6 + v7 );

			D3DXVec3Lerp( &v4, &v4, &vCenter, fMix );
			D3DXVec3Lerp( &v5, &v5, &vCenter, fMix );
			D3DXVec3Lerp( &v6, &v6, &vCenter, fMix );
			D3DXVec3Lerp( &v7, &v7, &vCenter, fMix );

			D3DXVECTOR3 n1;
			D3DXVECTOR3 n2;
			D3DXVECTOR3 n3;
			D3DXVECTOR3 n4;
			{
				D3DXVECTOR3 v1= PreMesh[ iOffsetVert1 ].Pos - PreMesh[ iOffsetVert0 ].Pos;
				D3DXVECTOR3 v2= v4 - PreMesh[ iOffsetVert0 ].Pos;
				D3DXVec3Cross( &n1, &v2, &v1 );
				D3DXVec3Normalize( &n1, &n1 );
			}
			{
				D3DXVECTOR3 v1= PreMesh[ iOffsetVert2 ].Pos - PreMesh[ iOffsetVert1 ].Pos;
				D3DXVECTOR3 v2= v5 - PreMesh[ iOffsetVert1 ].Pos;
				D3DXVec3Cross( &n2, &v2, &v1 );
				D3DXVec3Normalize( &n2, &n2 );
			}
			{
				D3DXVECTOR3 v1= PreMesh[ iOffsetVert3 ].Pos - PreMesh[ iOffsetVert2 ].Pos;
				D3DXVECTOR3 v2= v6 - PreMesh[ iOffsetVert2 ].Pos;
				D3DXVec3Cross( &n3, &v2, &v1 );
				D3DXVec3Normalize( &n3, &n3 );
			}
			{
				D3DXVECTOR3 v1= PreMesh[ iOffsetVert0 ].Pos - PreMesh[ iOffsetVert3 ].Pos;
				D3DXVECTOR3 v2= v7 - PreMesh[ iOffsetVert3 ].Pos;
				D3DXVec3Cross( &n4, &v2, &v1 );
				D3DXVec3Normalize( &n4, &n4 );
			}


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

			float AOLeft= pFloatAOVHorz[ iOffsetVert0 ];
			float AORight= pFloatAOVHorz[ iOffsetVert1 ];
			float AOTop= pFloatAOVert[ iOffsetVert0 ];
			float AOBottom= pFloatAOVert[ iOffsetVert3 ];

			DWORD dwNorm= 0xffffffff;
			DWORD dwLeft= (int)( 255.4f * AOLeft );
			DWORD dwRight= (int)( 255.4f * AORight );
			DWORD dwTop= (int)( 255.4f * AOTop );
			DWORD dwBottom= (int)( 255.4f * AOBottom );
			dwLeft= dwLeft << 16 | dwLeft << 8 | dwLeft | 0xff000000;
			dwRight= dwRight << 16 | dwRight << 8 | dwRight | 0xff000000;
			dwTop= dwTop << 16 | dwTop << 8 | dwTop | 0xff000000;
			dwBottom= dwBottom << 16 | dwBottom << 8 | dwBottom | 0xff000000;


			// Deckel
			FinalMesh[ iFinalOffset ].Pos= v4;
			FinalMesh[ iFinalOffset ].Normal= PreMesh[ iOffsetVert0 ].Normal;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v5;
			FinalMesh[ iFinalOffset ].Normal= PreMesh[ iOffsetVert1 ].Normal;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v7;
			FinalMesh[ iFinalOffset ].Normal= PreMesh[ iOffsetVert3 ].Normal;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v5;
			FinalMesh[ iFinalOffset ].Normal= PreMesh[ iOffsetVert1 ].Normal;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v6;
			FinalMesh[ iFinalOffset ].Normal= PreMesh[ iOffsetVert2 ].Normal;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v7;
			FinalMesh[ iFinalOffset ].Normal= PreMesh[ iOffsetVert3 ].Normal;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			// Flanke oben
			FinalMesh[ iFinalOffset ].Pos= PreMesh[ iOffsetVert0 ].Pos;
			FinalMesh[ iFinalOffset ].Normal= n1;
			FinalMesh[ iFinalOffset ].dwColor= dwTop;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= PreMesh[ iOffsetVert1 ].Pos;
			FinalMesh[ iFinalOffset ].Normal= n1;
			FinalMesh[ iFinalOffset ].dwColor= dwTop;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v4;
			FinalMesh[ iFinalOffset ].Normal= n1;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= PreMesh[ iOffsetVert1 ].Pos;
			FinalMesh[ iFinalOffset ].Normal= n1;
			FinalMesh[ iFinalOffset ].dwColor= dwTop;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v5;
			FinalMesh[ iFinalOffset ].Normal= n1;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v4;
			FinalMesh[ iFinalOffset ].Normal= n1;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			// Flanke rechts
			FinalMesh[ iFinalOffset ].Pos= PreMesh[ iOffsetVert1 ].Pos;
			FinalMesh[ iFinalOffset ].Normal= n2;
			FinalMesh[ iFinalOffset ].dwColor= dwRight;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= PreMesh[ iOffsetVert2 ].Pos;
			FinalMesh[ iFinalOffset ].Normal= n2;
			FinalMesh[ iFinalOffset ].dwColor= dwRight;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v5;
			FinalMesh[ iFinalOffset ].Normal= n2;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= PreMesh[ iOffsetVert2 ].Pos;
			FinalMesh[ iFinalOffset ].Normal= n2;
			FinalMesh[ iFinalOffset ].dwColor= dwRight;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v6;
			FinalMesh[ iFinalOffset ].Normal= n2;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v5;
			FinalMesh[ iFinalOffset ].Normal= n2;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			// Flanke unten
			FinalMesh[ iFinalOffset ].Pos= PreMesh[ iOffsetVert2 ].Pos;
			FinalMesh[ iFinalOffset ].Normal= n3;
			FinalMesh[ iFinalOffset ].dwColor= dwBottom;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= PreMesh[ iOffsetVert3 ].Pos;
			FinalMesh[ iFinalOffset ].Normal= n3;
			FinalMesh[ iFinalOffset ].dwColor= dwBottom;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v6;
			FinalMesh[ iFinalOffset ].Normal= n3;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= PreMesh[ iOffsetVert3 ].Pos;
			FinalMesh[ iFinalOffset ].Normal= n3;
			FinalMesh[ iFinalOffset ].dwColor= dwBottom;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v7;
			FinalMesh[ iFinalOffset ].Normal= n3;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v6;
			FinalMesh[ iFinalOffset ].Normal= n3;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			// Flanke links
			FinalMesh[ iFinalOffset ].Pos= PreMesh[ iOffsetVert3 ].Pos;
			FinalMesh[ iFinalOffset ].Normal= n4;
			FinalMesh[ iFinalOffset ].dwColor= dwLeft;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= PreMesh[ iOffsetVert0 ].Pos;
			FinalMesh[ iFinalOffset ].Normal= n4;
			FinalMesh[ iFinalOffset ].dwColor= dwLeft;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v7;
			FinalMesh[ iFinalOffset ].Normal= n4;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= PreMesh[ iOffsetVert0 ].Pos;
			FinalMesh[ iFinalOffset ].Normal= n4;
			FinalMesh[ iFinalOffset ].dwColor= dwLeft;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v4;
			FinalMesh[ iFinalOffset ].Normal= n4;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;

			FinalMesh[ iFinalOffset ].Pos= v7;
			FinalMesh[ iFinalOffset ].Normal= n4;
			FinalMesh[ iFinalOffset ].dwColor= dwNorm;
			iFinalOffset++;
		}
	}

	return VertsPerStep * ( iStepsX - 1 ) * ( iStepsY - 1 ) / 3;
}

void 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;
	}
}

int PrepMesh( SObjectDescription* pObj, float fTime )
{
	const int iSizeX= pObj->m_iSizeX;
	const int iSizeY= pObj->m_iSizeY;

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


	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 );
		
	PrepAO(
		iSizeX,
		iSizeY ,
		PreFloat(1),	// pFloatHeight,
		PreFloat(2),	// pFloatCenterMix,
		PreFloat(3),		// pFloatAOVert,
		PreFloat(4),		// pFloatAOVHorz
		PreFloat(5)			// Intermediate
		);

	return CreateFinal3DMesh(
		iSizeX,
		iSizeY ,
		PreFloat(1),	// pFloatHeight,
		PreFloat(2),	// pFloatCenterMix,
		PreFloat(3),		// pFloatAOVert,
		PreFloat(4)		// pFloatAOVHorz
		);

}

void 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 SetTransformation( SObjectDescription* pObj, float fTime )
{
	D3DXMATRIX mat;

	switch( pObj->m_iTransformFunc )
	{
	case 0:
		D3DXMatrixIdentity( &mat );
		break;
	case 1:
		CreateInterpolationMatrix( &mat, pObj->m_iTransformBank, fTime );
		break;
	}
 
	g_d3d_device->SetTransform( D3DTS_WORLD, &mat ); 
}

void 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;


	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;
		}
	}

}*/