974 lines
25 KiB
C
974 lines
25 KiB
C
#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;
|
|
}
|
|
}
|
|
|
|
}*/
|
|
|