BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/engine/debugoverlay.cpp

1309 lines
34 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Debugging overlay functions
//
// $Workfile: $
// $Date: $
// $NoKeywords: $
//===========================================================================//
#include "render_pch.h"
#include "edict.h"
#include "client.h"
#include "debugoverlay.h"
#include "cdll_int.h"
#include "ivideomode.h"
#include "materialsystem/imesh.h"
#include "gl_matsysiface.h"
#include "server.h"
#include "client_class.h"
#include "icliententitylist.h"
#include "mathlib/vmatrix.h"
#include "icliententity.h"
#include "overlaytext.h"
#include "engine/ivdebugoverlay.h"
#include "cmodel_engine.h"
#include "vphysics_interface.h"
#include "materialsystem/imaterial.h"
#include "tier2/renderutils.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern edict_t *EDICT_NUM(int n);
ConVar enable_debug_overlays( "enable_debug_overlays", "1", FCVAR_GAMEDLL | FCVAR_CHEAT, "Enable rendering of debug overlays" );
int GetOverlayTick()
{
if ( sv.IsActive() )
return sv.m_nTickCount;
return cl.GetClientTickCount();
}
bool OverlayText_t::IsDead()
{
if ( IsXbox() && cl.IsPaused() )
return false;
if ( m_nServerCount != cl.m_nServerCount )
return true;
if ( m_nCreationTick != -1 )
{
if ( GetOverlayTick() > m_nCreationTick )
return true;
return false;
}
if ( m_flEndTime == NDEBUG_PERSIST_TILL_NEXT_SERVER )
return false;
return (cl.GetTime() >= m_flEndTime);
}
void OverlayText_t::SetEndTime( float duration )
{
m_nServerCount = cl.m_nServerCount;
if ( duration <= 0.0f )
{
m_flEndTime = 0.0f;
m_nCreationTick = GetOverlayTick();
return;
}
if ( duration == NDEBUG_PERSIST_TILL_NEXT_SERVER )
{
m_flEndTime = NDEBUG_PERSIST_TILL_NEXT_SERVER;
}
else
{
m_flEndTime = cl.GetTime() + duration;
}
}
namespace CDebugOverlay
{
enum OverlayType_t
{
OVERLAY_BOX = 0,
OVERLAY_SPHERE,
OVERLAY_LINE,
OVERLAY_TRIANGLE,
OVERLAY_SWEPT_BOX,
OVERLAY_BOX2
};
struct OverlayBase_t
{
OverlayBase_t()
{
m_Type = OVERLAY_BOX;
m_nServerCount = -1;
m_nCreationTick = -1;
m_flEndTime = 0.0f;
m_pNextOverlay = NULL;
}
bool IsDead()
{
if ( IsXbox() && cl.IsPaused() )
return false;
if ( m_nServerCount != cl.m_nServerCount )
return true;
if ( m_nCreationTick != -1 )
{
if ( GetOverlayTick() > m_nCreationTick )
return true;
return false;
}
if ( m_flEndTime == NDEBUG_PERSIST_TILL_NEXT_SERVER )
return false;
return (cl.GetTime() >= m_flEndTime) ;
}
void SetEndTime( float duration )
{
m_nServerCount = cl.m_nServerCount;
if ( duration <= 0.0f )
{
m_nCreationTick = GetOverlayTick(); // stay alive for only one frame
return;
}
if ( duration == NDEBUG_PERSIST_TILL_NEXT_SERVER )
{
m_flEndTime = NDEBUG_PERSIST_TILL_NEXT_SERVER;
}
else
{
m_flEndTime = cl.GetTime() + duration;
}
}
OverlayType_t m_Type; // What type of overlay is it?
int m_nCreationTick; // Duration -1 means go away after this frame #
int m_nServerCount; // Latch server count, too
float m_flEndTime; // When does this box go away
OverlayBase_t *m_pNextOverlay;
};
struct OverlayBox_t : public OverlayBase_t
{
OverlayBox_t() { m_Type = OVERLAY_BOX; }
Vector origin;
Vector mins;
Vector maxs;
QAngle angles;
int r;
int g;
int b;
int a;
};
struct OverlayBox2_t : public OverlayBase_t
{
OverlayBox2_t() { m_Type = OVERLAY_BOX2; }
Vector origin;
Vector mins;
Vector maxs;
QAngle angles;
Color edgeColor;
Color faceColor;
};
struct OverlaySphere_t : public OverlayBase_t
{
OverlaySphere_t() { m_Type = OVERLAY_SPHERE; }
Vector vOrigin;
float flRadius;
int nTheta;
int nPhi;
int r;
int g;
int b;
int a;
};
struct OverlayLine_t : public OverlayBase_t
{
OverlayLine_t() { m_Type = OVERLAY_LINE; }
Vector origin;
Vector dest;
int r;
int g;
int b;
int a;
bool noDepthTest;
};
struct OverlayTriangle_t : public OverlayBase_t
{
OverlayTriangle_t() { m_Type = OVERLAY_TRIANGLE; }
Vector p1;
Vector p2;
Vector p3;
int r;
int g;
int b;
int a;
bool noDepthTest;
};
struct OverlaySweptBox_t : public OverlayBase_t
{
OverlaySweptBox_t() { m_Type = OVERLAY_SWEPT_BOX; }
Vector start;
Vector end;
Vector mins;
Vector maxs;
QAngle angles;
int r;
int g;
int b;
int a;
};
//-----------------------------------------------------------------------------
// Forward declarations
//-----------------------------------------------------------------------------
void DrawOverlays();
void DrawGridOverlay();
void ClearAllOverlays();
void ClearDeadOverlays();
//-----------------------------------------------------------------------------
// Init static member variables
//-----------------------------------------------------------------------------
OverlayText_t* s_pOverlayText = NULL; // text is handled differently; for backward compatibility reasons
OverlayBase_t* s_pOverlays = NULL;
Vector s_vGridPosition(0,0,0);
bool s_bDrawGrid = false;
CThreadFastMutex s_OverlayMutex;
//-----------------------------------------------------------------------------
// Purpose: Hack to allow this code to run on a client that's not connected to a server
// (i.e., demo playback, or multiplayer game )
// Input : ent_num -
// origin -
// mins -
// maxs -
// Output : static void
//-----------------------------------------------------------------------------
static bool GetEntityOriginClientOrServer( int ent_num, Vector& origin )
{
AUTO_LOCK( s_OverlayMutex );
// Assume failure
origin.Init();
if ( sv.IsActive() )
{
edict_t *e = EDICT_NUM( ent_num );
if ( e )
{
IServerEntity *serverEntity = e->GetIServerEntity();
if ( serverEntity )
{
CM_WorldSpaceCenter( serverEntity->GetCollideable(), &origin );
}
return true;
}
}
else
{
IClientEntity *clent = entitylist->GetClientEntity( ent_num );
if ( clent )
{
CM_WorldSpaceCenter( clent->GetCollideable(), &origin );
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Given a point, return the screen position
// Input :
// Output :
//-----------------------------------------------------------------------------
int ScreenPosition(const Vector& point, Vector& screen)
{
AUTO_LOCK( s_OverlayMutex );
CMatRenderContextPtr pRenderContext( materials );
int retval = g_EngineRenderer->ClipTransform(point,&screen);
int x, y, w, h;
pRenderContext->GetViewport( x, y, w, h );
screen[0] = 0.5 * screen[0] * w;
screen[1] = -0.5 * screen[1] * h;
screen[0] += 0.5 * w;
screen[1] += 0.5 * h;
return retval;
}
//-----------------------------------------------------------------------------
// Purpose: Given an xy screen pos (0-1), return the screen position
// Input :
// Output :
//-----------------------------------------------------------------------------
int ScreenPosition(float flXPos, float flYPos, Vector& screen)
{
if (flXPos > 1.0 || flYPos > 1.0 || flXPos < 0.0 || flYPos < 0.0 )
return 1; // Fail
AUTO_LOCK( s_OverlayMutex );
CMatRenderContextPtr pRenderContext( materials );
int x, y, w, h;
pRenderContext->GetViewport( x, y, w, h );
screen[0] = flXPos * w;
screen[1] = flYPos * h;
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: Add new entity positioned overlay text
// Input : Entity to attach text to
// How many lines to offset text from entity origin
// The text to print
// Output :
//-----------------------------------------------------------------------------
void AddEntityTextOverlay(int ent_index, int line_offset, float duration, int r, int g, int b, int a, const char *text)
{
if ( cl.IsPaused() )
return;
AUTO_LOCK( s_OverlayMutex );
OverlayText_t *new_overlay = new OverlayText_t;
Vector myPos, myMins, myMaxs;
GetEntityOriginClientOrServer( ent_index, myPos );
VectorCopy(myPos,new_overlay->origin);
Q_strncpy(new_overlay->text,text, sizeof( new_overlay->text ) );
new_overlay->bUseOrigin = true;
new_overlay->lineOffset = line_offset;
new_overlay->SetEndTime( duration );
new_overlay->r = r;
new_overlay->g = g;
new_overlay->b = b;
new_overlay->a = a;
new_overlay->nextOverlayText = s_pOverlayText;
s_pOverlayText = new_overlay;
}
//-----------------------------------------------------------------------------
// Purpose: Add new overlay text
// Input : Position of text & text
// Output :
//-----------------------------------------------------------------------------
void AddGridOverlay(const Vector& vPos)
{
if ( cl.IsPaused() )
return;
AUTO_LOCK( s_OverlayMutex );
s_vGridPosition[0] = vPos[0];
s_vGridPosition[1] = vPos[1];
s_vGridPosition[2] = vPos[2];
s_bDrawGrid = true;
}
void AddCoordFrameOverlay(const matrix3x4_t& frame, float flScale, int vColorTable[3][3]/*=NULL*/)
{
static int s_defaultColorTable[3][3] =
{
{ 255, 0, 0 },
{ 0 , 255, 0 },
{ 0 , 0, 255 }
};
AUTO_LOCK( s_OverlayMutex );
if ( vColorTable == NULL )
vColorTable = s_defaultColorTable;
Vector startPt, endPt;
MatrixGetColumn( frame, 3, startPt );
for (int k = 0; k < 3; k++)
{
endPt.x = frame[0][3] + frame[0][k] * flScale;
endPt.y = frame[1][3] + frame[1][k] * flScale;
endPt.z = frame[2][3] + frame[2][k] * flScale;
AddLineOverlay(
startPt,
endPt,
vColorTable[k][0], vColorTable[k][1], vColorTable[k][2], 255,
true,
NDEBUG_PERSIST_TILL_NEXT_SERVER
);
}
}
//-----------------------------------------------------------------------------
// Purpose: Add new overlay text
// Input : Position of text & text
// Output :
//-----------------------------------------------------------------------------
void AddTextOverlay(const Vector& textPos, float duration, const char *text)
{
if ( cl.IsPaused() )
return;
AUTO_LOCK( s_OverlayMutex );
OverlayText_t *new_overlay = new OverlayText_t;
VectorCopy(textPos,new_overlay->origin);
Q_strncpy(new_overlay->text,text, sizeof( new_overlay->text ) );
new_overlay->bUseOrigin = true;
new_overlay->lineOffset = 0;
new_overlay->SetEndTime( duration );
new_overlay->r = 255;
new_overlay->g = 255;
new_overlay->b = 255;
new_overlay->a = 255;
new_overlay->nextOverlayText = s_pOverlayText;
s_pOverlayText = new_overlay;
}
//-----------------------------------------------------------------------------
// Purpose: Add new overlay text
// Input : Position of text & text
// Output :
//-----------------------------------------------------------------------------
void AddTextOverlay(const Vector& textPos, float duration, float alpha, const char *text)
{
if ( cl.IsPaused() )
return;
AUTO_LOCK( s_OverlayMutex );
OverlayText_t *new_overlay = new OverlayText_t;
VectorCopy(textPos,new_overlay->origin);
Q_strncpy(new_overlay->text,text, sizeof( new_overlay->text ) );
new_overlay->bUseOrigin = true;
new_overlay->lineOffset = 0;
new_overlay->SetEndTime( duration );
new_overlay->r = 255;
new_overlay->g = 255;
new_overlay->b = 255;
new_overlay->a = (int)clamp(alpha * 255.f,0.f,255.f);
new_overlay->nextOverlayText = s_pOverlayText;
s_pOverlayText = new_overlay;
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void AddScreenTextOverlay(float flXPos, float flYPos, int line_offset, float duration, int r, int g, int b, int a, const char *text)
{
if ( cl.IsPaused() )
return;
AUTO_LOCK( s_OverlayMutex );
OverlayText_t *new_overlay = new OverlayText_t;
Q_strncpy(new_overlay->text,text, sizeof( new_overlay->text ) );
new_overlay->flXPos = flXPos;
new_overlay->flYPos = flYPos;
new_overlay->bUseOrigin = false;
new_overlay->lineOffset = line_offset;
new_overlay->SetEndTime( duration );
new_overlay->r = r;
new_overlay->g = g;
new_overlay->b = b;
new_overlay->a = a;
new_overlay->nextOverlayText = s_pOverlayText;
s_pOverlayText = new_overlay;
}
void AddScreenTextOverlay( float flXPos, float flYPos, float duration, int r, int g, int b, int a, const char *text )
{
AddScreenTextOverlay( flXPos, flYPos, 0, duration, r, g, b, a, text );
}
//-----------------------------------------------------------------------------
// Purpose: Add new overlay text
// Input : Position of text
// How many lines to offset text from position
// ext
// Output :
//-----------------------------------------------------------------------------
void AddTextOverlay(const Vector& textPos, int line_offset, float duration, const char *text)
{
if ( cl.IsPaused() )
return;
AUTO_LOCK( s_OverlayMutex );
OverlayText_t *new_overlay = new OverlayText_t;
VectorCopy(textPos,new_overlay->origin);
Q_strncpy(new_overlay->text,text, sizeof( new_overlay->text ) );
new_overlay->bUseOrigin = true;
new_overlay->lineOffset = line_offset;
new_overlay->SetEndTime( duration );
new_overlay->r = 255;
new_overlay->g = 255;
new_overlay->b = 255;
new_overlay->a = 255;
new_overlay->bUseOrigin = true;
new_overlay->nextOverlayText = s_pOverlayText;
s_pOverlayText = new_overlay;
}
void AddTextOverlay(const Vector& textPos, int line_offset, float duration, float alpha, const char *text)
{
if ( cl.IsPaused() )
return;
AUTO_LOCK( s_OverlayMutex );
OverlayText_t *new_overlay = new OverlayText_t;
VectorCopy(textPos,new_overlay->origin);
Q_strncpy(new_overlay->text,text, sizeof( new_overlay->text ) );
new_overlay->bUseOrigin = true;
new_overlay->lineOffset = line_offset;
new_overlay->SetEndTime( duration );
new_overlay->r = 255;
new_overlay->g = 255;
new_overlay->b = 255;
new_overlay->a = (int)clamp(alpha * 255.f,0.f,255.f);
new_overlay->bUseOrigin = true;
new_overlay->nextOverlayText = s_pOverlayText;
s_pOverlayText = new_overlay;
}
void AddTextOverlay(const Vector& textPos, int line_offset, float duration, float r, float g, float b, float alpha, const char *text)
{
if ( cl.IsPaused() )
return;
AUTO_LOCK( s_OverlayMutex );
OverlayText_t *new_overlay = new OverlayText_t;
VectorCopy(textPos,new_overlay->origin);
Q_strncpy(new_overlay->text,text, sizeof( new_overlay->text ) );
new_overlay->bUseOrigin = true;
new_overlay->lineOffset = line_offset;
new_overlay->SetEndTime( duration );
new_overlay->r = (int)clamp(r * 255.f,0.f,255.f);
new_overlay->g = (int)clamp(g * 255.f,0.f,255.f);
new_overlay->b = (int)clamp(b * 255.f,0.f,255.f);
new_overlay->a = (int)clamp(alpha * 255.f,0.f,255.f);
new_overlay->bUseOrigin = true;
new_overlay->nextOverlayText = s_pOverlayText;
s_pOverlayText = new_overlay;
}
//-----------------------------------------------------------------------------
// Purpose: Add new overlay box
// Input : Position of box
// size of box
// angles of box
// color & alpha
// duration
// Output :
//-----------------------------------------------------------------------------
void AddBoxOverlay(const Vector& origin, const Vector& mins, const Vector& maxs, QAngle const& angles, int r, int g, int b, int a, float flDuration)
{
if ( cl.IsPaused() )
return;
AUTO_LOCK( s_OverlayMutex );
OverlayBox_t *new_overlay = new OverlayBox_t;
new_overlay->origin = origin;
new_overlay->mins[0] = mins[0];
new_overlay->mins[1] = mins[1];
new_overlay->mins[2] = mins[2];
new_overlay->maxs[0] = maxs[0];
new_overlay->maxs[1] = maxs[1];
new_overlay->maxs[2] = maxs[2];
new_overlay->angles = angles;
new_overlay->r = r;
new_overlay->g = g;
new_overlay->b = b;
new_overlay->a = a;
new_overlay->SetEndTime( flDuration );
new_overlay->m_pNextOverlay = s_pOverlays;
s_pOverlays = new_overlay;
}
void AddBoxOverlay2( const Vector& origin, const Vector& mins, const Vector& maxs, QAngle const& orientation, const Color& faceColor, const Color& edgeColor, float duration )
{
if ( cl.IsPaused() )
return;
AUTO_LOCK( s_OverlayMutex );
OverlayBox2_t *new_overlay = new OverlayBox2_t;
new_overlay->origin = origin;
new_overlay->mins[0] = mins[0];
new_overlay->mins[1] = mins[1];
new_overlay->mins[2] = mins[2];
new_overlay->maxs[0] = maxs[0];
new_overlay->maxs[1] = maxs[1];
new_overlay->maxs[2] = maxs[2];
new_overlay->angles = orientation;
new_overlay->faceColor = faceColor;
new_overlay->edgeColor = edgeColor;
new_overlay->SetEndTime( duration );
new_overlay->m_pNextOverlay = s_pOverlays;
s_pOverlays = new_overlay;
}
//-----------------------------------------------------------------------------
// Purpose: Add new overlay sphere
// Input : Position of sphere
// radius of sphere
// color & alpha
// duration
// Output :
//-----------------------------------------------------------------------------
void AddSphereOverlay(const Vector& vOrigin, float flRadius, int nTheta, int nPhi, int r, int g, int b, int a, float flDuration)
{
if ( cl.IsPaused() )
return;
AUTO_LOCK( s_OverlayMutex );
OverlaySphere_t *new_overlay = new OverlaySphere_t;
new_overlay->vOrigin = vOrigin;
new_overlay->flRadius = flRadius;
new_overlay->nTheta = nTheta;
new_overlay->nPhi = nPhi;
new_overlay->r = r;
new_overlay->g = g;
new_overlay->b = b;
new_overlay->a = a;
new_overlay->SetEndTime( flDuration );
new_overlay->m_pNextOverlay = s_pOverlays;
s_pOverlays = new_overlay;
}
void AddSweptBoxOverlay(const Vector& start, const Vector& end,
const Vector& mins, const Vector& maxs, QAngle const& angles, int r, int g, int b, int a, float flDuration)
{
if ( cl.IsPaused() )
return;
AUTO_LOCK( s_OverlayMutex );
OverlaySweptBox_t *new_overlay = new OverlaySweptBox_t;
new_overlay->start = start;
new_overlay->end = end;
new_overlay->mins[0] = mins[0];
new_overlay->mins[1] = mins[1];
new_overlay->mins[2] = mins[2];
new_overlay->maxs[0] = maxs[0];
new_overlay->maxs[1] = maxs[1];
new_overlay->maxs[2] = maxs[2];
new_overlay->angles = angles;
new_overlay->r = r;
new_overlay->g = g;
new_overlay->b = b;
new_overlay->a = a;
new_overlay->SetEndTime( flDuration );
new_overlay->m_pNextOverlay = s_pOverlays;
s_pOverlays = new_overlay;
}
//-----------------------------------------------------------------------------
// Purpose: Add new overlay text
// Input : Entity to attach text to
// How many lines to offset text from entity origin
// The text to print
// Output :
//-----------------------------------------------------------------------------
void AddLineOverlay(const Vector& origin, const Vector& dest, int r, int g, int b, int a, bool noDepthTest, float flDuration)
{
if ( cl.IsPaused() )
return;
AUTO_LOCK( s_OverlayMutex );
OverlayLine_t *new_loverlay = new OverlayLine_t;
new_loverlay->origin[0] = origin[0];
new_loverlay->origin[1] = origin[1];
new_loverlay->origin[2] = origin[2];
new_loverlay->dest[0] = dest[0];
new_loverlay->dest[1] = dest[1];
new_loverlay->dest[2] = dest[2];
new_loverlay->r = r;
new_loverlay->g = g;
new_loverlay->b = b;
new_loverlay->a = a;
new_loverlay->noDepthTest = noDepthTest;
new_loverlay->SetEndTime( flDuration );
new_loverlay->m_pNextOverlay = s_pOverlays;
s_pOverlays = new_loverlay;
}
//-----------------------------------------------------------------------------
// Purpose: Add new triangle overlay
//-----------------------------------------------------------------------------
void AddTriangleOverlay(const Vector& p1, const Vector& p2, const Vector &p3,
int r, int g, int b, int a, bool noDepthTest, float flDuration)
{
if ( cl.IsPaused() )
return;
AUTO_LOCK( s_OverlayMutex );
OverlayTriangle_t *pTriangle = new OverlayTriangle_t;
pTriangle->p1 = p1;
pTriangle->p2 = p2;
pTriangle->p3 = p3;
pTriangle->r = r;
pTriangle->g = g;
pTriangle->b = b;
pTriangle->a = a;
pTriangle->noDepthTest = noDepthTest;
pTriangle->SetEndTime( flDuration );
pTriangle->m_pNextOverlay = s_pOverlays;
s_pOverlays = pTriangle;
}
//------------------------------------------------------------------------------
// Purpose : Draw a grid around the s_vGridPosition
// Input :
// Output :
//------------------------------------------------------------------------------
void DrawGridOverlay(void)
{
AUTO_LOCK( s_OverlayMutex );
static int gridSpacing = 100;
static int numHorzSpaces = 16;
static int numVertSpaces = 3;
Vector startGrid;
startGrid[0] = gridSpacing*((int)s_vGridPosition[0]/gridSpacing);
startGrid[1] = gridSpacing*((int)s_vGridPosition[1]/gridSpacing);
startGrid[2] = s_vGridPosition[2];
// Shift to the left
startGrid[0] -= (numHorzSpaces/2)*gridSpacing;
startGrid[1] -= (numHorzSpaces/2)*gridSpacing;
Vector color( 20, 180, 190 );
for (int i=1;i<numVertSpaces+1;i++)
{
// Draw x axis lines
Vector startLine;
VectorCopy(startGrid,startLine);
for (int j=0;j<numHorzSpaces+1;j++)
{
Vector endLine;
VectorCopy(startLine,endLine);
endLine[0] += gridSpacing*numHorzSpaces;
RenderLine( startLine, endLine, Color( color.x, color.y, color.z, 255 ), true );
Vector bottomStartLine;
VectorCopy(startLine,bottomStartLine);
for ( int k=0; k<numHorzSpaces+1; k++ )
{
Vector bottomEndLine;
VectorCopy(bottomStartLine,bottomEndLine);
bottomEndLine[2] -= gridSpacing;
RenderLine( bottomStartLine, bottomEndLine, Color( color.x, color.y, color.z, 255 ), true );
bottomStartLine[0] += gridSpacing;
}
startLine[1] += gridSpacing;
}
// Draw y axis lines
VectorCopy(startGrid,startLine);
for ( int j=0; j<numHorzSpaces+1; j++ )
{
Vector endLine;
VectorCopy(startLine,endLine);
endLine[1] += gridSpacing*numHorzSpaces;
RenderLine( startLine, endLine, Color( color.x, color.y, color.z, 255 ), true );
startLine[0] += gridSpacing;
}
VectorScale( color, 0.7, color );
startGrid[2] -= gridSpacing;
}
s_bDrawGrid = false;
}
//------------------------------------------------------------------------------
// Draws a generic overlay
//------------------------------------------------------------------------------
void DrawOverlay( OverlayBase_t *pOverlay )
{
AUTO_LOCK( s_OverlayMutex );
switch( pOverlay->m_Type)
{
case OVERLAY_LINE:
{
// Draw the line
OverlayLine_t *pLine = static_cast<OverlayLine_t*>(pOverlay);
RenderLine( pLine->origin, pLine->dest, Color( pLine->r, pLine->g, pLine->b, pLine->a ), !pLine->noDepthTest);
}
break;
case OVERLAY_BOX:
{
// Draw the box
OverlayBox_t *pCurrBox = static_cast<OverlayBox_t*>(pOverlay);
if ( pCurrBox->a > 0 )
{
RenderBox( pCurrBox->origin, pCurrBox->angles, pCurrBox->mins, pCurrBox->maxs, Color( pCurrBox->r, pCurrBox->g, pCurrBox->b, pCurrBox->a ), false );
}
RenderWireframeBox( pCurrBox->origin, pCurrBox->angles, pCurrBox->mins, pCurrBox->maxs, Color( pCurrBox->r, pCurrBox->g, pCurrBox->b, 255 ), true );
}
break;
case OVERLAY_BOX2:
{
// Draw the box
OverlayBox2_t *pCurrBox = static_cast<OverlayBox2_t*>(pOverlay);
if ( pCurrBox->faceColor.a() > 0 )
{
RenderBox( pCurrBox->origin, pCurrBox->angles, pCurrBox->mins, pCurrBox->maxs, pCurrBox->faceColor, false );
}
if ( pCurrBox->edgeColor.a() > 0 )
{
RenderWireframeBox( pCurrBox->origin, pCurrBox->angles, pCurrBox->mins, pCurrBox->maxs, pCurrBox->edgeColor, false );
}
}
break;
case OVERLAY_SPHERE:
{
// Draw the sphere
OverlaySphere_t *pSphere = static_cast<OverlaySphere_t*>(pOverlay);
RenderSphere( pSphere->vOrigin, pSphere->flRadius, pSphere->nTheta, pSphere->nPhi, Color( pSphere->r, pSphere->g, pSphere->b, pSphere->a ), g_pMaterialAmbientCube );
}
break;
case OVERLAY_SWEPT_BOX:
{
OverlaySweptBox_t *pBox = static_cast<OverlaySweptBox_t*>(pOverlay);
RenderWireframeSweptBox( pBox->start, pBox->end, pBox->angles, pBox->mins, pBox->maxs, Color( pBox->r, pBox->g, pBox->b, pBox->a ), true );
}
break;
case OVERLAY_TRIANGLE:
{
OverlayTriangle_t *pTriangle = static_cast<OverlayTriangle_t*>(pOverlay);
RenderTriangle( pTriangle->p1, pTriangle->p2, pTriangle->p3,
Color( pTriangle->r, pTriangle->g, pTriangle->b, pTriangle->a ), !pTriangle->noDepthTest );
}
break;
default:
Assert(0);
}
}
void DestroyOverlay( OverlayBase_t *pOverlay )
{
AUTO_LOCK( s_OverlayMutex );
switch( pOverlay->m_Type)
{
case OVERLAY_LINE:
{
OverlayLine_t *pCurrLine = static_cast<OverlayLine_t*>(pOverlay);
delete pCurrLine;
}
break;
case OVERLAY_BOX:
{
OverlayBox_t *pCurrBox = static_cast<OverlayBox_t*>(pOverlay);
delete pCurrBox;
}
break;
case OVERLAY_BOX2:
{
OverlayBox2_t *pCurrBox = static_cast<OverlayBox2_t*>(pOverlay);
delete pCurrBox;
}
break;
case OVERLAY_SPHERE:
{
OverlaySphere_t *pCurrSphere = static_cast<OverlaySphere_t*>(pOverlay);
delete pCurrSphere;
}
break;
case OVERLAY_SWEPT_BOX:
{
OverlaySweptBox_t *pCurrBox = static_cast<OverlaySweptBox_t*>(pOverlay);
delete pCurrBox;
}
break;
case OVERLAY_TRIANGLE:
{
OverlayTriangle_t *pTriangle = static_cast<OverlayTriangle_t*>(pOverlay);
delete pTriangle;
}
break;
default:
Assert(0);
}
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void DrawAllOverlays(void)
{
if ( !enable_debug_overlays.GetBool() )
return;
AUTO_LOCK( s_OverlayMutex );
OverlayBase_t* pCurrOverlay = s_pOverlays;
OverlayBase_t* pPrevOverlay = NULL;
OverlayBase_t* pNextOverlay;
while (pCurrOverlay)
{
// Is it time to kill this overlay?
if ( pCurrOverlay->IsDead() )
{
if (pPrevOverlay)
{
// If I had a last overlay reset it's next pointer
pPrevOverlay->m_pNextOverlay = pCurrOverlay->m_pNextOverlay;
}
else
{
// If the first line, reset the s_pOverlays pointer
s_pOverlays = pCurrOverlay->m_pNextOverlay;
}
pNextOverlay = pCurrOverlay->m_pNextOverlay;
DestroyOverlay( pCurrOverlay );
pCurrOverlay = pNextOverlay;
}
else
{
DrawOverlay( pCurrOverlay );
pPrevOverlay = pCurrOverlay;
pCurrOverlay = pCurrOverlay->m_pNextOverlay;
}
}
}
//------------------------------------------------------------------------------
// Purpose : Remove from the linkedlist overlays that have the special "until next
// server tick" frametime
// Input :
// Output :
//------------------------------------------------------------------------------
//0.01234f
void PurgeServerOverlays( void )
{
AUTO_LOCK( s_OverlayMutex );
OverlayBase_t* pCurrOverlay = s_pOverlays;
while (pCurrOverlay)
{
if ( pCurrOverlay->m_flEndTime == NDEBUG_PERSIST_TILL_NEXT_SERVER )
{
pCurrOverlay->m_flEndTime = cl.GetTime() + host_state.interval_per_tick;
}
pCurrOverlay = pCurrOverlay->m_pNextOverlay;
}
OverlayText_t* pCurrText = s_pOverlayText;
while (pCurrText)
{
if ( pCurrText->m_flEndTime == NDEBUG_PERSIST_TILL_NEXT_SERVER )
{
pCurrText->m_flEndTime = cl.GetTime() + host_state.interval_per_tick;
}
pCurrText = pCurrText->nextOverlayText;
}
}
void PurgeTextOverlays( void )
{
AUTO_LOCK( s_OverlayMutex );
OverlayText_t* pCurrOverlay = s_pOverlayText;
while ( pCurrOverlay )
{
if ( pCurrOverlay->m_flEndTime == 0.0f &&
pCurrOverlay->m_nCreationTick != -1 )
{
pCurrOverlay->m_nCreationTick = 0;
}
pCurrOverlay = pCurrOverlay->nextOverlayText;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void Draw3DOverlays(void)
{
// Clear overlays every frame
AUTO_LOCK( s_OverlayMutex );
static int previous_servercount = 0;
if ( previous_servercount != cl.m_nServerCount )
{
ClearAllOverlays();
previous_servercount = cl.m_nServerCount;
}
DrawAllOverlays();
if (s_bDrawGrid)
{
DrawGridOverlay();
}
}
//------------------------------------------------------------------------------
// Purpose : Deletes all overlays
// Input :
// Output :
//------------------------------------------------------------------------------
void ClearAllOverlays(void)
{
AUTO_LOCK( s_OverlayMutex );
while (s_pOverlays)
{
OverlayBase_t *pOldOverlay = s_pOverlays;
s_pOverlays = s_pOverlays->m_pNextOverlay;
DestroyOverlay( pOldOverlay );
}
while (s_pOverlayText)
{
OverlayText_t *cur_ol = s_pOverlayText;
s_pOverlayText = s_pOverlayText->nextOverlayText;
delete cur_ol;
}
s_bDrawGrid = false;
}
void ClearDeadOverlays( void )
{
AUTO_LOCK( s_OverlayMutex );
OverlayText_t* pCurrText = s_pOverlayText;
OverlayText_t* pLastText = NULL;
OverlayText_t* pNextText = NULL;
while (pCurrText)
{
// Is it time to kill this Text?
if ( pCurrText->IsDead() )
{
// If I had a last Text reset it's next pointer
if (pLastText)
{
pLastText->nextOverlayText = pCurrText->nextOverlayText;
}
// If the first Text, reset the s_pOverlayText pointer
else
{
s_pOverlayText = pCurrText->nextOverlayText;
}
pNextText = pCurrText->nextOverlayText;
delete pCurrText;
pCurrText = pNextText;
}
else
{
pLastText = pCurrText;
pCurrText = pCurrText->nextOverlayText;
}
}
}
} // end namespace CDebugOverlay
//-----------------------------------------------------------------------------
// Purpose: export debug overlay to client DLL
// Input :
// Output :
//-----------------------------------------------------------------------------
class CIVDebugOverlay : public IVDebugOverlay, public IVPhysicsDebugOverlay
{
private:
char m_text[1024];
va_list m_argptr;
public:
void AddEntityTextOverlay(int ent_index, int line_offset, float duration, int r, int g, int b, int a, const char *format, ...)
{
va_start( m_argptr, format );
Q_vsnprintf( m_text, sizeof( m_text ), format, m_argptr );
va_end( m_argptr );
CDebugOverlay::AddEntityTextOverlay(ent_index, line_offset, duration, r, g, b, a, m_text);
}
void AddBoxOverlay(const Vector& origin, const Vector& mins, const Vector& max, QAngle const& angles, int r, int g, int b, int a, float duration)
{
CDebugOverlay::AddBoxOverlay(origin, mins, max, angles, r, g, b, a, duration);
}
void AddSweptBoxOverlay(const Vector& start, const Vector& end, const Vector& mins, const Vector& max, const QAngle & angles, int r, int g, int b, int a, float flDuration)
{
CDebugOverlay::AddSweptBoxOverlay(start, end, mins, max, angles, r, g, b, a, flDuration);
}
void AddLineOverlay(const Vector& origin, const Vector& dest, int r, int g, int b, bool noDepthTest, float duration)
{
CDebugOverlay::AddLineOverlay(origin, dest, r, g, b, 255, noDepthTest, duration);
}
void AddTriangleOverlay(const Vector& p1, const Vector& p2, const Vector &p3, int r, int g, int b, int a, bool noDepthTest, float duration)
{
CDebugOverlay::AddTriangleOverlay(p1, p2, p3, r, g, b, a, noDepthTest, duration);
}
void AddTextOverlay(const Vector& origin, float duration, const char *format, ...)
{
va_start( m_argptr, format );
Q_vsnprintf( m_text, sizeof( m_text ), format, m_argptr );
va_end( m_argptr );
CDebugOverlay::AddTextOverlay(origin, duration, m_text);
}
void AddTextOverlay(const Vector& origin, int line_offset, float duration, const char *format, ...)
{
va_start( m_argptr, format );
Q_vsnprintf( m_text, sizeof( m_text ), format, m_argptr );
va_end( m_argptr );
CDebugOverlay::AddTextOverlay(origin, line_offset, duration, m_text);
}
void AddTextOverlayRGB(const Vector& origin, int line_offset, float duration, float r, float g, float b, float alpha, const char *format, ...)
{
va_start( m_argptr, format );
Q_vsnprintf( m_text, sizeof( m_text ), format, m_argptr );
va_end( m_argptr );
CDebugOverlay::AddTextOverlay(origin, line_offset, duration, r, g, b, alpha, m_text);
}
void AddTextOverlayRGB(const Vector& origin, int line_offset, float flDuration, int r, int g, int b, int alpha, const char *format, ...)
{
va_start( m_argptr, format );
Q_vsnprintf( m_text, sizeof( m_text ), format, m_argptr );
va_end( m_argptr );
CDebugOverlay::AddTextOverlay( origin, line_offset, flDuration, r * 1.0f/255.0f, g * 1.0f/255.0f, b * 1.0f/255.0f, alpha * 1.0f/255.0f, m_text );
}
void AddScreenTextOverlay(float flXPos, float flYPos,float flDuration, int r, int g, int b, int a, const char *text)
{
CDebugOverlay::AddScreenTextOverlay( flXPos, flYPos, flDuration, r, g, b, a, text );
}
void AddGridOverlay(const Vector& origin)
{
CDebugOverlay::AddGridOverlay( origin );
}
void AddCoordFrameOverlay(const matrix3x4_t& frame, float flScale, int vColorTable[3][3] = NULL)
{
CDebugOverlay::AddCoordFrameOverlay( frame, flScale, vColorTable );
}
int ScreenPosition(const Vector& point, Vector& screen)
{
return CDebugOverlay::ScreenPosition( point, screen );
}
int ScreenPosition(float flXPos, float flYPos, Vector& screen)
{
return CDebugOverlay::ScreenPosition( flXPos, flYPos, screen );
}
virtual OverlayText_t *GetFirst( void )
{
return CDebugOverlay::s_pOverlayText;
}
virtual OverlayText_t *GetNext( OverlayText_t *current )
{
return current->nextOverlayText;
}
virtual void ClearDeadOverlays( void )
{
CDebugOverlay::ClearDeadOverlays();
}
virtual void ClearAllOverlays()
{
CDebugOverlay::ClearAllOverlays();
}
void AddLineOverlayAlpha(const Vector& origin, const Vector& dest, int r, int g, int b, int a, bool noDepthTest, float duration)
{
CDebugOverlay::AddLineOverlay(origin, dest, r, g, b, a, noDepthTest, duration);
}
void AddBoxOverlay2( const Vector& origin, const Vector& mins, const Vector& maxs, QAngle const& orientation, const Color& faceColor, const Color& edgeColor, float duration )
{
CDebugOverlay::AddBoxOverlay2(origin, mins, maxs, orientation, faceColor, edgeColor, duration );
}
void PurgeTextOverlays()
{
CDebugOverlay::PurgeTextOverlays();
}
};
static CIVDebugOverlay g_DebugOverlay;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CIVDebugOverlay, IVDebugOverlay, VDEBUG_OVERLAY_INTERFACE_VERSION, g_DebugOverlay );
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CIVDebugOverlay, IVPhysicsDebugOverlay, VPHYSICS_DEBUG_OVERLAY_INTERFACE_VERSION, g_DebugOverlay );
Reference in New Issue View Git Blame Copy Permalink