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.

2960 lines
93 KiB

5 years ago
//========= 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 );
5 years ago
// 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) );
5 years ago
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();
}