#include "defines.h"

#include "Renderjob.h"

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

#include "ObjMesh.h"

void Renderjob::Render()
{
	if( m_pTerrain == NULL && 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::SetTransform(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::RenderWater(bool bFlipped)
{
	// Wasser rendern
	g_d3d_device->SetRenderState( D3DRS_CULLMODE,  bFlipped ? D3DCULL_CW : D3DCULL_CCW );

	// sampler2D reflectionSampler : register(s1);
	g_d3d_device->SetSamplerState( 1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
	g_d3d_device->SetSamplerState( 1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
	g_d3d_device->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
	g_d3d_device->SetSamplerState( 1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
	g_d3d_device->SetSamplerState( 1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
	g_d3d_device->SetTexture( 1, g_pFullScreenRT[ RT_REFLECTION ] );

	// sampler2D refractionSampler : register(s2);
	g_d3d_device->SetSamplerState( 2, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
	g_d3d_device->SetSamplerState( 2, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
	g_d3d_device->SetSamplerState( 2, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
	g_d3d_device->SetSamplerState( 2, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
	g_d3d_device->SetSamplerState( 2, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
	g_d3d_device->SetTexture( 2, g_pFullScreenRT[ RT_COLOR ] );

	Render();
}

void Renderjob::RenderWaterDepth(bool bFlipped)
{
	g_d3d_device->SetRenderState( D3DRS_CULLMODE,  bFlipped ? D3DCULL_CW : D3DCULL_CCW );

	PreRender();
}


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

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

void Renderjob::DrawCall()
{
	if( m_pTerrain != NULL )
	{
		m_pTerrain->Render();
		return;
	}
	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_pTerrain == NULL && 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::SetTransform(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;

	m_bDynamic= false;

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

	m_pMesh= NULL;
	m_pTerrain= NULL;

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

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

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

	m_bDynamic = false; // bDynamic;

	D3DPOOL pool = m_bDynamic ? D3DPOOL_DEFAULT : D3DPOOL_MANAGED;
	DWORD usageDynamic = m_bDynamic ? D3DUSAGE_DYNAMIC : 0;

	g_d3d_device->CreateVertexBuffer(
		iVertCount * sizeof(SVertex),
		usageDynamic, /* no D3DUSAGE_WRITEONLY */
		c_dwFVF, 
		pool,
		&m_pVB,
		NULL );

	m_iSafeVertMem= iVertCount;

	g_d3d_device->CreateIndexBuffer( 
		iIndexCount * sizeof( WORD ),
		usageDynamic, /* no D3DUSAGE_WRITEONLY */
		D3DFMT_INDEX16,
		pool,
		&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()
{
	DWORD flagDiscard = m_bDynamic ? D3DLOCK_DISCARD : 0;

	m_iVertCount= 0;

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

	m_iIndexCount= 0;

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

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

IDirect3DVertexBuffer9* Renderjob::GetVB()
{
	return m_pVB;
}

IDirect3DIndexBuffer9* Renderjob::GetIB()
{
	return m_pIB;
}

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

int Renderjob::GetIndexCount()
{
	return m_iIndexCount;
}

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::AddPlane( const D3DXVECTOR3& vecCenter, const D3DXVECTOR3& vecRot, DWORD dwColor,
						  const D3DXVECTOR3& vecInnerExtent, const D3DXVECTOR3& vecOuterExtent )
{
	D3DXVECTOR3 vecPointOffsets[ 4 ]= 
	{
		D3DXVECTOR3(  -1.0f, 0.0f, -1.0f ),
		D3DXVECTOR3( -1.0f, 0.0f, 1.0f ),
		D3DXVECTOR3(  1.0f, 0.0f, 1.0f ),
		D3DXVECTOR3(  1.0f, 0.0f, -1.0f )
	};

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

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

	for ( int q = -1; q < 8; q++ )
	{
		D3DXVECTOR3 vecPoints[4];
		memcpy(vecPoints, vecPointOffsets, sizeof(D3DXVECTOR3)*4);

		int qh = q / 2;
		int qn = (qh + 1) % 4;

		for ( int i = 0; i < 4; ++i )
		{
			if ( q == -1 )
			{
				vecPoints[i].x *= vecInnerExtent.x;
				vecPoints[i].y *= vecInnerExtent.y;
				vecPoints[i].z *= vecInnerExtent.z;
			}
			else
			{
				vecPoints[i].x *= vecOuterExtent.x;
				vecPoints[i].y *= vecOuterExtent.y;
				vecPoints[i].z *= vecOuterExtent.z;

				D3DXVECTOR3 vecOffset = vecPointOffsets[qh];
				
				if ( q % 2 != 0 )
					vecOffset = (vecOffset + vecPointOffsets[qn]) / 2.0f;

				vecPoints[i].x += vecOffset.x * (vecOuterExtent.x + vecInnerExtent.x);
				vecPoints[i].y += vecOffset.y * (vecOuterExtent.y + vecInnerExtent.y);
				vecPoints[i].z += vecOffset.z * (vecOuterExtent.z + vecInnerExtent.z);
			}

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

		AddQuadFlat( 
			vecPoints[ 0 ],
			vecPoints[ 1 ],
			vecPoints[ 3 ],
			vecPoints[ 2 ],
			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()
{
	m_bDynamic= false;

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

	m_pMesh = NULL;
	m_pTerrain= 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, DWORD dwColor  )
{
	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); 

	ID3DXMesh *pWrongFVFMesh = NULL;

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

	if(pWrongFVFMesh)
	{
		pWrongFVFMesh->CloneMeshFVF(D3DXMESH_MANAGED, c_dwFVF, g_d3d_device, &m_pMesh); /* no D3DXMESH_WRITEONLY */
		pWrongFVFMesh->Release();
	}

	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 );*/

	AddVertexColor( dwColor );
}

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


D3DXMATRIX Renderjob::GetTransformation()
{
	return m_Transform;
}

void Renderjob::CreateObjMesh( ObjMesh* pReader, DWORD dwColor  )
{
	if( pReader->GetVertexCount() == 0 )
	{
		return;
	}

	Create( pReader->GetVertexCount(), pReader->GetIndexCount() * 2 );
	Lock();
	for( unsigned int i= 0; i < pReader->GetVertexCount(); ++i )
	{
		SVertex v;
		
		v.x= pReader->GetVertexBuffer()[ i ].position.x;
		v.y= pReader->GetVertexBuffer()[ i ].position.y;
		v.z= pReader->GetVertexBuffer()[ i ].position.z;
		v.nx= pReader->GetVertexBuffer()[ i ].normal.x;
		v.ny= pReader->GetVertexBuffer()[ i ].normal.y;
		v.nz= pReader->GetVertexBuffer()[ i ].normal.z;
		
		v.dwColor= dwColor;
		v.tu= 0.0f;
		v.tv= 0.0f;

		AddVertex( v );
	}
	
	for( unsigned int i= 0; i < pReader->GetIndexCount(); ++i )
	{
		int iCount= pReader->GetIndexBuffer()[ i ];
		if( iCount == 3 )
		{
			for( int j= 0; j < 3; ++j )
			{
				AddIndex( pReader->GetIndexBuffer()[ i + 1 + j ] );
			}
		}
		else if( iCount == 4 )
		{
			AddIndex( pReader->GetIndexBuffer()[ i + 1 + 0 ] );
			AddIndex( pReader->GetIndexBuffer()[ i + 1 + 1 ] );
			AddIndex( pReader->GetIndexBuffer()[ i + 1 + 2 ] );
			AddIndex( pReader->GetIndexBuffer()[ i + 1 + 0 ] );
			AddIndex( pReader->GetIndexBuffer()[ i + 1 + 2 ] );
			AddIndex( pReader->GetIndexBuffer()[ i + 1 + 3 ] );
		}
		i+= iCount;
	}

	Unlock();
}

void Renderjob::CreateTorus()
{
	Release();

	ID3DXMesh *pWrongFVFMesh = NULL;

	D3DXCreateTorus(	g_d3d_device, 
		0.375f, 
		0.625f, 
		96,
		32, 
		&pWrongFVFMesh,
		NULL// &pAdj 
		);

	if(pWrongFVFMesh)
	{
		pWrongFVFMesh->CloneMeshFVF(D3DXMESH_MANAGED, c_dwFVF, g_d3d_device, &m_pMesh);  /* no D3DXMESH_WRITEONLY */
		pWrongFVFMesh->Release();
	}
}

void Renderjob::AddVertexColor( DWORD dwColor )
{
	assert( m_pMesh != NULL );
	assert( m_pMesh->GetFVF() == c_dwFVF );

	SVertex *pVertices = NULL;
	m_pMesh->LockVertexBuffer( NULL, (void**)&pVertices );

	assert( pVertices != NULL );

	const DWORD nVertexCount = m_pMesh->GetNumVertices();

	for(DWORD n = 0; n < nVertexCount; n++)
		pVertices[n].dwColor = dwColor;

	m_pMesh->UnlockVertexBuffer();

}