d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
506 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Branch: ios
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ios'
${ noResults }
source-engine/engine/OcclusionSystem.cpp

2959 lines
93 KiB
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//===========================================================================//
#include "IOcclusionSystem.h"
#include "mathlib/vector.h"
#include "UtlSortVector.h"
#include "utllinkedlist.h"
#include "utlvector.h"
#include "collisionutils.h"
#include "filesystem.h"
#include "gl_model_private.h"
#include "gl_matsysiface.h"
#include "client.h"
#include "gl_shader.h"
#include "materialsystem/imesh.h"
#include "tier0/vprof.h"
#include "tier0/icommandline.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// Uncomment this if you want to get a whole bunch of paranoid error checking
// #define DEBUG_OCCLUSION_SYSTEM 1
//-----------------------------------------------------------------------------
// Used to visualizes what the occlusion system is doing.
//-----------------------------------------------------------------------------
#ifdef _X360
#define DEFAULT_MIN_OCCLUDER_AREA 70.0f
#else
#define DEFAULT_MIN_OCCLUDER_AREA 5.0f
#endif
#define DEFAULT_MAX_OCCLUDEE_AREA 5.0f
ConVar r_visocclusion( "r_visocclusion", "0", FCVAR_CHEAT, "Activate/deactivate wireframe rendering of what the occlusion system is doing." );
ConVar r_occlusion( "r_occlusion", "1", 0, "Activate/deactivate the occlusion system." );
static ConVar r_occludermincount( "r_occludermincount", "0", 0, "At least this many occluders will be used, no matter how big they are." );
static ConVar r_occlusionspew( "r_occlusionspew", "0", FCVAR_CHEAT, "Activate/deactivates spew about what the occlusion system is doing." );
ConVar r_occluderminarea( "r_occluderminarea", "0", 0, "Prevents this occluder from being used if it takes up less than X% of the screen. 0 means use whatever the level said to use." );
ConVar r_occludeemaxarea( "r_occludeemaxarea", "0", 0, "Prevents occlusion testing for entities that take up more than X% of the screen. 0 means use whatever the level said to use." );
#ifdef DEBUG_OCCLUSION_SYSTEM
static ConVar r_occtest( "r_occtest", "0" );
// Set this in the debugger to activate debugging spew
bool s_bSpew = false;
#endif // DEBUG_OCCLUSION_SYSTEM
//-----------------------------------------------------------------------------
// Visualization
//-----------------------------------------------------------------------------
struct EdgeVisualizationInfo_t
{
Vector m_vecPoint[2];
unsigned char m_pColor[4];
};
//-----------------------------------------------------------------------------
// Queued up rendering
//-----------------------------------------------------------------------------
static CUtlVector<EdgeVisualizationInfo_t> g_EdgeVisualization;
//-----------------------------------------------------------------------------
//
// Edge list that's fast to iterate over, fast to insert into
//
//-----------------------------------------------------------------------------
class CWingedEdgeList
{
public:
struct WingedEdge_t
{
Vector m_vecPosition; // of the upper point in y, measured in screen space
Vector m_vecPositionEnd; // of the lower point in y, measured in screen space
float m_flDxDy; // Change in x per unit in y.
float m_flOODy;
float m_flX;
short m_nLeaveSurfID; // Unique index of the surface this is a part of
short m_nEnterSurfID; // Unique index of the surface this is a part of
WingedEdge_t *m_pPrevActiveEdge;
WingedEdge_t *m_pNextActiveEdge;
};
public:
CWingedEdgeList();
// Clears out the edge list
void Clear();
// Iteration
int EdgeCount() const;
WingedEdge_t &WingedEdge( int i );
// Adds an edge
int AddEdge( );
int AddEdge( const Vector &vecStartVert, const Vector &vecEndVert, int nLeaveSurfID, int nEnterSurfID );
// Adds a surface
int AddSurface( const cplane_t &plane );
// Does this edge list occlude another winged edge list?
bool IsOccludingEdgeList( CWingedEdgeList &testList );
// Queues up stuff to visualize
void QueueVisualization( unsigned char *pColor );
// Renders the winged edge list
void Visualize( unsigned char *pColor );
// Checks consistency of the edge list...
void CheckConsistency();
private:
struct Surface_t
{
cplane_t m_Plane; // measured in projection space
};
private:
// Active edges...
WingedEdge_t *FirstActiveEdge( );
WingedEdge_t *LastActiveEdge( );
bool AtListEnd( const WingedEdge_t* pEdge ) const;
bool AtListStart( const WingedEdge_t* pEdge ) const;
void LinkActiveEdgeAfter( WingedEdge_t *pPrevEdge, WingedEdge_t *pInsertEdge );
void UnlinkActiveEdge( WingedEdge_t *pEdge );
// Used to insert an edge into the active edge list
bool IsEdgeXGreater( const WingedEdge_t *pEdge1, const WingedEdge_t *pEdge2 );
// Clears the active edge list
void ResetActiveEdgeList();
// Spew active edge list
void SpewActiveEdgeList( float y, bool bHex = false );
// Inserts an edge into the active edge list, sorted by X
void InsertActiveEdge( WingedEdge_t *pPrevEdge, WingedEdge_t *pInsertEdge );
// Returns true if this active edge list occludes another active edge list
bool IsOccludingActiveEdgeList( CWingedEdgeList &testList, float y );
// Advances the X values of the active edge list, with no reordering
bool AdvanceActiveEdgeList( float flCurrY );
// Advance the active edge list until a particular X value is reached.
WingedEdge_t *AdvanceActiveEdgeListToX( WingedEdge_t *pEdge, float x );
// Returns the z value of a surface given and x,y coordinate
float ComputeZValue( const Surface_t *pSurface, float x, float y ) const;
// Returns the next time in Y the edge list will undergo a change
float NextDiscontinuity() const;
private:
// Active Edge list...
WingedEdge_t m_StartTerminal;
WingedEdge_t m_EndTerminal;
// Back surface...
Surface_t m_BackSurface;
// Next discontinuity..
float m_flNextDiscontinuity;
int m_nCurrentEdgeIndex;
CUtlVector< WingedEdge_t > m_WingedEdges;
CUtlVector< Surface_t > m_Surfaces;
};
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CWingedEdgeList::CWingedEdgeList() : m_WingedEdges( 0, 64 )
{
m_StartTerminal.m_vecPosition.Init( -FLT_MAX, -FLT_MAX, -FLT_MAX );
m_StartTerminal.m_vecPositionEnd.Init( -FLT_MAX, FLT_MAX, -FLT_MAX );
m_StartTerminal.m_nLeaveSurfID = -1;
m_StartTerminal.m_nEnterSurfID = -1;
m_StartTerminal.m_pPrevActiveEdge = NULL;
m_StartTerminal.m_pNextActiveEdge = NULL;
m_StartTerminal.m_flDxDy = 0.0f;
m_StartTerminal.m_flOODy = 0.0f;
m_StartTerminal.m_flX = -FLT_MAX;
m_EndTerminal.m_vecPosition.Init( FLT_MAX, -FLT_MAX, -FLT_MAX );
m_EndTerminal.m_vecPositionEnd.Init( FLT_MAX, FLT_MAX, -FLT_MAX );
m_EndTerminal.m_nLeaveSurfID = -1;
m_EndTerminal.m_nEnterSurfID = -1;
m_EndTerminal.m_pPrevActiveEdge = NULL;
m_EndTerminal.m_pNextActiveEdge = NULL;
m_EndTerminal.m_flDxDy = 0.0f;
m_EndTerminal.m_flOODy = 0.0f;
m_EndTerminal.m_flX = FLT_MAX;
m_BackSurface.m_Plane.normal.Init( 0, 0, 1 );
m_BackSurface.m_Plane.dist = FLT_MAX;
}
//-----------------------------------------------------------------------------
// Renders the winged edge list for debugging
//-----------------------------------------------------------------------------
void CWingedEdgeList::Clear()
{
m_WingedEdges.RemoveAll();
m_Surfaces.RemoveAll();
}
//-----------------------------------------------------------------------------
// Iterate over the winged edges
//-----------------------------------------------------------------------------
inline int CWingedEdgeList::EdgeCount() const
{
return m_WingedEdges.Count();
}
inline CWingedEdgeList::WingedEdge_t &CWingedEdgeList::WingedEdge( int i )
{
return m_WingedEdges[i];
}
//-----------------------------------------------------------------------------
// Adds new edges
//-----------------------------------------------------------------------------
inline int CWingedEdgeList::AddEdge( )
{
int i = m_WingedEdges.AddToTail();
WingedEdge_t &newEdge = m_WingedEdges[i];
newEdge.m_pPrevActiveEdge = NULL;
newEdge.m_pNextActiveEdge = NULL;
return i;
}
int CWingedEdgeList::AddEdge( const Vector &vecStartVert, const Vector &vecEndVert, int nLeaveSurfID, int nEnterSurfID )
{
// This is true if we've clipped to the near clip plane
Assert( (vecStartVert.z >= 0.0) && (vecEndVert.z >= 0.0) );
// Don't bother adding edges with dy == 0
float dy;
dy = vecEndVert.y - vecStartVert.y;
if (dy == 0.0f)
return -1;
int i = m_WingedEdges.AddToTail();
WingedEdge_t &newEdge = m_WingedEdges[i];
newEdge.m_flOODy = 1.0f / dy;
newEdge.m_nLeaveSurfID = nLeaveSurfID;
newEdge.m_nEnterSurfID = nEnterSurfID;
newEdge.m_vecPosition = vecStartVert;
newEdge.m_vecPositionEnd = vecEndVert;
newEdge.m_pPrevActiveEdge = NULL;
newEdge.m_pNextActiveEdge = NULL;
newEdge.m_flDxDy = (vecEndVert.x - vecStartVert.x) * newEdge.m_flOODy;
return i;
}
//-----------------------------------------------------------------------------
// Adds new surfaces
//-----------------------------------------------------------------------------
int CWingedEdgeList::AddSurface( const cplane_t &plane )
{
int i = m_Surfaces.AddToTail();
m_Surfaces[i].m_Plane = plane;
return i;
}
//-----------------------------------------------------------------------------
// Active edges...
//-----------------------------------------------------------------------------
inline CWingedEdgeList::WingedEdge_t *CWingedEdgeList::FirstActiveEdge( )
{
return m_StartTerminal.m_pNextActiveEdge;
}
inline CWingedEdgeList::WingedEdge_t *CWingedEdgeList::LastActiveEdge( )
{
return m_EndTerminal.m_pPrevActiveEdge;
}
inline bool CWingedEdgeList::AtListEnd( const WingedEdge_t* pEdge ) const
{
return pEdge == &m_EndTerminal;
}
inline bool CWingedEdgeList::AtListStart( const WingedEdge_t* pEdge ) const
{
return pEdge == &m_StartTerminal;
}
inline void CWingedEdgeList::LinkActiveEdgeAfter( WingedEdge_t *pPrevEdge, WingedEdge_t *pInsertEdge )
{
pInsertEdge->m_pNextActiveEdge = pPrevEdge->m_pNextActiveEdge;
pInsertEdge->m_pPrevActiveEdge = pPrevEdge;
pInsertEdge->m_pNextActiveEdge->m_pPrevActiveEdge = pInsertEdge;
pPrevEdge->m_pNextActiveEdge = pInsertEdge;
}
inline void CWingedEdgeList::UnlinkActiveEdge( WingedEdge_t *pEdge )
{
pEdge->m_pPrevActiveEdge->m_pNextActiveEdge = pEdge->m_pNextActiveEdge;
pEdge->m_pNextActiveEdge->m_pPrevActiveEdge = pEdge->m_pPrevActiveEdge;
#ifdef _DEBUG
pEdge->m_pPrevActiveEdge = pEdge->m_pNextActiveEdge = NULL;
#endif
}
//-----------------------------------------------------------------------------
// Checks consistency of the edge list...
//-----------------------------------------------------------------------------
void CWingedEdgeList::CheckConsistency()
{
float flLastY = -FLT_MAX;
float flLastX = -FLT_MAX;
float flLastDxDy = 0;
int nEdgeCount = EdgeCount();
for ( int i = 0; i < nEdgeCount; ++i )
{
WingedEdge_t *pEdge = &WingedEdge(i);
Assert( pEdge->m_vecPosition.y >= flLastY );
if ( pEdge->m_vecPosition.y == flLastY )
{
Assert( pEdge->m_vecPosition.x >= flLastX );
if ( pEdge->m_vecPosition.x == flLastX )
{
Assert( pEdge->m_flDxDy >= flLastDxDy );
}
}
flLastX = pEdge->m_vecPosition.x;
flLastY = pEdge->m_vecPosition.y;
flLastDxDy = pEdge->m_flDxDy;
}
ResetActiveEdgeList();
float flCurrentY = NextDiscontinuity();
AdvanceActiveEdgeList( flCurrentY );
while ( flCurrentY != FLT_MAX )
{
// Make sure all edges have correct Xs + enter + leave surfaces..
int nCurrentSurfID = -1;
float flX = -FLT_MAX;
WingedEdge_t *pCurEdge = FirstActiveEdge();
while ( !AtListEnd( pCurEdge ) )
{
Assert( pCurEdge->m_nLeaveSurfID == nCurrentSurfID );
Assert( pCurEdge->m_flX >= flX );
Assert( pCurEdge->m_nLeaveSurfID != pCurEdge->m_nEnterSurfID );
nCurrentSurfID = pCurEdge->m_nEnterSurfID;
flX = pCurEdge->m_flX;
pCurEdge = pCurEdge->m_pNextActiveEdge;
}
// Assert( nCurrentSurfID == -1 );
flCurrentY = NextDiscontinuity();
AdvanceActiveEdgeList( flCurrentY );
}
}
//-----------------------------------------------------------------------------
// Returns the z value of a surface given and x,y coordinate
//-----------------------------------------------------------------------------
inline float CWingedEdgeList::ComputeZValue( const Surface_t *pSurface, float x, float y ) const
{
const cplane_t &plane = pSurface->m_Plane;
Assert( plane.normal.z == 1.0f );
return plane.dist - plane.normal.x * x - plane.normal.y * y;
}
//-----------------------------------------------------------------------------
// Used to insert an edge into the active edge list, sorted by X
// If Xs match, sort by Dx/Dy
//-----------------------------------------------------------------------------
inline bool CWingedEdgeList::IsEdgeXGreater( const WingedEdge_t *pEdge1, const WingedEdge_t *pEdge2 )
{
float flDelta = pEdge1->m_flX - pEdge2->m_flX;
if ( flDelta > 0 )
return true;
if ( flDelta < 0 )
return false;
// NOTE: Using > instead of >= means coincident edges won't continually swap places
return pEdge1->m_flDxDy > pEdge2->m_flDxDy;
}
//-----------------------------------------------------------------------------
// Inserts an edge into the active edge list, sorted by X
//-----------------------------------------------------------------------------
inline void CWingedEdgeList::InsertActiveEdge( WingedEdge_t *pPrevEdge, WingedEdge_t *pInsertEdge )
{
while( !AtListStart(pPrevEdge) && IsEdgeXGreater( pPrevEdge, pInsertEdge ) )
{
pPrevEdge = pPrevEdge->m_pPrevActiveEdge;
}
LinkActiveEdgeAfter( pPrevEdge, pInsertEdge );
}
//-----------------------------------------------------------------------------
// Clears the active edge list
//-----------------------------------------------------------------------------
void CWingedEdgeList::ResetActiveEdgeList()
{
// This shouldn't be called unless we're about to do active edge checking
Assert( EdgeCount() );
m_nCurrentEdgeIndex = 0;
// Don't bother with edges below the screen edge
m_flNextDiscontinuity = WingedEdge( 0 ).m_vecPosition.y;
m_flNextDiscontinuity = max( m_flNextDiscontinuity, -1.0f );
m_StartTerminal.m_pNextActiveEdge = &m_EndTerminal;
m_EndTerminal.m_pPrevActiveEdge = &m_StartTerminal;
Assert( m_StartTerminal.m_pPrevActiveEdge == NULL );
Assert( m_EndTerminal.m_pNextActiveEdge == NULL );
}
//-----------------------------------------------------------------------------
// Spew active edge list
//-----------------------------------------------------------------------------
void CWingedEdgeList::SpewActiveEdgeList( float y, bool bHex )
{
WingedEdge_t *pEdge = FirstActiveEdge();
Msg( "%.3f : ", y );
while ( !AtListEnd( pEdge ) )
{
if (!bHex)
{
Msg( "(%d %.3f [%d/%d]) ", (int)(pEdge - m_WingedEdges.Base()), pEdge->m_flX, pEdge->m_nLeaveSurfID, pEdge->m_nEnterSurfID );
}
else
{
Msg( "(%d %X [%d/%d]) ", (int)(pEdge - m_WingedEdges.Base()), *(int*)&pEdge->m_flX, pEdge->m_nLeaveSurfID, pEdge->m_nEnterSurfID );
}
pEdge = pEdge->m_pNextActiveEdge;
}
Msg( "\n" );
}
//-----------------------------------------------------------------------------
// Returns the next time in Y the edge list will undergo a change
//-----------------------------------------------------------------------------
inline float CWingedEdgeList::NextDiscontinuity() const
{
return m_flNextDiscontinuity;
}
//-----------------------------------------------------------------------------
// Advances the X values of the active edge list, with no reordering
//-----------------------------------------------------------------------------
bool CWingedEdgeList::AdvanceActiveEdgeList( float flCurrY )
{
// Reordering is unnecessary because the winged edges are guaranteed to be non-overlapping
m_flNextDiscontinuity = FLT_MAX;
// Advance all edges until the current Y; we don't need to re-order *any* edges.
WingedEdge_t *pCurEdge;
WingedEdge_t *pNextEdge;
for ( pCurEdge = FirstActiveEdge(); !AtListEnd( pCurEdge ); pCurEdge = pNextEdge )
{
pNextEdge = pCurEdge->m_pNextActiveEdge;
if ( pCurEdge->m_vecPositionEnd.y <= flCurrY )
{
UnlinkActiveEdge( pCurEdge );
continue;
}
pCurEdge->m_flX = pCurEdge->m_vecPosition.x + (flCurrY - pCurEdge->m_vecPosition.y) * pCurEdge->m_flDxDy;
if ( pCurEdge->m_vecPositionEnd.y < m_flNextDiscontinuity )
{
m_flNextDiscontinuity = pCurEdge->m_vecPositionEnd.y;
}
}
int nEdgeCount = EdgeCount();
if ( m_nCurrentEdgeIndex == nEdgeCount )
return (m_flNextDiscontinuity != FLT_MAX);
pCurEdge = &WingedEdge( m_nCurrentEdgeIndex );
// Add new edges, computing the x + z coordinates at the requested y value
while ( pCurEdge->m_vecPosition.y <= flCurrY )
{
// This is necessary because of our initial skip up to y == -1.0f
if ( pCurEdge->m_vecPositionEnd.y > flCurrY )
{
float flDy = flCurrY - pCurEdge->m_vecPosition.y;
pCurEdge->m_flX = pCurEdge->m_vecPosition.x + flDy * pCurEdge->m_flDxDy;
if ( pCurEdge->m_vecPositionEnd.y < m_flNextDiscontinuity )
{
m_flNextDiscontinuity = pCurEdge->m_vecPositionEnd.y;
}
// Now re-insert in the list, sorted by X
InsertActiveEdge( LastActiveEdge(), pCurEdge );
}
if ( ++m_nCurrentEdgeIndex == nEdgeCount )
return (m_flNextDiscontinuity != FLT_MAX);
pCurEdge = &WingedEdge( m_nCurrentEdgeIndex );
}
// The next edge in y will also present a discontinuity
if ( pCurEdge->m_vecPosition.y < m_flNextDiscontinuity )
{
m_flNextDiscontinuity = pCurEdge->m_vecPosition.y;
}
return (m_flNextDiscontinuity != FLT_MAX);
}
//-----------------------------------------------------------------------------
// Advance the active edge list until a particular X value is reached.
//-----------------------------------------------------------------------------
inline CWingedEdgeList::WingedEdge_t *CWingedEdgeList::AdvanceActiveEdgeListToX( WingedEdge_t *pEdge, float x )
{
// <= is necessary because we always want to point *after* the edge
while( pEdge->m_flX <= x )
{
pEdge = pEdge->m_pNextActiveEdge;
}
return pEdge;
}
//-----------------------------------------------------------------------------
// Returns true if this active edge list occludes another active edge list
//-----------------------------------------------------------------------------
bool CWingedEdgeList::IsOccludingActiveEdgeList( CWingedEdgeList &testList, float y )
{
WingedEdge_t *pTestEdge = testList.FirstActiveEdge();
// If the occludee is off screen, it's occluded
if ( pTestEdge->m_flX >= 1.0f )
return true;
pTestEdge = AdvanceActiveEdgeListToX( pTestEdge, -1.0f );
// If all occludee edges have x values <= -1.0f, it's occluded
if ( testList.AtListEnd( pTestEdge ) )
return true;
// Start at the first edge whose x value is <= -1.0f
// if the occludee goes off the left side of the screen.
float flNextTestX = pTestEdge->m_flX;
if ( !testList.AtListStart( pTestEdge->m_pPrevActiveEdge ) )
{
// In this case, we should be on a span crossing from x <= -1.0f to x > 1.0f.
// Do the first occlusion test at x = -1.0f.
Assert( pTestEdge->m_flX > -1.0f );
pTestEdge = pTestEdge->m_pPrevActiveEdge;
Assert( pTestEdge->m_flX <= -1.0f );
flNextTestX = -1.0f;
}
WingedEdge_t *pOccluderEdge = FirstActiveEdge();
pOccluderEdge = AdvanceActiveEdgeListToX( pOccluderEdge, flNextTestX );
Surface_t *pTestSurf = (pTestEdge->m_nEnterSurfID >= 0) ? &testList.m_Surfaces[pTestEdge->m_nEnterSurfID] : &m_BackSurface;
// Use the leave surface because we know the occluder has been advanced *beyond* the test surf X.
Surface_t *pOccluderSurf = (pOccluderEdge->m_nLeaveSurfID >= 0) ? &m_Surfaces[pOccluderEdge->m_nLeaveSurfID] : &m_BackSurface;
float flCurrentX = flNextTestX;
float flNextOccluderX = pOccluderEdge->m_flX;
flNextTestX = pTestEdge->m_pNextActiveEdge->m_flX;
while ( true )
{
// Is the occludee in front of the occluder? No dice!
float flTestOOz = ComputeZValue( pTestSurf, flCurrentX, y );
float flOccluderOOz = ComputeZValue( pOccluderSurf, flCurrentX, y );
if ( flTestOOz < flOccluderOOz )
return false;
// We're done if there's no more occludees
if ( flNextTestX == FLT_MAX )
return true;
// We're done if there's no more occluders
if ( flNextOccluderX == FLT_MAX )
return false;
if ( flNextTestX <= flNextOccluderX )
{
flCurrentX = flNextTestX;
pTestEdge = pTestEdge->m_pNextActiveEdge;
if ( pTestEdge->m_nEnterSurfID >= 0 )
{
pTestSurf = &testList.m_Surfaces[pTestEdge->m_nEnterSurfID];
}
else
{
pTestSurf = (pTestEdge->m_nLeaveSurfID >= 0) ? &testList.m_Surfaces[pTestEdge->m_nLeaveSurfID] : &m_BackSurface;
}
flNextTestX = pTestEdge->m_pNextActiveEdge->m_flX;
}
else
{
flCurrentX = flNextOccluderX;
pOccluderEdge = pOccluderEdge->m_pNextActiveEdge;
pOccluderSurf = (pOccluderEdge->m_nLeaveSurfID >= 0) ? &m_Surfaces[pOccluderEdge->m_nLeaveSurfID] : &m_BackSurface;
flNextOccluderX = pOccluderEdge->m_flX;
}
}
}
//-----------------------------------------------------------------------------
// Does this edge list occlude another winged edge list?
//-----------------------------------------------------------------------------
bool CWingedEdgeList::IsOccludingEdgeList( CWingedEdgeList &testList )
{
#ifdef DEBUG_OCCLUSION_SYSTEM
testList.CheckConsistency();
CheckConsistency();
#endif
// Did all the edges get culled for some reason? Then it's occluded
if ( testList.EdgeCount() == 0 )
return true;
testList.ResetActiveEdgeList();
ResetActiveEdgeList();
// What we're going to do is look for the first discontinuities we can find
// in both edge lists. Then, at each discontinuity, we must check the
// active edge lists against each other and see if the occluders always
// block the occludees...
float flCurrentY = testList.NextDiscontinuity();
// The edge list for the occluder must completely obscure the occludee...
// If, then, the first occluder edge starts *below* the first occludee edge, it doesn't occlude.
if ( flCurrentY < NextDiscontinuity() )
return false;
// If we start outside the screen bounds, then it's occluded!
if ( flCurrentY >= 1.0f )
return true;
testList.AdvanceActiveEdgeList( flCurrentY );
AdvanceActiveEdgeList( flCurrentY );
while ( true )
{
if ( !IsOccludingActiveEdgeList( testList, flCurrentY ) )
return false;
// If we got outside the screen bounds, then it's occluded!
if ( flCurrentY >= 1.0f )
return true;
float flTestY = testList.NextDiscontinuity();
float flOccluderY = NextDiscontinuity();
flCurrentY = min( flTestY, flOccluderY );
// NOTE: This check here is to help occlusion @ the top of the screen
// We cut the occluders off at y = 1.0 + epsilon, which means there's
// not necessarily a discontinuity at y == 1.0. We need to create a discontinuity
// there so that the occluder edges are still being used.
if ( flCurrentY > 1.0f )
{
flCurrentY = 1.0f;
}
// If the occludee list is empty, then it's occluded!
if ( !testList.AdvanceActiveEdgeList( flCurrentY ) )
return true;
// If the occluder list is empty, then the occludee is not occluded!
if ( !AdvanceActiveEdgeList( flCurrentY ) )
return false;
}
}
//-----------------------------------------------------------------------------
// Queues up stuff to visualize
//-----------------------------------------------------------------------------
void CWingedEdgeList::QueueVisualization( unsigned char *pColor )
{
#ifndef SWDS
if ( !r_visocclusion.GetInt() )
return;
int nFirst = g_EdgeVisualization.AddMultipleToTail( m_WingedEdges.Count() );
for ( int i = m_WingedEdges.Count(); --i >= 0; )
{
WingedEdge_t *pEdge = &m_WingedEdges[i];
EdgeVisualizationInfo_t &info = g_EdgeVisualization[nFirst + i];
info.m_vecPoint[0] = pEdge->m_vecPosition;
info.m_vecPoint[1] = pEdge->m_vecPositionEnd;
*(int*)(info.m_pColor) = *(int*)pColor;
}
#endif
}
//-----------------------------------------------------------------------------
// Renders the winged edge list for debugging
//-----------------------------------------------------------------------------
void CWingedEdgeList::Visualize( unsigned char *pColor )
{
#ifndef SWDS
if ( !r_visocclusion.GetInt() )
return;
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->MatrixMode( MATERIAL_MODEL );
pRenderContext->PushMatrix();
pRenderContext->LoadIdentity();
pRenderContext->MatrixMode( MATERIAL_VIEW );
pRenderContext->PushMatrix();
pRenderContext->LoadIdentity();
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
pRenderContext->PushMatrix();
pRenderContext->LoadIdentity();
pRenderContext->Bind( g_pMaterialWireframeVertexColorIgnoreZ );
IMesh *pMesh = pRenderContext->GetDynamicMesh( );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_LINES, m_WingedEdges.Count() );
int i;
int nCount = m_WingedEdges.Count();
for ( i = nCount; --i >= 0; )
{
WingedEdge_t *pEdge = &m_WingedEdges[i];
meshBuilder.Position3fv( pEdge->m_vecPosition.Base() );
meshBuilder.Color4ubv( pColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( pEdge->m_vecPositionEnd.Base() );
#ifdef DEBUG_OCCLUSION_SYSTEM
meshBuilder.Color4ub( 0, 0, 255, 255 );
#else
meshBuilder.Color4ubv( pColor );
#endif
meshBuilder.AdvanceVertex();
}
meshBuilder.End();
pMesh->Draw();
pRenderContext->MatrixMode( MATERIAL_MODEL );
pRenderContext->PopMatrix();
pRenderContext->MatrixMode( MATERIAL_VIEW );
pRenderContext->PopMatrix();
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
pRenderContext->PopMatrix();
#endif
}
//-----------------------------------------------------------------------------
// Edge list that's fast to iterate over, fast to insert into
//-----------------------------------------------------------------------------
class CEdgeList
{
public:
struct Edge_t
{
Vector m_vecPosition; // of the upper point in y, measured in screen space
Vector m_vecPositionEnd; // of the lower point in y, measured in screen space
float m_flDxDy; // Change in x per unit in y.
float m_flOODy;
float m_flX;
int m_nSurfID; // Unique index of the surface this is a part of
// Active edge list
Edge_t *m_pPrevActiveEdge;
Edge_t *m_pNextActiveEdge;
};
public:
CEdgeList();
// Insertion
void AddEdge( Vector **ppEdgeVertices, int nSurfID );
// Surface ID management
int AddSurface( const cplane_t &plane );
void SetSurfaceArea( int nSurfID, float flArea );
// Removal
void RemoveAll();
// Visualization
void QueueVisualization( unsigned char *pColor );
void Visualize( unsigned char *pColor );
// Access
int EdgeCount() const;
int ActualEdgeCount() const;
const Edge_t &EdgeFromSortIndex( int nSortIndex ) const;
Edge_t &EdgeFromSortIndex( int nSortIndex );
// Is the test edge list occluded by this edge list
bool IsOccludingEdgeList( CEdgeList &testList );
// Reduces the active occlusion edge list to the bare minimum set of edges
void ReduceActiveList( CWingedEdgeList &newEdgeList );
// Removal of small occluders
void CullSmallOccluders();
private:
struct Surface_t
{
cplane_t m_Plane; // measured in projection space
float m_flOOz;
Surface_t *m_pPrevSurface;
Surface_t *m_pNextSurface;
int m_nSurfID;
float m_flArea; // Area in screen space
};
struct ReduceInfo_t
{
short m_hEdge;
short m_nWingedEdge;
const Edge_t *m_pEdge;
};
enum
{
MAX_EDGE_CROSSINGS = 64
};
typedef CUtlVector<Edge_t> EdgeList_t;
private:
// Gets an edge
const Edge_t &Edge( int nIndex ) const;
// Active edges...
const Edge_t *FirstActiveEdge( ) const;
Edge_t *FirstActiveEdge( );
const Edge_t *LastActiveEdge( ) const;
Edge_t *LastActiveEdge( );
bool AtListEnd( const Edge_t* pEdge ) const;
bool AtListStart( const Edge_t* pEdge ) const;
void LinkActiveEdgeAfter( Edge_t *pPrevEdge, Edge_t *pInsertEdge );
void UnlinkActiveEdge( Edge_t *pEdge );
// Surface list
Surface_t* TopSurface();
bool AtSurfListEnd( const Surface_t* pSurface ) const;
void CleanupCurrentSurfaceList();
// Active edge list
void ResetActiveEdgeList();
float NextDiscontinuity() const;
// Clears the current scan line
float ClearCurrentSurfaceList();
// Returns the z value of a surface given and x,y coordinate
float ComputeZValue( const Surface_t *pSurface, float x, float y ) const;
// Computes a point at a specified y value along an edge
void ComputePointAlongEdge( const Edge_t *pEdge, int nSurfID, float y, Vector *pPoint ) const;
// Inserts an edge into the active edge list, sorted by X
void InsertActiveEdge( Edge_t *pPrevEdge, Edge_t *pInsertEdge );
// Used to insert an edge into the active edge list
bool IsEdgeXGreater( const Edge_t *pEdge1, const Edge_t *pEdge2 );
// Reduces the active edge list into a subset of ones we truly care about
void ReduceActiveEdgeList( CWingedEdgeList &newEdgeList, float flMinY, float flMaxY );
// Discovers the first edge crossing discontinuity
float LocateEdgeCrossingDiscontinuity( float flNextY, float flPrevY, int &nCount, Edge_t **pInfo );
// Generates a list of surfaces on the current scan line
void UpdateCurrentSurfaceZValues( float x, float y );
// Intoruces a single new edge
void IntroduceSingleActiveEdge( const Edge_t *pEdge, float flCurrY );
// Returns true if pTestSurf is closer (lower z value)
bool IsSurfaceBehind( Surface_t *pTestSurf, Surface_t *pSurf );
// Advances the X values of the active edge list, with no reordering
void AdvanceActiveEdgeList( float flNextY );
void IntroduceNewActiveEdges( float y );
void ReorderActiveEdgeList( int nCount, Edge_t **ppInfo );
// Debugging spew
void SpewActiveEdgeList( float y, bool bHex = false );
// Checks consistency of the edge list...
void CheckConsistency();
class EdgeLess
{
public:
bool Less( const unsigned short& src1, const unsigned short& src2, void *pCtx );
};
static int __cdecl SurfCompare( const void *elem1, const void *elem2 );
private:
// Used to sort surfaces by screen area
static Surface_t *s_pSortSurfaces;
// List of all edges
EdgeList_t m_Edges;
CUtlSortVector<unsigned short, EdgeLess > m_OrigSortIndices;
CUtlVector<unsigned short> m_SortIndices;
Edge_t m_StartTerminal;
Edge_t m_EndTerminal;
// Surfaces
CUtlVector< Surface_t > m_Surfaces;
CUtlVector< int > m_SurfaceSort;
Surface_t m_StartSurfTerminal;
Surface_t m_EndSurfTerminal;
// Active edges
int m_nCurrentEdgeIndex;
float m_flNextDiscontinuity;
// List of edges on the current Y scan-line
Edge_t *m_pCurrentActiveEdge;
// Last X on the current scan line
float m_flLastX;
// Reduce list
ReduceInfo_t *m_pNewReduceInfo;
ReduceInfo_t *m_pPrevReduceInfo;
int m_nNewReduceCount;
int m_nPrevReduceCount;
};
//-----------------------------------------------------------------------------
// Used to sort the edge list
//-----------------------------------------------------------------------------
bool CEdgeList::EdgeLess::Less( const unsigned short& src1, const unsigned short& src2, void *pCtx )
{
EdgeList_t *pEdgeList = (EdgeList_t*)pCtx;
const Edge_t &e1 = pEdgeList->Element(src1);
const Edge_t &e2 = pEdgeList->Element(src2);
if ( e1.m_vecPosition.y < e2.m_vecPosition.y )
return true;
if ( e1.m_vecPosition.y > e2.m_vecPosition.y )
return false;
if ( e1.m_vecPosition.x < e2.m_vecPosition.x )
return true;
if ( e1.m_vecPosition.x > e2.m_vecPosition.x )
return false;
// This makes it so that if two edges start on the same point,
// the leftmost edge is always selected
return ( e1.m_flDxDy <= e2.m_flDxDy );
}
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CEdgeList::CEdgeList() : m_Edges( 0, 32 ), m_OrigSortIndices( 0, 32 )
{
m_OrigSortIndices.SetLessContext( &m_Edges );
m_StartTerminal.m_vecPosition.Init( -FLT_MAX, -FLT_MAX, -FLT_MAX );
m_StartTerminal.m_vecPositionEnd.Init( -FLT_MAX, FLT_MAX, -FLT_MAX );
m_StartTerminal.m_nSurfID = -1;
m_StartTerminal.m_pPrevActiveEdge = NULL;
m_StartTerminal.m_pNextActiveEdge = NULL;
m_StartTerminal.m_flDxDy = 0.0f;
m_StartTerminal.m_flOODy = 0.0f;
m_StartTerminal.m_flX = -FLT_MAX;
m_EndTerminal.m_vecPosition.Init( FLT_MAX, -FLT_MAX, -FLT_MAX );
m_EndTerminal.m_vecPositionEnd.Init( FLT_MAX, FLT_MAX, -FLT_MAX );
m_EndTerminal.m_nSurfID = -1;
m_EndTerminal.m_pPrevActiveEdge = NULL;
m_EndTerminal.m_pNextActiveEdge = NULL;
m_EndTerminal.m_flDxDy = 0.0f;
m_EndTerminal.m_flOODy = 0.0f;
m_EndTerminal.m_flX = FLT_MAX;
m_StartSurfTerminal.m_flOOz = -FLT_MAX;
m_StartSurfTerminal.m_Plane.normal.Init( 0, 0, 1 );
m_StartSurfTerminal.m_Plane.dist = -FLT_MAX;
m_StartSurfTerminal.m_nSurfID = -1;
m_StartSurfTerminal.m_pNextSurface = NULL;
m_StartSurfTerminal.m_pPrevSurface = NULL;
m_EndSurfTerminal.m_flOOz = FLT_MAX;
m_EndSurfTerminal.m_Plane.normal.Init( 0, 0, 1 );
m_EndSurfTerminal.m_Plane.dist = FLT_MAX;
m_EndSurfTerminal.m_nSurfID = -1;
m_EndSurfTerminal.m_pNextSurface = NULL;
m_EndSurfTerminal.m_pPrevSurface = NULL;
}
//-----------------------------------------------------------------------------
// iteration
//-----------------------------------------------------------------------------
inline int CEdgeList::EdgeCount() const
{
return m_Edges.Count();
}
inline int CEdgeList::ActualEdgeCount() const
{
return m_SortIndices.Count();
}
inline const CEdgeList::Edge_t &CEdgeList::EdgeFromSortIndex( int nSortIndex ) const
{
return m_Edges[ m_SortIndices[nSortIndex] ];
}
inline CEdgeList::Edge_t &CEdgeList::EdgeFromSortIndex( int nSortIndex )
{
return m_Edges[ m_SortIndices[nSortIndex] ];
}
inline const CEdgeList::Edge_t &CEdgeList::Edge( int nIndex ) const
{
return m_Edges[ nIndex ];
}
//-----------------------------------------------------------------------------
// Active edges...
//-----------------------------------------------------------------------------
inline const CEdgeList::Edge_t *CEdgeList::FirstActiveEdge( ) const
{
return m_StartTerminal.m_pNextActiveEdge;
}
inline CEdgeList::Edge_t *CEdgeList::FirstActiveEdge( )
{
return m_StartTerminal.m_pNextActiveEdge;
}
inline const CEdgeList::Edge_t *CEdgeList::LastActiveEdge( ) const
{
return m_EndTerminal.m_pPrevActiveEdge;
}
inline CEdgeList::Edge_t *CEdgeList::LastActiveEdge( )
{
return m_EndTerminal.m_pPrevActiveEdge;
}
inline bool CEdgeList::AtListEnd( const Edge_t* pEdge ) const
{
return pEdge == &m_EndTerminal;
}
inline bool CEdgeList::AtListStart( const Edge_t* pEdge ) const
{
return pEdge == &m_StartTerminal;
}
inline void CEdgeList::LinkActiveEdgeAfter( Edge_t *pPrevEdge, Edge_t *pInsertEdge )
{
pInsertEdge->m_pNextActiveEdge = pPrevEdge->m_pNextActiveEdge;
pInsertEdge->m_pPrevActiveEdge = pPrevEdge;
pInsertEdge->m_pNextActiveEdge->m_pPrevActiveEdge = pInsertEdge;
pPrevEdge->m_pNextActiveEdge = pInsertEdge;
}
inline void CEdgeList::UnlinkActiveEdge( Edge_t *pEdge )
{
pEdge->m_pPrevActiveEdge->m_pNextActiveEdge = pEdge->m_pNextActiveEdge;
pEdge->m_pNextActiveEdge->m_pPrevActiveEdge = pEdge->m_pPrevActiveEdge;
#ifdef _DEBUG
pEdge->m_pPrevActiveEdge = pEdge->m_pNextActiveEdge = NULL;
#endif
}
//-----------------------------------------------------------------------------
// Surface list
//-----------------------------------------------------------------------------
inline CEdgeList::Surface_t* CEdgeList::TopSurface()
{
return m_StartSurfTerminal.m_pNextSurface;
}
inline bool CEdgeList::AtSurfListEnd( const Surface_t* pSurface ) const
{
return pSurface == &m_EndSurfTerminal;
}
void CEdgeList::CleanupCurrentSurfaceList()
{
Surface_t *pSurf = TopSurface();
while ( !AtSurfListEnd(pSurf) )
{
Surface_t *pNext = pSurf->m_pNextSurface;
pSurf->m_pPrevSurface = pSurf->m_pNextSurface = NULL;
pSurf = pNext;
}
}
inline void CEdgeList::SetSurfaceArea( int nSurfID, float flArea )
{
m_Surfaces[nSurfID].m_flArea = flArea;
}
//-----------------------------------------------------------------------------
// Returns the z value of a surface given and x,y coordinate
//-----------------------------------------------------------------------------
inline float CEdgeList::ComputeZValue( const Surface_t *pSurface, float x, float y ) const
{
const cplane_t &plane = pSurface->m_Plane;
Assert( plane.normal.z == 1.0f );
return plane.dist - plane.normal.x * x - plane.normal.y * y;
}
//-----------------------------------------------------------------------------
// Computes a point at a specified y value along an edge
//-----------------------------------------------------------------------------
inline void CEdgeList::ComputePointAlongEdge( const Edge_t *pEdge, int nSurfID, float y, Vector *pPoint ) const
{
Assert( (y >= pEdge->m_vecPosition.y) && (y <= pEdge->m_vecPositionEnd.y) );
float t;
t = (y - pEdge->m_vecPosition.y) * pEdge->m_flOODy;
pPoint->x = pEdge->m_vecPosition.x + ( pEdge->m_vecPositionEnd.x - pEdge->m_vecPosition.x ) * t;
pPoint->y = y;
pPoint->z = ComputeZValue( &m_Surfaces[nSurfID], pPoint->x, y );
}
//-----------------------------------------------------------------------------
// Surface ID management
//-----------------------------------------------------------------------------
int CEdgeList::AddSurface( const cplane_t &plane )
{
int nIndex = m_Surfaces.AddToTail();
Surface_t &surf = m_Surfaces[nIndex];
surf.m_flOOz = 0.0f;
surf.m_Plane = plane;
surf.m_pNextSurface = NULL;
surf.m_pPrevSurface = NULL;
surf.m_nSurfID = nIndex;
m_SurfaceSort.AddToTail(nIndex);
return nIndex;
}
//-----------------------------------------------------------------------------
// Insertion
//-----------------------------------------------------------------------------
void CEdgeList::AddEdge( Vector **ppEdgeVertices, int nSurfID )
{
int nMinIndex = ( ppEdgeVertices[0]->y >= ppEdgeVertices[1]->y );
const Vector &vecStartVert = *(ppEdgeVertices[ nMinIndex ]);
const Vector &vecEndVert = *(ppEdgeVertices[ 1 - nMinIndex ]);
// This is true if we've clipped to the near clip plane
Assert( (vecStartVert.z >= 0.0f) && (vecEndVert.z >= 0.0f) );
// Don't bother adding edges with dy == 0
float dy = vecEndVert.y - vecStartVert.y;
if (dy == 0.0f)
return;
int i = m_Edges.AddToTail();
Edge_t &newEdge = m_Edges[i];
newEdge.m_flOODy = 1.0f / dy;
newEdge.m_vecPosition = vecStartVert;
newEdge.m_vecPositionEnd = vecEndVert;
newEdge.m_nSurfID = nSurfID;
newEdge.m_flDxDy = (vecEndVert.x - vecStartVert.x) * newEdge.m_flOODy;
newEdge.m_pPrevActiveEdge = NULL;
newEdge.m_pNextActiveEdge = NULL;
// Insert it into the sorted list
m_OrigSortIndices.Insert( i );
}
//-----------------------------------------------------------------------------
// Used to sort the surfaces
//-----------------------------------------------------------------------------
CEdgeList::Surface_t *CEdgeList::s_pSortSurfaces = NULL;
int __cdecl CEdgeList::SurfCompare( const void *elem1, const void *elem2 )
{
int nSurfID1 = *(int*)elem1;
float flArea1 = s_pSortSurfaces[nSurfID1].m_flArea;
int nSurfID2 = *(int*)elem2;
float flArea2 = s_pSortSurfaces[nSurfID2].m_flArea;
if (flArea1 > flArea2)
return -1;
if (flArea1 < flArea2)
return 1;
return 0;
}
//-----------------------------------------------------------------------------
// Removal of small occluders
//-----------------------------------------------------------------------------
void CEdgeList::CullSmallOccluders()
{
// Cull out all surfaces with too small of a screen area...
// Sort the surfaces by screen area, in descending order
int nSurfCount = m_Surfaces.Count();
s_pSortSurfaces = m_Surfaces.Base();
if( m_SurfaceSort.Base() )
qsort( m_SurfaceSort.Base(), nSurfCount, sizeof(int), SurfCompare );
// We're going to keep the greater of r_occludermin + All surfaces with a screen area >= r_occluderarea
int nMinSurfaces = r_occludermincount.GetInt();
// The *2 here is because surf areas are 2x bigger than actual
float flMinScreenArea = r_occluderminarea.GetFloat() * 0.02f;
if ( flMinScreenArea == 0.0f )
{
flMinScreenArea = OcclusionSystem()->MinOccluderArea() * 0.02f;
}
bool *bUseSurface = (bool*)stackalloc( nSurfCount * sizeof(bool) );
memset( bUseSurface, 0, nSurfCount * sizeof(bool) );
int i;
for ( i = 0; i < nSurfCount; ++i )
{
int nSurfID = m_SurfaceSort[i];
if (( m_Surfaces[ nSurfID ].m_flArea < flMinScreenArea ) && (i >= nMinSurfaces ))
break;
bUseSurface[nSurfID] = true;
}
MEM_ALLOC_CREDIT();
int nEdgeCount = m_OrigSortIndices.Count();
m_SortIndices.RemoveAll();
m_SortIndices.EnsureCapacity( nEdgeCount );
for( i = 0; i < nEdgeCount; ++i )
{
int nEdgeIndex = m_OrigSortIndices[i];
if ( bUseSurface[ m_Edges[ nEdgeIndex ].m_nSurfID ] )
{
m_SortIndices.AddToTail( nEdgeIndex );
}
}
}
//-----------------------------------------------------------------------------
// Removal
//-----------------------------------------------------------------------------
void CEdgeList::RemoveAll()
{
m_Edges.RemoveAll();
m_SortIndices.RemoveAll();
m_OrigSortIndices.RemoveAll();
m_Surfaces.RemoveAll();
m_SurfaceSort.RemoveAll();
}
//-----------------------------------------------------------------------------
// Active edge list
//-----------------------------------------------------------------------------
void CEdgeList::ResetActiveEdgeList()
{
// This shouldn't be called unless we're about to do active edge checking
Assert( ActualEdgeCount() );
m_nCurrentEdgeIndex = 0;
m_flNextDiscontinuity = EdgeFromSortIndex( 0 ).m_vecPosition.y;
m_StartTerminal.m_pNextActiveEdge = &m_EndTerminal;
m_EndTerminal.m_pPrevActiveEdge = &m_StartTerminal;
Assert( m_StartTerminal.m_pPrevActiveEdge == NULL );
Assert( m_EndTerminal.m_pNextActiveEdge == NULL );
}
//-----------------------------------------------------------------------------
// Returns the next time in Y the edge list will undergo a change
//-----------------------------------------------------------------------------
inline float CEdgeList::NextDiscontinuity() const
{
return m_flNextDiscontinuity;
}
//-----------------------------------------------------------------------------
// Used to insert an edge into the active edge list, sorted by X
// If Xs match, sort by Dx/Dy
//-----------------------------------------------------------------------------
inline bool CEdgeList::IsEdgeXGreater( const Edge_t *pEdge1, const Edge_t *pEdge2 )
{
float flDelta = pEdge1->m_flX - pEdge2->m_flX;
if ( flDelta > 0 )
return true;
if ( flDelta < 0 )
return false;
// NOTE: Using > instead of >= means coincident edges won't continually swap places
return pEdge1->m_flDxDy > pEdge2->m_flDxDy;
}
//-----------------------------------------------------------------------------
// Inserts an edge into the active edge list, sorted by X
//-----------------------------------------------------------------------------
inline void CEdgeList::InsertActiveEdge( Edge_t *pPrevEdge, Edge_t *pInsertEdge )
{
while( !AtListStart(pPrevEdge) && IsEdgeXGreater( pPrevEdge, pInsertEdge ) )
{
pPrevEdge = pPrevEdge->m_pPrevActiveEdge;
}
LinkActiveEdgeAfter( pPrevEdge, pInsertEdge );
}
//-----------------------------------------------------------------------------
// Clears the current scan line
//-----------------------------------------------------------------------------
float CEdgeList::ClearCurrentSurfaceList()
{
m_pCurrentActiveEdge = FirstActiveEdge();
m_flLastX = m_pCurrentActiveEdge->m_flX;
m_StartSurfTerminal.m_pNextSurface = &m_EndSurfTerminal;
m_EndSurfTerminal.m_pPrevSurface = &m_StartSurfTerminal;
return m_flLastX;
}
//-----------------------------------------------------------------------------
// Generates a list of surfaces on the current scan line
//-----------------------------------------------------------------------------
inline void CEdgeList::UpdateCurrentSurfaceZValues( float x, float y )
{
// Update the z values of all active surfaces
for ( Surface_t *pSurf = TopSurface(); !AtSurfListEnd( pSurf ); pSurf = pSurf->m_pNextSurface )
{
// NOTE: As long as we assume no interpenetrating surfaces,
// we don't need to re-sort by ooz here.
pSurf->m_flOOz = ComputeZValue( pSurf, x, y );
}
}
//-----------------------------------------------------------------------------
// Returns true if pTestSurf is closer (lower z value)
//-----------------------------------------------------------------------------
inline bool CEdgeList::IsSurfaceBehind( Surface_t *pTestSurf, Surface_t *pSurf )
{
if ( pTestSurf->m_flOOz - pSurf->m_flOOz <= -1e-6 )
return true;
if ( pTestSurf->m_flOOz - pSurf->m_flOOz >= 1e-6 )
return false;
// If they're nearly equal, then the thing that's approaching the screen
// more quickly as we ascend in y is closer
return ( pTestSurf->m_Plane.normal.y >= pSurf->m_Plane.normal.y );
}
//-----------------------------------------------------------------------------
// Introduces a single new edge
//-----------------------------------------------------------------------------
void CEdgeList::IntroduceSingleActiveEdge( const Edge_t *pEdge, float flCurrY )
{
Surface_t *pCurrentSurf = &m_Surfaces[ pEdge->m_nSurfID ];
if ( !pCurrentSurf->m_pNextSurface )
{
pCurrentSurf->m_flOOz = ComputeZValue( pCurrentSurf, pEdge->m_flX, flCurrY );
// Determine where to insert the surface into the surface list...
// Insert it so that the surface list is sorted by OOz
Surface_t *pNextSurface = TopSurface();
while( IsSurfaceBehind( pNextSurface, pCurrentSurf ) )
{
pNextSurface = pNextSurface->m_pNextSurface;
}
pCurrentSurf->m_pNextSurface = pNextSurface;
pCurrentSurf->m_pPrevSurface = pNextSurface->m_pPrevSurface;
pNextSurface->m_pPrevSurface = pCurrentSurf;
pCurrentSurf->m_pPrevSurface->m_pNextSurface = pCurrentSurf;
}
else
{
// This means this edge is associated with a surface
// already in the current surface list
// In this case, simply remove the surface from the surface list
pCurrentSurf->m_pNextSurface->m_pPrevSurface = pCurrentSurf->m_pPrevSurface;
pCurrentSurf->m_pPrevSurface->m_pNextSurface = pCurrentSurf->m_pNextSurface;
pCurrentSurf->m_pPrevSurface = pCurrentSurf->m_pNextSurface = NULL;
}
}
//-----------------------------------------------------------------------------
// Reduces the active occlusion edge list to the bare minimum set of edges
//-----------------------------------------------------------------------------
void CEdgeList::IntroduceNewActiveEdges( float y )
{
int nEdgeCount = ActualEdgeCount();
if ( m_nCurrentEdgeIndex == nEdgeCount )
return;
Edge_t *pCurEdge = &EdgeFromSortIndex( m_nCurrentEdgeIndex );
// Add new edges, computing the x + z coordinates at the requested y value
while ( pCurEdge->m_vecPosition.y <= y )
{
// This is necessary because of our initial skip up to y == -1.0f
if (pCurEdge->m_vecPositionEnd.y > y)
{
float flDy = y - pCurEdge->m_vecPosition.y;
pCurEdge->m_flX = pCurEdge->m_vecPosition.x + flDy * pCurEdge->m_flDxDy;
if ( pCurEdge->m_vecPositionEnd.y < m_flNextDiscontinuity )
{
m_flNextDiscontinuity = pCurEdge->m_vecPositionEnd.y;
}
// Now re-insert in the list, sorted by X
InsertActiveEdge( LastActiveEdge(), pCurEdge );
}
if ( ++m_nCurrentEdgeIndex == nEdgeCount )
return;
pCurEdge = &EdgeFromSortIndex( m_nCurrentEdgeIndex );
}
// The next edge in y will also present a discontinuity
if ( pCurEdge->m_vecPosition.y < m_flNextDiscontinuity )
{
m_flNextDiscontinuity = pCurEdge->m_vecPosition.y;
}
}
//-----------------------------------------------------------------------------
// Reduces the active edge list into a subset of ones we truly care about
//-----------------------------------------------------------------------------
void CEdgeList::ReduceActiveEdgeList( CWingedEdgeList &wingedEdgeList, float flMinY, float flMaxY )
{
// Surface lists should be empty
int i;
#ifdef DEBUG_OCCLUSION_SYSTEM
for ( i = m_Surfaces.Count(); --i >= 0; )
{
Assert( m_Surfaces[i].m_pNextSurface == NULL );
}
#endif
int nLeaveSurfID = -1;
const Edge_t *pCurEdge = FirstActiveEdge();
const Edge_t *pNextEdge;
// NOTE: This algorithm depends on the fact that the active edge
// list is not only sorted by ascending X, but also because edges
// that land on the same X value are sorted by ascending dy/dx
float flPrevX = pCurEdge->m_flX;
for ( ; !AtListEnd( pCurEdge ); pCurEdge = pNextEdge )
{
if ( pCurEdge->m_flX != flPrevX )
{
UpdateCurrentSurfaceZValues( pCurEdge->m_flX, flMinY );
}
IntroduceSingleActiveEdge( pCurEdge, flMinY );
flPrevX = pCurEdge->m_flX;
// If we have coincident edges, we have to introduce them at the same time...
pNextEdge = pCurEdge->m_pNextActiveEdge;
if ( (flPrevX == pNextEdge->m_flX) && (pCurEdge->m_flDxDy == pNextEdge->m_flDxDy) )
continue;
// If there's more than one overlapping surface at this point,
// we can eliminate some edges.
int nEnterSurfID = TopSurface()->m_nSurfID;
// No change in the top surface? No edges needed...
if ( nLeaveSurfID == nEnterSurfID )
continue;
Assert( ( nLeaveSurfID != -1 ) || ( nEnterSurfID != -1 ) );
int nEdgeSurfID = ( nEnterSurfID != -1 ) ? nEnterSurfID : nLeaveSurfID;
// Seam up edges...
for ( i = m_nPrevReduceCount; --i >= 0; )
{
CWingedEdgeList::WingedEdge_t &testEdge = wingedEdgeList.WingedEdge( m_pPrevReduceInfo[i].m_nWingedEdge );
if (( testEdge.m_nLeaveSurfID != nLeaveSurfID ) || ( testEdge.m_nEnterSurfID != nEnterSurfID ))
continue;
if ( ( testEdge.m_flDxDy != pCurEdge->m_flDxDy) || ( fabs( testEdge.m_vecPositionEnd.x - pCurEdge->m_flX ) >= 1e-3 ) )
continue;
ComputePointAlongEdge( m_pPrevReduceInfo[i].m_pEdge, nEdgeSurfID, flMaxY, &testEdge.m_vecPositionEnd );
// Don't try to seam up edges that end on this line...
if ( pCurEdge->m_vecPositionEnd.y > flMaxY )
{
ReduceInfo_t *pNewEdge = &m_pNewReduceInfo[ m_nNewReduceCount ];
++m_nNewReduceCount;
pNewEdge->m_pEdge = m_pPrevReduceInfo[i].m_pEdge;
pNewEdge->m_nWingedEdge = m_pPrevReduceInfo[i].m_nWingedEdge;
}
break;
}
// This edge didn't exist on the previous y discontinuity line
// We'll need to make a new one
if ( i < 0 )
{
i = wingedEdgeList.AddEdge();
CWingedEdgeList::WingedEdge_t &newWingedEdge = wingedEdgeList.WingedEdge(i);
newWingedEdge.m_nLeaveSurfID = nLeaveSurfID;
newWingedEdge.m_nEnterSurfID = nEnterSurfID;
newWingedEdge.m_flDxDy = pCurEdge->m_flDxDy;
ComputePointAlongEdge( pCurEdge, nEdgeSurfID, flMinY, &newWingedEdge.m_vecPosition );
ComputePointAlongEdge( pCurEdge, nEdgeSurfID, flMaxY, &newWingedEdge.m_vecPositionEnd );
// Enforce sort order...
// Required because we're computing the x position here, which can introduce error.
if ( i != 0 )
{
CWingedEdgeList::WingedEdge_t &prevWingedEdge = wingedEdgeList.WingedEdge(i - 1);
if ( newWingedEdge.m_vecPosition.y == prevWingedEdge.m_vecPosition.y )
{
if ( newWingedEdge.m_vecPosition.x < prevWingedEdge.m_vecPosition.x )
{
newWingedEdge.m_vecPosition.x = prevWingedEdge.m_vecPosition.x;
}
}
}
// Don't try to seam up edges that end on this line...
if ( pCurEdge->m_vecPositionEnd.y > flMaxY )
{
ReduceInfo_t *pNewEdge = &m_pNewReduceInfo[ m_nNewReduceCount ];
++m_nNewReduceCount;
pNewEdge->m_pEdge = pCurEdge;
pNewEdge->m_nWingedEdge = i;
}
#ifdef DEBUG_OCCLUSION_SYSTEM
wingedEdgeList.CheckConsistency();
#endif
}
nLeaveSurfID = nEnterSurfID;
}
Assert( nLeaveSurfID == -1 );
// Msg("\n");
}
//-----------------------------------------------------------------------------
// Discovers the first edge crossing discontinuity
//-----------------------------------------------------------------------------
float CEdgeList::LocateEdgeCrossingDiscontinuity( float flNextY, float flPrevY, int &nCount, Edge_t **ppInfo )
{
nCount = 0;
float flCurrX = -FLT_MAX;
float flNextX = -FLT_MAX;
float flCurrY = flNextY;
Vector2D vecDelta, vecIntersection;
Edge_t *pCurEdge;
for ( pCurEdge = FirstActiveEdge(); !AtListEnd(pCurEdge); flCurrX = flNextX, pCurEdge = pCurEdge->m_pNextActiveEdge )
{
// Don't take into account edges that end on the current line
Assert( pCurEdge->m_vecPositionEnd.y >= flCurrY );
flNextX = pCurEdge->m_vecPosition.x + (flCurrY - pCurEdge->m_vecPosition.y) * pCurEdge->m_flDxDy;
// Look for an X-crossing... This check helps for nearly co-linear lines
// NOTE: You might think this would crash since it could dereference a NULL
// pointer the first time through the loop, but it never hits that check since the
// first X test is guaranteed to pass
Edge_t *pPrevEdge = pCurEdge->m_pPrevActiveEdge;
if ( ( flNextX > flCurrX ) || ( pPrevEdge->m_flDxDy <= pCurEdge->m_flDxDy ) )
continue;
// This test is necessary to not capture edges that meet at a point...
if ( pPrevEdge->m_vecPositionEnd == pCurEdge->m_vecPositionEnd )
continue;
Assert( pPrevEdge->m_flDxDy != pCurEdge->m_flDxDy );
// Found one! Let's find the intersection of these two
// edges and up the Y discontinuity to that point.
// We'll solve this by doing an intersection of point + plane in 2D...
// For the line, we'll use the previous line where
// P = Pop + D * t, Pop = prevEdge.m_vecPosition, D = [dx dy] = [(dx/dy) 1]
// For the plane, we'll use the current line where
// N * P = d
// Normal is perpendicular to the line, therefore N = [-dy dx] = [-1 (dx/dy)]
// d = DotProduct( N, edge.m_vecPosition ) = N dot Pon
// So, the t that solve the equation is given by t = (d - N dot Pop) / (N dot D)
// Or, t = (N dot Pon - N dot Pop) / (N dot D)
// t = (N dot (Pon - Pop)) / (N dot D)
float flDenominator = 1.0f / (-pPrevEdge->m_flDxDy + pCurEdge->m_flDxDy);
Vector2DSubtract( pCurEdge->m_vecPosition.AsVector2D(), pPrevEdge->m_vecPosition.AsVector2D(), vecDelta );
float flNumerator = - vecDelta.x + pCurEdge->m_flDxDy * vecDelta.y;
float t = flNumerator * flDenominator;
float flYCrossing = pPrevEdge->m_vecPosition.y + t;
// Precision errors...
// NOTE: The optimizer unfortunately causes this test to not return ==
// if the bitpattern of flYCrossing and flNextY are the exact same, because it's
// doing the test with the 80bit fp registers. flYCrossing is still sitting in the register
// from the computation on the line above, but flNextY isn't. Therefore it returns not equal.
// That's why I have to do the explicit bitpattern check.
if ( ( flYCrossing >= flNextY ) || ( *(int*)&flYCrossing == *(int*)&flNextY ) )
continue;
if ( flYCrossing < flPrevY )
{
flYCrossing = flPrevY;
}
// If we advanced in Y, then reset the edge crossings
if ( flCurrY != flYCrossing )
{
flCurrY = flYCrossing;
nCount = 0;
}
Assert( nCount < MAX_EDGE_CROSSINGS );
flNextX = pPrevEdge->m_vecPosition.x + t * pPrevEdge->m_flDxDy;
ppInfo[nCount++] = pCurEdge;
}
return flCurrY;
}
//-----------------------------------------------------------------------------
// Advances the X values of the active edge list, with no reordering
//-----------------------------------------------------------------------------
void CEdgeList::AdvanceActiveEdgeList( float flCurrY )
{
m_flNextDiscontinuity = FLT_MAX;
// Advance all edges until the current Y; we don't need to re-order *any* edges.
Edge_t *pCurEdge;
Edge_t *pNextEdge;
float flPrevX = -FLT_MAX;
for ( pCurEdge = FirstActiveEdge(); !AtListEnd( pCurEdge ); pCurEdge = pNextEdge )
{
pNextEdge = pCurEdge->m_pNextActiveEdge;
if ( pCurEdge->m_vecPositionEnd.y <= flCurrY )
{
UnlinkActiveEdge( pCurEdge );
continue;
}
pCurEdge->m_flX = pCurEdge->m_vecPosition.x + (flCurrY - pCurEdge->m_vecPosition.y) * pCurEdge->m_flDxDy;
// Eliminate precision errors by guaranteeing sort ordering...
if ( pCurEdge->m_flX < flPrevX )
{
pCurEdge->m_flX = flPrevX;
}
else
{
flPrevX = pCurEdge->m_flX;
}
if ( pCurEdge->m_vecPositionEnd.y < m_flNextDiscontinuity )
{
m_flNextDiscontinuity = pCurEdge->m_vecPositionEnd.y;
}
}
}
//-----------------------------------------------------------------------------
// Reorders the active edge list based on where edge crossings occur
//-----------------------------------------------------------------------------
void CEdgeList::ReorderActiveEdgeList( int nCount, Edge_t **ppCrossings )
{
int nCurCrossing = 0;
while ( nCurCrossing < nCount )
{
// Re-order the list where the edge crossing occurred.
// For all edges that passed through the exact same point, we need only
// reverse the order of those edges. At the same time, slam the X value of each
// crossing edge to reduce precision errors
Edge_t *pCurCrossing = ppCrossings[nCurCrossing++];
Edge_t *pFirstCrossing = pCurCrossing->m_pPrevActiveEdge;
// First, bring shared (or nearly shared) edges into the crossing list...
while ( pFirstCrossing->m_pPrevActiveEdge->m_flX == pFirstCrossing->m_flX )
{
pFirstCrossing = pFirstCrossing->m_pPrevActiveEdge;
}
// Find the last crossing...
Edge_t *pLastCrossing = pCurCrossing->m_pNextActiveEdge;
Edge_t *pPrevCrossing = pCurCrossing;
while ( true )
{
if ( (nCurCrossing < nCount) && (pLastCrossing == ppCrossings[nCurCrossing]) )
{
pPrevCrossing = pLastCrossing;
pLastCrossing = pLastCrossing->m_pNextActiveEdge;
++nCurCrossing;
continue;
}
if ( pPrevCrossing->m_flX != pLastCrossing->m_flX )
break;
pLastCrossing = pLastCrossing->m_pNextActiveEdge;
}
// This should always be true, since there's always an edge at FLT_MAX.
Assert( pLastCrossing );
// Slam all x values to be the same to avoid precision errors...
// This guarantees that this crossing at least will occur
float flXCrossing = pFirstCrossing->m_flX;
for ( Edge_t *pCrossing = pFirstCrossing->m_pNextActiveEdge; pCrossing != pLastCrossing; pCrossing = pCrossing->m_pNextActiveEdge )
{
pCrossing->m_flX = flXCrossing;
}
}
// Now re-insert everything to take into account other edges which may well have
// crossed on this line
Edge_t *pEdge;
Edge_t *pNextEdge;
for( pEdge = FirstActiveEdge(); !AtListEnd(pEdge); pEdge = pNextEdge )
{
pNextEdge = pEdge->m_pNextActiveEdge;
Edge_t *pPrevEdge = pEdge->m_pPrevActiveEdge;
if ( pPrevEdge->m_flX == pEdge->m_flX )
{
UnlinkActiveEdge( pEdge );
InsertActiveEdge( pPrevEdge, pEdge );
}
}
}
//-----------------------------------------------------------------------------
// Reduces the active occlusion edge list to the bare minimum set of edges
//-----------------------------------------------------------------------------
void CEdgeList::SpewActiveEdgeList( float y, bool bHex)
{
Edge_t *pEdge = FirstActiveEdge();
Msg( "%.3f : ", y );
while ( !AtListEnd( pEdge ) )
{
if (!bHex)
{
Msg( "(%d %.3f [%d]) ", (int)(pEdge - m_Edges.Base()), pEdge->m_flX, pEdge->m_nSurfID );
}
else
{
Msg( "(%d %X [%d]) ", (int)(pEdge - m_Edges.Base()), *(int*)&pEdge->m_flX, pEdge->m_nSurfID );
}
pEdge = pEdge->m_pNextActiveEdge;
}
Msg( "\n" );
}
//-----------------------------------------------------------------------------
// Checks consistency of the edge list...
//-----------------------------------------------------------------------------
void CEdgeList::CheckConsistency()
{
Edge_t *pEdge = FirstActiveEdge();
while( !AtListEnd( pEdge ) )
{
Edge_t *pPrevEdge = pEdge->m_pPrevActiveEdge;
Assert( pEdge->m_flX >= pPrevEdge->m_flX );
if ( pEdge->m_flX == pPrevEdge->m_flX )
{
// End point check necessary because of precision errors
Assert( (pEdge->m_flDxDy >= pPrevEdge->m_flDxDy) || (pEdge->m_vecPositionEnd == pPrevEdge->m_vecPositionEnd) );
}
pEdge = pEdge->m_pNextActiveEdge;
}
}
//-----------------------------------------------------------------------------
// Reduces the active occlusion edge list to the bare minimum set of edges
//-----------------------------------------------------------------------------
void CEdgeList::ReduceActiveList( CWingedEdgeList &newEdgeList )
{
int nEdgeCount = ActualEdgeCount();
if ( nEdgeCount == 0 )
return;
// Copy the surfaces over
int nCount = m_Surfaces.Count();
// newEdgeList.m_Surfaces.EnsureCapacity( nCount );
for ( int i = 0; i < nCount; ++i )
{
newEdgeList.AddSurface( m_Surfaces[i].m_Plane );
}
Edge_t *pEdgeCrossings[MAX_EDGE_CROSSINGS];
ReduceInfo_t *pBuf[2];
pBuf[0] = (ReduceInfo_t*)stackalloc( nEdgeCount * sizeof(ReduceInfo_t) );
pBuf[1] = (ReduceInfo_t*)stackalloc( nEdgeCount * sizeof(ReduceInfo_t) );
m_nPrevReduceCount = m_nNewReduceCount = 0;
int nIndex = 0;
ResetActiveEdgeList();
ClearCurrentSurfaceList();
// We can skip everything up to y = -1.0f; since that's offscreen
float flPrevY = NextDiscontinuity();
flPrevY = fpmax( -1.0f, flPrevY );
m_flNextDiscontinuity = FLT_MAX;
IntroduceNewActiveEdges( flPrevY );
int nEdgeCrossingCount = 0;
bool bDone = false;
while( !bDone )
{
// Don't immediately progress to the next discontinuity if there are edge crossings.
float flNextY = LocateEdgeCrossingDiscontinuity( NextDiscontinuity(), flPrevY, nEdgeCrossingCount, pEdgeCrossings );
#ifdef DEBUG_OCCLUSION_SYSTEM
if ( s_bSpew )
{
// Debugging spew
SpewActiveEdgeList( flPrevY );
}
#endif
// Reduce the active edge list
m_pNewReduceInfo = pBuf[1 - nIndex];
m_pPrevReduceInfo = pBuf[nIndex];
m_nPrevReduceCount = m_nNewReduceCount;
m_nNewReduceCount = 0;
// Add a small epsilon so we occlude things on the top edge at y = 1.0
if (flNextY >= 1.001f)
{
flNextY = 1.001f;
bDone = true;
}
ReduceActiveEdgeList( newEdgeList, flPrevY, flNextY );
flPrevY = flNextY;
// Advance the active edge list, with no resorting necessary!!
AdvanceActiveEdgeList( flNextY );
// If we had an edge crossing, re-order the edges. Otherwise introduce new active edges
if ( !nEdgeCrossingCount )
{
IntroduceNewActiveEdges( flNextY );
// Keep advancing the active edge list until it's got no more discontinuities
if ( NextDiscontinuity() == FLT_MAX )
return;
}
else
{
ReorderActiveEdgeList( nEdgeCrossingCount, pEdgeCrossings );
// The next edge in y will also present a discontinuity
if ( m_nCurrentEdgeIndex < nEdgeCount )
{
float flNextEdgeY = EdgeFromSortIndex( m_nCurrentEdgeIndex ).m_vecPosition.y;
if ( flNextEdgeY < m_flNextDiscontinuity )
{
m_flNextDiscontinuity = flNextEdgeY;
}
}
}
#ifdef DEBUG_OCCLUSION_SYSTEM
CheckConsistency();
#endif
nIndex = 1 - nIndex;
}
}
//-----------------------------------------------------------------------------
// Used to debug the occlusion system
//-----------------------------------------------------------------------------
void CEdgeList::QueueVisualization( unsigned char *pColor )
{
#ifndef SWDS
if ( !r_visocclusion.GetInt() )
return;
int nFirst = g_EdgeVisualization.AddMultipleToTail( m_Edges.Count() );
for ( int i = m_Edges.Count(); --i >= 0; )
{
EdgeVisualizationInfo_t &info = g_EdgeVisualization[nFirst + i];
info.m_vecPoint[0] = m_Edges[i].m_vecPosition;
info.m_vecPoint[1] = m_Edges[i].m_vecPositionEnd;
*(int*)(info.m_pColor) = *(int*)pColor;
}
#endif
}
void CEdgeList::Visualize( unsigned char *pColor )
{
#ifndef SWDS
if ( !r_visocclusion.GetInt() )
return;
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->MatrixMode( MATERIAL_MODEL );
pRenderContext->PushMatrix();
pRenderContext->LoadIdentity();
pRenderContext->MatrixMode( MATERIAL_VIEW );
pRenderContext->PushMatrix();
pRenderContext->LoadIdentity();
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
pRenderContext->PushMatrix();
pRenderContext->LoadIdentity();
pRenderContext->Bind( g_pMaterialWireframeVertexColorIgnoreZ );
IMesh *pMesh = pRenderContext->GetDynamicMesh( );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_LINES, m_Edges.Count() );
int i;
for ( i = m_Edges.Count(); --i >= 0; )
{
meshBuilder.Position3fv( m_Edges[i].m_vecPosition.Base() );
meshBuilder.Color4ubv( pColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( m_Edges[i].m_vecPositionEnd.Base() );
#ifdef DEBUG_OCCLUSION_SYSTEM
meshBuilder.Color4ub( 0, 0, 255, 255 );
#else
meshBuilder.Color4ubv( pColor );
#endif
meshBuilder.AdvanceVertex();
}
meshBuilder.End();
pMesh->Draw();
pRenderContext->MatrixMode( MATERIAL_MODEL );
pRenderContext->PopMatrix();
pRenderContext->MatrixMode( MATERIAL_VIEW );
pRenderContext->PopMatrix();
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
pRenderContext->PopMatrix();
#endif
}
//-----------------------------------------------------------------------------
// Implementation of IOcclusionSystem
//-----------------------------------------------------------------------------
class COcclusionSystem : public IOcclusionSystem
{
public:
COcclusionSystem();
~COcclusionSystem();
// Inherited from IOcclusionSystem
virtual void ActivateOccluder( int nOccluderIndex, bool bActive );
virtual void SetView( const Vector &vecCameraPos, float flFOV, const VMatrix &worldToCamera, const VMatrix &cameraToProjection, const VPlane &nearClipPlane );
virtual bool IsOccluded( const Vector &vecAbsMins, const Vector &vecAbsMaxs );
virtual void SetOcclusionParameters( float flMaxOccludeeArea, float flMinOccluderArea );
virtual float MinOccluderArea() const;
virtual void DrawDebugOverlays();
private:
struct AxisAlignedPlane_t
{
int m_nAxis;
float m_flSign;
float m_flDist;
};
// Recomputes the edge list for occluders
void RecomputeOccluderEdgeList();
// Is the point inside the near plane?
bool IsPointInsideNearPlane( const Vector &vecPos ) const;
void IntersectWithNearPlane( const Vector &vecStart, const Vector &vecEnd, Vector &outPos ) const;
// Clips a polygon to the near clip plane
int ClipPolygonToNearPlane( Vector **ppVertices, int nVertexCount, Vector **ppOutVerts, bool *pClipped ) const;
// Project world-space verts + add into the edge list
void AddPolygonToEdgeList( CEdgeList &edgeList, Vector **ppPolygon, int nCount, int nSurfID, bool bClipped );
// Computes the plane equation of a polygon in screen space from a camera-space plane
void ComputeScreenSpacePlane( const cplane_t &cameraSpacePlane, cplane_t *pScreenSpacePlane );
// Used to clip the screen space polygons to the screen
void ResetClipTempVerts();
int ClipPolygonToAxisAlignedPlane( Vector **ppVertices, int nVertexCount,
const AxisAlignedPlane_t &plane, Vector **ppOutVerts ) const;
// Is the point within an axis-aligned plane?
bool IsPointInsideAAPlane( const Vector &vecPos, const AxisAlignedPlane_t &plane ) const;
void IntersectWithAAPlane( const Vector &vecStart, const Vector &vecEnd, const AxisAlignedPlane_t &plane, Vector &outPos ) const;
// Stitches up clipped vertices
void StitchClippedVertices( Vector *pVertices, int nCount );
private:
// Per-frame information
bool m_bEdgeListDirty;
VMatrix m_WorldToProjection;
VMatrix m_WorldToCamera;
float m_flXProjScale;
float m_flYProjScale;
float m_flProjDistScale;
float m_flProjDistOffset;
Vector m_vecCameraPosition; // in world space
cplane_t m_NearClipPlane;
float m_flNearPlaneDist;
float m_flFOVFactor;
CEdgeList m_EdgeList;
CWingedEdgeList m_WingedEdgeList;
CUtlVector< Vector > m_ClippedVerts;
float m_flMaxOccludeeArea;
float m_flMinOccluderArea;
// Stats
int m_nTests;
int m_nOccluded;
};
static COcclusionSystem g_OcclusionSystem;
//-----------------------------------------------------------------------------
// Singleton accessor
//-----------------------------------------------------------------------------
IOcclusionSystem *OcclusionSystem()
{
return &g_OcclusionSystem;
}
//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
COcclusionSystem::COcclusionSystem() : m_ClippedVerts( 0, 64 )
{
m_bEdgeListDirty = false;
m_nTests = 0;
m_nOccluded = 0;
m_flMinOccluderArea = DEFAULT_MIN_OCCLUDER_AREA;
m_flMaxOccludeeArea = DEFAULT_MAX_OCCLUDEE_AREA;
}
COcclusionSystem::~COcclusionSystem()
{
}
//-----------------------------------------------------------------------------
// Occlusion parameters?
//-----------------------------------------------------------------------------
void COcclusionSystem::SetOcclusionParameters( float flMaxOccludeeArea, float flMinOccluderArea )
{
m_flMaxOccludeeArea = (flMaxOccludeeArea ? flMaxOccludeeArea : DEFAULT_MAX_OCCLUDEE_AREA) * 0.01f;
m_flMinOccluderArea = (flMinOccluderArea ? flMinOccluderArea : DEFAULT_MIN_OCCLUDER_AREA);
}
float COcclusionSystem::MinOccluderArea() const
{
return m_flMinOccluderArea;
}
//-----------------------------------------------------------------------------
// Is the point within the near plane?
//-----------------------------------------------------------------------------
inline bool COcclusionSystem::IsPointInsideNearPlane( const Vector &vecPos ) const
{
return DotProduct( vecPos, m_NearClipPlane.normal ) >= m_NearClipPlane.dist;
}
inline void COcclusionSystem::IntersectWithNearPlane( const Vector &vecStart, const Vector &vecEnd, Vector &outPos ) const
{
Vector vecDir;
VectorSubtract( vecEnd, vecStart, vecDir );
float t = IntersectRayWithPlane( vecStart, vecDir, m_NearClipPlane.normal, m_NearClipPlane.dist );
VectorLerp( vecStart, vecEnd, t, outPos );
}
//-----------------------------------------------------------------------------
// Clips a surface to the near clip plane
// FIXME: This blows: a *third* S-H clipper in the engine! All because the
// vertex formats are different owing to different goals of the 3 clippers
//-----------------------------------------------------------------------------
static Vector s_TempVertMemory[256];
int COcclusionSystem::ClipPolygonToNearPlane( Vector **ppVertices, int nVertexCount, Vector **ppOutVerts, bool *pClipped ) const
{
*pClipped = false;
if ( nVertexCount < 3 )
return 0;
// Ye Olde Sutherland-Hodgman clipping algorithm
int nOutVertCount = 0;
int nNewVertCount = 0;
Vector* pStart = ppVertices[ nVertexCount - 1 ];
bool bStartInside = IsPointInsideNearPlane( *pStart );
for ( int i = 0; i < nVertexCount; ++i )
{
Vector* pEnd = ppVertices[ i ];
bool bEndInside = IsPointInsideNearPlane( *pEnd );
if (bEndInside)
{
if (!bStartInside)
{
// Started outside, ended inside, need to clip the edge
ppOutVerts[nOutVertCount] = &s_TempVertMemory[ nNewVertCount++ ];
IntersectWithNearPlane( *pStart, *pEnd, *ppOutVerts[nOutVertCount] );
++nOutVertCount;
*pClipped = true;
}
ppOutVerts[nOutVertCount++] = pEnd;
}
else
{
if (bStartInside)
{
// Started inside, ended outside, need to clip the edge
ppOutVerts[nOutVertCount] = &s_TempVertMemory[ nNewVertCount++ ];
IntersectWithNearPlane( *pStart, *pEnd, *ppOutVerts[nOutVertCount] );
++nOutVertCount;
*pClipped = true;
}
}
pStart = pEnd;
bStartInside = bEndInside;
}
return nOutVertCount;
}
//-----------------------------------------------------------------------------
// Is the point within an axis-aligned plane?
//-----------------------------------------------------------------------------
inline bool COcclusionSystem::IsPointInsideAAPlane( const Vector &vecPos, const AxisAlignedPlane_t &plane ) const
{
return vecPos[plane.m_nAxis] * plane.m_flSign >= plane.m_flDist;
}
inline void COcclusionSystem::IntersectWithAAPlane( const Vector &vecStart, const Vector &vecEnd, const AxisAlignedPlane_t &plane, Vector &outPos ) const
{
float t = IntersectRayWithAAPlane( vecStart, vecEnd, plane.m_nAxis, plane.m_flSign, plane.m_flDist );
VectorLerp( vecStart, vecEnd, t, outPos );
}
//-----------------------------------------------------------------------------
// Clips a surface to the edges of the screen (axis-aligned planes)
//-----------------------------------------------------------------------------
static int s_nTempVertCount = 0;
void COcclusionSystem::ResetClipTempVerts()
{
s_nTempVertCount = 0;
}
int COcclusionSystem::ClipPolygonToAxisAlignedPlane( Vector **ppVertices, int nVertexCount,
const AxisAlignedPlane_t &plane, Vector **ppOutVerts ) const
{
// Ye Olde Sutherland-Hodgman clipping algorithm
int nOutVertCount = 0;
Vector* pStart = ppVertices[ nVertexCount - 1 ];
bool bStartInside = IsPointInsideAAPlane( *pStart, plane );
for ( int i = 0; i < nVertexCount; ++i )
{
Vector* pEnd = ppVertices[ i ];
bool bEndInside = IsPointInsideAAPlane( *pEnd, plane );
if (bEndInside)
{
if (!bStartInside)
{
// Started outside, ended inside, need to clip the edge
ppOutVerts[nOutVertCount] = &s_TempVertMemory[ s_nTempVertCount++ ];
IntersectWithAAPlane( *pStart, *pEnd, plane, *ppOutVerts[nOutVertCount] );
++nOutVertCount;
}
ppOutVerts[nOutVertCount++] = pEnd;
}
else
{
if (bStartInside)
{
// Started inside, ended outside, need to clip the edge
ppOutVerts[nOutVertCount] = &s_TempVertMemory[ s_nTempVertCount++ ];
IntersectWithAAPlane( *pStart, *pEnd, plane, *ppOutVerts[nOutVertCount] );
++nOutVertCount;
}
}
pStart = pEnd;
bStartInside = bEndInside;
}
return nOutVertCount;
}
//-----------------------------------------------------------------------------
// Computes the plane equation of a polygon in screen space from a world-space plane
//-----------------------------------------------------------------------------
void COcclusionSystem::ComputeScreenSpacePlane( const cplane_t &cameraSpacePlane, cplane_t *pScreenSpacePlane )
{
// Here's how this is computed:
// If the *camera* space plane is Ax+By+Cz = D,
// and xs = -(xf) * x/z, ys = -(yf) y/z, zs = - (zc + zf * ooz)
// Then x = -xs * z / xf, y = -ys * z / yf, ooz = -(zs + zc) / zf
// So - A * xs * z / xf - B * ys * z / yf + C * z = D
// - A xs / xf - B ys / yf + C = D * ooz
// (A/D) xs/xf + (B/D) ys/yf + ooz = (C/D)
// (A/D) xs/xf + (B/D) ys/yf - (zs + zc) / zf = (C/D)
// -(A/D) xs/xf - (B/D) ys/yf + (zs + zc) / zf = -(C/D)
// -zf * (A/D) xs/xf - zf * (B/D) ys/yf + zs = -zf * (C/D) - zc
// Let A' = -zf/xf*(A/D), B' = -zf/yf*(B/D), D' = -zf * (C/D) - zc
// A' xs + B' ys + zs = D' is the screen space plane equation
float ooD = (cameraSpacePlane.dist != 0) ? (1.0f / cameraSpacePlane.dist) : 0.0f;
pScreenSpacePlane->normal.x = cameraSpacePlane.normal.x * ooD * m_flXProjScale;
pScreenSpacePlane->normal.y = cameraSpacePlane.normal.y * ooD * m_flYProjScale;
pScreenSpacePlane->normal.z = 1;
pScreenSpacePlane->dist = cameraSpacePlane.normal.z * ooD * m_flProjDistScale + m_flProjDistOffset;
}
//-----------------------------------------------------------------------------
// Stitches up clipped vertices
//-----------------------------------------------------------------------------
void COcclusionSystem::StitchClippedVertices( Vector *pVertices, int nCount )
{
for ( int i = 0; i < nCount; ++i )
{
// Only stitch ones that have been clipped by the near clip plane
if ( fabs( pVertices[i].z ) > 1e-3 )
continue;
int j;
for ( j = m_ClippedVerts.Count(); --j >= 0; )
{
if ( VectorsAreEqual( pVertices[i], m_ClippedVerts[j], 1e-3 ) )
{
pVertices[i] = m_ClippedVerts[j];
break;
}
}
if ( j < 0 )
{
MEM_ALLOC_CREDIT();
// No match found...
m_ClippedVerts.AddToTail( pVertices[i] );
}
}
}
//-----------------------------------------------------------------------------
// Project world-space verts + add into the edge list
//-----------------------------------------------------------------------------
void COcclusionSystem::AddPolygonToEdgeList( CEdgeList &edgeList, Vector **ppPolygon, int nCount, int nSurfID, bool bClipped )
{
// Transform the verts into projection space
// Transform into projection space (extra logic here is to simply guarantee that we project each vert exactly once)
int nMaxClipVerts = (nCount * 4);
int nClipCount, nClipCount1;
Vector **ppClipVertex = (Vector**)stackalloc( nMaxClipVerts * sizeof(Vector*) );
Vector **ppClipVertex1 = (Vector**)stackalloc( nMaxClipVerts * sizeof(Vector*) );
Vector *pVecProjectedVertex = (Vector*)stackalloc( nCount * sizeof(Vector) );
int k;
for ( k = 0; k < nCount; ++k )
{
Vector3DMultiplyPositionProjective( m_WorldToProjection, *(ppPolygon[k]), pVecProjectedVertex[k] );
// Clamp needed to avoid precision problems.
// if ( pVecProjectedVertex[k].z < 0.0f )
// pVecProjectedVertex[k].z = 0.0f;
pVecProjectedVertex[k].z *= (pVecProjectedVertex[k].z > 0.0f);
ppClipVertex[k] = &pVecProjectedVertex[k];
}
// Clip vertices to the screen in x,y...
AxisAlignedPlane_t aaPlane;
aaPlane.m_nAxis = 0;
aaPlane.m_flDist = -1;
aaPlane.m_flSign = -1;
nClipCount = nCount;
ResetClipTempVerts();
nClipCount1 = ClipPolygonToAxisAlignedPlane( ppClipVertex, nClipCount, aaPlane, ppClipVertex1 );
if ( nClipCount1 < 3 )
return;
Assert( nClipCount1 < nMaxClipVerts );
aaPlane.m_flSign = 1;
nClipCount = ClipPolygonToAxisAlignedPlane( ppClipVertex1, nClipCount1, aaPlane, ppClipVertex );
if ( nClipCount < 3 )
return;
Assert( nClipCount < nMaxClipVerts );
aaPlane.m_nAxis = 1;
nClipCount1 = ClipPolygonToAxisAlignedPlane( ppClipVertex, nClipCount, aaPlane, ppClipVertex1 );
if ( nClipCount1 < 3 )
return;
Assert( nClipCount1 < nMaxClipVerts );
aaPlane.m_flSign = -1;
nClipCount = ClipPolygonToAxisAlignedPlane( ppClipVertex1, nClipCount1, aaPlane, ppClipVertex );
if ( nClipCount < 3 )
return;
Assert( nClipCount < nMaxClipVerts );
// Compute the screen area...
float flScreenArea = 0.0f;
int nLastClipVert = nClipCount - 1;
for ( k = 1; k < nLastClipVert; ++k )
{
// Using area times two simply because it's faster...
float flTriArea = TriArea2DTimesTwo( (*ppClipVertex[0]), (*ppClipVertex[k]), (*ppClipVertex[k+1]) );
Assert( flTriArea <= 1e-3 );
if ( flTriArea < 0 )
{
flScreenArea += -flTriArea;
}
}
edgeList.SetSurfaceArea( nSurfID, flScreenArea );
// If there's a clipped vertex, attempt to seam up with other edges...
if ( bClipped )
{
StitchClippedVertices( pVecProjectedVertex, nCount );
}
// Add in the edges of the *unclipped* polygon: to avoid precision errors
Vector *ppEdgeVertices[2];
int nLastVert = nCount - 1;
ppEdgeVertices[ 1 ] = &pVecProjectedVertex[ nLastVert ];
for ( k = 0; k < nLastVert; ++k )
{
ppEdgeVertices[ k & 0x1 ] = &pVecProjectedVertex[ k ];
edgeList.AddEdge( ppEdgeVertices, nSurfID );
}
ppEdgeVertices[ nLastVert & 0x1 ] = &pVecProjectedVertex[ nLastVert ];
edgeList.AddEdge( ppEdgeVertices, nSurfID );
}
//-----------------------------------------------------------------------------
// Recomputes the occluder edge list
//-----------------------------------------------------------------------------
void COcclusionSystem::RecomputeOccluderEdgeList()
{
if ( !m_bEdgeListDirty )
return;
// Tracker 17772: If building cubemaps can end up calling into here w/o cl.pAreaBits setup yet, oh well.
if ( !cl.m_bAreaBitsValid && CommandLine()->FindParm( "-buildcubemaps" ) )
return;
m_bEdgeListDirty = false;
m_EdgeList.RemoveAll();
m_WingedEdgeList.Clear();
m_ClippedVerts.RemoveAll();
mvertex_t *pVertices = host_state.worldbrush->vertexes;
int *pIndices = host_state.worldbrush->occludervertindices;
doccluderdata_t *pOccluders = host_state.worldbrush->occluders;
int i, j, k;
for ( i = host_state.worldbrush->numoccluders ; --i >= 0; )
{
if ( pOccluders[i].flags & OCCLUDER_FLAGS_INACTIVE )
continue;
// Skip the occluder if it's in a disconnected area
if ( cl.m_chAreaBits &&
(cl.m_chAreaBits[pOccluders[i].area >> 3] & (1 << ( pOccluders[i].area & 0x7 )) ) == 0 )
continue;
int nSurfID = pOccluders[i].firstpoly;
int nSurfCount = pOccluders[i].polycount;
for ( j = 0; j < nSurfCount; ++j, ++nSurfID )
{
doccluderpolydata_t *pSurf = &host_state.worldbrush->occluderpolys[nSurfID];
int nFirstVertexIndex = pSurf->firstvertexindex;
int nVertexCount = pSurf->vertexcount;
// If the surface is backfacing, blow it off...
const cplane_t &surfPlane = host_state.worldbrush->planes[ pSurf->planenum ];
if ( DotProduct( surfPlane.normal, m_vecCameraPosition ) <= surfPlane.dist )
continue;
// Clip to the near plane (has to be done in world space)
Vector **ppSurfVerts = (Vector**)stackalloc( ( nVertexCount ) * sizeof(Vector*) );
Vector **ppClipVerts = (Vector**)stackalloc( ( nVertexCount * 2 ) * sizeof(Vector*) );
for ( k = 0; k < nVertexCount; ++k )
{
int nVertIndex = pIndices[nFirstVertexIndex + k];
ppSurfVerts[k] = &( pVertices[nVertIndex].position );
}
bool bClipped;
int nClipCount = ClipPolygonToNearPlane( ppSurfVerts, nVertexCount, ppClipVerts, &bClipped );
Assert( nClipCount <= ( nVertexCount * 2 ) );
if ( nClipCount < 3 )
continue;
cplane_t projectionSpacePlane;
cplane_t cameraSpacePlane;
MatrixTransformPlane( m_WorldToCamera, surfPlane, cameraSpacePlane );
ComputeScreenSpacePlane( cameraSpacePlane, &projectionSpacePlane );
int nEdgeSurfID = m_EdgeList.AddSurface( projectionSpacePlane );
// Transform into projection space (extra logic here is to simply guarantee that we project each vert exactly once)
AddPolygonToEdgeList( m_EdgeList, ppClipVerts, nClipCount, nEdgeSurfID, bClipped );
}
}
m_EdgeList.CullSmallOccluders();
m_EdgeList.ReduceActiveList( m_WingedEdgeList );
// Msg("Edge count %d -> %d\n", m_EdgeList.EdgeCount(), m_WingedEdgeList.EdgeCount() );
// Draw the occluders
unsigned char color[4] = { 255, 255, 255, 255 };
m_WingedEdgeList.QueueVisualization( color );
}
//-----------------------------------------------------------------------------
// Occluder list management
//-----------------------------------------------------------------------------
void COcclusionSystem::ActivateOccluder( int nOccluderIndex, bool bActive )
{
if ( ( nOccluderIndex >= host_state.worldbrush->numoccluders ) || ( nOccluderIndex < 0 ) )
return;
if ( bActive )
{
host_state.worldbrush->occluders[nOccluderIndex].flags &= ~OCCLUDER_FLAGS_INACTIVE;
}
else
{
host_state.worldbrush->occluders[nOccluderIndex].flags |= OCCLUDER_FLAGS_INACTIVE;
}
m_bEdgeListDirty = true;
}
void COcclusionSystem::SetView( const Vector &vecCameraPos, float flFOV, const VMatrix &worldToCamera,
const VMatrix &cameraToProjection, const VPlane &nearClipPlane )
{
m_vecCameraPosition = vecCameraPos;
m_WorldToCamera = worldToCamera;
// See ComputeScreenSpacePlane() for the use of these constants
m_flXProjScale = -cameraToProjection[2][3] / cameraToProjection[0][0];
m_flYProjScale = -cameraToProjection[2][3] / cameraToProjection[1][1];
m_flProjDistScale = -cameraToProjection[2][3];
m_flProjDistOffset = -cameraToProjection[2][2];
MatrixMultiply( cameraToProjection, worldToCamera, m_WorldToProjection );
m_NearClipPlane.normal = nearClipPlane.m_Normal;
m_NearClipPlane.dist = nearClipPlane.m_Dist;
m_NearClipPlane.type = 3;
m_bEdgeListDirty = true;
m_flNearPlaneDist = -( DotProduct( vecCameraPos, m_NearClipPlane.normal ) - m_NearClipPlane.dist );
Assert( m_flNearPlaneDist > 0.0f );
m_flFOVFactor = m_flNearPlaneDist * tan( flFOV * 0.5f * M_PI / 180.0f );
m_flFOVFactor = m_flNearPlaneDist / m_flFOVFactor;
m_flFOVFactor *= m_flFOVFactor;
if ( r_occlusionspew.GetInt() )
{
if ( m_nTests )
{
float flPercent = 100.0f * ((float)m_nOccluded / (float)m_nTests);
Msg("Occl %.2f (%d/%d)\n", flPercent, m_nOccluded, m_nTests );
m_nTests = 0;
m_nOccluded = 0;
}
}
}
//-----------------------------------------------------------------------------
// Used to build the quads to test for occlusion
//-----------------------------------------------------------------------------
static int s_pFaceIndices[6][4] =
{
{ 0, 4, 6, 2 }, // -x
{ 1, 3, 7, 5 }, // +x
{ 0, 1, 5, 4 }, // -y
{ 2, 6, 7, 3 }, // +y
{ 0, 2, 3, 1 }, // -z
{ 4, 5, 7, 6 }, // +z
};
static int s_pSourceIndices[8] =
{
-1, 0, 0, 1, 0, 1, 2, 3
};
static int s_pDeltaIndices[8] =
{
-1, 0, 1, 1, 2, 2, 2, 2
};
static unsigned char s_VisualizationColor[2][4] =
{
{ 255, 0, 0, 255 },
{ 0, 255, 0, 255 }
};
struct EdgeInfo_t
{
unsigned char m_nVert[2];
unsigned char m_nFace[2];
int m_nTestCount;
int m_nMinVert;
};
// NOTE: The face indices here have to very carefully ordered for the algorithm
// to work. They must be ordered so that vert0 -> vert1 is clockwise
// for the first face listed and vert1 -> vert0 is clockwise for the 2nd face listed
static EdgeInfo_t s_pEdges[12] =
{
{ { 0, 1 }, { 2, 4 }, 0, 0 }, // 0: Edge between -y + -z
{ { 2, 0 }, { 0, 4 }, 0, 0 }, // 1: Edge between -x + -z
{ { 1, 3 }, { 1, 4 }, 0, 0 }, // 2: Edge between +x + -z
{ { 3, 2 }, { 3, 4 }, 0, 0 }, // 3: Edge between +y + -z
{ { 0, 4 }, { 0, 2 }, 0, 0 }, // 4: Edge between -x + -y
{ { 5, 1 }, { 1, 2 }, 0, 0 }, // 5: Edge between +x + -y
{ { 6, 2 }, { 0, 3 }, 0, 0 }, // 6: Edge between -x + +y
{ { 3, 7 }, { 1, 3 }, 0, 0 }, // 7: Edge between +x + +y
{ { 5, 4 }, { 2, 5 }, 0, 0 }, // 8: Edge between -y + +z
{ { 4, 6 }, { 0, 5 }, 0, 0 }, // 9: Edge between -x + +z
{ { 7, 5 }, { 1, 5 }, 0, 0 }, // 10:Edge between +x + +z
{ { 6, 7 }, { 3, 5 }, 0, 0 }, // 11:Edge between +y + +z
};
static int s_pFaceEdges[6][4] =
{
{ 4, 9, 6, 1 },
{ 2, 7, 10, 5 },
{ 0, 5, 8, 4 },
{ 6, 11, 7, 3 },
{ 1, 3, 2, 0 },
{ 8, 10, 11, 9 },
};
//-----------------------------------------------------------------------------
// Occlusion checks
//-----------------------------------------------------------------------------
static CWingedEdgeList s_WingedTestEdgeList;
class WingedEdgeLessFunc
{
public:
bool Less( const int& src1, const int& src2, void *pCtx )
{
Vector *pVertices = (Vector*)pCtx;
EdgeInfo_t *pEdge1 = &s_pEdges[ src1 ];
EdgeInfo_t *pEdge2 = &s_pEdges[ src2 ];
Vector *pV1 = &pVertices[ pEdge1->m_nVert[ pEdge1->m_nMinVert ] ];
Vector *pV2 = &pVertices[ pEdge2->m_nVert[ pEdge2->m_nMinVert ] ];
if (pV1->y < pV2->y)
return true;
if (pV1->y > pV2->y)
return false;
if (pV1->x < pV2->x)
return true;
if (pV1->x > pV2->x)
return false;
// This is the same as the following line:
// return (pEdge1->m_flDxDy <= pEdge2->m_flDxDy);
Vector2D dEdge1, dEdge2;
Vector2DSubtract( pVertices[ pEdge1->m_nVert[ 1 - pEdge1->m_nMinVert ] ].AsVector2D(), pV1->AsVector2D(), dEdge1 );
Vector2DSubtract( pVertices[ pEdge2->m_nVert[ 1 - pEdge2->m_nMinVert ] ].AsVector2D(), pV2->AsVector2D(), dEdge2 );
Assert( dEdge1.y >= 0.0f );
Assert( dEdge2.y >= 0.0f );
return dEdge1.x * dEdge2.y <= dEdge1.y * dEdge2.x;
}
};
bool COcclusionSystem::IsOccluded( const Vector &vecAbsMins, const Vector &vecAbsMaxs )
{
if ( r_occlusion.GetInt() == 0 )
return false;
VPROF_BUDGET( "COcclusionSystem::IsOccluded", VPROF_BUDGETGROUP_OCCLUSION );
// @MULTICORE (toml 9/11/2006): need to eliminate this mutex
static CThreadFastMutex mutex;
AUTO_LOCK( mutex );
RecomputeOccluderEdgeList();
// No occluders? Then the edge list isn't occluded
if ( m_WingedEdgeList.EdgeCount() == 0 )
return false;
// Don't occlude things that have large screen area
// Use a super cheap but inaccurate screen area computation
Vector vecCenter;
VectorAdd( vecAbsMaxs, vecAbsMins, vecCenter );
vecCenter *= 0.5f;
vecCenter -= m_vecCameraPosition;
float flDist = DotProduct( m_NearClipPlane.normal, vecCenter );
if (flDist <= 0.0f)
return false;
flDist += m_flNearPlaneDist;
Vector vecSize;
VectorSubtract( vecAbsMaxs, vecAbsMins, vecSize );
float flRadiusSq = DotProduct( vecSize, vecSize ) * 0.25f;
float flScreenArea = m_flFOVFactor * flRadiusSq / (flDist * flDist);
float flMaxSize = r_occludeemaxarea.GetFloat() * 0.01f;
if ( flMaxSize == 0.0f )
{
flMaxSize = m_flMaxOccludeeArea;
}
if (flScreenArea >= flMaxSize)
return false;
// Clear out its state
s_WingedTestEdgeList.Clear();
// NOTE: This assumes that frustum culling has already occurred on this object
// If that were not the case, we'd need to add a little extra into this
// (probably a single plane test, which tests if the box is wholly behind the camera )
// Convert the bbox into a max of 3 quads...
const Vector *pCornerVert[2] = { &vecAbsMins, &vecAbsMaxs };
// Compute the 8 box verts, and transform them into projective space...
// NOTE: We'd want to project them *after* the plane test if there were
// no frustum culling.
int i;
Vector pVecProjectedVertex[8];
// NOTE: The code immediately below is an optimized version of this loop
// The optimization takes advantage of the fact that the verts are all
// axis aligned.
// Vector vecBoxVertex;
// for ( i = 0; i < 8; ++i )
// {
// vecBoxVertex.x = pCornerVert[ (i & 0x1) ]->x;
// vecBoxVertex.y = pCornerVert[ (i & 0x2) >> 1 ]->y;
// vecBoxVertex.z = pCornerVert[ (i & 0x4) >> 2 ]->z;
// Vector3DMultiplyPositionProjective( m_WorldToProjection, vecBoxVertex, pVecProjectedVertex[ i ] );
// if ( pVecProjectedVertex[ i ].z <= 0.0f )
// return false;
// }
Vector4D vecProjVert[8];
Vector4D vecDeltaProj[3];
Vector4D vecAbsMins4D( vecAbsMins.x, vecAbsMins.y, vecAbsMins.z, 1.0f );
Vector4DMultiply( m_WorldToProjection, vecAbsMins4D, vecProjVert[0] );
if ( vecProjVert[0].w <= 0.0f )
return false;
float flOOW = 1.0f / vecProjVert[0].w;
vecDeltaProj[0].Init( vecSize.x * m_WorldToProjection[0][0], vecSize.x * m_WorldToProjection[1][0], vecSize.x * m_WorldToProjection[2][0], vecSize.x * m_WorldToProjection[3][0] );
vecDeltaProj[1].Init( vecSize.y * m_WorldToProjection[0][1], vecSize.y * m_WorldToProjection[1][1], vecSize.y * m_WorldToProjection[2][1], vecSize.y * m_WorldToProjection[3][1] );
vecDeltaProj[2].Init( vecSize.z * m_WorldToProjection[0][2], vecSize.z * m_WorldToProjection[1][2], vecSize.z * m_WorldToProjection[2][2], vecSize.z * m_WorldToProjection[3][2] );
pVecProjectedVertex[0].Init( vecProjVert[0].x * flOOW, vecProjVert[0].y * flOOW, vecProjVert[0].z * flOOW );
if ( pVecProjectedVertex[0].z <= 0.0f )
return false;
for ( i = 1; i < 8; ++i )
{
int nIndex = s_pSourceIndices[i];
int nDelta = s_pDeltaIndices[i];
Vector4DAdd( vecProjVert[nIndex], vecDeltaProj[nDelta], vecProjVert[i] );
if ( vecProjVert[ i ].w <= 0.0f )
return false;
flOOW = 1.0f / vecProjVert[i].w;
pVecProjectedVertex[ i ].Init( vecProjVert[i].x * flOOW, vecProjVert[i].y * flOOW, vecProjVert[i].z * flOOW );
if ( pVecProjectedVertex[ i ].z <= 0.0f )
return false;
}
// Precompute stuff needed by the loop over faces below
float pSign[2] = { -1, 1 };
Vector vecDelta[2];
VectorSubtract( *pCornerVert[0], m_vecCameraPosition, vecDelta[0] );
VectorSubtract( m_vecCameraPosition, *pCornerVert[1], vecDelta[1] );
// Determine which faces + edges are visible...
++m_nTests;
int pSurfInd[6];
for ( i = 0; i < 6; ++i )
{
int nDim = ( i >> 1 );
int nInd = i & 0x1;
// Try to backface cull each of the 6 box faces
if ( vecDelta[nInd][nDim] <= 0.0f )
{
pSurfInd[i] = -1;
continue;
}
cplane_t cameraSpacePlane, projectionSpacePlane;
float flSign = pSign[nInd];
float flPlaneDist = (*pCornerVert[nInd])[ nDim ] * flSign;
MatrixTransformAxisAlignedPlane( m_WorldToCamera, nDim, flSign, flPlaneDist, cameraSpacePlane );
ComputeScreenSpacePlane( cameraSpacePlane, &projectionSpacePlane );
int nSurfID = s_WingedTestEdgeList.AddSurface( projectionSpacePlane );
pSurfInd[i] = nSurfID;
// Mark edges as being used...
int *pFaceEdges = s_pFaceEdges[i];
s_pEdges[ pFaceEdges[0] ].m_nTestCount = m_nTests;
s_pEdges[ pFaceEdges[1] ].m_nTestCount = m_nTests;
s_pEdges[ pFaceEdges[2] ].m_nTestCount = m_nTests;
s_pEdges[ pFaceEdges[3] ].m_nTestCount = m_nTests;
}
// Sort edges by minimum Y + dx/dy...
int pEdgeSort[12];
CUtlSortVector< int, WingedEdgeLessFunc > edgeSort( pEdgeSort, 12 );
edgeSort.SetLessContext( pVecProjectedVertex );
for ( i = 0; i < 12; ++i )
{
// Skip non-visible edges
EdgeInfo_t *pEdge = &s_pEdges[i];
if ( pEdge->m_nTestCount != m_nTests )
continue;
pEdge->m_nMinVert = ( pVecProjectedVertex[ pEdge->m_nVert[0] ].y >= pVecProjectedVertex[ pEdge->m_nVert[1] ].y );
edgeSort.Insert( i );
}
// Now add them into the winged edge list, in sorted order...
int nEdgeCount = edgeSort.Count();
for ( i = 0; i < nEdgeCount; ++i )
{
EdgeInfo_t *pEdge = &s_pEdges[edgeSort[i]];
// The enter + leave ids depend entirely on which edge is further up
// This works because the edges listed in s_pEdges show the edges as they
// would be visited in *clockwise* order
const Vector &startVert = pVecProjectedVertex[pEdge->m_nVert[pEdge->m_nMinVert]];
const Vector &endVert = pVecProjectedVertex[pEdge->m_nVert[1 - pEdge->m_nMinVert]];
int nLeaveSurfID = pSurfInd[ pEdge->m_nFace[pEdge->m_nMinVert] ];
int nEnterSurfID = pSurfInd[ pEdge->m_nFace[1 - pEdge->m_nMinVert] ];
s_WingedTestEdgeList.AddEdge( startVert, endVert, nLeaveSurfID, nEnterSurfID );
}
#ifdef DEBUG_OCCLUSION_SYSTEM
s_WingedTestEdgeList.CheckConsistency();
#endif
// Now let's see if this edge list is occluded or not..
bool bOccluded = m_WingedEdgeList.IsOccludingEdgeList( s_WingedTestEdgeList );
if (bOccluded)
{
++m_nOccluded;
}
s_WingedTestEdgeList.QueueVisualization( s_VisualizationColor[bOccluded] );
return bOccluded;
}
//-----------------------------------------------------------------------------
// Used to debug the occlusion system
//-----------------------------------------------------------------------------
void VisualizeQueuedEdges( )
{
#ifndef SWDS
if ( !g_EdgeVisualization.Count() )
return;
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->MatrixMode( MATERIAL_MODEL );
pRenderContext->PushMatrix();
pRenderContext->LoadIdentity();
pRenderContext->MatrixMode( MATERIAL_VIEW );
pRenderContext->PushMatrix();
pRenderContext->LoadIdentity();
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
pRenderContext->PushMatrix();
pRenderContext->LoadIdentity();
pRenderContext->Bind( g_pMaterialWireframeVertexColorIgnoreZ );
IMesh *pMesh = pRenderContext->GetDynamicMesh( );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_LINES, g_EdgeVisualization.Count() );
int i;
for ( i = g_EdgeVisualization.Count(); --i >= 0; )
{
EdgeVisualizationInfo_t &info = g_EdgeVisualization[i];
meshBuilder.Position3fv( info.m_vecPoint[0].Base() );
meshBuilder.Color4ubv( info.m_pColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( info.m_vecPoint[1].Base() );
#ifdef DEBUG_OCCLUSION_SYSTEM
meshBuilder.Color4ub( 0, 0, 255, 255 );
#else
meshBuilder.Color4ubv( info.m_pColor );
#endif
meshBuilder.AdvanceVertex();
}
meshBuilder.End();
pMesh->Draw();
pRenderContext->MatrixMode( MATERIAL_MODEL );
pRenderContext->PopMatrix();
pRenderContext->MatrixMode( MATERIAL_VIEW );
pRenderContext->PopMatrix();
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
pRenderContext->PopMatrix();
g_EdgeVisualization.RemoveAll();
#endif
}
//-----------------------------------------------------------------------------
// Render debugging overlay
//-----------------------------------------------------------------------------
void COcclusionSystem::DrawDebugOverlays()
{
// Draw the occludees
VisualizeQueuedEdges();
}