// Render aditional pass for fog and haze
void shaDoFogPass(void)
{
// if full bright
if(shaGetFlags()&BASE_FULL_BRIGHT) {
// no fog pass
return;
}
ASSERT(_paFogUVMap==NULL);
ASSERT(_paHazeUVMap==NULL);
// Calculate fog and haze uvmap for this opaque surface
RM_DoFogAndHaze(TRUE);
// if fog uvmap has been given
if(_paFogUVMap!=NULL) {
// setup texture/color arrays and rendering mode
gfxSetTextureWrapping( GFX_CLAMP, GFX_CLAMP);
gfxSetTexture( _fog_ulTexture, _fog_tpLocal);
gfxSetTexCoordArray(_paFogUVMap, FALSE);
gfxSetConstantColor(_fog_fp.fp_colColor);
gfxBlendFunc( GFX_SRC_ALPHA, GFX_INV_SRC_ALPHA);
gfxEnableBlend();
// render fog pass
gfxDrawElements( _ctIndices, _paIndices);
}
// if haze uvmap has been given
if(_paHazeUVMap!=NULL) {
gfxSetTextureWrapping( GFX_CLAMP, GFX_CLAMP);
gfxSetTexture( _haze_ulTexture, _haze_tpLocal);
gfxSetTexCoordArray(_paHazeUVMap, TRUE);
gfxBlendFunc( GFX_SRC_ALPHA, GFX_INV_SRC_ALPHA);
gfxEnableBlend();
// set vertex color array for haze
if(_pacolVtxHaze !=NULL ) {
gfxSetColorArray( _pacolVtxHaze);
}
// render fog pass
gfxDrawElements( _ctIndices, _paIndices);
}
}
static void RenderHazeLayer(INDEX itt)
{
FLOAT3D vObjPosition = _ptrTerrain->tr_penEntity->en_plPlacement.pl_PositionVector;
_fHazeAdd = -_haze_hp.hp_fNear;
_fHazeAdd += _vViewer(1) * (vObjPosition(1) - _aprProjection->pr_vViewerPosition(1));
_fHazeAdd += _vViewer(2) * (vObjPosition(2) - _aprProjection->pr_vViewerPosition(2));
_fHazeAdd += _vViewer(3) * (vObjPosition(3) - _aprProjection->pr_vViewerPosition(3));
GFXVertex *pvVtx;
INDEX *piIndices;
INDEX ctVertices;
INDEX ctIndices;
// if this is tile
if(itt>=0) {
CTerrainTile &tt = _ptrTerrain->tr_attTiles[itt];
pvVtx = &tt.GetVertices()[0];
piIndices = &tt.GetIndices()[0];
ctVertices = tt.GetVertices().Count();
ctIndices = tt.GetIndices().Count();
// else this are batched tiles
} else {
pvVtx = &_avDelayedVertices[0];
piIndices = &_aiDelayedIndices[0];
ctVertices = _avDelayedVertices.Count();
ctIndices = _aiDelayedIndices.Count();
}
GFXTexCoord *pfHazeTC = _atcHaze.Push(ctVertices);
GFXColor *pcolHaze = _acolHaze.Push(ctVertices);
const COLOR colH = AdjustColor( _haze_hp.hp_colColor, _slTexHueShift, _slTexSaturation);
GFXColor colHaze(colH);
// for each vertex in tile
for(INDEX ivx=0;ivx<ctVertices;ivx++) {
GetHazeMapInVertex(pvVtx[ivx],pfHazeTC[ivx]);
pcolHaze[ivx] = colHaze;
}
// render haze layer
gfxDepthFunc(GFX_EQUAL);
gfxSetTextureWrapping( GFX_CLAMP, GFX_CLAMP);
gfxSetTexture( _haze_ulTexture, _haze_tpLocal);
gfxSetTexCoordArray(pfHazeTC, FALSE);
gfxSetColorArray(pcolHaze);
gfxBlendFunc( GFX_SRC_ALPHA, GFX_INV_SRC_ALPHA);
gfxEnableBlend();
gfxDrawElements(ctIndices,piIndices);
gfxDepthFunc(GFX_LESS_EQUAL);
_atcHaze.PopAll();
_acolHaze.PopAll();
}
static void InitTexture(void)
{
const SLONG slSize = 256*256 *4 *4/3 +16;
_pubTexture = (UBYTE*)AllocMemory(slSize);
for( INDEX i=0; i<256; i++) {
for( INDEX j=0; j<256; j++) {
_pubTexture[(j*256+i)*4+0] = i;
_pubTexture[(j*256+i)*4+1] = j;
_pubTexture[(j*256+i)*4+2] = i+j;
_pubTexture[(j*256+i)*4+3] = i-j;
}
}
MakeMipmaps( 15, (ULONG*)_pubTexture, 256,256);
_tpLocal.tp_bSingleMipmap = FALSE;
gfxGenerateTexture( _ulTexObject);
gfxSetTexture( _ulTexObject, _tpLocal);
}
// fill rate benchmark
static DOUBLE FillRatePass(INDEX ct)
{
if( !_pdp->Lock()) {
ASSERT(FALSE);
return 0.0;
}
StartTimer();
_pdp->Fill(C_GRAY|255);
_pdp->FillZBuffer(1.0f);
GFXVertex avtx[4];
avtx[0].x = 0; avtx[0].y = 0; avtx[0].z = 0.5f;
avtx[1].x = 0; avtx[1].y = _pixSizeJ; avtx[1].z = 0.5f;
avtx[2].x = _pixSizeI; avtx[2].y = _pixSizeJ; avtx[2].z = 0.5f;
avtx[3].x = _pixSizeI; avtx[3].y = 0; avtx[3].z = 0.5f;
GFXTexCoord atex[4] = { {0,0}, {0,1}, {1,1}, {1,0} };
GFXColor acol[4] = { 0xFF0000FF, 0xFF00FF00, 0xFFFF0000, 0xFFFF00FF };
INDEX_T aidx[6] = { 0,1,2, 0,2,3};
gfxSetVertexArray( &avtx[0], 4);
gfxSetTexCoordArray( &atex[0], FALSE);
gfxSetColorArray( &acol[0]);
if(_bTexture) {
gfxEnableTexture();
if(_bMultiTexture) {
gfxSetTextureUnit(1);
gfxEnableTexture();
gfxSetTexture( _ulTexObject, _tpLocal);
gfxSetTexCoordArray(atex, FALSE);
gfxSetTextureUnit(0);
}
} else {
gfxDisableTexture();
}
if(_bBlend) {
gfxEnableBlend();
if(_bTexture) {
gfxBlendFunc( GFX_SRC_ALPHA, GFX_INV_SRC_ALPHA);
} else {
gfxBlendFunc( GFX_ONE, GFX_ONE);
}
} else {
gfxDisableBlend();
}
if(_bDepth) {
gfxEnableDepthTest();
gfxEnableDepthWrite();
} else {
gfxDisableDepthTest();
gfxDisableDepthWrite();
}
gfxDisableAlphaTest();
for( INDEX i=0; i<ct; i++) gfxDrawElements( 6, &aidx[0]);
if(_bMultiTexture) {
gfxSetTextureUnit(1);
gfxDisableTexture();
gfxSetTextureUnit(0);
}
_pdp->Unlock();
gfxFinish();
_pvp->SwapBuffers();
return StopTimer();
}
static DOUBLE TrisTroughputPass(INDEX ct)
{
if( !_pdp->Lock()) {
ASSERT(FALSE);
return 0.0;
}
StartTimer();
gfxSetFrustum( -0.5f, +0.5f, -0.5f, +0.5f, 0.5f, 2.0f);
gfxSetViewMatrix(NULL);
gfxCullFace(GFX_NONE);
_pdp->Fill(C_GRAY|255);
_pdp->FillZBuffer(1.0f);
if(_bTexture) {
gfxEnableTexture();
} else {
gfxDisableTexture();
}
if(_bBlend) {
gfxEnableBlend();
gfxBlendFunc( GFX_ONE, GFX_ONE);
} else {
gfxDisableBlend();
}
if(_bDepth) {
gfxEnableDepthTest();
gfxEnableDepthWrite();
} else {
gfxDisableDepthTest();
gfxDisableDepthWrite();
}
gfxDisableAlphaTest();
gfxSetVertexArray( &_avtx[0], _avtx.Count());
gfxLockArrays();
gfxSetTexCoordArray( &_atex[0], FALSE);
gfxSetColorArray( &_acol[0]);
if(_bMultiTexture) {
gfxSetTextureUnit(1);
gfxEnableTexture();
gfxSetTexture( _ulTexObject, _tpLocal);
gfxSetTexCoordArray( &_atex[0], FALSE);
gfxSetTextureUnit(0);
}
for( INDEX i=0; i<ct; i++) gfxDrawElements( _aiElements.Count(), &_aiElements[0]);
gfxUnlockArrays();
if(_bMultiTexture) {
gfxSetTextureUnit(1);
gfxDisableTexture();
gfxSetTextureUnit(0);
}
_pdp->Unlock();
gfxFinish();
_pvp->SwapBuffers();
return StopTimer();
}
static void RenderFogLayer(INDEX itt)
{
FLOATmatrix3D &mViewer = _aprProjection->pr_ViewerRotationMatrix;
FLOAT3D vObjPosition = _ptrTerrain->tr_penEntity->en_plPlacement.pl_PositionVector;
// get viewer -z in object space
_vFViewerObj = FLOAT3D(0,0,-1) * !_mObjectToView;
// get fog direction in object space
_vHDirObj = _fog_vHDirAbs * !(!mViewer*_mObjectToView);
// get viewer offset
_fFogAddZ = _vViewer(1) * (vObjPosition(1) - _aprProjection->pr_vViewerPosition(1));
_fFogAddZ += _vViewer(2) * (vObjPosition(2) - _aprProjection->pr_vViewerPosition(2));
_fFogAddZ += _vViewer(3) * (vObjPosition(3) - _aprProjection->pr_vViewerPosition(3));
// get fog offset
_fFogAddH = (_fog_vHDirAbs % vObjPosition) + _fog_fp.fp_fH3;
GFXVertex *pvVtx;
INDEX *piIndices;
INDEX ctVertices;
INDEX ctIndices;
// if this is tile
if(itt>=0) {
CTerrainTile &tt = _ptrTerrain->tr_attTiles[itt];
pvVtx = &tt.GetVertices()[0];
piIndices = &tt.GetIndices()[0];
ctVertices = tt.GetVertices().Count();
ctIndices = tt.GetIndices().Count();
// else this are batched tiles
} else {
pvVtx = &_avDelayedVertices[0];
piIndices = &_aiDelayedIndices[0];
ctVertices = _avDelayedVertices.Count();
ctIndices = _aiDelayedIndices.Count();
}
GFXTexCoord *pfFogTC = _atcHaze.Push(ctVertices);
GFXColor *pcolFog = _acolHaze.Push(ctVertices);
const COLOR colF = AdjustColor( _fog_fp.fp_colColor, _slTexHueShift, _slTexSaturation);
GFXColor colFog(colF);
// for each vertex in tile
for(INDEX ivx=0;ivx<ctVertices;ivx++) {
GetFogMapInVertex(pvVtx[ivx],pfFogTC[ivx]);
pcolFog[ivx] = colFog;
}
// render fog layer
gfxDepthFunc(GFX_EQUAL);
gfxSetTextureWrapping( GFX_CLAMP, GFX_CLAMP);
gfxSetTexture( _fog_ulTexture, _fog_tpLocal);
gfxSetTexCoordArray(pfFogTC, FALSE);
gfxSetColorArray(pcolFog);
gfxBlendFunc( GFX_SRC_ALPHA, GFX_INV_SRC_ALPHA);
gfxEnableBlend();
gfxDisableAlphaTest();
gfxDrawElements(ctIndices,piIndices);
gfxDepthFunc(GFX_LESS_EQUAL);
_atcHaze.PopAll();
_acolHaze.PopAll();
}
