#include "defines.h"

#include "Renderjob.h"

#include "shader.h"
#include "intrin.h"
#include "globals.h"

void Renderjob::Render()
{
	if( m_pMesh == NULL )
	{
		if( m_iVertCount <= 0 || m_iIndexCount <= 0 || m_pVB == NULL || m_pIB == NULL )
		{
			return;
		}
	}

	for(int iLayer = 0; iLayer < MaxRenderLayerCount && (!iLayer || m_iUsedShader[iLayer] >= 0); iLayer++)
	{
		if( m_iUsedShader[iLayer] < 0 )
		{
			Shader::Deactivate();
			g_d3d_device->SetTransform(D3DTS_WORLD, &m_Transform);
		}
		else
		{
			g_Shaders[ m_iUsedShader[iLayer] ].Activate();
			Shader::SetShaderTransform(m_Transform, m_TransformInverse);
		}

		if( m_bAlphaEnable[ iLayer ] )
		{
			g_d3d_device->SetRenderState( D3DRS_ALPHABLENDENABLE, m_bAlphaEnable[ iLayer ] );
			g_d3d_device->SetRenderState( D3DRS_SRCBLEND, m_SrcBlend[ iLayer ] );
			g_d3d_device->SetRenderState( D3DRS_DESTBLEND, m_DestBlend[ iLayer ] );
			g_d3d_device->SetRenderState( D3DRS_BLENDOP, m_BlendOp[ iLayer ] );
		}

		DrawCall();

		if( m_bAlphaEnable[ iLayer ] )
		{
			g_d3d_device->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
		}
	}

}


void Renderjob::RenderSky()
{
	// Himmel rendern
	g_d3d_device->SetRenderState( D3DRS_LIGHTING,       FALSE );
	g_d3d_device->SetRenderState( D3DRS_ZWRITEENABLE,	FALSE );
	g_d3d_device->SetRenderState( D3DRS_CULLMODE,  D3DCULL_CW );
	Render();
}

void Renderjob::RenderSkyDepth()
{
	// Himmel rendern
	g_d3d_device->SetRenderState( D3DRS_ZWRITEENABLE,	FALSE );
	g_d3d_device->SetRenderState( D3DRS_CULLMODE,  D3DCULL_CW );
	PreRender();
}


void Renderjob::DrawCall()
{
	if( m_pMesh != NULL )
	{
		m_pMesh->DrawSubset( 0 );
		return;
	}
	assert( m_iIndexCount % 3 == 0 );
	assert( m_iVertCount <= m_iSafeVertMem );
	assert( m_iIndexCount <= m_iSafeIndexMem );

	g_d3d_device->SetFVF( c_dwFVF );
	g_d3d_device->SetStreamSource( 0, m_pVB, 0, sizeof( SVertex ) );
	g_d3d_device->SetIndices( m_pIB );

	g_d3d_device->DrawIndexedPrimitive(
		D3DPT_TRIANGLELIST,
		0,
		0,
		m_iVertCount,
		0,
		m_iIndexCount / 3 );
}


void Renderjob::PreRender()
{
	if( m_iUsedPreShader < -2 )
	{
		return;
	}

	if( m_pMesh == NULL )
	{
		if( m_iVertCount <= 0 || m_iIndexCount <= 0 || m_pVB == NULL || m_pIB == NULL )
		{
			return;
		}
	}

	if( m_iUsedPreShader < 0 )
	{
		Shader::Deactivate();
		g_d3d_device->SetTransform(D3DTS_WORLD, &m_Transform);
	}
	else
	{
		g_Shaders[ m_iUsedPreShader ].Activate();
		Shader::SetShaderTransform(m_Transform, m_TransformInverse);
	}

	DrawCall();
}

void Renderjob::Init()
{
	m_iVertCount= 0;

	m_pVB= 0;
	m_iSafeVertMem= -1;
	m_pLockVertex= NULL;

	m_iIndexCount= 0;

	m_pIB= 0;
	m_iSafeIndexMem= -1;

	m_pLockIndex= NULL;

	for(int i = 0; i < MaxRenderLayerCount; i++)
	{
		m_iUsedShader[i]= -1;
		m_bAlphaEnable[i] = false;
	}
	m_iUsedPreShader= -2;

	m_pMesh= NULL;

	D3DXMatrixIdentity( &m_Transform );
	D3DXMatrixInverse( &m_TransformInverse, NULL, &m_Transform );
}

void Renderjob::DeInit()
{
	Release();
}

void Renderjob::Create( int iVertCount, int iIndexCount )
{
	Release();

	g_d3d_device->CreateVertexBuffer(
		iVertCount * sizeof(SVertex),
		D3DUSAGE_WRITEONLY,
		c_dwFVF, 
		D3DPOOL_MANAGED,
		&m_pVB,
		NULL );

	m_iSafeVertMem= iVertCount;

	g_d3d_device->CreateIndexBuffer( 
		iIndexCount * sizeof( WORD ),
		D3DUSAGE_WRITEONLY,
		D3DFMT_INDEX16,
		D3DPOOL_MANAGED,
		&m_pIB,
		NULL );
	m_iSafeIndexMem= iIndexCount;

}

void Renderjob::Release()
{
	Unlock();
	if( m_pVB != NULL )
	{
		m_pVB->Release();
		m_pVB= NULL;
	}
	m_iSafeVertMem= -1;

	if( m_pIB != NULL )
	{
		m_pIB->Release();
		m_pIB= NULL;
	}
	m_iSafeIndexMem= -1;

	if( m_pMesh != NULL )
	{
		m_pMesh->Release();
		m_pMesh= NULL;
	}
}

void Renderjob::Lock()
{
	m_iVertCount= 0;

	m_pVB->Lock(	0,
		0,
		(void**)&m_pLockVertex,
		NULL );

	m_iIndexCount= 0;

	m_pIB->Lock(
		0,
		0,
		(void**)&m_pLockIndex,
		NULL );
}

void Renderjob::LockVertexOnly()
{
	m_iVertCount= 0;

	m_pVB->Lock(	0,
		0,
		(void**)&m_pLockVertex,
		NULL );
}

void Renderjob::Unlock()
{
	if( m_pLockVertex != NULL )
	{
		m_pVB->Unlock();
		m_pLockVertex= NULL;
	}
	if( m_pLockIndex != NULL )
	{
		m_pIB->Unlock();
		m_pLockIndex= NULL;
	}
}

void Renderjob::HideVertexData()
{
	//disables Rendering without locking und unlocking 
	m_iVertCount= 0;
	m_iIndexCount= 0;
}

int Renderjob::GetVertCount()
{
	return m_iVertCount;
}

void Renderjob::AddVertex( const SVertex& v )
{
#ifdef _DEBUG
	if( m_pLockVertex == NULL )
	{
		return;
	}
#endif
	assert( m_iVertCount < m_iSafeVertMem );
	m_pLockVertex[ m_iVertCount ]= v;
	m_iVertCount++;
}


void Renderjob::AddIndex( WORD Index )
{
#ifdef _DEBUG
	if( m_pLockIndex == NULL )
	{
		return;
	}
#endif
	assert( m_iIndexCount < m_iSafeIndexMem );
	m_pLockIndex[ m_iIndexCount ]= Index;
	m_iIndexCount++;
}

void Renderjob::AddTriangle( const D3DXVECTOR3& vec1, const D3DXVECTOR3& vec2, const D3DXVECTOR3& vec3, DWORD dwColor )
{
	SVertex v1;
	v1.x= vec1.x;
	v1.y= vec1.y;
	v1.z= vec1.z;
	v1.dwColor= dwColor;

	SVertex v2;
	v2.x= vec2.x;
	v2.y= vec2.y;
	v2.z= vec2.z;
	v2.dwColor= dwColor;

	SVertex v3;
	v3.x= vec3.x;
	v3.y= vec3.y;
	v3.z= vec3.z;
	v3.dwColor= dwColor;


	D3DXVECTOR3 vecA( v2.x - v1.x, v2.y - v1.y, v2.z - v1.z );
	D3DXVECTOR3 vecB( v3.x - v1.x, v3.y - v1.y, v3.z - v1.z );

	D3DXVECTOR3 vecN;
	D3DXVec3Cross( &vecN, &vecA, &vecB );
	D3DXVec3Normalize( &vecN, &vecN );

	v1.nx= v2.nx= v3.nx= vecN.x;
	v1.ny= v2.ny= v3.ny= vecN.y;
	v1.nz= v2.nz= v3.nz= vecN.z;

	D3DXVECTOR3 vecBT( 0.0f, 1.0f, 0.0f );
	if( abs( D3DXVec3Dot( &vecBT, &vecN ) ) > 0.95f )
	{
		vecBT = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
	}

	D3DXVECTOR3 vecT;
	D3DXVec3Cross( &vecT, &vecN, &vecBT );
	D3DXVec3Normalize( &vecT, &vecT );
	D3DXVec3Cross( &vecBT, &vecT, &vecN );

	v1.tu= D3DXVec3Dot( &vecT, (D3DXVECTOR3*)&v1 );
	v1.tv= D3DXVec3Dot( &vecBT, (D3DXVECTOR3*)&v1 );
	v2.tu= D3DXVec3Dot( &vecT, (D3DXVECTOR3*)&v2 );
	v2.tv= D3DXVec3Dot( &vecBT, (D3DXVECTOR3*)&v2 );
	v3.tu= D3DXVec3Dot( &vecT, (D3DXVECTOR3*)&v3 );
	v3.tv= D3DXVec3Dot( &vecBT, (D3DXVECTOR3*)&v3 );

	AddVertex( v1 );
	AddVertex( v2 );
	AddVertex( v3 );

	AddIndex( m_iVertCount - 3 );
	AddIndex( m_iVertCount - 2 );
	AddIndex( m_iVertCount - 1 );
}

void  Renderjob::AddQuadFlat(	const D3DXVECTOR3& vec1, 
								const D3DXVECTOR3& vec2, 
								const D3DXVECTOR3& vec3,
								const D3DXVECTOR3& vec4,
								DWORD dwColor )
{
	float fTex[ 4 ]= { 0.0f, 0.0f, 0.0f, 0.0f };
	AddQuadTex( vec1, vec2, vec3, vec4, fTex, dwColor );
}

void Renderjob::AddQuadTex(	const D3DXVECTOR3& vec1, 
							const D3DXVECTOR3& vec2, 
							const D3DXVECTOR3& vec3,
							const D3DXVECTOR3& vec4,
							float fTex[ 4 ],
							DWORD dwColor )
{
	SVertex v1;
	v1.x= vec1.x;
	v1.y= vec1.y;
	v1.z= vec1.z;
	v1.dwColor= dwColor;
	v1.tu= fTex[ 0 ];
	v1.tv= fTex[ 1 ];

	SVertex v2;
	v2.x= vec2.x;
	v2.y= vec2.y;
	v2.z= vec2.z;
	v2.dwColor= dwColor;
	v2.tu= fTex[ 2 ];
	v2.tv= fTex[ 1 ];

	SVertex v3;
	v3.x= vec3.x;
	v3.y= vec3.y;
	v3.z= vec3.z;
	v3.dwColor= dwColor;
	v3.tu= fTex[ 0 ];
	v3.tv= fTex[ 3 ];

	SVertex v4;
	v4.x= vec4.x;
	v4.y= vec4.y;
	v4.z= vec4.z;
	v4.dwColor= dwColor;
	v4.tu= fTex[ 2 ];
	v4.tv= fTex[ 3 ];

	D3DXVECTOR3 vecA( v2.x - v1.x, v2.y - v1.y, v2.z - v1.z );
	D3DXVECTOR3 vecB( v3.x - v1.x, v3.y - v1.y, v3.z - v1.z );

	D3DXVECTOR3 vecN;
	D3DXVec3Cross( &vecN, &vecA, &vecB );
	D3DXVec3Normalize( &vecN, &vecN );

	v1.nx= v2.nx= v3.nx= v4.nx= vecN.x;
	v1.ny= v2.ny= v3.ny= v4.ny= vecN.y;
	v1.nz= v2.nz= v3.nz= v4.nz= vecN.z;

	AddVertex( v1 );
	AddVertex( v2 );
	AddVertex( v3 );
	AddVertex( v4 );

	AddIndex( m_iVertCount - 4 );
	AddIndex( m_iVertCount - 3 );
	AddIndex( m_iVertCount - 2 );

	AddIndex( m_iVertCount - 3 );
	AddIndex( m_iVertCount - 1 );
	AddIndex( m_iVertCount - 2 );
}

void Renderjob::AddCylinder(const D3DXVECTOR3& vecCenter, 
							const D3DXVECTOR3& vecRot, 
							float radius,
							float height,
							bool upperCap,
							bool lowerCap,
							DWORD dwColor)
{
	const int segmentCount = 21;
	D3DXVECTOR3 vecPoints[segmentCount * 4];
	int baseIndexList[ 6 ] = { 0, 1, 2,0, 3, 2 };

	for(int i = 0; i < segmentCount; ++i)
	{
		float fTheta = (c_2PI * i) / (segmentCount - 1);

		vecPoints[2*i+0] = D3DXVECTOR3( radius * sin(fTheta),-height/2, radius * cos(fTheta) );
		vecPoints[2*i+1] = D3DXVECTOR3( radius * sin(fTheta), height/2, radius * cos(fTheta) );
	}

	D3DXMATRIX m1;
	D3DXMatrixRotationYawPitchRoll( &m1, vecRot.x, vecRot.y, vecRot.z );
	D3DXMATRIX m2;
	D3DXMatrixTranslation( &m2, vecCenter.x, vecCenter.y, vecCenter.z );
	D3DXMATRIX mFinal;
	D3DXMatrixMultiply( &mFinal, &m1, &m2 );

	for(int i = 0; i < segmentCount * 4; ++i)
	{
		D3DXVec3TransformCoord( vecPoints + i, vecPoints + i, &mFinal );
	}

	for( int i= 0; i < (segmentCount-1) * 2; i += 2 )
	{
		AddQuadFlat(
			vecPoints[i + 0],
			vecPoints[i + 2],
			vecPoints[i + 1],
			vecPoints[i + 3],
			dwColor );
	}

	D3DXVECTOR3 capCenter;
	D3DXVec3TransformCoord(&capCenter, &D3DXVECTOR3(0, height/2, 0), &mFinal);
	if (upperCap)
	{
		for( int i= 0; i < (segmentCount-1) * 2; i += 2 )
		{
			AddTriangle(
				capCenter,
				vecPoints[i + 1],
				vecPoints[i + 3],
				dwColor);
		}
	}

	D3DXVec3TransformCoord(&capCenter, &D3DXVECTOR3(0, -height/2, 0), &mFinal);
	if (lowerCap)
	{
		for( int i= 0; i < (segmentCount-1) * 2; i += 2 )
		{
			AddTriangle(
				capCenter,
				vecPoints[i + 2],
				vecPoints[i + 0],
				dwColor);
		}
	}
}

void Renderjob::AddGround( const D3DXVECTOR3& vecCenter, const D3DXVECTOR3& vecExtent, const D3DXVECTOR3& vecRot, DWORD dwColor,
						   float fInnerRadius, float fOuterRadius, float fFrequency, float fAmplitude,
						   int iResX, int iResY )
{
	D3DXVECTOR3 vecPointOffsets[ 4 ]= 
	{
		D3DXVECTOR3(  -1.0f, 1.0f, -1.0f ),
		D3DXVECTOR3( -1.0f, 1.0f, 1.0f ),
		D3DXVECTOR3(  1.0f, 1.0f, -1.0f ),
		D3DXVECTOR3(  1.0f, 1.0f, 1.0f )
	};

	D3DXMATRIX m1;
	D3DXMatrixScaling( &m1, vecExtent.x / iResX, vecExtent.y, vecExtent.z / iResY );
	D3DXMATRIX m2;
	D3DXMatrixRotationYawPitchRoll( &m2, vecRot.x, vecRot.y, vecRot.z );
	D3DXMATRIX m3;
	D3DXMatrixTranslation( &m3, vecCenter.x, vecCenter.y, vecCenter.z );

	D3DXMATRIX mFinal;
	D3DXMatrixMultiply( &mFinal, &m1, &m2 );
	D3DXMatrixMultiply( &mFinal, &mFinal, &m3 );

	float fInnerRadiusSq = fInnerRadius * fInnerRadius;
	float fOuterRadiusSq = fOuterRadius * fOuterRadius;

	for( int y = 0; y < iResY; ++y )
	{
		for( int x = 0; x < iResX; ++x )
		{
			D3DXVECTOR3 vecPoints[4];
			memcpy(vecPoints, vecPointOffsets, sizeof(D3DXVECTOR3)*4);

			for ( int i = 0; i < 4; ++i )
			{
				vecPoints[i].x += 2 * x - iResX;
				vecPoints[i].z += 2 * y - iResY;

				float fCenterDist = vecPoints[i].x * vecPoints[i].x + vecPoints[i].z * vecPoints[i].z;
				fCenterDist -= fInnerRadiusSq;
				fCenterDist /= fOuterRadiusSq - fInnerRadiusSq;
				fCenterDist = maximum( minimum( fCenterDist, 1.f ) , 0.f );

				float fDX = fFrequency * vecPoints[i].x / iResX;
				float fDY = fFrequency * vecPoints[i].z / iResY;

				float fDisplacement = 0.86f;
				fDisplacement -= fabs( sin( 5 * fDX ) * sin( 7 * fDY ) / 2.0f );
				fDisplacement += sin( 13 * fDX ) * sin( 17 * fDY ) / 4.0f;
				fDisplacement -= fabs( sin( 23 * fDX ) ) * fabs( sin( 29 * fDY ) ) / 8.0f;
				fDisplacement += sin( 37 * fDX ) * sin( 41 * fDY ) / 16.0f;
				fDisplacement *= 0.5f;

				vecPoints[i].y += fCenterDist * fAmplitude * fDisplacement;

				D3DXVec3TransformCoord( vecPoints + i, vecPoints + i, &mFinal );
			}

			AddQuadFlat( 
				vecPoints[ 0 ],
				vecPoints[ 1 ],
				vecPoints[ 2 ],
				vecPoints[ 3 ],
				dwColor );
		}
	}
}

void Renderjob::AddBox( const D3DXVECTOR3& vecCenter, const D3DXVECTOR3& vecExtent, const D3DXVECTOR3& vecRot, DWORD dwColor )
{
	D3DXVECTOR3 vecPoints[ 8 ]= 
	{
		D3DXVECTOR3( -1.0f, 1.0f, 1.0f ),
		D3DXVECTOR3(  -1.0f, 1.0f, -1.0f ),
		D3DXVECTOR3(  -1.0f, -1.0f, 1.0f ),
		D3DXVECTOR3(  -1.0f, -1.0f, -1.0f ),
		D3DXVECTOR3(  1.0f, 1.0f, 1.0f ),
		D3DXVECTOR3(  1.0f, 1.0f, -1.0f ),
		D3DXVECTOR3(  1.0f, -1.0f, 1.0f ),
		D3DXVECTOR3(  1.0f, -1.0f, -1.0f )
	};

	int IndexList[ 24 ]=
	{
		0, 1, 2,	3,
		4, 6, 5,	7,
		0, 4, 1,	5,
		2, 3, 6,	7,
		0, 2, 4,	6,
		1, 5, 3,	7,
	};

	D3DXMATRIX m1;
	D3DXMatrixScaling( &m1, vecExtent.x, vecExtent.y, vecExtent.z );
	D3DXMATRIX m2;
	D3DXMatrixRotationYawPitchRoll( &m2, vecRot.x, vecRot.y, vecRot.z );
	D3DXMATRIX m3;
	D3DXMatrixTranslation( &m3, vecCenter.x, vecCenter.y, vecCenter.z );

	D3DXMATRIX mFinal;
	D3DXMatrixMultiply( &mFinal, &m1, &m2 );
	D3DXMatrixMultiply( &mFinal, &mFinal, &m3 );

	for( int i= 0; i < 8; ++i )
	{
		D3DXVec3TransformCoord( vecPoints + i, vecPoints + i, &mFinal );
	}

	for( int i= 0; i < 6 * 4; i+= 4 )
	{
		AddQuadFlat( 
			vecPoints[ IndexList[ i ] ],
			vecPoints[ IndexList[  i + 1 ] ],
			vecPoints[ IndexList[  i + 2 ] ],
			vecPoints[ IndexList[  i + 3 ] ],
			dwColor );
	}
}

void Renderjob::AddBox(	const D3DXVECTOR3& vecCenter, 
					const D3DXVECTOR3& vecExtent, 
					const D3DXVECTOR3& vecRot, 
					DWORD dwColor,
					float fTU, float fTV )
{
		D3DXVECTOR3 vecPoints[ 8 ]= 
	{
		D3DXVECTOR3( -1.0f, 1.0f, 1.0f ),
		D3DXVECTOR3(  -1.0f, 1.0f, -1.0f ),
		D3DXVECTOR3(  -1.0f, -1.0f, 1.0f ),
		D3DXVECTOR3(  -1.0f, -1.0f, -1.0f ),
		D3DXVECTOR3(  1.0f, 1.0f, 1.0f ),
		D3DXVECTOR3(  1.0f, 1.0f, -1.0f ),
		D3DXVECTOR3(  1.0f, -1.0f, 1.0f ),
		D3DXVECTOR3(  1.0f, -1.0f, -1.0f )
	};

	int IndexList[ 24 ]=
	{
		0, 1, 2,	3,
		4, 6, 5,	7,
		0, 4, 1,	5,
		2, 3, 6,	7,
		0, 2, 4,	6,
		1, 5, 3,	7,
	};

	D3DXMATRIX m1;
	D3DXMatrixScaling( &m1, vecExtent.x, vecExtent.y, vecExtent.z );
	D3DXMATRIX m2;
	D3DXMatrixRotationYawPitchRoll( &m2, vecRot.x, vecRot.y, vecRot.z );
	D3DXMATRIX m3;
	D3DXMatrixTranslation( &m3, vecCenter.x, vecCenter.y, vecCenter.z );

	D3DXMATRIX mFinal;
	D3DXMatrixMultiply( &mFinal, &m1, &m2 );
	D3DXMatrixMultiply( &mFinal, &mFinal, &m3 );

	for( int i= 0; i < 8; ++i )
	{
		D3DXVec3TransformCoord( vecPoints + i, vecPoints + i, &mFinal );
	}

	for( int i= 0; i < 6 * 4; i+= 4 )
	{
		float fTex[ 4 ]= { fTU, fTV, fTU, fTV };
		AddQuadTex(
			vecPoints[ IndexList[ i ] ],
			vecPoints[ IndexList[  i + 1 ] ],
			vecPoints[ IndexList[  i + 2 ] ],
			vecPoints[ IndexList[  i + 3 ] ],
			fTex,
			dwColor );
	}
}

void Renderjob::AddRainbow(	const D3DXVECTOR3& vecCenter, 
					float fRadiusInner,
					float fRadiusOuter,
					float fWidth,
					float fStartAngle,
					float fEndAngle,
					const D3DXVECTOR3& vecRot )
{
	DWORD dwColor= 0xffffffff;
	int iSteps= max( 1, (int)((fEndAngle - fStartAngle ) * 20.0f ) );

	D3DXVECTOR3 vecSide( 1.0f, 0.0f, 0.0f );
	D3DXVECTOR3 vecTop( 0.0f, 1.0f, 0.0f );
	D3DXVECTOR3 vecStart( 0.0f, 0.0f, 1.0f );

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

	D3DXVec3TransformCoord( &vecSide, &vecSide, &m );
	D3DXVec3TransformCoord( &vecTop, &vecTop, &m );
	D3DXVec3TransformCoord( &vecStart, &vecStart, &m );
	D3DXVECTOR3 vecWidth= vecSide * fWidth;

	int iBaseIndex;
	SVertex* pV;
	D3DXVECTOR3 v[4];
	for( int i= 0; i <= iSteps; ++i )
	{
		float fAngle= (fStartAngle * (float)( iSteps - i )  + fEndAngle * (float)i ) / (float)iSteps;
		D3DXVECTOR3 vecAngle= cos( fAngle ) * vecStart + sin( fAngle ) * vecTop;

		v[ 0 ]= vecCenter + vecWidth + vecAngle * fRadiusInner;
		v[ 1 ]= vecCenter - vecWidth + vecAngle * fRadiusInner;
		v[ 2 ]= vecCenter + vecWidth + vecAngle * fRadiusOuter;
		v[ 3 ]= vecCenter - vecWidth + vecAngle * fRadiusOuter;

		if( i == 0 )
		{
			float fTex[ 4 ]= { 0.0f, fStartAngle, 1.0f, fStartAngle };
			AddQuadTex( v[0], v[2], v[1], v[3], fTex, dwColor );
			iBaseIndex= m_iVertCount;
			pV= m_pLockVertex + m_iVertCount;
		}

		pV->x= v[ 0 ].x; pV->y= v[ 0 ].y; pV->z= v[ 0 ].z;
		pV->nx= -vecAngle.x; pV->ny= -vecAngle.y; pV->nz= -vecAngle.z;
		pV->dwColor= dwColor; pV->tu= 0.0f; pV->tv= fAngle;
		pV++;
		pV->x= v[ 1 ].x; pV->y= v[ 1 ].y; pV->z= v[ 1 ].z;
		pV->nx= -vecAngle.x; pV->ny= -vecAngle.y; pV->nz= -vecAngle.z;
		pV->dwColor= dwColor; pV->tu= 0.0f; pV->tv= fAngle;
		pV++;

		pV->x= v[ 2 ].x; pV->y= v[ 2 ].y; pV->z= v[ 2 ].z;
		pV->nx= vecAngle.x; pV->ny= vecAngle.y; pV->nz= vecAngle.z;
		pV->dwColor= dwColor; pV->tu= 1.0f; pV->tv= fAngle;
		pV++;
		pV->x= v[ 3 ].x; pV->y= v[ 3 ].y; pV->z= v[ 3 ].z;
		pV->nx= vecAngle.x; pV->ny= vecAngle.y; pV->nz= vecAngle.z;
		pV->dwColor= dwColor; pV->tu= 1.0f; pV->tv= fAngle;
		pV++;

		pV->x= v[ 0 ].x; pV->y= v[ 0 ].y; pV->z= v[ 0 ].z;
		pV->nx= vecSide.x; pV->ny= vecSide.y; pV->nz= vecSide.z;
		pV->dwColor= dwColor; pV->tu= 0.0f; pV->tv= fAngle;
		pV++;
		pV->x= v[ 2 ].x; pV->y= v[ 2 ].y; pV->z= v[ 2 ].z;
		pV->nx= vecSide.x; pV->ny= vecSide.y; pV->nz= vecSide.z;
		pV->dwColor= dwColor; pV->tu= 1.0f; pV->tv= fAngle;
		pV++;

		pV->x= v[ 1 ].x; pV->y= v[ 1 ].y; pV->z= v[ 1 ].z;
		pV->nx= -vecSide.x; pV->ny= -vecSide.y; pV->nz= -vecSide.z;
		pV->dwColor= dwColor; pV->tu= 0.0f; pV->tv= fAngle;
		pV++;
		pV->x= v[ 3 ].x; pV->y= v[ 3 ].y; pV->z= v[ 3 ].z;
		pV->nx= -vecSide.x; pV->ny= -vecSide.y; pV->nz= -vecSide.z;
		pV->dwColor= dwColor; pV->tu= 1.0f; pV->tv= fAngle;
		pV++;
	}

	for( int i= 0; i < iSteps; ++i )
	{
		AddIndex( i * 8 + iBaseIndex );
		AddIndex( i * 8 + iBaseIndex + 1);
		AddIndex( i * 8 + iBaseIndex + 8);
		AddIndex( i * 8 + iBaseIndex + 8);
		AddIndex( i * 8 + iBaseIndex + 1);
		AddIndex( i * 8 + iBaseIndex + 9);
	}
	iBaseIndex+= 2;
	for( int i= 0; i < iSteps; ++i )
	{
		AddIndex( i * 8 + iBaseIndex );
		AddIndex( i * 8 + iBaseIndex + 8);
		AddIndex( i * 8 + iBaseIndex + 1);
		AddIndex( i * 8 + iBaseIndex + 1);
		AddIndex( i * 8 + iBaseIndex + 8);
		AddIndex( i * 8 + iBaseIndex + 9);
	}
	iBaseIndex+= 2;
	for( int i= 0; i < iSteps; ++i )
	{
		AddIndex( i * 8 + iBaseIndex );
		AddIndex( i * 8 + iBaseIndex + 8);
		AddIndex( i * 8 + iBaseIndex + 1);
		AddIndex( i * 8 + iBaseIndex + 1);
		AddIndex( i * 8 + iBaseIndex + 8);
		AddIndex( i * 8 + iBaseIndex + 9);
	}
	iBaseIndex+= 2;
	for( int i= 0; i < iSteps; ++i )
	{
		AddIndex( i * 8 + iBaseIndex );
		AddIndex( i * 8 + iBaseIndex + 1);
		AddIndex( i * 8 + iBaseIndex + 8);
		AddIndex( i * 8 + iBaseIndex + 8);
		AddIndex( i * 8 + iBaseIndex + 1);
		AddIndex( i * 8 + iBaseIndex + 9);
	}
	m_iVertCount+= ( iSteps + 1 ) * 8;

	float fTex[ 4 ]= { 1.0f, fEndAngle, 0.0f, fEndAngle };
	AddQuadTex( v[2], v[0], v[3], v[1], fTex, dwColor );
}

void Renderjob::InitFullScreenQuad()
{
	//Shader zuweisen
	for(int i = 0; i < MaxRenderLayerCount; i++)
	{
		m_iUsedShader[i]= -666;
		m_bAlphaEnable[i] = false;
	}

	m_pMesh = NULL;

	D3DXMatrixIdentity( &m_Transform );
	D3DXMatrixIdentity( &m_TransformInverse );

	Create( 4, 6 );

	Lock();
	AddQuadFlat(
		D3DXVECTOR3(1.0f, 1.0f, 1.0f),
		D3DXVECTOR3(1.0f, -1.0f, 1.0f),
		D3DXVECTOR3(-1.0f, 1.0f, 1.0f),
		D3DXVECTOR3(-1.0f, -1.0f, 1.0f), 0);
	Unlock();
}

void Renderjob::CreateTextMesh( const char* pcText )
{
	Release();

	HDC hdc = CreateCompatibleDC( NULL );
	HFONT hFont;
	HFONT hFontOld;

	hFont = CreateFont(512, 0, 0, 0, 999, FALSE, FALSE, FALSE, DEFAULT_CHARSET, 
		OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Verdana");

	hFontOld = (HFONT)SelectObject(hdc, hFont); 

	//LPD3DXBUFFER pAdj;
	D3DXCreateText(	g_d3d_device, 
		hdc, 
		pcText, 
		1.0f / 2048.0f, 
		0.5f, 
		&m_pMesh,
		NULL,// &pAdj,
		NULL);

	SelectObject(hdc, hFontOld);
	DeleteObject( hFont );
	DeleteDC( hdc );

	//D3DXComputeNormals( m_pMesh, (DWORD*)pAdj->GetBufferPointer() );
	//pAdj->Release();

	/*D3DXMATRIX mat;
	D3DXMatrixScaling( &mat, 28.0f, 32.0f, 28.0f );
	mat._41= -20.0f;
	mat._43= 31.0f;
	SetTransformation( mat );*/
}

void Renderjob::SetTransformation( const D3DXMATRIX& mat)
{
	m_Transform= mat;
	D3DXMatrixInverse( &m_TransformInverse, NULL, &m_Transform );
}