q3aql/Serious-Engine
q3aql/Serious-Engine
1
0
Fork 0
mirror of https://github.com/ptitSeb/Serious-Engine synced 2024-11-25 19:55:54 +01:00
Code Issues Packages Projects Releases Wiki Activity
3ef902a04a
Serious-Engine/Sources/Engine/Graphics/DrawPort_RenderScene.cpp

1999 lines
68 KiB
C++
Executable File
Raw Blame History

/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include <Engine/StdH.h>
#include <Engine/Graphics/DrawPort.h>
#include <Engine/Base/Statistics_Internal.h>
#include <Engine/Base/Console.h>
#include <Engine/Math/Projection.h>
#include <Engine/Graphics/RenderScene.h>
#include <Engine/Graphics/Texture.h>
#include <Engine/Graphics/GfxLibrary.h>
#include <Engine/Graphics/GfxProfile.h>
#include <Engine/Graphics/ShadowMap.h>
#include <Engine/Graphics/Fog_internal.h>
#include <Engine/Brushes/Brush.h>
#include <Engine/Brushes/BrushTransformed.h>
#include <Engine/Templates/StaticStackArray.cpp>
// asm shortcuts
#define O offset
#define Q qword ptr
#define D dword ptr
#define W word ptr
#define B byte ptr
#define MAXTEXUNITS 4
#define SHADOWTEXTURE 3
extern INDEX wld_bShowTriangles;
extern INDEX wld_bShowDetailTextures;
extern INDEX wld_bRenderShadowMaps;
extern INDEX wld_bRenderTextures;
extern INDEX wld_bRenderDetailPolygons;
extern INDEX wld_iDetailRemovingBias;
extern INDEX wld_bAccurateColors;
extern INDEX gfx_bRenderWorld;
extern INDEX shd_iForceFlats;
extern INDEX shd_bShowFlats;
extern BOOL _bMultiPlayer;
extern BOOL CVA_bWorld;
static GfxAPIType eAPI;
// vertex coordinates and elements used by one pass of polygons
static CStaticStackArray<GFXVertex> _avtxPass;
static CStaticStackArray<GFXTexCoord> _atexPass[MAXTEXUNITS];
static CStaticStackArray<GFXColor> _acolPass;
static CStaticStackArray<INDEX_T> _aiElements;
// general coordinate stack referenced by the scene polygons
CStaticStackArray<GFXVertex3> _avtxScene;
// group flags (single-texturing)
#define GF_TX0 (1L<<0)
#define GF_TX1 (1L<<1)
#define GF_TX2 (1L<<2)
#define GF_SHD (1L<<3)
#define GF_FLAT (1L<<4) // flat fill instead of texture 1
#define GF_TA1 (1L<<5) // texture 2 after shade
#define GF_TA2 (1L<<6) // texture 3 after shade
#define GF_FOG (1L<<7)
#define GF_HAZE (1L<<8)
#define GF_SEL (1L<<9)
#define GF_KEY (1L<<10) // first layer requires alpha-keying
// texture combinations for max 4 texture units (fog, haze and selection not included)
#define GF_TX0_TX1 (1L<<11)
#define GF_TX0_TX2 (1L<<12)
#define GF_TX0_SHD (1L<<13)
#define GF_TX2_SHD (1L<<14) // second pass
#define GF_TX0_TX1_TX2 (1L<<15)
#define GF_TX0_TX1_SHD (1L<<16)
#define GF_TX0_TX2_SHD (1L<<17)
#define GF_TX0_TX1_TX2_SHD (1L<<18)
// total number of groups
#define GROUPS_MAXCOUNT (1L<<11) // max group +1 !
#define GROUPS_MINCOUNT (1L<<4)-1 // min group !
static ScenePolygon *_apspoGroups[GROUPS_MAXCOUNT];
static INDEX _ctGroupsCount=0;
// some static vars
static FLOAT _fHazeMul, _fHazeAdd;
static FLOAT _fFogMul;
static COLOR _colSelection;
static INDEX _ctUsableTexUnits;
static BOOL _bTranslucentPass; // rendering translucent polygons
static ULONG _ulLastFlags[MAXTEXUNITS];
static ULONG _ulLastBlends[MAXTEXUNITS];
static INDEX _iLastFrameNo[MAXTEXUNITS];
static CTextureData *_ptdLastTex[MAXTEXUNITS];
static CDrawPort *_pDP;
static CPerspectiveProjection3D *_ppr = NULL;
// draw batched elements
static void FlushElements(void)
{
// skip if empty
const INDEX ctElements = _aiElements.Count();
if( ctElements<3) return;
// draw
const INDEX ctTris = ctElements/3;
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_DRAWELEMENTS);
_pfGfxProfile.IncrementCounter( CGfxProfile::PCI_RS_TRIANGLEPASSESOPT, ctTris);
_sfStats.IncrementCounter( CStatForm::SCI_SCENE_TRIANGLEPASSES, ctTris);
_pGfx->gl_ctWorldTriangles += ctTris;
gfxDrawElements( ctElements, &_aiElements[0]);
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_DRAWELEMENTS);
// reset
_aiElements.PopAll();
}
// batch elements of one polygon
static
#if (!defined __GNUC__)
__forceinline
#endif
void AddElements( ScenePolygon *pspo)
{
const INDEX ctElems = pspo->spo_ctElements;
INDEX_T *piDst = _aiElements.Push(ctElems);
#if (defined __MSVC_INLINE__)
__asm {
mov eax,D [pspo]
mov ecx,D [ctElems]
mov edi,D [piDst]
mov esi,D [eax]ScenePolygon.spo_piElements
mov ebx,D [eax]ScenePolygon.spo_iVtx0Pass
movd mm1,ebx
movq mm0,mm1
psllq mm1,32
por mm1,mm0
shr ecx,1
jz elemRest
elemLoop:
movq mm0,Q [esi]
paddd mm0,mm1
movq Q [edi],mm0
add esi,8
add edi,8
dec ecx
jnz elemLoop
elemRest:
emms
test [ctElems],1
jz elemDone
mov eax,D [esi]
add eax,ebx
mov D [edi],eax
elemDone:
}
#elif (defined __GNU_INLINE_X86_32__)
__asm__ __volatile__ (
"movl %[ctElems], %%ecx \n\t"
"movl %[piDst], %%edi \n\t"
"movl %[piElements], %%esi \n\t"
"movd %[iVtx0Pass], %%mm1 \n\t"
"movq %%mm1, %%mm0 \n\t"
"psllq $32, %%mm1 \n\t"
"por %%mm0, %%mm1 \n\t"
"shrl $1, %%ecx \n\t"
"jz 1f \n\t" // elemRest
"0: \n\t" // elemLoop
"movq (%%esi), %%mm0 \n\t"
"paddd %%mm1, %%mm0 \n\t"
"movq %%mm0, (%%edi) \n\t"
"addl $8, %%esi \n\t"
"addl $8, %%edi \n\t"
"decl %%ecx \n\t"
"jnz 0b \n\t" // elemLoop
"1: \n\t" // elemRest
"emms \n\t"
"testl $1, %[ctElems] \n\t"
"jz 2f \n\t" // elemDone
"movl (%%esi), %%eax \n\t"
"addl %[iVtx0Pass], %%eax \n\t"
"movl %%eax, (%%edi) \n\t"
"2: \n\t" // elemDone
: // no outputs.
: [ctElems] "g" (ctElems), [piDst] "g" (piDst),
[piElements] "g" (pspo->spo_piElements),
[iVtx0Pass] "g" (pspo->spo_iVtx0Pass)
: FPU_REGS, "mm0", "mm1", "eax", "ecx", "esi", "edi",
"cc", "memory"
);
#else
const INDEX iVtx0Pass = pspo->spo_iVtx0Pass;
const INDEX *piSrc = pspo->spo_piElements;
for( INDEX iElem=0; iElem<ctElems; iElem++) {
// make an element in per-pass arrays
piDst[iElem] = piSrc[iElem]+iVtx0Pass;
}
#endif
}
// draw all elements of one pass
static __forceinline void DrawAllElements( ScenePolygon *pspoFirst)
{
ASSERT( _aiElements.Count()==0);
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_DRAWELEMENTS);
for( ScenePolygon *pspo=pspoFirst; pspo!=NULL; pspo=pspo->spo_pspoSucc) {
const INDEX ctTris = pspo->spo_ctElements/3;
_pfGfxProfile.IncrementCounter( CGfxProfile::PCI_RS_TRIANGLEPASSESOPT, ctTris);
_sfStats.IncrementCounter( CStatForm::SCI_SCENE_TRIANGLEPASSES, ctTris);
_pGfx->gl_ctWorldTriangles += ctTris;
AddElements(pspo);
}
FlushElements();
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_DRAWELEMENTS);
}
// calculate mip factor for a texture and adjust its mapping vectors
static BOOL RSMakeMipFactorAndAdjustMapping( ScenePolygon *pspo, INDEX iLayer)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_MAKEMIPFACTOR);
BOOL bRemoved = FALSE;
MEX mexTexSizeU, mexTexSizeV;
CMappingVectors &mv = pspo->spo_amvMapping[iLayer];
// texture map ?
if( iLayer<SHADOWTEXTURE)
{
const ULONG ulBlend = pspo->spo_aubTextureFlags[iLayer] & STXF_BLEND_MASK;
CTextureData *ptd = (CTextureData*)pspo->spo_aptoTextures[iLayer]->GetData();
mexTexSizeU = ptd->GetWidth();
mexTexSizeV = ptd->GetHeight();
// check whether detail can be rejected (but don't reject colorized textures)
if( ulBlend==STXF_BLEND_SHADE && (ptd->td_ulFlags&TEX_EQUALIZED)
&& (pspo->spo_acolColors[iLayer]&0xFFFFFF00)==0xFFFFFF00)
{ // get nearest vertex Z distance from viewer and u and v steps
const FLOAT fZ = pspo->spo_fNearestZ;
const FLOAT f1oPZ1 = fZ / _ppr->ppr_PerspectiveRatios(1);
const FLOAT f1oPZ2 = fZ / _ppr->ppr_PerspectiveRatios(2);
const FLOAT fDUoDI = Abs( mv.mv_vU(1) *f1oPZ1);
const FLOAT fDUoDJ = Abs( mv.mv_vU(2) *f1oPZ2);
const FLOAT fDVoDI = Abs( mv.mv_vV(1) *f1oPZ1);
const FLOAT fDVoDJ = Abs( mv.mv_vV(2) *f1oPZ2);
// find mip factor and adjust removing of texture layer
const FLOAT fMaxDoD = Max( Max(fDUoDI,fDUoDJ), Max(fDVoDI,fDVoDJ));
const INDEX iMipFactor = wld_iDetailRemovingBias + (((SLONG&)fMaxDoD)>>23) -127 +10;
const INDEX iLastMip = ptd->td_iFirstMipLevel + ptd->GetNoOfMips() -1; // determine last mipmap in texture
bRemoved = (iMipFactor>=iLastMip);
// check for detail texture showing
extern INDEX wld_bShowDetailTextures;
if( wld_bShowDetailTextures) {
if( iLayer==2) pspo->spo_acolColors[iLayer] = C_MAGENTA|255;
else pspo->spo_acolColors[iLayer] = C_CYAN |255;
}
}
// check if texture has been blended with low alpha
else bRemoved = (ulBlend==STXF_BLEND_ALPHA) && ((pspo->spo_acolColors[iLayer]&CT_AMASK)>>CT_ASHIFT)<3;
}
// shadow map
else
{
mexTexSizeU = pspo->spo_psmShadowMap->sm_mexWidth;
mexTexSizeV = pspo->spo_psmShadowMap->sm_mexHeight;
}
// adjust texture gradients
if( mexTexSizeU!=1024) {
const FLOAT fMul = 1024.0f /mexTexSizeU; // (no need to do shift-opt, because it won't speed up much!)
mv.mv_vU(1) *=fMul; mv.mv_vU(2) *=fMul; mv.mv_vU(3) *=fMul;
}
if( mexTexSizeV!=1024) {
const FLOAT fMul = 1024.0f /mexTexSizeV;
mv.mv_vV(1) *=fMul; mv.mv_vV(2) *=fMul; mv.mv_vV(3) *=fMul;
}
// all done
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_MAKEMIPFACTOR);
return bRemoved;
}
// Remove all polygons with no triangles from a list
static void RSRemoveDummyPolygons( ScenePolygon *pspoAll, ScenePolygon **ppspoNonDummy)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_REMOVEDUMMY);
*ppspoNonDummy = NULL;
// for all span polygons in list (remember one ahead to be able to reconnect them)
ScenePolygon *pspoNext;
for( ScenePolygon *pspoThis=pspoAll; pspoThis!=NULL; pspoThis=pspoNext) {
pspoNext = pspoThis->spo_pspoSucc;
// if the polygon has some triangles
if( pspoThis->spo_ctElements >0) {
// move it to the other list
pspoThis->spo_pspoSucc = *ppspoNonDummy;
*ppspoNonDummy = pspoThis;
}
}
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_REMOVEDUMMY);
}
// bin polygons into groups
static void RSBinToGroups( ScenePolygon *pspoFirst)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_BINTOGROUPS);
// clamp texture layers
extern INDEX wld_bTextureLayers;
BOOL bTextureLayer1 =(wld_bTextureLayers /100) || _bMultiPlayer; // must be enabled in multiplayer mode!
BOOL bTextureLayer2 = wld_bTextureLayers /10 %10;
BOOL bTextureLayer3 = wld_bTextureLayers %10;
wld_bTextureLayers = 0;
if( bTextureLayer1) wld_bTextureLayers += 100;
if( bTextureLayer2) wld_bTextureLayers += 10;
if( bTextureLayer3) wld_bTextureLayers += 1;
// cache rendering states
bTextureLayer1 = bTextureLayer1 && wld_bRenderTextures;
bTextureLayer2 = bTextureLayer2 && wld_bRenderTextures;
bTextureLayer3 = bTextureLayer3 && wld_bRenderTextures;
// clear all groups initially
memset( _apspoGroups, 0, sizeof(_apspoGroups));
_ctGroupsCount = GROUPS_MINCOUNT;
// for all span polygons in list (remember one ahead to be able to reconnect them)
for( ScenePolygon *pspoNext, *pspo=pspoFirst; pspo!=NULL; pspo=pspoNext)
{
pspoNext = pspo->spo_pspoSucc;
const INDEX ctTris = pspo->spo_ctElements/3;
ULONG ulBits = NONE;
// if it has texture 1 active
if( pspo->spo_aptoTextures[0]!=NULL && bTextureLayer1) {
_pfGfxProfile.IncrementCounter( CGfxProfile::PCI_RS_TRIANGLEPASSESORG, ctTris);
// prepare mapping for texture 0 and generate its mip factor
const BOOL bRemoved = RSMakeMipFactorAndAdjustMapping( pspo, 0);
if( !bRemoved) ulBits |= GF_TX0; // add if not removed
} else {
// flat fill is mutually exclusive with texture layer0
_ctGroupsCount |= GF_FLAT;
ulBits |= GF_FLAT;
}
// if it has texture 2 active
if( pspo->spo_aptoTextures[1]!=NULL && bTextureLayer2) {
_pfGfxProfile.IncrementCounter( CGfxProfile::PCI_RS_TRIANGLEPASSESORG, ctTris);
// prepare mapping for texture 1 and generate its mip factor
const BOOL bRemoved = RSMakeMipFactorAndAdjustMapping( pspo, 1);
if( !bRemoved) { // add if not removed
if( pspo->spo_aubTextureFlags[1] & STXF_AFTERSHADOW) {
_ctGroupsCount |= GF_TA1;
ulBits |= GF_TA1;
} else {
ulBits |= GF_TX1;
}
}
}
// if it has texture 3 active
if( pspo->spo_aptoTextures[2]!=NULL && bTextureLayer3) {
_pfGfxProfile.IncrementCounter( CGfxProfile::PCI_RS_TRIANGLEPASSESORG, ctTris);
// prepare mapping for texture 2 and generate its mip factor
const BOOL bRemoved = RSMakeMipFactorAndAdjustMapping( pspo, 2);
if( !bRemoved) { // add if not removed
if( pspo->spo_aubTextureFlags[2] & STXF_AFTERSHADOW) {
_ctGroupsCount |= GF_TA2;
ulBits |= GF_TA2;
} else {
ulBits |= GF_TX2;
}
}
}
// if it has shadowmap active
if( pspo->spo_psmShadowMap!=NULL && wld_bRenderShadowMaps) {
_pfGfxProfile.IncrementCounter( CGfxProfile::PCI_RS_TRIANGLEPASSESORG, ctTris);
// prepare shadow map
CShadowMap *psmShadow = pspo->spo_psmShadowMap;
psmShadow->Prepare();
const BOOL bFlat = psmShadow->IsFlat();
COLOR colFlat = psmShadow->sm_colFlat & 0xFFFFFF00;
const BOOL bOverbright = (colFlat & 0x80808000);
// only need to update poly color if shadowmap is flat
if( bFlat) {
if( !bOverbright || shd_iForceFlats==1) {
if( shd_bShowFlats) colFlat = C_mdMAGENTA; // show flat shadows?
else { // enhance light color to emulate overbrighting
if( !bOverbright) colFlat<<=1;
else {
UBYTE ubR,ubG,ubB;
ColorToRGB( colFlat, ubR,ubG,ubB);
const ULONG ulR = ClampUp( ((ULONG)ubR)<<1, (ULONG) 255);
const ULONG ulG = ClampUp( ((ULONG)ubG)<<1, (ULONG) 255);
const ULONG ulB = ClampUp( ((ULONG)ubB)<<1, (ULONG) 255);
colFlat = RGBToColor(ulR,ulG,ulB);
}
} // mix color in the first texture layer
COLOR &colTotal = pspo->spo_acolColors[0];
COLOR colLayer = pspo->spo_acolColors[3];
if( colTotal==0xFFFFFFFF) colTotal = colLayer;
else if( colLayer!=0xFFFFFFFF) colTotal = MulColors( colTotal, colLayer);
if( colTotal==0xFFFFFFFF) colTotal = colFlat;
else colTotal = MulColors( colTotal, colFlat);
psmShadow->MarkDrawn();
}
else {
// need to update poly color if shadowmap is flat and overbrightened
COLOR &colTotal = pspo->spo_acolColors[3];
if( shd_bShowFlats) colFlat = C_mdBLUE; // overbrightened!
if( colTotal==0xFFFFFFFF) colTotal = colFlat;
else colTotal = MulColors( colTotal, colFlat);
ulBits |= GF_SHD; // mark the need for shadow layer
}
} else {
// prepare mapping for shadowmap and generate its mip factor
RSMakeMipFactorAndAdjustMapping( pspo, SHADOWTEXTURE);
ulBits |= GF_SHD;
}
}
// if it has fog active
if( pspo->spo_ulFlags&SPOF_RENDERFOG) {
_pfGfxProfile.IncrementCounter( CGfxProfile::PCI_RS_TRIANGLEPASSESORG, ctTris);
_ctGroupsCount |= GF_FOG;
ulBits |= GF_FOG;
}
// if it has haze active
if( pspo->spo_ulFlags&SPOF_RENDERHAZE) {
_pfGfxProfile.IncrementCounter( CGfxProfile::PCI_RS_TRIANGLEPASSESORG, ctTris);
_ctGroupsCount |= GF_HAZE;
ulBits |= GF_HAZE;
}
// if it is selected
if( pspo->spo_ulFlags&SPOF_SELECTED) {
_pfGfxProfile.IncrementCounter( CGfxProfile::PCI_RS_TRIANGLEPASSESORG, ctTris);
_ctGroupsCount |= GF_SEL;
ulBits |= GF_SEL;
}
// if it is transparent
if( pspo->spo_ulFlags&SPOF_TRANSPARENT) {
_pfGfxProfile.IncrementCounter( CGfxProfile::PCI_RS_TRIANGLEPASSESORG, ctTris);
_ctGroupsCount |= GF_KEY;
ulBits |= GF_KEY;
}
// in case of at least one layer, add it to proper group
if( ulBits) {
_pfGfxProfile.IncrementCounter( CGfxProfile::PCI_RS_TRIANGLES, ctTris);
pspo->spo_pspoSucc = _apspoGroups[ulBits];
_apspoGroups[ulBits] = pspo;
}
}
// determine maximum used groups
ASSERT( _ctGroupsCount);
#if (defined __MSVC_INLINE__)
__asm {
mov eax,2
bsr ecx,D [_ctGroupsCount]
shl eax,cl
mov D [_ctGroupsCount],eax
}
#elif (defined __GNU_INLINE_X86_32__)
__asm__ __volatile__ (
"movl $2, %%eax \n\t"
"bsrl (%%esi), %%ecx \n\t"
"shll %%cl, %%eax \n\t"
"movl %%eax, (%%esi) \n\t"
: // no outputs.
: "S" (&_ctGroupsCount)
: "eax", "ecx", "cc", "memory"
);
#else
// emulate x86's bsr opcode...
// GCC and clang have an architecture-independent intrinsic for this
// (it counts leading zeros starting at MSB and is undefined for 0)
#ifdef __GNUC__
INDEX bsr = 31;
if(_ctGroupsCount != 0) bsr -= __builtin_clz(_ctGroupsCount);
else bsr = 0;
#else // another compiler - doing it manually.. not fast. :/
register DWORD val = _ctGroupsCount;
register INDEX bsr = 31;
if (val != 0)
{
while (bsr > 0)
{
if (val & (1l << bsr))
break;
bsr--;
}
}
#endif
_ctGroupsCount = 2 << bsr;
#endif
// done with bining
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_BINTOGROUPS);
}
// bin polygons that can use dual-texturing
static void RSBinByDualTexturing( ScenePolygon *pspoGroup, INDEX iLayer1, INDEX iLayer2,
ScenePolygon **ppspoST, ScenePolygon **ppspoMT)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_BINBYMULTITEXTURING);
*ppspoST = NULL;
*ppspoMT = NULL;
// for all span polygons in list (remember one ahead to be able to reconnect them)
for( ScenePolygon *pspoNext, *pspo=pspoGroup; pspo!=NULL; pspo=pspoNext)
{
pspoNext = pspo->spo_pspoSucc;
// if first texture is opaque or shade and second layer is shade
if( ((pspo->spo_aubTextureFlags[iLayer1]&STXF_BLEND_MASK)==STXF_BLEND_OPAQUE
|| (pspo->spo_aubTextureFlags[iLayer1]&STXF_BLEND_MASK)==STXF_BLEND_SHADE)
&& (pspo->spo_aubTextureFlags[iLayer2]&STXF_BLEND_MASK)==STXF_BLEND_SHADE) {
// can be merged, so put to multi-texture
pspo->spo_pspoSucc = *ppspoMT;
*ppspoMT = pspo;
} else {
// cannot be merged, so put to single-texture
pspo->spo_pspoSucc = *ppspoST;
*ppspoST = pspo;
}
}
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_BINBYMULTITEXTURING);
}
// bin polygons that can use triple-texturing
static void RSBinByTripleTexturing( ScenePolygon *pspoGroup, INDEX iLayer2, INDEX iLayer3,
ScenePolygon **ppspoST, ScenePolygon **ppspoMT)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_BINBYMULTITEXTURING);
*ppspoST = NULL;
*ppspoMT = NULL;
// for all span polygons in list (remember one ahead to be able to reconnect them)
for( ScenePolygon *pspoNext, *pspo=pspoGroup; pspo!=NULL; pspo=pspoNext)
{
pspoNext = pspo->spo_pspoSucc;
// if texture is shade and colors allow merging
if( (pspo->spo_aubTextureFlags[iLayer3]&STXF_BLEND_MASK)==STXF_BLEND_SHADE) {
// can be merged, so put to multi-texture
pspo->spo_pspoSucc = *ppspoMT;
*ppspoMT = pspo;
} else {
// cannot be merged, so put to single-texture
pspo->spo_pspoSucc = *ppspoST;
*ppspoST = pspo;
}
}
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_BINBYMULTITEXTURING);
}
// bin polygons that can use quad-texturing
static void RSBinByQuadTexturing( ScenePolygon *pspoGroup, ScenePolygon **ppspoST, ScenePolygon **ppspoMT)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_BINBYMULTITEXTURING);
*ppspoST = NULL;
*ppspoMT = pspoGroup;
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_BINBYMULTITEXTURING);
}
// check if all layers in all shadow maps are up to date
static void RSCheckLayersUpToDate( ScenePolygon *pspoFirst)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_CHECKLAYERSUPTODATE);
// for all span polygons in list
for( ScenePolygon *pspo=pspoFirst; pspo!=NULL; pspo=pspo->spo_pspoSucc) {
if( pspo->spo_psmShadowMap!=NULL) pspo->spo_psmShadowMap->CheckLayersUpToDate();
}
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_CHECKLAYERSUPTODATE);
}
// prepare parameters individual to a polygon texture
inline void RSSetTextureWrapping( ULONG ulFlags)
{
gfxSetTextureWrapping( (ulFlags&STXF_CLAMPU) ? GFX_CLAMP : GFX_REPEAT,
(ulFlags&STXF_CLAMPV) ? GFX_CLAMP : GFX_REPEAT);
}
// prepare parameters individual to a polygon texture
static void RSSetInitialTextureParameters(void)
{
_ulLastFlags[0] = STXF_BLEND_OPAQUE;
_ulLastBlends[0] = STXF_BLEND_OPAQUE;
_iLastFrameNo[0] = 0;
_ptdLastTex[0] = NULL;
gfxSetTextureModulation(1);
gfxDisableBlend();
}
static void RSSetTextureParameters( ULONG ulFlags)
{
// if blend flags have changed
ULONG ulBlendFlags = ulFlags&STXF_BLEND_MASK;
if( _ulLastBlends[0] != ulBlendFlags)
{ // determine new texturing mode
switch( ulBlendFlags) {
case STXF_BLEND_OPAQUE: // opaque texturing
gfxDisableBlend();
break;
case STXF_BLEND_ALPHA: // blend using texture alpha
gfxEnableBlend();
gfxBlendFunc( GFX_SRC_ALPHA, GFX_INV_SRC_ALPHA);
break;
case STXF_BLEND_ADD: // add to screen
gfxEnableBlend();
gfxBlendFunc( GFX_ONE, GFX_ONE);
break;
default: // screen*texture*2
ASSERT( ulBlendFlags==STXF_BLEND_SHADE);
gfxEnableBlend();
gfxBlendFunc( GFX_DST_COLOR, GFX_SRC_COLOR);
break;
}
// remember new flags
_ulLastBlends[0] = ulFlags;
}
}
// prepare initial parameters for polygon texture
static void RSSetInitialTextureParametersMT(void)
{
INDEX i;
// reset bleding modes
for( i=0; i<MAXTEXUNITS; i++) {
_ulLastFlags[i] = STXF_BLEND_OPAQUE;
_ulLastBlends[i] = STXF_BLEND_OPAQUE;
_iLastFrameNo[i] = 0;
_ptdLastTex[i] = NULL;
}
// reset for texture
gfxDisableBlend();
for( i=1; i<_ctUsableTexUnits; i++) {
gfxSetTextureUnit(i);
gfxSetTextureModulation(2);
}
gfxSetTextureUnit(0);
gfxSetTextureModulation(1);
}
// prepare parameters individual to a polygon texture
static void RSSetTextureParametersMT( ULONG ulFlags)
{
// skip if the same as last time
const ULONG ulBlendFlags = ulFlags&STXF_BLEND_MASK;
if( _ulLastBlends[0]==ulBlendFlags) return;
// update
if( ulBlendFlags==STXF_BLEND_OPAQUE) {
// opaque texturing
gfxDisableBlend();
} else {
// shade texturing
ASSERT( ulBlendFlags==STXF_BLEND_SHADE);
gfxEnableBlend();
gfxBlendFunc( GFX_DST_COLOR, GFX_SRC_COLOR);
} // keep
_ulLastBlends[0] = ulBlendFlags;
}
// make vertex coordinates for all polygons in the group
static void RSMakeVertexCoordinates( ScenePolygon *pspoGroup)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_MAKEVERTEXCOORDS);
_avtxPass.PopAll();
INDEX ctGroupVtx = 0;
// for all scene polygons in list
for( ScenePolygon *pspo=pspoGroup; pspo!=NULL; pspo=pspo->spo_pspoSucc)
{
// create new vertices for that polygon in per-pass array
const INDEX ctVtx = pspo->spo_ctVtx;
pspo->spo_iVtx0Pass = _avtxPass.Count();
GFXVertex3 *pvtxScene = &_avtxScene[pspo->spo_iVtx0];
GFXVertex4 *pvtxPass = _avtxPass.Push(ctVtx);
// copy the vertex coordinates
for( INDEX iVtx=0; iVtx<ctVtx; iVtx++) {
pvtxPass[iVtx].x = pvtxScene[iVtx].x;
pvtxPass[iVtx].y = pvtxScene[iVtx].y;
pvtxPass[iVtx].z = pvtxScene[iVtx].z;
}
// add polygon vertices to total
ctGroupVtx += ctVtx;
}
// prepare texture and color arrays
_acolPass.PopAll();
_atexPass[0].PopAll();
_atexPass[1].PopAll();
_atexPass[2].PopAll();
_atexPass[3].PopAll();
_acolPass.Push(ctGroupVtx);
for( INDEX i=0; i<_ctUsableTexUnits; i++) _atexPass[i].Push(ctGroupVtx);
// done
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_MAKEVERTEXCOORDS);
}
static void RSSetPolygonColors( ScenePolygon *pspoGroup, UBYTE ubAlpha)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_SETCOLORS);
// for all scene polygons in list
COLOR col;
GFXColor *pcol;
for( ScenePolygon *pspo = pspoGroup; pspo != NULL; pspo = pspo->spo_pspoSucc) {
col = ByteSwap( AdjustColor( pspo->spo_cColor|ubAlpha, _slTexHueShift, _slTexSaturation));
pcol = &_acolPass[pspo->spo_iVtx0Pass];
for( INDEX i=0; i<pspo->spo_ctVtx; i++) pcol[i].ul.abgr = col;
}
gfxSetColorArray( &_acolPass[0]);
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_SETCOLORS);
}
static void RSSetConstantColors( COLOR col)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_SETCOLORS);
col = ByteSwap( AdjustColor( col, _slTexHueShift, _slTexSaturation));
GFXColor *pcol = &_acolPass[0];
for( INDEX i=0; i<_acolPass.Count(); i++) pcol[i].ul.abgr = col;
gfxSetColorArray( &_acolPass[0]);
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_SETCOLORS);
}
static void RSSetTextureColors( ScenePolygon *pspoGroup, ULONG ulLayerMask)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_SETCOLORS);
ASSERT( !(ulLayerMask & (GF_TA1|GF_TA2|GF_FOG|GF_HAZE|GF_SEL)));
// for all scene polygons in list
COLOR colLayer, colTotal;
for( ScenePolygon *pspo = pspoGroup; pspo != NULL; pspo = pspo->spo_pspoSucc)
{ // adjust hue/saturation and set colors
colTotal = C_WHITE|CT_OPAQUE;
if( ulLayerMask&GF_TX0) {
colLayer = AdjustColor( pspo->spo_acolColors[0], _slTexHueShift, _slTexSaturation);
if( colLayer!=0xFFFFFFFF) colTotal = MulColors( colTotal, colLayer);
}
if( ulLayerMask&GF_TX1) {
colLayer = AdjustColor( pspo->spo_acolColors[1], _slTexHueShift, _slTexSaturation);
if( colLayer!=0xFFFFFFFF) colTotal = MulColors( colTotal, colLayer);
}
if( ulLayerMask&GF_TX2) {
colLayer = AdjustColor( pspo->spo_acolColors[2], _slTexHueShift, _slTexSaturation);
if( colLayer!=0xFFFFFFFF) colTotal = MulColors( colTotal, colLayer);
}
if( ulLayerMask&GF_SHD) {
colLayer = AdjustColor( pspo->spo_acolColors[3], _slShdHueShift, _slShdSaturation);
if( colLayer!=0xFFFFFFFF) colTotal = MulColors( colTotal, colLayer);
}
// store
colTotal = ByteSwap(colTotal);
GFXColor *pcol= &_acolPass[pspo->spo_iVtx0Pass];
for( INDEX i=0; i<pspo->spo_ctVtx; i++) pcol[i].ul.abgr = colTotal;
}
// set color array
gfxSetColorArray( &_acolPass[0]);
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_SETCOLORS);
}
// make texture coordinates for one texture in all polygons in group
static INDEX _iLastUnit = -1;
static void RSSetTextureCoords( ScenePolygon *pspoGroup, INDEX iLayer, INDEX iUnit)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_SETTEXCOORDS);
// eventualy switch texture unit
if( _iLastUnit != iUnit) {
gfxSetTextureUnit(iUnit);
gfxEnableTexture();
_iLastUnit = iUnit;
}
// generate tex coord for all scene polygons in list
const FLOATmatrix3D &mViewer = _ppr->pr_ViewerRotationMatrix;
const INDEX iMappingOffset = iLayer * sizeof(CMappingVectors);
(void)iMappingOffset; // shut up compiler, this is used if inline ASM is used
for( ScenePolygon *pspo=pspoGroup; pspo!=NULL; pspo=pspo->spo_pspoSucc)
{
ASSERT( pspo->spo_ctVtx>0);
const FLOAT3D &vN = ((CBrushPolygon*)pspo->spo_pvPolygon)->bpo_pbplPlane->bpl_pwplWorking->wpl_plView;
const GFXVertex *pvtx = &_avtxPass[pspo->spo_iVtx0Pass];
GFXTexCoord *ptex = &_atexPass[iUnit][pspo->spo_iVtx0Pass];
// reflective mapping?
if( pspo->spo_aubTextureFlags[iLayer] & STXF_REFLECTION) {
for( INDEX i=0; i<pspo->spo_ctVtx; i++) {
const FLOAT fNorm = 1.0f / sqrt(pvtx[i].x*pvtx[i].x + pvtx[i].y*pvtx[i].y + pvtx[i].z*pvtx[i].z);
const FLOAT fVx = pvtx[i].x *fNorm;
const FLOAT fVy = pvtx[i].y *fNorm;
const FLOAT fVz = pvtx[i].z *fNorm;
const FLOAT fNV = fVx*vN(1) + fVy*vN(2) + fVz*vN(3);
const FLOAT fRVx = fVx - 2*vN(1)*fNV;
const FLOAT fRVy = fVy - 2*vN(2)*fNV;
const FLOAT fRVz = fVz - 2*vN(3)*fNV;
const FLOAT fRVxT = fRVx*mViewer(1,1) + fRVy*mViewer(2,1) + fRVz*mViewer(3,1);
const FLOAT fRVzT = fRVx*mViewer(1,3) + fRVy*mViewer(2,3) + fRVz*mViewer(3,3);
ptex[i].st.s = fRVxT*0.5f +0.5f;
ptex[i].st.t = fRVzT*0.5f +0.5f;
}
// advance to next polygon
continue;
}
#if (defined __MSVC_INLINE__)
__asm {
mov esi,D [pspo]
mov edi,D [iMappingOffset]
// (This doesn't work with the Intel C++ compiler. :( --ryan.)
#ifdef _MSC_VER
lea eax,[esi].spo_amvMapping[edi].mv_vO
lea ebx,[esi].spo_amvMapping[edi].mv_vU
lea ecx,[esi].spo_amvMapping[edi].mv_vV
#else
lea ebx,[esi].spo_amvMapping[edi]
lea eax,[ebx].mv_vO
lea ecx,[ebx].mv_vV
lea ebx,[ebx].mv_vU
#endif
mov edx,D [esi].spo_ctVtx
mov esi,D [pvtx]
mov edi,D [ptex]
vtxLoop:
fld D [ebx+0]
fld D [esi]GFXVertex.x
fsub D [eax+0]
fmul st(1),st(0)
fmul D [ecx+0] // vV(1)*fDX, vU(1)*fDX
fld D [ebx+4]
fld D [esi]GFXVertex.y
fsub D [eax+4]
fmul st(1),st(0)
fmul D [ecx+4] // vV(2)*fDY, vU(2)*fDY, vV(1)*fDX, vU(1)*fDX
fld D [ebx+8]
fld D [esi]GFXVertex.z
fsub D [eax+8]
fmul st(1),st(0)
fmul D [ecx+8] // vV(3)*fDZ, vU(3)*fDZ, vV(2)*fDY, vU(2)*fDY, vV(1)*fDX, vU(1)*fDX
fxch st(5)
faddp st(3),st(0) // vU(3)*fDZ, vV(2)*fDY, vU(1)*fDX+vU(2)*fDY, vV(1)*fDX, vV(3)*fDZ
fxch st(1)
faddp st(3),st(0) // vU(3)*fDZ, vU(1)*fDX+vU(2)*fDY, vV(1)*fDX+vV(2)*fDY, vV(3)*fDZ
faddp st(1),st(0) // vU(1)*fDX+vU(2)*fDY+vU(3)*fDZ, vV(1)*fDX+vV(2)*fDY, vV(3)*fDZ
fxch st(1)
faddp st(2),st(0) // vU(1)*fDX+vU(2)*fDY+vU(3)*fDZ, vV(1)*fDX+vV(2)*fDY+vV(3)*fDZ
fstp D [edi]GFXTexCoord.st.s
fstp D [edi]GFXTexCoord.st.t
add esi,4*4
add edi,2*4
dec edx
jnz vtxLoop
}
/*
// !!! FIXME: rcg11232001 This inline conversion is broken. Use the
// !!! FIXME: rcg11232001 C version for now on Linux.
#elif (defined __GNU_INLINE_X86_32__)
STUBBED("debug this");
__asm__ __volatile__ (
"0: \n\t" // vtxLoop
"flds (%%ebx) \n\t"
"flds (%%esi) \n\t"
"fsubs (%%eax) \n\t"
"fmul %%st(0), %%st(1) \n\t"
"fmuls (%%ecx) \n\t" // vV(1)*fDX, vU(1)*fDX
"flds 4(%%ebx) \n\t"
"flds 4(%%esi) \n\t" // GFXVertex.y
"fsubs 4(%%eax) \n\t"
"fmul %%st(0), %%st(1) \n\t"
"fmuls 4(%%ecx) \n\t" // vV(2)*fDY, vU(2)*fDY, vV(1)*fDX, vU(1)*fDX
"flds 8(%%ebx) \n\t"
"flds 8(%%esi) \n\t" // GFXVertex.z
"fsubs 8(%%eax) \n\t"
"fmul %%st(0), %%st(1) \n\t"
"fmuls 8(%%ecx) \n\t" // vV(3)*fDZ, vU(3)*fDZ, vV(2)*fDY, vU(2)*fDY, vV(1)*fDX, vU(1)*fDX
"fxch %%st(5) \n\t"
"faddp %%st(0), %%st(3) \n\t" // vU(3)*fDZ, vV(2)*fDY, vU(1)*fDX+vU(2)*fDY, vV(1)*fDX, vV(3)*fDZ
"fxch %%st(1) \n\t"
"faddp %%st(0), %%st(3) \n\t" // vU(3)*fD Z, vU(1)*fDX+vU(2)*fDY, vV(1)*fDX+vV(2)*fDY, vV(3)*fDZ
"faddp %%st(0), %%st(1) \n\t" // vU(1)*fDX+vU(2)*fDY+vU(3)*fDZ, vV(1)*fDX+vV(2)*fDY, vV(3)*fDZ
"fxch %%st(1) \n\t"
"faddp %%st(0), %%st(2) \n\t" // vU(1)*fDX+vU(2)*fDY+vU(3)*fDZ, vV(1)*fDX+vV(2)*fDY+vV(3)*fDZ
"fstps 0(%%edi) \n\t" // GFXTexCoord.st.s
"fstps 4(%%edi) \n\t" // GFXTexCoord.st.t
"addl $16, %%esi \n\t"
"addl $8, %%edi \n\t"
"decl %%edx \n\t"
"jnz 0b \n\t" // vtxLoop
: // no outputs.
: "a" (&pspo->spo_amvMapping[iMappingOffset].mv_vO.vector),
"b" (&pspo->spo_amvMapping[iMappingOffset].mv_vU.vector),
"c" (&pspo->spo_amvMapping[iMappingOffset].mv_vV.vector),
"d" (pspo->spo_ctVtx), "S" (pvtx), "D" (ptex)
: "cc", "memory"
);
*/
#else
// diffuse mapping
const FLOAT3D &vO = pspo->spo_amvMapping[iLayer].mv_vO;
const FLOAT3D &vU = pspo->spo_amvMapping[iLayer].mv_vU;
const FLOAT3D &vV = pspo->spo_amvMapping[iLayer].mv_vV;
for( INDEX i=0; i<pspo->spo_ctVtx; i++) {
const FLOAT fDX = pvtx[i].x -vO(1);
const FLOAT fDY = pvtx[i].y -vO(2);
const FLOAT fDZ = pvtx[i].z -vO(3);
ptex[i].st.s = vU(1)*fDX + vU(2)*fDY + vU(3)*fDZ;
ptex[i].st.t = vV(1)*fDX + vV(2)*fDY + vV(3)*fDZ;
}
#endif
}
// init array
gfxSetTexCoordArray( &_atexPass[iUnit][0], FALSE);
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_SETTEXCOORDS);
}
// make fog texture coordinates for all polygons in group
static void RSSetFogCoordinates( ScenePolygon *pspoGroup)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_SETTEXCOORDS);
// for all scene polygons in list
for( ScenePolygon *pspo=pspoGroup; pspo!=NULL; pspo=pspo->spo_pspoSucc) {
const GFXVertex *pvtx = &_avtxPass[pspo->spo_iVtx0Pass];
GFXTexCoord *ptex = &_atexPass[0][pspo->spo_iVtx0Pass];
for( INDEX i=0; i<pspo->spo_ctVtx; i++) {
ptex[i].st.s = pvtx[i].z *_fFogMul;
ptex[i].st.t = (_fog_vHDirView(1)*pvtx[i].x + _fog_vHDirView(2)*pvtx[i].y
+ _fog_vHDirView(3)*pvtx[i].z + _fog_fAddH) * _fog_fMulH;
}
}
gfxSetTexCoordArray( &_atexPass[0][0], FALSE);
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_SETTEXCOORDS);
}
// make haze texture coordinates for all polygons in group
static void RSSetHazeCoordinates( ScenePolygon *pspoGroup)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_SETTEXCOORDS);
// for all scene polygons in list
for( ScenePolygon *pspo=pspoGroup; pspo!=NULL; pspo=pspo->spo_pspoSucc) {
const GFXVertex *pvtx = &_avtxPass[pspo->spo_iVtx0Pass];
GFXTexCoord *ptex = &_atexPass[0][pspo->spo_iVtx0Pass];
for( INDEX i=0; i<pspo->spo_ctVtx; i++) {
ptex[i].st.s = (pvtx[i].z + _fHazeAdd) *_fHazeMul;
ptex[i].st.t = 0;
}
}
gfxSetTexCoordArray( &_atexPass[0][0], FALSE);
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_SETTEXCOORDS);
}
// render textures for all triangles in polygon list
static void RSRenderTEX( ScenePolygon *pspoFirst, INDEX iLayer)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_RENDERTEXTURES);
RSSetInitialTextureParameters();
// for all span polygons in list
for( ScenePolygon *pspo=pspoFirst; pspo!=NULL; pspo=pspo->spo_pspoSucc)
{
ASSERT(pspo->spo_aptoTextures[iLayer]!=NULL);
CTextureData *ptdTextureData = (CTextureData*)pspo->spo_aptoTextures[iLayer]->GetData();
const INDEX iFrameNo = pspo->spo_aptoTextures[iLayer]->GetFrame();
if( _ptdLastTex[0] != ptdTextureData
|| _ulLastFlags[0] != pspo->spo_aubTextureFlags[iLayer]
|| _iLastFrameNo[0] != iFrameNo) {
// flush
FlushElements();
_ptdLastTex[0] = ptdTextureData;
_ulLastFlags[0] = pspo->spo_aubTextureFlags[iLayer];
_iLastFrameNo[0] = iFrameNo;
// set texture parameters if needed
RSSetTextureWrapping( pspo->spo_aubTextureFlags[iLayer]);
RSSetTextureParameters( pspo->spo_aubTextureFlags[iLayer]);
// prepare texture to be used by accelerator
ptdTextureData->SetAsCurrent(iFrameNo);
}
// render all triangles
AddElements(pspo);
}
// flush leftovers
FlushElements();
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_RENDERTEXTURES);
}
// render shadows for all triangles in polygon list
static void RSRenderSHD( ScenePolygon *pspoFirst)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_RENDERSHADOWS);
RSSetInitialTextureParameters();
// for all span polygons in list
for( ScenePolygon *pspo = pspoFirst; pspo != NULL; pspo = pspo->spo_pspoSucc)
{
// get shadow map for the polygon
CShadowMap *psmShadow = pspo->spo_psmShadowMap;
ASSERT( psmShadow!=NULL); // shadows have been already sorted out
// set texture parameters if needed
RSSetTextureWrapping( pspo->spo_aubTextureFlags[SHADOWTEXTURE]);
RSSetTextureParameters( pspo->spo_aubTextureFlags[SHADOWTEXTURE]);
// upload the shadow to accelerator memory
psmShadow->SetAsCurrent();
// batch and render triangles
AddElements(pspo);
FlushElements();
}
// done
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_RENDERSHADOWS);
}
// render texture and shadow for all triangles in polygon list
static void RSRenderTEX_SHD( ScenePolygon *pspoFirst, INDEX iLayer)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_RENDERMT);
RSSetInitialTextureParametersMT();
// for all span polygons in list
for( ScenePolygon *pspo=pspoFirst; pspo!=NULL; pspo=pspo->spo_pspoSucc)
{
// render batched triangles
FlushElements();
ASSERT( pspo->spo_aptoTextures[iLayer]!=NULL && pspo->spo_psmShadowMap!=NULL);
// upload the shadow to accelerator memory
gfxSetTextureUnit(1);
RSSetTextureWrapping( pspo->spo_aubTextureFlags[SHADOWTEXTURE]);
pspo->spo_psmShadowMap->SetAsCurrent();
// prepare texture to be used by accelerator
CTextureData *ptd = (CTextureData*)pspo->spo_aptoTextures[iLayer]->GetData();
const INDEX iFrameNo = pspo->spo_aptoTextures[iLayer]->GetFrame();
gfxSetTextureUnit(0);
if( _ptdLastTex[0]!=ptd || _iLastFrameNo[0]!=iFrameNo || _ulLastFlags[0]!=pspo->spo_aubTextureFlags[iLayer]) {
_ptdLastTex[0]=ptd; _iLastFrameNo[0]=iFrameNo; _ulLastFlags[0]=pspo->spo_aubTextureFlags[iLayer];
RSSetTextureWrapping( pspo->spo_aubTextureFlags[iLayer]);
ptd->SetAsCurrent(iFrameNo);
// set rendering parameters if needed
RSSetTextureParametersMT( pspo->spo_aubTextureFlags[iLayer]);
}
// batch triangles
AddElements(pspo);
}
// flush leftovers
FlushElements();
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_RENDERMT);
}
// render two textures for all triangles in polygon list
static void RSRender2TEX( ScenePolygon *pspoFirst, INDEX iLayer2)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_RENDERMT);
RSSetInitialTextureParametersMT();
// for all span polygons in list
for( ScenePolygon *pspo=pspoFirst; pspo!=NULL; pspo=pspo->spo_pspoSucc)
{
ASSERT( pspo->spo_aptoTextures[0]!=NULL && pspo->spo_aptoTextures[iLayer2]!=NULL);
CTextureData *ptd0 = (CTextureData*)pspo->spo_aptoTextures[0]->GetData();
CTextureData *ptd1 = (CTextureData*)pspo->spo_aptoTextures[iLayer2]->GetData();
const INDEX iFrameNo0 = pspo->spo_aptoTextures[0]->GetFrame();
const INDEX iFrameNo1 = pspo->spo_aptoTextures[iLayer2]->GetFrame();
if( _ptdLastTex[0]!=ptd0 || _iLastFrameNo[0]!=iFrameNo0 || _ulLastFlags[0]!=pspo->spo_aubTextureFlags[0]
|| _ptdLastTex[1]!=ptd1 || _iLastFrameNo[1]!=iFrameNo1 || _ulLastFlags[1]!=pspo->spo_aubTextureFlags[iLayer2]) {
FlushElements();
_ptdLastTex[0]=ptd0; _iLastFrameNo[0]=iFrameNo0; _ulLastFlags[0]=pspo->spo_aubTextureFlags[0];
_ptdLastTex[1]=ptd1; _iLastFrameNo[1]=iFrameNo1; _ulLastFlags[1]=pspo->spo_aubTextureFlags[iLayer2];
// upload the second texture to unit 1
gfxSetTextureUnit(1);
RSSetTextureWrapping( pspo->spo_aubTextureFlags[iLayer2]);
ptd1->SetAsCurrent(iFrameNo1);
// upload the first texture to unit 0
gfxSetTextureUnit(0);
RSSetTextureWrapping( pspo->spo_aubTextureFlags[0]);
ptd0->SetAsCurrent(iFrameNo0);
// set rendering parameters if needed
RSSetTextureParametersMT( pspo->spo_aubTextureFlags[0]);
}
// render all triangles
AddElements(pspo);
}
// flush leftovers
FlushElements();
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_RENDERMT);
}
// render two textures and shadowmap for all triangles in polygon list
static void RSRender2TEX_SHD( ScenePolygon *pspoFirst, INDEX iLayer2)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_RENDERMT);
RSSetInitialTextureParametersMT();
// for all span polygons in list
for( ScenePolygon *pspo=pspoFirst; pspo!=NULL; pspo=pspo->spo_pspoSucc)
{
ASSERT( pspo->spo_aptoTextures[0]!=NULL
&& pspo->spo_aptoTextures[iLayer2]!=NULL
&& pspo->spo_psmShadowMap!=NULL);
// render batched triangles
FlushElements();
// upload the shadow to accelerator memory
gfxSetTextureUnit(2);
RSSetTextureWrapping( pspo->spo_aubTextureFlags[SHADOWTEXTURE]);
pspo->spo_psmShadowMap->SetAsCurrent();
// prepare textures to be used by accelerator
CTextureData *ptd0 = (CTextureData*)pspo->spo_aptoTextures[0]->GetData();
CTextureData *ptd1 = (CTextureData*)pspo->spo_aptoTextures[iLayer2]->GetData();
const INDEX iFrameNo0 = pspo->spo_aptoTextures[0]->GetFrame();
const INDEX iFrameNo1 = pspo->spo_aptoTextures[iLayer2]->GetFrame();
gfxSetTextureUnit(0);
if( _ptdLastTex[0]!=ptd0 || _iLastFrameNo[0]!=iFrameNo0 || _ulLastFlags[0]!=pspo->spo_aubTextureFlags[0]
|| _ptdLastTex[1]!=ptd1 || _iLastFrameNo[1]!=iFrameNo1 || _ulLastFlags[1]!=pspo->spo_aubTextureFlags[iLayer2]) {
_ptdLastTex[0]=ptd0; _iLastFrameNo[0]=iFrameNo0; _ulLastFlags[0]=pspo->spo_aubTextureFlags[0];
_ptdLastTex[1]=ptd1; _iLastFrameNo[1]=iFrameNo1; _ulLastFlags[1]=pspo->spo_aubTextureFlags[iLayer2];
// upload the second texture to unit 1
gfxSetTextureUnit(1);
RSSetTextureWrapping( pspo->spo_aubTextureFlags[iLayer2]);
ptd1->SetAsCurrent(iFrameNo1);
// upload the first texture to unit 0
gfxSetTextureUnit(0);
RSSetTextureWrapping( pspo->spo_aubTextureFlags[0]);
ptd0->SetAsCurrent(iFrameNo0);
// set rendering parameters if needed
RSSetTextureParametersMT( pspo->spo_aubTextureFlags[0]);
}
// render all triangles
AddElements(pspo);
}
// flush leftovers
FlushElements();
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_RENDERMT);
}
// render three textures for all triangles in polygon list
static void RSRender3TEX( ScenePolygon *pspoFirst)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_RENDERMT);
RSSetInitialTextureParametersMT();
// for all span polygons in list
for( ScenePolygon *pspo=pspoFirst; pspo!=NULL; pspo=pspo->spo_pspoSucc)
{
ASSERT( pspo->spo_aptoTextures[0]!=NULL
&& pspo->spo_aptoTextures[1]!=NULL
&& pspo->spo_aptoTextures[2]!=NULL);
CTextureData *ptd0 = (CTextureData*)pspo->spo_aptoTextures[0]->GetData();
CTextureData *ptd1 = (CTextureData*)pspo->spo_aptoTextures[1]->GetData();
CTextureData *ptd2 = (CTextureData*)pspo->spo_aptoTextures[2]->GetData();
const INDEX iFrameNo0 = pspo->spo_aptoTextures[0]->GetFrame();
const INDEX iFrameNo1 = pspo->spo_aptoTextures[1]->GetFrame();
const INDEX iFrameNo2 = pspo->spo_aptoTextures[2]->GetFrame();
if( _ptdLastTex[0]!=ptd0 || _iLastFrameNo[0]!=iFrameNo0 || _ulLastFlags[0]!=pspo->spo_aubTextureFlags[0]
|| _ptdLastTex[1]!=ptd1 || _iLastFrameNo[1]!=iFrameNo1 || _ulLastFlags[1]!=pspo->spo_aubTextureFlags[1]
|| _ptdLastTex[2]!=ptd2 || _iLastFrameNo[2]!=iFrameNo2 || _ulLastFlags[2]!=pspo->spo_aubTextureFlags[2]) {
FlushElements();
_ptdLastTex[0]=ptd0; _iLastFrameNo[0]=iFrameNo0; _ulLastFlags[0]=pspo->spo_aubTextureFlags[0];
_ptdLastTex[1]=ptd1; _iLastFrameNo[1]=iFrameNo1; _ulLastFlags[1]=pspo->spo_aubTextureFlags[1];
_ptdLastTex[2]=ptd2; _iLastFrameNo[2]=iFrameNo2; _ulLastFlags[2]=pspo->spo_aubTextureFlags[2];
// upload the third texture to unit 2
gfxSetTextureUnit(2);
RSSetTextureWrapping( pspo->spo_aubTextureFlags[2]);
ptd2->SetAsCurrent(iFrameNo2);
// upload the second texture to unit 1
gfxSetTextureUnit(1);
RSSetTextureWrapping( pspo->spo_aubTextureFlags[1]);
ptd1->SetAsCurrent(iFrameNo1);
// upload the first texture to unit 0
gfxSetTextureUnit(0);
RSSetTextureWrapping( pspo->spo_aubTextureFlags[0]);
ptd0->SetAsCurrent(iFrameNo0);
// set rendering parameters if needed
RSSetTextureParametersMT( pspo->spo_aubTextureFlags[0]);
}
// render all triangles
AddElements(pspo);
}
// flush leftovers
FlushElements();
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_RENDERMT);
}
// render three textures and shadowmap for all triangles in polygon list
static void RSRender3TEX_SHD( ScenePolygon *pspoFirst)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_RENDERMT);
RSSetInitialTextureParametersMT();
// for all span polygons in list
for( ScenePolygon *pspo=pspoFirst; pspo!=NULL; pspo=pspo->spo_pspoSucc)
{
ASSERT( pspo->spo_aptoTextures[0]!=NULL
&& pspo->spo_aptoTextures[1]!=NULL
&& pspo->spo_aptoTextures[2]!=NULL
&& pspo->spo_psmShadowMap!=NULL);
// render batched triangles
FlushElements();
// upload the shadow to accelerator memory
gfxSetTextureUnit(3);
RSSetTextureWrapping( pspo->spo_aubTextureFlags[SHADOWTEXTURE]);
pspo->spo_psmShadowMap->SetAsCurrent();
// prepare textures to be used by accelerator
CTextureData *ptd0 = (CTextureData*)pspo->spo_aptoTextures[0]->GetData();
CTextureData *ptd1 = (CTextureData*)pspo->spo_aptoTextures[1]->GetData();
CTextureData *ptd2 = (CTextureData*)pspo->spo_aptoTextures[2]->GetData();
const INDEX iFrameNo0 = pspo->spo_aptoTextures[0]->GetFrame();
const INDEX iFrameNo1 = pspo->spo_aptoTextures[1]->GetFrame();
const INDEX iFrameNo2 = pspo->spo_aptoTextures[2]->GetFrame();
gfxSetTextureUnit(0);
if( _ptdLastTex[0]!=ptd0 || _iLastFrameNo[0]!=iFrameNo0 || _ulLastFlags[0]!=pspo->spo_aubTextureFlags[0]
|| _ptdLastTex[1]!=ptd1 || _iLastFrameNo[1]!=iFrameNo1 || _ulLastFlags[1]!=pspo->spo_aubTextureFlags[1]
|| _ptdLastTex[2]!=ptd2 || _iLastFrameNo[2]!=iFrameNo2 || _ulLastFlags[2]!=pspo->spo_aubTextureFlags[2]) {
_ptdLastTex[0]=ptd0; _iLastFrameNo[0]=iFrameNo0; _ulLastFlags[0]=pspo->spo_aubTextureFlags[0];
_ptdLastTex[1]=ptd1; _iLastFrameNo[1]=iFrameNo1; _ulLastFlags[1]=pspo->spo_aubTextureFlags[1];
_ptdLastTex[2]=ptd2; _iLastFrameNo[2]=iFrameNo2; _ulLastFlags[2]=pspo->spo_aubTextureFlags[2];
// upload the third texture to unit 2
gfxSetTextureUnit(2);
RSSetTextureWrapping( pspo->spo_aubTextureFlags[2]);
ptd2->SetAsCurrent(iFrameNo2);
// upload the second texture to unit 1
gfxSetTextureUnit(1);
RSSetTextureWrapping( pspo->spo_aubTextureFlags[1]);
ptd1->SetAsCurrent(iFrameNo1);
// upload the first texture to unit 0
gfxSetTextureUnit(0);
RSSetTextureWrapping( pspo->spo_aubTextureFlags[0]);
ptd0->SetAsCurrent(iFrameNo0);
// set rendering parameters if needed
RSSetTextureParametersMT( pspo->spo_aubTextureFlags[0]);
}
// render all triangles
AddElements(pspo);
}
// flush leftovers
FlushElements();
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_RENDERMT);
}
// render fog for all affected triangles in polygon list
__forceinline void RSRenderFog( ScenePolygon *pspoFirst)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_RENDERFOG);
// for all scene polygons in list
for( ScenePolygon *pspo=pspoFirst; pspo!=NULL; pspo=pspo->spo_pspoSucc)
{ // for all vertices in the polygon
const GFXTexCoord *ptex = &_atexPass[0][pspo->spo_iVtx0Pass];
for( INDEX i=0; i<pspo->spo_ctVtx; i++) {
// polygon is in fog, stop searching
if( InFog(ptex[i].st.t)) goto hasFog;
}
// hasn't got any fog, so skip it
continue;
hasFog:
// render all triangles
AddElements(pspo);
}
// all done
FlushElements();
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_RENDERFOG);
}
// render haze for all affected triangles in polygon list
__forceinline void RSRenderHaze( ScenePolygon *pspoFirst)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_RENDERFOG);
// for all scene polygons in list
for( ScenePolygon *pspo=pspoFirst; pspo!=NULL; pspo=pspo->spo_pspoSucc)
{ // for all vertices in the polygon
const GFXTexCoord *ptex = &_atexPass[0][pspo->spo_iVtx0Pass];
for( INDEX i=0; i<pspo->spo_ctVtx; i++) {
// polygon is in haze, stop searching
if( InHaze(ptex[i].st.s)) goto hasHaze;
}
// hasn't got any haze, so skip it
continue;
hasHaze:
// render all triangles
AddElements(pspo);
}
// all done
FlushElements();
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_RENDERFOG);
}
static void RSStartupFog(void)
{
// upload fog texture
gfxSetTextureWrapping( GFX_CLAMP, GFX_CLAMP);
gfxSetTexture( _fog_ulTexture, _fog_tpLocal);
// prepare fog rendering parameters
gfxEnableBlend();
gfxBlendFunc( GFX_SRC_ALPHA, GFX_INV_SRC_ALPHA);
// calculate fog mapping
_fFogMul = -1.0f / _fog_fp.fp_fFar;
}
static void RSStartupHaze(void)
{
// upload haze texture
gfxEnableTexture();
gfxSetTextureWrapping( GFX_CLAMP, GFX_CLAMP);
gfxSetTexture( _haze_ulTexture, _haze_tpLocal);
// prepare haze rendering parameters
gfxEnableBlend();
gfxBlendFunc( GFX_SRC_ALPHA, GFX_INV_SRC_ALPHA);
// calculate haze mapping
_fHazeMul = -1.0f / (_haze_hp.hp_fFar - _haze_hp.hp_fNear);
_fHazeAdd = _haze_hp.hp_fNear;
}
// process one group of polygons
void RSRenderGroupInternal( ScenePolygon *pspoGroup, ULONG ulGroupFlags);
void RSRenderGroup( ScenePolygon *pspoGroup, ULONG ulGroupFlags, ULONG ulTestedFlags)
{
// skip if the group is empty
if( pspoGroup==NULL) return;
ASSERT( !(ulTestedFlags&(GF_FOG|GF_HAZE))); // paranoia
// if multitexturing is enabled (start with 2-layer MT)
if( _ctUsableTexUnits>=2)
{
// if texture 1 could be merged with shadow
if( !(ulTestedFlags&GF_TX0_SHD)
&& (ulGroupFlags &GF_TX0)
&& !(ulGroupFlags &GF_TX1)
&& !(ulGroupFlags &GF_TX2)
&& (ulGroupFlags &GF_SHD))
{ // bin polygons that can use the merge and those that cannot
ScenePolygon *pspoST, *pspoMT;
RSBinByDualTexturing( pspoGroup, 0, SHADOWTEXTURE, &pspoST, &pspoMT);
// process the two groups separately
ulTestedFlags |= GF_TX0_SHD;
RSRenderGroup( pspoST, ulGroupFlags, ulTestedFlags);
ulGroupFlags &= ~(GF_TX0|GF_SHD);
ulGroupFlags |= GF_TX0_SHD;
RSRenderGroup( pspoMT, ulGroupFlags, ulTestedFlags);
return;
}
// if texture 1 could be merged with texture 2
if( !(ulTestedFlags&GF_TX0_TX1)
&& (ulGroupFlags &GF_TX0)
&& (ulGroupFlags &GF_TX1))
{ // bin polygons that can use the merge and those that cannot
ScenePolygon *pspoST, *pspoMT;
RSBinByDualTexturing( pspoGroup, 0, 1, &pspoST, &pspoMT);
// process the two groups separately
ulTestedFlags |= GF_TX0_TX1;
RSRenderGroup( pspoST, ulGroupFlags, ulTestedFlags);
ulGroupFlags &= ~(GF_TX0|GF_TX1);
ulGroupFlags |= GF_TX0_TX1;
RSRenderGroup( pspoMT, ulGroupFlags, ulTestedFlags);
return;
}
// if texture 1 could be merged with texture 3
if( !(ulTestedFlags&GF_TX0_TX2)
&& (ulGroupFlags &GF_TX0)
&& !(ulGroupFlags &GF_TX1)
&& (ulGroupFlags &GF_TX2))
{ // bin polygons that can use the merge and those that cannot
ScenePolygon *pspoST, *pspoMT;
RSBinByDualTexturing( pspoGroup, 0, 2, &pspoST, &pspoMT);
// process the two groups separately
ulTestedFlags |= GF_TX0_TX2;
RSRenderGroup( pspoST, ulGroupFlags, ulTestedFlags);
ulGroupFlags &= ~(GF_TX0|GF_TX2);
ulGroupFlags |= GF_TX0_TX2;
RSRenderGroup( pspoMT, ulGroupFlags, ulTestedFlags);
return;
}
// if texture 3 could be merged with shadow
if( !(ulTestedFlags&GF_TX2_SHD)
&& (ulGroupFlags &GF_TX0_TX1)
&& (ulGroupFlags &GF_TX2)
&& (ulGroupFlags &GF_SHD))
{ // bin polygons that can use the merge and those that cannot
ScenePolygon *pspoST, *pspoMT;
RSBinByDualTexturing( pspoGroup, 2, SHADOWTEXTURE, &pspoST, &pspoMT);
// process the two groups separately
ulTestedFlags |= GF_TX2_SHD;
RSRenderGroup( pspoST, ulGroupFlags, ulTestedFlags);
ulGroupFlags &= ~(GF_TX2|GF_SHD);
ulGroupFlags |= GF_TX2_SHD;
RSRenderGroup( pspoMT, ulGroupFlags, ulTestedFlags);
return;
}
}
// 4-layer multitexturing?
if( _ctUsableTexUnits>=4)
{
// if texture 1 and 2 could be merged with 3 and shadow
if( !(ulTestedFlags&GF_TX0_TX1_TX2_SHD)
&& (ulGroupFlags &GF_TX0_TX1)
&& (ulGroupFlags &GF_TX2_SHD))
{ // bin polygons that can use the merge and those that cannot
ScenePolygon *pspoST, *pspoMT;
RSBinByQuadTexturing( pspoGroup, &pspoST, &pspoMT);
// process the two groups separately
ulTestedFlags |= GF_TX0_TX1_TX2_SHD;
RSRenderGroup( pspoST, ulGroupFlags, ulTestedFlags);
ulGroupFlags &= ~(GF_TX0_TX1|GF_TX2_SHD);
ulGroupFlags |= GF_TX0_TX1_TX2_SHD;
RSRenderGroup( pspoMT, ulGroupFlags, ulTestedFlags);
return;
}
}
// 3-layer multitexturing?
if( _ctUsableTexUnits>=3)
{
// if texture 1 and 2 could be merged with 3
if( !(ulTestedFlags&GF_TX0_TX1_TX2)
&& (ulGroupFlags &GF_TX0_TX1)
&& (ulGroupFlags &GF_TX2))
{ // bin polygons that can use the merge and those that cannot
ScenePolygon *pspoST, *pspoMT;
RSBinByTripleTexturing( pspoGroup, 1, 2, &pspoST, &pspoMT);
// process the two groups separately
ulTestedFlags |= GF_TX0_TX1_TX2;
RSRenderGroup( pspoST, ulGroupFlags, ulTestedFlags);
ulGroupFlags &= ~(GF_TX0_TX1|GF_TX2);
ulGroupFlags |= GF_TX0_TX1_TX2;
RSRenderGroup( pspoMT, ulGroupFlags, ulTestedFlags);
return;
}
// if texture 1 and 2 could be merged with shadow
if( !(ulTestedFlags&GF_TX0_TX1_SHD)
&& (ulGroupFlags &GF_TX0_TX1)
&& !(ulGroupFlags &GF_TX2)
&& (ulGroupFlags &GF_SHD))
{ // bin polygons that can use the merge and those that cannot
ScenePolygon *pspoST, *pspoMT;
RSBinByTripleTexturing( pspoGroup, 1, SHADOWTEXTURE, &pspoST, &pspoMT);
// process the two groups separately
ulTestedFlags |= GF_TX0_TX1_SHD;
RSRenderGroup( pspoST, ulGroupFlags, ulTestedFlags);
ulGroupFlags &= ~(GF_TX0_TX1|GF_SHD);
ulGroupFlags |= GF_TX0_TX1_SHD;
RSRenderGroup( pspoMT, ulGroupFlags, ulTestedFlags);
return;
}
// if texture 1 and 3 could be merged with shadow
if( !(ulTestedFlags&GF_TX0_TX2_SHD)
&& (ulGroupFlags &GF_TX0_TX2)
&& !(ulGroupFlags &GF_TX1)
&& (ulGroupFlags &GF_SHD))
{ // bin polygons that can use the merge and those that cannot
ScenePolygon *pspoST, *pspoMT;
RSBinByTripleTexturing( pspoGroup, 2, SHADOWTEXTURE, &pspoST, &pspoMT);
// process the two groups separately
ulTestedFlags |= GF_TX0_TX2_SHD;
RSRenderGroup( pspoST, ulGroupFlags, ulTestedFlags);
ulGroupFlags &= ~(GF_TX0_TX2|GF_SHD);
ulGroupFlags |= GF_TX0_TX2_SHD;
RSRenderGroup( pspoMT, ulGroupFlags, ulTestedFlags);
return;
}
}
// render one group
extern INDEX ogl_iMaxBurstSize;
extern INDEX d3d_iMaxBurstSize;
ogl_iMaxBurstSize = Clamp( ogl_iMaxBurstSize, 0, 9999);
d3d_iMaxBurstSize = Clamp( d3d_iMaxBurstSize, 0, 9999);
const INDEX iMaxBurstSize = (eAPI==GAT_OGL) ? ogl_iMaxBurstSize : d3d_iMaxBurstSize;
// if unlimited lock count
if( iMaxBurstSize==0)
{ // render whole group
RSRenderGroupInternal( pspoGroup, ulGroupFlags);
}
// if lock count is specified
else
{ // render group in segments
while( pspoGroup!=NULL)
{ // find segment size
INDEX ctVtx = 0;
ScenePolygon *pspoThis = pspoGroup;
ScenePolygon *pspoLast = pspoGroup;
while( ctVtx<iMaxBurstSize && pspoGroup!=NULL) {
ctVtx += pspoGroup->spo_ctVtx;
pspoLast = pspoGroup;
pspoGroup = pspoGroup->spo_pspoSucc;
} // render one group segment
pspoLast->spo_pspoSucc = NULL;
RSRenderGroupInternal( pspoThis, ulGroupFlags);
}
}
}
// internal group rendering routine
void RSRenderGroupInternal( ScenePolygon *pspoGroup, ULONG ulGroupFlags)
{
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_RENDERGROUPINTERNAL);
_pfGfxProfile.IncrementCounter( CGfxProfile::PCI_RS_POLYGONGROUPS);
// make vertex coordinates for all polygons in the group
RSMakeVertexCoordinates(pspoGroup);
// prepare vertex, texture and color arrays
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_LOCKARRAYS);
gfxSetVertexArray( &_avtxPass[0], _avtxPass.Count());
if(CVA_bWorld) gfxLockArrays();
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_LOCKARRAYS);
// set alpha keying if required
if( ulGroupFlags & GF_KEY) gfxEnableAlphaTest();
else gfxDisableAlphaTest();
_iLastUnit = 0; // reset mulitex unit change
BOOL bUsedMT = FALSE;
BOOL bUsesMT = ulGroupFlags & (GF_TX0_TX1 | GF_TX0_TX2 | GF_TX0_SHD | GF_TX2_SHD
| GF_TX0_TX1_TX2 | GF_TX0_TX1_SHD | GF_TX0_TX2_SHD
| GF_TX0_TX1_TX2_SHD);
// dual texturing
if( ulGroupFlags & GF_TX0_SHD) {
RSSetTextureCoords( pspoGroup, SHADOWTEXTURE, 1);
RSSetTextureCoords( pspoGroup, 0, 0);
RSSetTextureColors( pspoGroup, GF_TX0|GF_SHD);
RSRenderTEX_SHD( pspoGroup, 0);
bUsedMT = TRUE;
}
else if( ulGroupFlags & GF_TX0_TX1) {
RSSetTextureCoords( pspoGroup, 1, 1);
RSSetTextureCoords( pspoGroup, 0, 0);
RSSetTextureColors( pspoGroup, GF_TX0|GF_TX1);
RSRender2TEX( pspoGroup, 1);
bUsedMT = TRUE;
}
else if( ulGroupFlags & GF_TX0_TX2) {
RSSetTextureCoords( pspoGroup, 2, 1);
RSSetTextureCoords( pspoGroup, 0, 0);
RSSetTextureColors( pspoGroup, GF_TX0|GF_TX2);
RSRender2TEX( pspoGroup, 2);
bUsedMT = TRUE;
}
// triple texturing
else if( ulGroupFlags & GF_TX0_TX1_TX2) {
RSSetTextureCoords( pspoGroup, 2, 2);
RSSetTextureCoords( pspoGroup, 1, 1);
RSSetTextureCoords( pspoGroup, 0, 0);
RSSetTextureColors( pspoGroup, GF_TX0|GF_TX1|GF_TX2);
RSRender3TEX( pspoGroup);
bUsedMT = TRUE;
}
else if( ulGroupFlags & GF_TX0_TX1_SHD) {
RSSetTextureCoords( pspoGroup, SHADOWTEXTURE, 2);
RSSetTextureCoords( pspoGroup, 1, 1);
RSSetTextureCoords( pspoGroup, 0, 0);
RSSetTextureColors( pspoGroup, GF_TX0|GF_TX1|GF_SHD);
RSRender2TEX_SHD( pspoGroup, 1);
bUsedMT = TRUE;
}
else if( ulGroupFlags & GF_TX0_TX2_SHD) {
RSSetTextureCoords( pspoGroup, SHADOWTEXTURE, 2);
RSSetTextureCoords( pspoGroup, 2, 1);
RSSetTextureCoords( pspoGroup, 0, 0);
RSSetTextureColors( pspoGroup, GF_TX0|GF_TX2|GF_SHD);
RSRender2TEX_SHD( pspoGroup, 2);
bUsedMT = TRUE;
}
// quad texturing
else if( ulGroupFlags & GF_TX0_TX1_TX2_SHD) {
RSSetTextureCoords( pspoGroup, SHADOWTEXTURE, 3);
RSSetTextureCoords( pspoGroup, 2, 2);
RSSetTextureCoords( pspoGroup, 1, 1);
RSSetTextureCoords( pspoGroup, 0, 0);
RSSetTextureColors( pspoGroup, GF_TX0|GF_TX1|GF_TX2|GF_SHD);
RSRender3TEX_SHD( pspoGroup);
bUsedMT = TRUE;
}
// if something was drawn and alpha keying was used
if( bUsedMT && (ulGroupFlags&GF_KEY)) {
// force z-buffer test to equal and disable subsequent alpha tests
gfxDepthFunc( GFX_EQUAL);
gfxDisableAlphaTest();
}
// dual texturing leftover
if( ulGroupFlags & GF_TX2_SHD) {
RSSetTextureCoords( pspoGroup, SHADOWTEXTURE, 1);
RSSetTextureCoords( pspoGroup, 2, 0);
RSSetTextureColors( pspoGroup, GF_TX2|GF_SHD);
RSRenderTEX_SHD( pspoGroup, 2);
bUsedMT = TRUE;
}
ASSERT( !bUsedMT==!bUsesMT);
// if some multi-tex units were used
if( bUsesMT) {
// disable them now
for( INDEX i=1; i<_ctUsableTexUnits; i++) {
gfxSetTextureUnit(i);
gfxDisableTexture();
}
_iLastUnit = 0;
gfxSetTextureUnit(0);
}
// if group has color for first layer
if( ulGroupFlags&GF_FLAT)
{ // render colors
if( _bTranslucentPass) {
// set opacity to 50%
if( !wld_bRenderTextures) RSSetConstantColors( 0x3F3F3F7F);
else RSSetPolygonColors( pspoGroup, 0x7F);
gfxEnableBlend();
gfxBlendFunc( GFX_SRC_ALPHA, GFX_INV_SRC_ALPHA);
} else {
// set opacity to 100%
if( !wld_bRenderTextures) RSSetConstantColors( 0x7F7F7FFF);
else RSSetPolygonColors( pspoGroup, CT_OPAQUE);
gfxDisableBlend();
}
gfxDisableTexture();
DrawAllElements( pspoGroup);
}
// if group has texture for first layer
if( ulGroupFlags&GF_TX0) {
// render texture 0
RSSetTextureCoords( pspoGroup, 0, 0);
RSSetTextureColors( pspoGroup, GF_TX0);
RSRenderTEX( pspoGroup, 0);
// eventually prepare subsequent layers for transparency
if( ulGroupFlags & GF_KEY) {
gfxDepthFunc( GFX_EQUAL);
gfxDisableAlphaTest();
}
}
// if group has texture for second layer
if( ulGroupFlags & GF_TX1) {
// render texture 1
RSSetTextureCoords( pspoGroup, 1, 0);
RSSetTextureColors( pspoGroup, GF_TX1);
RSRenderTEX( pspoGroup, 1);
}
// if group has texture for third layer
if( ulGroupFlags & GF_TX2) {
// render texture 2
RSSetTextureCoords( pspoGroup, 2, 0);
RSSetTextureColors( pspoGroup, GF_TX2);
RSRenderTEX( pspoGroup, 2);
}
// if group has shadow
if( ulGroupFlags & GF_SHD) {
// render shadow
RSSetTextureCoords( pspoGroup, SHADOWTEXTURE, 0);
RSSetTextureColors( pspoGroup, GF_SHD);
RSRenderSHD( pspoGroup);
}
// if group has aftershadow texture for second layer
if( ulGroupFlags & GF_TA1) {
// render texture 1
RSSetTextureCoords( pspoGroup, 1, 0);
RSSetTextureColors( pspoGroup, GF_TX1);
RSRenderTEX( pspoGroup, 1);
}
// if group has aftershadow texture for third layer
if( ulGroupFlags & GF_TA2) {
// render texture 2
RSSetTextureCoords( pspoGroup, 2, 0);
RSSetTextureColors( pspoGroup, GF_TX2);
RSRenderTEX( pspoGroup, 2);
}
// if group has fog
if( ulGroupFlags & GF_FOG) {
// render fog
RSStartupFog();
RSSetConstantColors( _fog_fp.fp_colColor);
RSSetFogCoordinates( pspoGroup);
RSRenderFog( pspoGroup);
}
// if group has haze
if( ulGroupFlags & GF_HAZE) {
// render haze
RSStartupHaze();
RSSetConstantColors( _haze_hp.hp_colColor);
RSSetHazeCoordinates( pspoGroup);
RSRenderHaze( pspoGroup);
}
// reset depth function and alpha keying back
// (maybe it was altered for transparent polygon rendering)
gfxDepthFunc( GFX_LESS_EQUAL);
gfxDisableAlphaTest();
// if group has selection
if( ulGroupFlags & GF_SEL) {
// render selection
gfxEnableBlend();
gfxBlendFunc( GFX_SRC_ALPHA, GFX_INV_SRC_ALPHA);
RSSetConstantColors( _colSelection|128);
gfxDisableTexture();
DrawAllElements( pspoGroup);
}
// render triangle wireframe if needed
extern INDEX wld_bShowTriangles;
if( wld_bShowTriangles) {
gfxEnableBlend();
gfxBlendFunc( GFX_SRC_ALPHA, GFX_INV_SRC_ALPHA);
RSSetConstantColors( C_mdYELLOW|222);
gfxDisableTexture();
// must write to front in z-buffer
gfxPolygonMode(GFX_LINE);
gfxEnableDepthTest();
gfxEnableDepthWrite();
gfxDepthFunc(GFX_ALWAYS);
gfxDepthRange( 0,0);
DrawAllElements(pspoGroup);
gfxDepthRange( _ppr->pr_fDepthBufferNear, _ppr->pr_fDepthBufferFar);
gfxDepthFunc(GFX_LESS_EQUAL);
if( _bTranslucentPass) gfxDisableDepthWrite();
gfxPolygonMode(GFX_FILL);
}
// all done
gfxUnlockArrays();
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_RENDERGROUPINTERNAL);
}
static void RSPrepare(void)
{
// set general params
gfxCullFace(GFX_NONE);
gfxEnableDepthTest();
gfxEnableClipping();
}
static void RSEnd(void)
{
// reset unusual gfx API parameters
gfxSetTextureUnit(0);
gfxSetTextureModulation(1);
}
void RenderScene( CDrawPort *pDP, ScenePolygon *pspoFirst, CAnyProjection3D &prProjection,
COLOR colSelection, BOOL bTranslucent)
{
// check API
eAPI = _pGfx->gl_eCurrentAPI;
ASSERT( GfxValidApi(eAPI) );
#ifdef SE1_D3D
if( eAPI!=GAT_OGL && eAPI!=GAT_D3D) return;
#else
if( eAPI!=GAT_OGL) return;
#endif
// some cvars cannot be altered in multiplayer mode!
if( _bMultiPlayer) {
shd_bShowFlats = FALSE;
gfx_bRenderWorld = TRUE;
wld_bRenderShadowMaps = TRUE;
wld_bRenderTextures = TRUE;
wld_bRenderDetailPolygons = TRUE;
wld_bShowDetailTextures = FALSE;
wld_bShowTriangles = FALSE;
}
// skip if not rendering world
if( !gfx_bRenderWorld) return;
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RENDERSCENE);
// remember input parameters
ASSERT( pDP != NULL);
_ppr = (CPerspectiveProjection3D*)&*prProjection;
_pDP = pDP;
_colSelection = colSelection;
_bTranslucentPass = bTranslucent;
// clamp detail textures LOD biasing
wld_iDetailRemovingBias = Clamp( wld_iDetailRemovingBias, -9, 9);
// set perspective projection
_pDP->SetProjection(prProjection);
// adjust multi-texturing support (for clip-plane emulation thru texture units)
extern BOOL GFX_bClipPlane; // WATCHOUT: set by 'SetProjection()' !
extern INDEX gap_iUseTextureUnits;
extern INDEX ogl_bAlternateClipPlane;
INDEX ctMaxUsableTexUnits = _pGfx->gl_ctTextureUnits;
if( eAPI==GAT_OGL && ogl_bAlternateClipPlane && GFX_bClipPlane && ctMaxUsableTexUnits>1) ctMaxUsableTexUnits--;
_ctUsableTexUnits = Clamp( gap_iUseTextureUnits, 1, ctMaxUsableTexUnits);
// prepare
RSPrepare();
// turn depth buffer writing on or off
if( bTranslucent) gfxDisableDepthWrite();
else gfxEnableDepthWrite();
// remove all polygons with no triangles from the polygon list
ScenePolygon *pspoNonDummy;
RSRemoveDummyPolygons( pspoFirst, &pspoNonDummy);
// check that layers of all shadows are up to date
RSCheckLayersUpToDate(pspoNonDummy);
// bin polygons to groups by texture passes
RSBinToGroups(pspoNonDummy);
// for each group
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RS_RENDERGROUP);
ASSERT( _apspoGroups[0]==NULL); // zero group must always be empty
for( INDEX iGroup=1; iGroup<_ctGroupsCount; iGroup++) {
// get the group polygon list and render it if not empty
ScenePolygon *pspoGroup = _apspoGroups[iGroup];
if( pspoGroup!=NULL) RSRenderGroup( pspoGroup, iGroup, 0);
}
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RS_RENDERGROUP);
// all done
RSEnd();
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RENDERSCENE);
}
// renders only scene z-buffer
void RenderSceneZOnly( CDrawPort *pDP, ScenePolygon *pspoFirst, CAnyProjection3D &prProjection)
{
if( _bMultiPlayer) gfx_bRenderWorld = 1;
if( !gfx_bRenderWorld) return;
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RENDERSCENE_ZONLY);
// set perspective projection
ASSERT(pDP!=NULL);
pDP->SetProjection(prProjection);
// prepare
RSPrepare();
// set for depth-only rendering
const ULONG ulCurrentColorMask = gfxGetColorMask();
gfxSetColorMask(NONE);
gfxEnableDepthTest();
gfxEnableDepthWrite();
gfxDisableTexture();
// make vertex coordinates for all polygons in the group and render the polygons
RSMakeVertexCoordinates(pspoFirst);
gfxSetVertexArray( &_avtxPass[0], _avtxPass.Count());
gfxDisableColorArray();
DrawAllElements(pspoFirst);
// restore color masking
gfxSetColorMask( ulCurrentColorMask);
RSEnd();
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RENDERSCENE_ZONLY);
}
// renders flat background of the scene
void RenderSceneBackground(CDrawPort *pDP, COLOR col)
{
if( _bMultiPlayer) gfx_bRenderWorld = 1;
if( !gfx_bRenderWorld) return;
// set orthographic projection
ASSERT(pDP!=NULL);
pDP->SetOrtho();
_pfGfxProfile.StartTimer( CGfxProfile::PTI_RENDERSCENE_BCG);
// prepare
gfxEnableDepthTest();
gfxDisableDepthWrite();
gfxDisableBlend();
gfxDisableAlphaTest();
gfxDisableTexture();
gfxEnableClipping();
col = AdjustColor( col, _slTexHueShift, _slTexSaturation);
GFXColor glcol(col|CT_OPAQUE);
const INDEX iW = pDP->GetWidth();
const INDEX iH = pDP->GetHeight();
// set arrays
gfxResetArrays();
GFXVertex *pvtx = _avtxCommon.Push(4);
/* GFXTexCoord *ptex = */ _atexCommon.Push(4);
GFXColor *pcol = _acolCommon.Push(4);
pvtx[0].x = 0; pvtx[0].y = 0; pvtx[0].z = 1;
pvtx[1].x = 0; pvtx[1].y = iH; pvtx[1].z = 1;
pvtx[2].x = iW; pvtx[2].y = iH; pvtx[2].z = 1;
pvtx[3].x = iW; pvtx[3].y = 0; pvtx[3].z = 1;
pcol[0] = glcol;
pcol[1] = glcol;
pcol[2] = glcol;
pcol[3] = glcol;
// render
_pGfx->gl_ctWorldTriangles += 2;
gfxFlushQuads();
_pfGfxProfile.StopTimer( CGfxProfile::PTI_RENDERSCENE_BCG);
}
Reference in New Issue View Git Blame Copy Permalink