858 lines
19 KiB
C++
858 lines
19 KiB
C++
#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 );
|
|
}
|