843 lines
23 KiB
C++
843 lines
23 KiB
C++
#pragma once
|
|
#include "Greeble.h"
|
|
#include "intrin.h"
|
|
#ifdef EXTRACODE
|
|
#include "greebledata.h"
|
|
#else
|
|
#include "greeblearrays.h"
|
|
#endif
|
|
#include "globals.h"
|
|
|
|
Greeble g_Greeble;
|
|
|
|
float Greeble::GetFloatParam( int iBank, int iOffset )
|
|
{
|
|
return g_GreebleParam[ iBank * 4 + iOffset ];
|
|
}
|
|
|
|
void Greeble::AddToScene( float fCurTime, int iObject, int iObjDesc )
|
|
{
|
|
iObjID= iObject;
|
|
pObj= g_GreebleObj + iObjDesc;
|
|
fTime= fCurTime;
|
|
PrepMesh();
|
|
}
|
|
|
|
void Greeble::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 Greeble::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 Greeble::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 Greeble::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 Greeble::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 Greeble::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 Greeble::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 Greeble::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 Greeble::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 Greeble::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 Greeble::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 ];
|
|
}
|
|
}
|
|
}
|
|
|
|
DWORD ShadeColor( DWORD dwBaseColor, float fShade )
|
|
{
|
|
DWORD dwRGB[3]=
|
|
{
|
|
( dwBaseColor & 0xff0000 ) >> 16,
|
|
( dwBaseColor & 0xff00 ) >> 8,
|
|
( dwBaseColor & 0xff )
|
|
};
|
|
dwRGB[0]= (int)( (float)dwRGB[0] * fShade );
|
|
dwRGB[1]= (int)( (float)dwRGB[1] * fShade );
|
|
dwRGB[2]= (int)( (float)dwRGB[2] * fShade );
|
|
return dwRGB[0] << 16 | dwRGB[1] << 8 | dwRGB[2] | ( 0xff000000 & dwBaseColor );
|
|
}
|
|
|
|
void Greeble::CreateFinal3DMesh( int iStepsX, int iStepsY, float* pFloatHeight, float* pFloatCenterMix, float* pFloatAOVert, float* pFloatAOVHorz, DWORD dwBaseColor )
|
|
{
|
|
g_Objects[ iObjID ].Lock();
|
|
const int QuadsPerStep= 5;
|
|
for( int iY= 0; iY < iStepsY - 1; ++iY )
|
|
{
|
|
for( int iX= 0; iX < iStepsX - 1; ++iX )
|
|
{
|
|
int iOffsetVert[ 4 ]=
|
|
{
|
|
iY * iStepsX + iX,
|
|
iY * iStepsX + iX + 1,
|
|
iY * iStepsX + iX + iStepsX + 1,
|
|
iY * iStepsX + iX + iStepsX
|
|
};
|
|
|
|
float fHeight= pFloatHeight[ iOffsetVert[ 0 ] ];
|
|
float fMix= pFloatCenterMix[ iOffsetVert[ 0 ] ];
|
|
|
|
D3DXVECTOR3 v[ 8 ]=
|
|
{
|
|
PreMesh[ iOffsetVert[ 0 ] ].Pos(),
|
|
PreMesh[ iOffsetVert[ 1 ] ].Pos(),
|
|
PreMesh[ iOffsetVert[ 2 ] ].Pos(),
|
|
PreMesh[ iOffsetVert[ 3 ] ].Pos(),
|
|
PreMesh[ iOffsetVert[ 0 ] ].Pos() + PreMesh[ iOffsetVert[ 0 ] ].Normal() * fHeight,
|
|
PreMesh[ iOffsetVert[ 1 ] ].Pos() + PreMesh[ iOffsetVert[ 1 ] ].Normal() * fHeight,
|
|
PreMesh[ iOffsetVert[ 2 ] ].Pos() + PreMesh[ iOffsetVert[ 2 ] ].Normal() * fHeight,
|
|
PreMesh[ iOffsetVert[ 3 ] ].Pos() + PreMesh[ iOffsetVert[ 3 ] ].Normal() * fHeight,
|
|
};
|
|
|
|
|
|
D3DXVECTOR3 vCenter= 0.25f * ( v[4] + v[5] + v[6] + v[7] );
|
|
|
|
D3DXVec3Lerp( &v[4], &v[4], &vCenter, fMix );
|
|
D3DXVec3Lerp( &v[5], &v[5], &vCenter, fMix );
|
|
D3DXVec3Lerp( &v[6], &v[6], &vCenter, fMix );
|
|
D3DXVec3Lerp( &v[7], &v[7], &vCenter, fMix );
|
|
|
|
D3DXVECTOR3 n[8]=
|
|
{
|
|
PreMesh[ iOffsetVert[ 0 ] ].Normal(),
|
|
PreMesh[ iOffsetVert[ 1 ] ].Normal(),
|
|
PreMesh[ iOffsetVert[ 2 ] ].Normal(),
|
|
PreMesh[ iOffsetVert[ 3 ] ].Normal(),
|
|
};
|
|
{
|
|
D3DXVECTOR3 v1= PreMesh[ iOffsetVert[ 1 ] ].Pos() - PreMesh[ iOffsetVert[ 0 ] ].Pos();
|
|
D3DXVECTOR3 v2= v[4] - PreMesh[ iOffsetVert[ 0 ] ].Pos();
|
|
D3DXVec3Cross( &n[4], &v2, &v1 );
|
|
D3DXVec3Normalize( &n[4], &n[4] );
|
|
}
|
|
{
|
|
D3DXVECTOR3 v1= PreMesh[ iOffsetVert[ 2 ] ].Pos() - PreMesh[ iOffsetVert[ 1 ] ].Pos();
|
|
D3DXVECTOR3 v2= v[5] - PreMesh[ iOffsetVert[ 1 ] ].Pos();
|
|
D3DXVec3Cross( &n[5], &v2, &v1 );
|
|
D3DXVec3Normalize( &n[5], &n[5] );
|
|
}
|
|
{
|
|
D3DXVECTOR3 v1= PreMesh[ iOffsetVert[ 3 ] ].Pos() - PreMesh[ iOffsetVert[ 2 ] ].Pos();
|
|
D3DXVECTOR3 v2= v[6] - PreMesh[ iOffsetVert[ 2 ] ].Pos();
|
|
D3DXVec3Cross( &n[6], &v2, &v1 );
|
|
D3DXVec3Normalize( &n[6], &n[6] );
|
|
}
|
|
{
|
|
D3DXVECTOR3 v1= PreMesh[ iOffsetVert[ 0 ] ].Pos() - PreMesh[ iOffsetVert[ 3 ] ].Pos();
|
|
D3DXVECTOR3 v2= v[7] - PreMesh[ iOffsetVert[ 3 ] ].Pos();
|
|
D3DXVec3Cross( &n[7], &v2, &v1 );
|
|
D3DXVec3Normalize( &n[7], &n[7] );
|
|
}
|
|
|
|
|
|
/*int iFinalOffset= iY * ( iStepsX - 1 )+ iX;
|
|
iFinalOffset*= VertsPerStep;*/
|
|
|
|
float AOLeft= pFloatAOVHorz[ iOffsetVert[ 0 ] ];
|
|
float AORight= pFloatAOVHorz[ iOffsetVert[ 1 ] ];
|
|
float AOTop= pFloatAOVert[ iOffsetVert[ 0 ] ];
|
|
float AOBottom= pFloatAOVert[ iOffsetVert[ 3 ] ];
|
|
|
|
DWORD dwColor[ 5 ]=
|
|
{
|
|
ShadeColor( dwBaseColor, 1.0f ),
|
|
ShadeColor( dwBaseColor, AOTop ),
|
|
ShadeColor( dwBaseColor, AORight ),
|
|
ShadeColor( dwBaseColor, AOBottom ),
|
|
ShadeColor( dwBaseColor, AOLeft ),
|
|
};
|
|
|
|
/*dwColor[ 1 ]= (int)( 255.4f * AOTop );
|
|
dwColor[ 2 ]= (int)( 255.4f * AORight );
|
|
dwColor[ 3 ]= (int)( 255.4f * AOBottom );
|
|
dwColor[ 4 ]= (int)( 255.4f * AOLeft );
|
|
|
|
dwColor[ 1 ]= dwColor[ 1 ] << 16 | dwColor[ 1 ] << 8 | dwColor[ 1 ] | 0xff000000;
|
|
dwColor[ 2 ]= dwColor[ 2 ] << 16 | dwColor[ 2 ] << 8 | dwColor[ 2 ] | 0xff000000;
|
|
dwColor[ 3 ]= dwColor[ 3 ] << 16 | dwColor[ 3 ] << 8 | dwColor[ 3 ] | 0xff000000;
|
|
dwColor[ 4 ]= dwColor[ 4 ] << 16 | dwColor[ 4 ] << 8 | dwColor[ 4 ] | 0xff000000;*/
|
|
|
|
int iQuadOffsets[]=
|
|
{
|
|
4, 0, 0, // Deckel
|
|
5, 1, 0,
|
|
7, 3, 0,
|
|
6, 2, 0,
|
|
|
|
0, 4, 1, // Flanke oben
|
|
1, 4, 1,
|
|
4, 4, 0,
|
|
5, 4, 0,
|
|
|
|
1, 5, 2, // Flanke rechts
|
|
2, 5, 2,
|
|
5, 5, 0,
|
|
6, 5, 0,
|
|
|
|
2, 6, 3, // Flanke unten
|
|
3, 6, 3,
|
|
6, 6, 0,
|
|
7, 6, 0,
|
|
|
|
3, 7, 4, // Flanke links
|
|
0, 7, 4,
|
|
7, 7, 0,
|
|
4, 7, 0,
|
|
};
|
|
|
|
for( int i= 0; i < QuadsPerStep * 4; ++i )
|
|
{
|
|
Renderjob::SVertex V;
|
|
V.Pos()= v[ iQuadOffsets[ i * 3 ] ];
|
|
V.Normal()= n[ iQuadOffsets[ i * 3 + 1 ] ];
|
|
V.dwColor= dwColor[ iQuadOffsets[ i * 3 + 2 ] ];
|
|
V.tu= 0.0f;
|
|
V.tv= 0.0f;
|
|
g_Objects[ iObjID ].AddVertex( V );
|
|
}
|
|
}
|
|
}
|
|
|
|
int iV= 0;
|
|
for( int i= 0; i < QuadsPerStep * ( iStepsX - 1 ) * ( iStepsY - 1 ); ++i )
|
|
{
|
|
g_Objects[ iObjID ].AddIndex( iV + 2);
|
|
g_Objects[ iObjID ].AddIndex( iV + 1);
|
|
g_Objects[ iObjID ].AddIndex( iV + 0);
|
|
|
|
g_Objects[ iObjID ].AddIndex( iV + 3);
|
|
g_Objects[ iObjID ].AddIndex( iV + 1);
|
|
g_Objects[ iObjID ].AddIndex( iV + 2);
|
|
|
|
iV+= 4;
|
|
assert( iV <= g_Objects[ iObjID ].GetVertCount() );
|
|
}
|
|
|
|
g_Objects[ iObjID ].Unlock();
|
|
}
|
|
|
|
void Greeble::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;
|
|
}
|
|
}
|
|
|
|
void Greeble::PrepMesh()
|
|
{
|
|
const int iSizeX= pObj->m_iSizeX;
|
|
const int iSizeY= pObj->m_iSizeY;
|
|
|
|
Create2DFunc(
|
|
pObj->m_iOffsetFunc,
|
|
pObj->m_iOffsetBank,
|
|
PreFloats,
|
|
iSizeX,
|
|
iSizeY,
|
|
fTime);
|
|
|
|
/*const float fPiX= c_2PI / (float)( iSizeX - 1 );
|
|
const float fPiY= c_2PI / (float)( iSizeY - 1 );
|
|
|
|
CreateFloatFieldPlasma(
|
|
pObj->m_iOffsetBank, // ParamBank,
|
|
PreFloats, // pFloat,
|
|
fPiX, // fStepX
|
|
iSizeX, // iStepsX,
|
|
fPiY, // fStepY
|
|
iSizeY // iStepsY
|
|
);*/
|
|
|
|
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 );
|
|
|
|
/*W
|
|
CreateFloatFieldPlasma(
|
|
pObj->m_iHeightBank, // ParamBank,
|
|
PreFloat(1), // pFloat,
|
|
fPiX, // fStepX
|
|
iSizeX, // iStepsX,
|
|
fPiY, // fStepY
|
|
iSizeY // iStepsY
|
|
);
|
|
|
|
CreateFloatFieldPlasma(
|
|
pObj->m_iMixBank, // ParamBank,
|
|
PreFloat(2), // pFloat,
|
|
fPiX, // fStepX
|
|
iSizeX, // iStepsX,
|
|
fPiY, // fStepY
|
|
iSizeY // iStepsY
|
|
);
|
|
*/
|
|
|
|
PrepAO(
|
|
iSizeX,
|
|
iSizeY ,
|
|
PreFloat(1), // pFloatHeight,
|
|
PreFloat(2), // pFloatCenterMix,
|
|
PreFloat(3), // pFloatAOVert,
|
|
PreFloat(4), // pFloatAOVHorz
|
|
PreFloat(5) // Intermediate
|
|
);
|
|
|
|
CreateFinal3DMesh(
|
|
iSizeX,
|
|
iSizeY ,
|
|
PreFloat(1), // pFloatHeight,
|
|
PreFloat(2), // pFloatCenterMix,
|
|
PreFloat(3), // pFloatAOVert,
|
|
PreFloat(4), // pFloatAOVHorz
|
|
pObj->m_dwColor
|
|
);
|
|
}
|
|
|
|
/*void Greeble::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 Greeble::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;
|
|
|
|
float zf= 400.0f;
|
|
float zn= 0.125f;
|
|
float xScale = 1.0f;
|
|
float yScale= xScale / (float)c_iScreenSizeY * (float)c_iScreenSizeX;
|
|
|
|
mat._11= xScale; mat._12= 0; mat._13= 0; mat._14= 0;
|
|
mat._21= 0; mat._22= yScale; mat._23= 0; mat._24= 0;
|
|
mat._31= 0; mat._32= 0; mat._33= zf/(zf-zn); mat._34= 1;
|
|
mat._41= 0; mat._42= 0; mat._43= -zn*zf/(zf-zn);mat._44= 0;
|
|
|
|
g_d3d_device->SetTransform( D3DTS_PROJECTION, &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;
|
|
}
|
|
}
|
|
}*/ |