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

843
evoke-64k/trunk/ev10/Greeble.cpp Normal file
View File

@@ -0,0 +1,843 @@
#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;
}
}
}*/