mirror of
https://github.com/ptitSeb/Serious-Engine
synced 2024-10-05 23:44:51 +02:00
24cb244d43
This was a _ton_ of changes, made 15 years ago, so there are probably some problems to work out still. Among others: Engine/Base/Stream.* was mostly abandoned and will need to be re-ported. Still, this is a pretty good start, and probably holds a world record for lines of changes or something. :)
855 lines
27 KiB
C++
855 lines
27 KiB
C++
/* Copyright (c) 2002-2012 Croteam Ltd. All rights reserved. */
|
|
|
|
/*
|
|
* Add all edges in add list to active list.
|
|
*/
|
|
void CRenderer::AddAddListToActiveList(INDEX iScanLine)
|
|
{
|
|
INDEX ctAddEdges = re_actAddCounts[iScanLine];
|
|
// if the add list is empty
|
|
if (ctAddEdges==0) {
|
|
// do nothing
|
|
return;
|
|
}
|
|
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_ADDADDLIST);
|
|
CListHead &lhAdd = re_alhAddLists[iScanLine];
|
|
ASSERT(ctAddEdges==lhAdd.Count());
|
|
// mark that scan-line coherence is lost
|
|
re_bCoherentScanLine = 0;
|
|
|
|
// allocate space in destination for sum of source and add
|
|
INDEX ctActiveEdges = re_aaceActiveEdges.Count();
|
|
re_aaceActiveEdgesTmp.Push(ctAddEdges+ctActiveEdges);
|
|
|
|
// check that the add list is sorted right
|
|
#if ASER_EXTREME_CHECKING
|
|
{
|
|
LISTITER(CAddEdge, ade_lnInAdd) itadeAdd(lhAdd);
|
|
FIX16_16 xLastI;
|
|
xLastI.slHolder = MIN_SLONG;
|
|
while(!itadeAdd.IsPastEnd()) {
|
|
CAddEdge &adeAdd = *itadeAdd;
|
|
ASSERT(adeAdd.ade_xI==adeAdd.ade_psedEdge->sed_xI);
|
|
ASSERT(xLastI.slHolder <= adeAdd.ade_xI.slHolder);
|
|
xLastI = adeAdd.ade_xI;
|
|
itadeAdd.MoveToNext();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// check that the active list is sorted right
|
|
#if ASER_EXTREME_CHECKING
|
|
{
|
|
CActiveEdge *paceEnd = &re_aaceActiveEdges[re_aaceActiveEdges.Count()-1];
|
|
CActiveEdge *paceSrc = &re_aaceActiveEdges[0];
|
|
while (paceSrc<paceEnd) {
|
|
ASSERT(paceSrc[0].ace_xI.slHolder <= paceSrc[1].ace_xI.slHolder);
|
|
paceSrc++;
|
|
};
|
|
}
|
|
#endif
|
|
|
|
// start at begining of add list, source active list and destination active list
|
|
LISTITER(CAddEdge, ade_lnInAdd) itadeAdd(lhAdd);
|
|
CActiveEdge *paceSrc = &re_aaceActiveEdges[0];
|
|
CActiveEdge *paceDst = &re_aaceActiveEdgesTmp[0];
|
|
|
|
IFDEBUG(INDEX ctNewActive=0);
|
|
IFDEBUG(INDEX ctOldActive1=0);
|
|
IFDEBUG(INDEX ctOldActive2=0);
|
|
|
|
// for each edge in add list
|
|
while(!itadeAdd.IsPastEnd()) {
|
|
CAddEdge &ade = *itadeAdd;
|
|
|
|
// while the edge in active list is left of the edge in add list
|
|
while (paceSrc->ace_xI.slHolder < itadeAdd->ade_xI.slHolder) {
|
|
// copy the active edge
|
|
ASSERT(paceSrc<=&re_aaceActiveEdges[ctActiveEdges-1]);
|
|
*paceDst++=*paceSrc++;
|
|
IFDEBUG(ctOldActive1++);
|
|
}
|
|
|
|
// copy the add edge
|
|
ASSERT(paceDst > &re_aaceActiveEdgesTmp[0]);
|
|
ASSERT(ade.ade_xI.slHolder == ade.ade_psedEdge->sed_xI.slHolder);
|
|
ASSERT(paceDst[-1].ace_xI.slHolder <= ade.ade_xI.slHolder);
|
|
|
|
*paceDst++=CActiveEdge(itadeAdd->ade_psedEdge);
|
|
IFDEBUG(ctNewActive++);
|
|
// advance iterator in add list
|
|
itadeAdd.MoveToNext();
|
|
}
|
|
// clear the add list
|
|
lhAdd.Clear();
|
|
re_actAddCounts[iScanLine] = 0;
|
|
// copy all edges left in the active list
|
|
while (paceSrc<=&re_aaceActiveEdges[ctActiveEdges-1]) {
|
|
*paceDst++=*paceSrc++;
|
|
IFDEBUG(ctOldActive2++);
|
|
}
|
|
|
|
// swap the lists
|
|
Swap(re_aaceActiveEdges.sa_Count , re_aaceActiveEdgesTmp.sa_Count );
|
|
Swap(re_aaceActiveEdges.sa_Array , re_aaceActiveEdgesTmp.sa_Array );
|
|
Swap(re_aaceActiveEdges.sa_UsedCount, re_aaceActiveEdgesTmp.sa_UsedCount);
|
|
re_aaceActiveEdgesTmp.PopAll();
|
|
|
|
if (ctAddEdges>_ctMaxAddEdges) {
|
|
_ctMaxAddEdges=ctAddEdges;
|
|
}
|
|
if (re_aaceActiveEdges.Count()>_ctMaxActiveEdges) {
|
|
_ctMaxActiveEdges=re_aaceActiveEdges.Count();
|
|
}
|
|
|
|
// check that the active list is sorted right
|
|
#if ASER_EXTREME_CHECKING
|
|
{
|
|
CActiveEdge *paceEnd = &re_aaceActiveEdges[re_aaceActiveEdges.Count()-1];
|
|
CActiveEdge *paceSrc = &re_aaceActiveEdges[0];
|
|
while (paceSrc<paceEnd) {
|
|
ASSERT(paceSrc[0].ace_xI.slHolder <= paceSrc[1].ace_xI.slHolder);
|
|
paceSrc++;
|
|
};
|
|
}
|
|
#endif
|
|
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_ADDADDLIST);
|
|
}
|
|
|
|
/*
|
|
* Remove all edges in remove list from active list and from other lists.
|
|
*/
|
|
void CRenderer::RemRemoveListFromActiveList(CScreenEdge *psedFirst)
|
|
{
|
|
// if the remove list is empty
|
|
if (psedFirst==NULL) {
|
|
// do nothing
|
|
return;
|
|
}
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_REMREMLIST);
|
|
// mark that scan-line coherence is lost
|
|
re_bCoherentScanLine = 0;
|
|
|
|
// for each edge to be removed on this line
|
|
CScreenEdge *psed = psedFirst;
|
|
do {
|
|
// mark it as removed
|
|
psed->sed_xI.slHolder = ACE_REMOVED;
|
|
psed = psed->sed_psedNextRemove;
|
|
} while (psed!=NULL);
|
|
|
|
// for each active edge
|
|
CActiveEdge *paceEnd = &re_aaceActiveEdges[re_aaceActiveEdges.Count()-1];
|
|
CActiveEdge *paceSrc = &re_aaceActiveEdges[1];
|
|
CActiveEdge *paceDst = paceSrc;
|
|
do {
|
|
// if it is not removed
|
|
if (paceSrc->ace_psedEdge->sed_xI.slHolder!=ACE_REMOVED) {
|
|
// copy it
|
|
*paceDst = *paceSrc;
|
|
paceDst++;
|
|
}
|
|
paceSrc++;
|
|
} while (paceSrc<=paceEnd);
|
|
// trim the end of active list
|
|
re_aaceActiveEdges.PopUntil(paceDst-&re_aaceActiveEdges[0]-1);
|
|
|
|
// check that the active list is sorted right
|
|
#if ASER_EXTREME_CHECKING
|
|
{
|
|
CActiveEdge *paceEnd = &re_aaceActiveEdges[re_aaceActiveEdges.Count()-1];
|
|
CActiveEdge *paceSrc = &re_aaceActiveEdges[0];
|
|
while (paceSrc<paceEnd) {
|
|
ASSERT(paceSrc[0].ace_xI.slHolder <= paceSrc[1].ace_xI.slHolder);
|
|
paceSrc++;
|
|
};
|
|
}
|
|
#endif
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_REMREMLIST);
|
|
}
|
|
|
|
/*
|
|
* Step all edges in active list by one scan line and resort them.
|
|
*/
|
|
void CRenderer::StepAndResortActiveList(void)
|
|
{
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_STEPANDRESORT);
|
|
|
|
// start after the left sentinel
|
|
CActiveEdge *pace = &re_aaceActiveEdges[1];
|
|
|
|
// for all edges before right sentinel
|
|
CActiveEdge *paceEnd = &re_aaceActiveEdges[re_aaceActiveEdges.Count()-1];
|
|
do {
|
|
|
|
// step the edge by one scan line
|
|
pace->ace_xI.slHolder += pace->ace_xIStep.slHolder;
|
|
|
|
// if the previous is right of the current
|
|
if (pace[-1].ace_xI.slHolder > pace->ace_xI.slHolder) {
|
|
// mark that scan-line coherence is lost
|
|
re_bCoherentScanLine = 0;
|
|
|
|
// find last one that is not right
|
|
CActiveEdge *pacePred = pace;
|
|
do {
|
|
pacePred--;
|
|
} while(pacePred->ace_xI.slHolder > pace->ace_xI.slHolder);
|
|
|
|
// remember the current one
|
|
CActiveEdge aceCurrent = *pace;
|
|
// move all of the edges between one place forward
|
|
CActiveEdge *paceMove=pace-1;
|
|
do {
|
|
paceMove[1]=paceMove[0];
|
|
paceMove--;
|
|
} while (paceMove>pacePred);
|
|
// insert the current to its new place
|
|
paceMove[1] = aceCurrent;
|
|
}
|
|
|
|
pace++;
|
|
} while (pace < paceEnd);
|
|
|
|
// check that the active list is sorted right
|
|
#if ASER_EXTREME_CHECKING
|
|
{
|
|
CActiveEdge *paceEnd = &re_aaceActiveEdges[re_aaceActiveEdges.Count()-1];
|
|
CActiveEdge *paceSrc = &re_aaceActiveEdges[0];
|
|
while (paceSrc<paceEnd) {
|
|
ASSERT(paceSrc[0].ace_xI.slHolder <= paceSrc[1].ace_xI.slHolder);
|
|
paceSrc++;
|
|
};
|
|
}
|
|
#endif
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_STEPANDRESORT);
|
|
}
|
|
|
|
/* Copy I coordinates from active list to edge data. */
|
|
void CRenderer::CopyActiveCoordinates(void)
|
|
{
|
|
// for all active edges
|
|
CActiveEdge *paceEnd = &re_aaceActiveEdges[re_aaceActiveEdges.Count()-1];
|
|
CActiveEdge *pace = &re_aaceActiveEdges[1];
|
|
do {
|
|
// copy active coordinates
|
|
pace->ace_psedEdge->sed_xI.slHolder = pace->ace_xI.slHolder;
|
|
pace++;
|
|
} while (pace<=paceEnd);
|
|
}
|
|
|
|
/*
|
|
* Remove an active portal from rendering
|
|
*/
|
|
void CRenderer::RemovePortal(CScreenPolygon &spo)
|
|
{
|
|
ASSERT(spo.IsPortal());
|
|
ASSERT(spo.spo_bActive);
|
|
spo.spo_bActive = FALSE;
|
|
|
|
// if it is a translucent portal
|
|
if (spo.spo_pbpoBrushPolygon->bpo_ulFlags & (BPOF_RENDERTRANSLUCENT|BPOF_TRANSPARENT)) {
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_PROCESSTRANSPORTAL);
|
|
// add polygon to scene polygons for rendering
|
|
AddPolygonToScene(&spo);
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_PROCESSTRANSPORTAL);
|
|
}
|
|
|
|
// if it is in the surface stack
|
|
if (spo.spo_lnInStack.IsLinked()) {
|
|
// remove it from surface stack
|
|
RemPolygonFromSurfaceStack(spo);
|
|
spo.spo_iInStack = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Add sector(s) adjoined to a portal to rendering and remove the portal.
|
|
*/
|
|
void CRenderer::PassPortal(CScreenPolygon &spo)
|
|
{
|
|
ChangeStatsMode(CStatForm::STI_WORLDTRANSFORM);
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_PASSPORTAL);
|
|
// remove the portal from rendering
|
|
RemovePortal(spo);
|
|
|
|
// for all sectors related to the portal
|
|
{FOREACHDSTOFSRC(spo.spo_pbpoBrushPolygon->bpo_rsOtherSideSectors, CBrushSector, bsc_rdOtherSidePortals, pbsc)
|
|
// if the sector is hidden when not rendering shadows
|
|
if ((pbsc->bsc_ulFlags&BSCF_HIDDEN) && !re_bRenderingShadows) {
|
|
// skip it
|
|
continue;
|
|
}
|
|
// get brush of the sector
|
|
CBrushMip *pbmSectorMip = pbsc->bsc_pbmBrushMip;
|
|
CBrush3D &brBrush = *pbmSectorMip->bm_pbrBrush;
|
|
// prepare the brush entity for rendering if not yet prepared
|
|
PrepareBrush(brBrush.br_penEntity);
|
|
// get relevant mip factor for that brush and current rendering prefs
|
|
CBrushMip *pbmRelevantMip;
|
|
if (brBrush.br_ulFlags&BRF_DRAWFIRSTMIP) {
|
|
pbmRelevantMip = brBrush.GetBrushMipByDistance(
|
|
_wrpWorldRenderPrefs.GetCurrentMipBrushingFactor(0.0f));
|
|
} else {
|
|
pbmRelevantMip = brBrush.GetBrushMipByDistance(
|
|
_wrpWorldRenderPrefs.GetCurrentMipBrushingFactor(brBrush.br_prProjection->MipFactor()));
|
|
}
|
|
// if relevant brush mip is same as the sector's brush mip
|
|
if (pbmSectorMip==pbmRelevantMip) {
|
|
// add that sector to active sectors
|
|
AddActiveSector(*pbsc);
|
|
}
|
|
ENDFOR}
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_PASSPORTAL);
|
|
ChangeStatsMode(CStatForm::STI_WORLDVISIBILITY);
|
|
}
|
|
|
|
/*
|
|
* Add a sector of a brush to rendering queues.
|
|
*/
|
|
void CRenderer::AddActiveSector(CBrushSector &bscSector)
|
|
{
|
|
// if already active
|
|
if (bscSector.bsc_lnInActiveSectors.IsLinked()) {
|
|
// do nothing;
|
|
return;
|
|
}
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_ADDSECTOR);
|
|
|
|
// add it to active sectors list
|
|
re_lhActiveSectors.AddTail(bscSector.bsc_lnInActiveSectors);
|
|
|
|
// !!! FIXME : rcg10132001 I'm lazy.
|
|
#ifdef PLATFORM_WIN32
|
|
ASSERT((_controlfp(0, 0)&_MCW_RC)==_RC_NEAR);
|
|
#endif
|
|
|
|
CBrush3D &br = *bscSector.bsc_pbmBrushMip->bm_pbrBrush;
|
|
// if should render field brush sector
|
|
if (br.br_penEntity->en_RenderType==CEntity::RT_FIELDBRUSH
|
|
&& !_wrpWorldRenderPrefs.IsFieldBrushesOn()) {
|
|
// skip it
|
|
bscSector.bsc_ulFlags|=BSCF_INVISIBLE;
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_ADDSECTOR);
|
|
return;
|
|
}
|
|
|
|
// test sector visibility
|
|
const INDEX iFrustrumTest = IsSectorVisible( br, bscSector);
|
|
if( iFrustrumTest==-1) {
|
|
// outside of frustrum - skip it
|
|
bscSector.bsc_ulFlags |= BSCF_INVISIBLE;
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_ADDSECTOR);
|
|
return;
|
|
} else if( iFrustrumTest==0) {
|
|
// partially in frustrum - needs clipping
|
|
bscSector.bsc_ulFlags |= BSCF_NEEDSCLIPPING;
|
|
} else {
|
|
// completely in frustrum - doesn't need clipping
|
|
bscSector.bsc_ulFlags &= ~BSCF_NEEDSCLIPPING;
|
|
}
|
|
// mark that sector is visible
|
|
bscSector.bsc_ulFlags &= ~BSCF_INVISIBLE;
|
|
|
|
// remember current sector
|
|
re_pbscCurrent = &bscSector;
|
|
re_pbrCurrent = &br;
|
|
_sfStats.IncrementCounter(CStatForm::SCI_SECTORS);
|
|
|
|
// if projection is perspective
|
|
if( br.br_prProjection.IsPerspective()) {
|
|
// prepare fog/haze
|
|
SetupFogAndHaze();
|
|
}
|
|
|
|
// transform all vertices and planes in this sector
|
|
PreClipVertices();
|
|
PreClipPlanes();
|
|
|
|
// if polygons should be drawn
|
|
if (_wrpWorldRenderPrefs.wrp_ftPolygons != CWorldRenderPrefs::FT_NONE
|
|
||re_bRenderingShadows) {
|
|
// find which portals should be rendered as portals or as pretenders
|
|
FindPretenders();
|
|
// make screen polygons for nondetail polygons in current sector
|
|
MakeNonDetailScreenPolygons();
|
|
// clip all polygons to all clip planes
|
|
if( bscSector.bsc_ulFlags&BSCF_NEEDSCLIPPING) ClipToAllPlanes( br.br_prProjection);
|
|
// project vertices to 2d
|
|
PostClipVertices();
|
|
// make final edges for all polygons in current sector
|
|
MakeFinalPolygonEdges();
|
|
// add screen edges for all polygons in current sector
|
|
AddScreenEdges();
|
|
// make screen polygons for detail polygons in current sector
|
|
MakeDetailScreenPolygons();
|
|
}
|
|
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_ADDSECTOR);
|
|
|
|
// get the entity the sector is in
|
|
CEntity *penSectorEntity = bscSector.bsc_pbmBrushMip->bm_pbrBrush->br_penEntity;
|
|
// if it has the entity (it is not the background brush)
|
|
if (penSectorEntity != NULL) {
|
|
// add all other entities near the sector
|
|
AddEntitiesInSector(&bscSector);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Initialize list of active edges.
|
|
*/
|
|
void CRenderer::InitScanEdges(void)
|
|
{
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_INITSCANEDGES);
|
|
|
|
// empty active lists
|
|
re_aaceActiveEdges.PopAll(); re_aaceActiveEdges.SetAllocationStep(256);
|
|
re_aaceActiveEdgesTmp.PopAll(); re_aaceActiveEdgesTmp.SetAllocationStep(256);
|
|
|
|
// set up left sentinel as left edge of screen and add it to head of active list
|
|
re_sedLeftSentinel.sed_xI = FIX16_16(re_fbbClipBox.Min()(1)-SENTINELEDGE_EPSILON);
|
|
re_sedLeftSentinel.sed_xIStep = FIX16_16(0);
|
|
re_sedLeftSentinel.sed_pspo = &re_spoFarSentinel;
|
|
re_aaceActiveEdges.Push() = CActiveEdge(&re_sedLeftSentinel);
|
|
|
|
// set up right sentinel as right edge of screen and add it to tail of active list
|
|
re_sedRightSentinel.sed_xI = FIX16_16(re_fbbClipBox.Max()(1)+SENTINELEDGE_EPSILON);
|
|
re_sedRightSentinel.sed_xIStep = FIX16_16(0);
|
|
re_sedRightSentinel.sed_pspo = &re_spoFarSentinel;
|
|
re_aaceActiveEdges.Push() = CActiveEdge(&re_sedRightSentinel);
|
|
|
|
// set up far sentinel as infinitely far polygon
|
|
re_spoFarSentinel.spo_pgOoK.Constant(-999999.0f); // further than infinity
|
|
re_spoFarSentinel.spo_iInStack = 1;
|
|
re_spoFarSentinel.spo_psedSpanStart = &re_sedLeftSentinel;
|
|
re_spoFarSentinel.spo_pbpoBrushPolygon = NULL;
|
|
re_spoFarSentinel.spo_ubIllumination = 0;
|
|
|
|
// initialize list of spans for far sentinel
|
|
re_spoFarSentinel.spo_spoScenePolygon.spo_cColor = re_pwoWorld->wo_colBackground;
|
|
re_spoFarSentinel.spo_spoScenePolygon.spo_aptoTextures[0] = NULL;
|
|
re_spoFarSentinel.spo_spoScenePolygon.spo_aptoTextures[1] = NULL;
|
|
re_spoFarSentinel.spo_spoScenePolygon.spo_aptoTextures[2] = NULL;
|
|
re_spoFarSentinel.spo_spoScenePolygon.spo_psmShadowMap = NULL;
|
|
re_spoFarSentinel.spo_spoScenePolygon.spo_ulFlags = SPOF_BACKLIGHT;
|
|
|
|
// add it to the list of background span polygons in this renderer
|
|
re_spoFarSentinel.spo_spoScenePolygon.spo_pspoSucc = re_pspoFirstBackground;
|
|
re_pspoFirstBackground = &re_spoFarSentinel.spo_spoScenePolygon;
|
|
|
|
// add far sentinel as bottom of surface stack
|
|
ASSERT(re_lhSurfaceStack.IsEmpty());
|
|
re_lhSurfaceStack.AddTail(re_spoFarSentinel.spo_lnInStack);
|
|
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_INITSCANEDGES);
|
|
}
|
|
|
|
/*
|
|
* Clean up list of active edges.
|
|
*/
|
|
void CRenderer::EndScanEdges(void)
|
|
{
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_ENDSCANEDGES);
|
|
|
|
// remove far sentinel from surface stack
|
|
ASSERT(re_spoFarSentinel.spo_iInStack == 1);
|
|
re_spoFarSentinel.spo_lnInStack.Remove();
|
|
re_spoFarSentinel.spo_iInStack = 0;
|
|
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_ENDSCANEDGES);
|
|
}
|
|
|
|
/*
|
|
* Add a polygon to surface stack.
|
|
*/
|
|
BOOL CRenderer::AddPolygonToSurfaceStack(CScreenPolygon &spo)
|
|
{
|
|
// increment in-stack counter
|
|
spo.spo_iInStack++;
|
|
|
|
// if it doesn't have to be added
|
|
if (spo.spo_iInStack!=1) {
|
|
// return that this is not new top
|
|
return FALSE;
|
|
}
|
|
|
|
#define BIAS (1)
|
|
//#define BIAS (0)
|
|
|
|
FLOAT fScanI = FLOAT(re_xCurrentScanI)+BIAS;
|
|
FLOAT fScanJ = re_fCurrentScanJ;//+re_fMinJ;
|
|
|
|
// calculate 1/k for new polygon
|
|
CPlanarGradients &pg = spo.spo_pgOoK;
|
|
FLOAT fOoK = pg.pg_f00 + pg.pg_fDOverDI*fScanI + pg.pg_fDOverDJ*fScanJ;
|
|
|
|
// bias for right edges - fix against generating extra trapezoids
|
|
fOoK*=re_fEdgeAdjustK;
|
|
|
|
// must not be infinitely far, except if background polygon
|
|
//ASSERT(fOneOverK>0.0f || fOneOverK==-9999.0f);
|
|
// cannot assert on this, because of +1 bias
|
|
|
|
// start at top surface in stack
|
|
LISTITER(CScreenPolygon, spo_lnInStack) itspo(re_lhSurfaceStack);
|
|
|
|
// if the projection is not perspective
|
|
if (!re_prProjection.IsPerspective()) {
|
|
// while new polygon is further than polygon in stack
|
|
while(
|
|
((fOoK -
|
|
itspo->spo_pgOoK.pg_f00 -
|
|
itspo->spo_pgOoK.pg_fDOverDI*fScanI -
|
|
itspo->spo_pgOoK.pg_fDOverDJ*fScanJ)<0)
|
|
&& (&*itspo != &re_spoFarSentinel)) {
|
|
// move to next polygon in stack
|
|
itspo.MoveToNext();
|
|
}
|
|
} else {
|
|
// while new polygon is further than polygon in stack
|
|
FLOAT fDelta = fOoK -
|
|
itspo->spo_pgOoK.pg_f00 -
|
|
itspo->spo_pgOoK.pg_fDOverDI*fScanI -
|
|
itspo->spo_pgOoK.pg_fDOverDJ*fScanJ;
|
|
|
|
if (((SLONG &)fDelta) < 0) {
|
|
do {
|
|
// the polygon in stack must not be far sentinel
|
|
ASSERT(&*itspo != &re_spoFarSentinel);
|
|
// move to next polygon in stack
|
|
itspo.MoveToNext();
|
|
fDelta = fOoK -
|
|
itspo->spo_pgOoK.pg_f00 -
|
|
itspo->spo_pgOoK.pg_fDOverDI*fScanI -
|
|
itspo->spo_pgOoK.pg_fDOverDJ*fScanJ;
|
|
} while (((SLONG &)fDelta) < 0);
|
|
}
|
|
}
|
|
|
|
// add the new polygon before the one in stack
|
|
itspo.InsertBeforeCurrent(spo.spo_lnInStack);
|
|
|
|
// return if this is new top of stack
|
|
return spo.spo_lnInStack.IsHead();
|
|
}
|
|
|
|
/*
|
|
* Remove a polygon from surface stack.
|
|
*/
|
|
BOOL CRenderer::RemPolygonFromSurfaceStack(CScreenPolygon &spo)
|
|
{
|
|
// decrement in-stack counter
|
|
spo.spo_iInStack--;
|
|
|
|
// if it doesn't have to be removed
|
|
if (spo.spo_iInStack!=0) {
|
|
// return that this was not top
|
|
return FALSE;
|
|
}
|
|
|
|
// if the polygon is top of stack
|
|
if (spo.spo_lnInStack.IsHead()) {
|
|
// remove the polygon from stack
|
|
spo.spo_lnInStack.Remove();
|
|
// return that this was top
|
|
return TRUE;
|
|
|
|
// if the polygon is not top of stack
|
|
} else {
|
|
// remove the polygon from stack
|
|
spo.spo_lnInStack.Remove();
|
|
// return that this was not top
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Swap two polygons in surface stack.
|
|
*/
|
|
BOOL CRenderer::SwapPolygonsInSurfaceStack(CScreenPolygon &spoOld, CScreenPolygon &spoNew)
|
|
{
|
|
// !!!!! fix the problems with surfaces beeing multiple times added
|
|
// to the stack before reenabling this feature!
|
|
|
|
ASSERT(FALSE);
|
|
// decrement/increment in-stack counters
|
|
spoOld.spo_iInStack--;
|
|
spoNew.spo_iInStack++;
|
|
|
|
ASSERT(spoOld.spo_iInStack==0);
|
|
ASSERT(spoNew.spo_iInStack==1);
|
|
|
|
// if the left polygon is top of stack
|
|
if (spoOld.spo_lnInStack.IsHead()) {
|
|
// swap them
|
|
CListNode &lnBefore = spoOld.spo_lnInStack.IterationPred();
|
|
spoOld.spo_lnInStack.Remove();
|
|
lnBefore.IterationInsertAfter(spoNew.spo_lnInStack);
|
|
return TRUE;
|
|
|
|
// if the polygon is not top of stack
|
|
} else {
|
|
// swap them
|
|
CListNode &lnBefore = spoOld.spo_lnInStack.IterationPred();
|
|
spoOld.spo_lnInStack.Remove();
|
|
lnBefore.IterationInsertAfter(spoNew.spo_lnInStack);
|
|
// return that this was not top
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Remove all polygons from surface stack.
|
|
*/
|
|
void CRenderer::FlushSurfaceStack(void)
|
|
{
|
|
// while there is some polygon above far sentinel in surface stack
|
|
CScreenPolygon *pspoTop;
|
|
while ((pspoTop = LIST_HEAD(re_lhSurfaceStack, CScreenPolygon, spo_lnInStack))
|
|
!= &re_spoFarSentinel) {
|
|
|
|
// it must be linked in stack
|
|
#if 0
|
|
if (pspoTop->spo_iInStack<=0) {
|
|
_pSCape->DebugSave();
|
|
FatalError("Surface stack bug encountered!\nDebug game saved!");
|
|
}
|
|
ASSERT(pspoTop->spo_iInStack>0);
|
|
#endif
|
|
|
|
// remove it from stack
|
|
pspoTop->spo_lnInStack.Remove();
|
|
pspoTop->spo_iInStack = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Scan list of active edges into spans.
|
|
*/
|
|
CScreenPolygon *CRenderer::ScanOneLine(void)
|
|
{
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_SCANONELINE);
|
|
IFDEBUG(FIX16_16 xCurrentI = FIX16_16(-10));
|
|
|
|
// reinit far sentinel
|
|
re_spoFarSentinel.spo_iInStack = 1;
|
|
re_spoFarSentinel.spo_psedSpanStart = &re_sedLeftSentinel;
|
|
|
|
// clear list of spans for current line
|
|
re_aspSpans.PopAll();
|
|
|
|
// if left and right sentinels are sorted wrong
|
|
if (re_aaceActiveEdges[0].ace_psedEdge!=&re_sedLeftSentinel
|
|
||re_aaceActiveEdges[re_aaceActiveEdges.Count()-1].ace_psedEdge!=&re_sedRightSentinel) {
|
|
// skip entire line (this patches some extremely rare crash situations)
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_SCANONELINE);
|
|
return NULL;
|
|
}
|
|
|
|
// for all edges in the line
|
|
CActiveEdge *pace = &re_aaceActiveEdges[1];
|
|
CActiveEdge *paceEnd = &re_aaceActiveEdges[re_aaceActiveEdges.Count()-1];
|
|
while (pace<paceEnd) {
|
|
CScreenEdge &sed = *pace->ace_psedEdge;
|
|
ASSERT(&sed!=&re_sedLeftSentinel);
|
|
ASSERT(&sed!=&re_sedRightSentinel);
|
|
// set up current I coordinate on the scan line
|
|
re_xCurrentScanI = sed.sed_xI = pace->ace_xI;
|
|
|
|
// check that edges are sorted ok
|
|
|
|
ASSERT(xCurrentI <= sed.sed_xI);
|
|
|
|
// count edge transitions
|
|
_pfRenderProfile.IncrementCounter(CRenderProfile::PCI_EDGETRANSITIONS);
|
|
_sfStats.IncrementCounter(CStatForm::SCI_EDGETRANSITIONS);
|
|
|
|
// if this edge has active polygon
|
|
if (sed.sed_pspo!= NULL && sed.sed_pspo->spo_bActive) {
|
|
CScreenPolygon &spo = *sed.sed_pspo;
|
|
// if it is right edge of the polygon
|
|
if (sed.sed_ldtDirection==LDT_ASCENDING) {
|
|
|
|
// remove the left polygon from stack
|
|
BOOL bWasTop = RemPolygonFromSurfaceStack(spo);
|
|
|
|
// if that was top polygon in surface stack
|
|
if (bWasTop) {
|
|
// if it is portal
|
|
if (spo.IsPortal() &&
|
|
(re_ubLightIllumination==0||re_ubLightIllumination!=spo.spo_ubIllumination)) {
|
|
// fail scanning and add that portal
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_SCANONELINE);
|
|
return &spo;
|
|
}
|
|
// generate a span for it
|
|
MakeSpan(spo, spo.spo_psedSpanStart, &sed);
|
|
|
|
// mark that span of new top starts here
|
|
CScreenPolygon *pspoNewTop =
|
|
LIST_HEAD(re_lhSurfaceStack, CScreenPolygon, spo_lnInStack);
|
|
pspoNewTop->spo_psedSpanStart = &sed;
|
|
}
|
|
|
|
// if it is left edge of the polygon
|
|
} else {
|
|
ASSERT(sed.sed_ldtDirection==LDT_DESCENDING);
|
|
|
|
// add the right polygon to stack
|
|
BOOL bIsTop = AddPolygonToSurfaceStack(spo);
|
|
|
|
// if it is the new top of surface stack
|
|
if (bIsTop) {
|
|
// get the old top
|
|
CScreenPolygon &spoOldTop = *LIST_SUCC(spo, CScreenPolygon, spo_lnInStack);
|
|
// if it is portal
|
|
if (spoOldTop.IsPortal() &&
|
|
(re_ubLightIllumination==0||re_ubLightIllumination!=spoOldTop.spo_ubIllumination)) {
|
|
// if its span has at least one pixel in length
|
|
if ( PIXCoord(re_xCurrentScanI)-PIXCoord(spoOldTop.spo_psedSpanStart->sed_xI)>0) {
|
|
// fail scanning and add that portal
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_SCANONELINE);
|
|
return &spoOldTop;
|
|
}
|
|
// if it is not portal
|
|
} else {
|
|
// generate span for old top
|
|
MakeSpan(spoOldTop, spoOldTop.spo_psedSpanStart, &sed);
|
|
}
|
|
|
|
// mark that span of new polygon starts here
|
|
spo.spo_psedSpanStart = &sed;
|
|
}
|
|
}
|
|
|
|
IFDEBUG(xCurrentI = pace->ace_xI);
|
|
// if this edge has no active polygon
|
|
} else {
|
|
// mark it for removal
|
|
sed.sed_xI.slHolder = ACE_REMOVED;
|
|
}
|
|
|
|
pace++;
|
|
}
|
|
|
|
// NOTE: In some rare and extreme situations (usually when casting shadows)
|
|
// the stack might not be empty after scanning - this code fixes that.
|
|
|
|
// if surface stack contains something else except background
|
|
CScreenPolygon *pspoTop = LIST_HEAD(re_lhSurfaceStack, CScreenPolygon, spo_lnInStack);
|
|
if (&re_spoFarSentinel != pspoTop) {
|
|
// ASSERTALWAYS("Bug in ASER: Surface stack not empty!");
|
|
CScreenPolygon &spo = *pspoTop;
|
|
// generate span of the top polygon to the right border
|
|
if (!(spo.IsPortal()
|
|
&& (re_ubLightIllumination==0 || re_ubLightIllumination!=spo.spo_ubIllumination))) {
|
|
MakeSpan(spo, spo.spo_psedSpanStart, &re_sedRightSentinel);
|
|
}
|
|
// remove all left-over polygons from stack
|
|
do {
|
|
BOOL bWasTop = RemPolygonFromSurfaceStack(*pspoTop);
|
|
pspoTop = LIST_HEAD(re_lhSurfaceStack, CScreenPolygon, spo_lnInStack);
|
|
} while (&re_spoFarSentinel != pspoTop);
|
|
// mark start of background span at right border
|
|
re_spoFarSentinel.spo_psedSpanStart = &re_sedRightSentinel;
|
|
}
|
|
|
|
// generate span for far sentinel
|
|
MakeSpan(re_spoFarSentinel, re_spoFarSentinel.spo_psedSpanStart, &re_sedRightSentinel);
|
|
|
|
// return that no portal was encountered
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_SCANONELINE);
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Rasterize edges into spans.
|
|
*/
|
|
void CRenderer::ScanEdges(void)
|
|
{
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_SCANEDGES);
|
|
// set up the list of active edges, surface stack and the sentinels
|
|
InitScanEdges();
|
|
|
|
// mark that first line is never coherent with previous one
|
|
re_bCoherentScanLine = 0;
|
|
|
|
// for each scan line, top to bottom
|
|
for (re_iCurrentScan = 0; re_iCurrentScan<re_ctScanLines; re_iCurrentScan++) {
|
|
re_pixCurrentScanJ = re_iCurrentScan + re_pixTopScanLineJ;
|
|
re_fCurrentScanJ = FLOAT(re_pixCurrentScanJ);
|
|
|
|
_pfRenderProfile.IncrementCounter(CRenderProfile::PCI_OVERALLSCANLINES);
|
|
|
|
CScreenPolygon *pspoPortal; // pointer to portal encountered while scanning
|
|
|
|
// add all edges that start on this scan line to active list
|
|
AddAddListToActiveList(re_iCurrentScan);
|
|
|
|
// if scan-line is coherent with the last one
|
|
/*!!!! if (re_bCoherentScanLine>0) {
|
|
// increment counter of coherent scan lines
|
|
_pfRenderProfile.IncrementCounter(CRenderProfile::PCI_COHERENTSCANLINES);
|
|
// just copy I coordinates from active list to edge data
|
|
CopyActiveCoordinates();
|
|
|
|
// if scan-line is not coherent with the last one
|
|
} else/**/ {
|
|
|
|
// scan list of active edges into spans
|
|
pspoPortal = ScanOneLine();
|
|
|
|
// while portal is encountered during scanning
|
|
while (pspoPortal != NULL) {
|
|
// increment counter of portal retries
|
|
_pfRenderProfile.IncrementCounter(CRenderProfile::PCI_SCANLINEPORTALRETRIES);
|
|
|
|
// remove all polygons from surface stack
|
|
FlushSurfaceStack();
|
|
|
|
// add sectors near the encountered portal to rendering
|
|
PassPortal(*pspoPortal);
|
|
// add all newly added edges that start on this scan line to active list
|
|
AddAddListToActiveList(re_iCurrentScan);
|
|
|
|
// rescan list of active edges into spans again
|
|
pspoPortal = ScanOneLine();
|
|
}
|
|
}
|
|
|
|
// set scan-line coherence marker
|
|
re_bCoherentScanLine++;
|
|
|
|
// surface stack must contain only background
|
|
ASSERT(&re_spoFarSentinel == LIST_HEAD(re_lhSurfaceStack, CScreenPolygon, spo_lnInStack)
|
|
&& &re_spoFarSentinel == LIST_TAIL(re_lhSurfaceStack, CScreenPolygon, spo_lnInStack));
|
|
|
|
// add spans in this line to the scene
|
|
AddSpansToScene();
|
|
|
|
// uncomment this for extreme checking of surface stack management -- very slow
|
|
#if 0
|
|
// all surfaces must have in-stack counter of zero
|
|
FOREACHINDYNAMICARRAY(re_aspoScreenPolygons, CScreenPolygon, itspo) {
|
|
CScreenPolygon &spo = itspo.Current();
|
|
ASSERT(spo.spo_iInStack == 0);
|
|
}
|
|
#endif
|
|
|
|
// remove all edges that stop on this scan from active list and from other lists.
|
|
RemRemoveListFromActiveList(re_apsedRemoveFirst[re_iCurrentScan]);
|
|
|
|
// step all remaining edges by one scan line and resort the active list
|
|
StepAndResortActiveList();
|
|
|
|
}
|
|
|
|
// clean up the list of active edges, surface stack and the sentinels
|
|
|
|
EndScanEdges();
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_SCANEDGES);
|
|
}
|