xTr1m/bluflame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

port from perforce

Browse Source
This commit is contained in:
Frank Tovar
2026-04-18 22:31:51 +02:00
commit 8d0ab5b7cc
8409 changed files with 3972376 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

877
evoke-64k/bp10/renderjob.cpp Normal file
View File

@@ -0,0 +1,877 @@
#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;
m_bDynamic= false;
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, bool bDynamic )
{
Release();
m_bDynamic = bDynamic;
D3DPOOL pool = m_bDynamic ? D3DPOOL_DEFAULT : D3DPOOL_MANAGED;
DWORD usageDynamic = m_bDynamic ? D3DUSAGE_DYNAMIC : 0;
g_d3d_device->CreateVertexBuffer(
iVertCount * sizeof(SVertex),
D3DUSAGE_WRITEONLY | usageDynamic,
c_dwFVF,
pool,
&m_pVB,
NULL );
m_iSafeVertMem= iVertCount;
g_d3d_device->CreateIndexBuffer(
iIndexCount * sizeof( WORD ),
D3DUSAGE_WRITEONLY | usageDynamic,
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()
{
m_iVertCount= 0;
DWORD flagDiscard = m_bDynamic ? D3DLOCK_DISCARD : 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;
}
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()
{
m_bDynamic= false;
//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);
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 | D3DXMESH_WRITEONLY, c_dwFVF, g_d3d_device, &m_pMesh);
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 );*/
}
void Renderjob::SetTransformation( const D3DXMATRIX& mat)
{
m_Transform= mat;
D3DXMatrixInverse( &m_TransformInverse, NULL, &m_Transform );
}