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