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

731 lines
19 KiB
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================
#include <stdio.h>
#include "GraphPanel.h"
#include <vgui/ISystem.h>
#include <vgui/ISurface.h>
#include <vgui/IVGui.h>
#include <vgui/IScheme.h>
#include <vgui/ILocalize.h>
#include <KeyValues.h>
#include <vgui_controls/Label.h>
#include <vgui_controls/TextEntry.h>
#include <vgui_controls/Button.h>
#include <vgui_controls/ToggleButton.h>
#include <vgui_controls/RadioButton.h>
#include <vgui_controls/ListPanel.h>
#include <vgui_controls/ComboBox.h>
#include <vgui_controls/PHandle.h>
#include <vgui_controls/PropertySheet.h>
#include <vgui_controls/CheckButton.h>
#define max(a,b) (((a) > (b)) ? (a) : (b))
#define STATS_UPDATE_RATE 5.0f
// colors for the various graph lines+controls
Color CGraphPanel::CGraphsImage::CPUColor= Color(0,255,0,255); // green
Color CGraphPanel::CGraphsImage::FPSColor= Color(255,0,0,255); // red
Color CGraphPanel::CGraphsImage::NetInColor = Color(255,255,0,255); // yellow
Color CGraphPanel::CGraphsImage::NetOutColor = Color(0,255,255,255); // light blue
Color CGraphPanel::CGraphsImage::PlayersColor = Color(255,0,255,255); // purple
Color CGraphPanel::CGraphsImage::PingColor = Color(0,0,0,255); // black
//Color CGraphPanel::CGraphsImage::lineColor = Color(76,88,68,255);
using namespace vgui;
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CGraphPanel::CGraphPanel(vgui::Panel *parent, const char *name) : PropertyPage(parent, name)
{
SetMinimumSize(300,200);
m_pGraphsPanel = new ImagePanel(this,"Graphs");
m_pGraphs = new CGraphsImage();
m_pGraphsPanel->SetImage(m_pGraphs);
m_pInButton = new CheckButton(this,"InCheck","#Graph_In");
m_pOutButton = new CheckButton(this,"OutCheck","#Graph_Out");
m_pFPSButton = new CheckButton(this,"FPSCheck","#Graph_FPS");
m_pCPUButton = new CheckButton(this,"CPUCheck","#Graph_CPU");
m_pPINGButton = new CheckButton(this,"PingCheck","#Graph_Ping");
m_pPlayerButton = new CheckButton(this,"PlayersCheck","#Graph_Players");
m_pTimeCombo = new ComboBox(this, "TimeCombo",3,false);
m_pTimeCombo->AddItem("#Graph_Minutes", NULL);
int defaultItem = m_pTimeCombo->AddItem("#Graph_Hours", NULL);
m_pTimeCombo->AddItem("#Graph_Day", NULL);
m_pTimeCombo->ActivateItem(defaultItem);
m_pVertCombo = new ComboBox(this, "VertCombo",6,false);
m_pVertCombo->AddItem("#Graph_In", NULL);
m_pVertCombo->AddItem("#Graph_Out", NULL);
m_pVertCombo->AddItem("#Graph_FPS", NULL);
defaultItem = m_pVertCombo->AddItem("#Graph_CPU", NULL);
m_pVertCombo->AddItem("#Graph_Ping", NULL);
m_pVertCombo->AddItem("#Graph_Players", NULL);
m_pVertCombo->ActivateItem(defaultItem);
// now setup defaults
m_pCPUButton->SetSelected(true);
m_pInButton->SetSelected(false);
m_pOutButton->SetSelected(false);
m_pFPSButton->SetSelected(false);
m_pPINGButton->SetSelected(false);
LoadControlSettings("Admin/GraphPanel.res", "PLATFORM");
int w,h;
m_pGraphsPanel->GetSize(w,h);
m_pGraphs->SaveSize(w,h);
m_pGraphs->SetDraw(m_pCPUButton->IsSelected(),m_pFPSButton->IsSelected(),
m_pInButton->IsSelected(),m_pOutButton->IsSelected(),m_pPINGButton->IsSelected(),m_pPlayerButton->IsSelected());
m_pPINGButton->SetFgColor(m_pGraphs->GetPingColor());
m_pCPUButton->SetFgColor(m_pGraphs->GetCPUColor());
m_pFPSButton->SetFgColor(m_pGraphs->GetFPSColor());
m_pInButton->SetFgColor(m_pGraphs->GetInColor());
m_pOutButton->SetFgColor(m_pGraphs->GetOutColor());
m_pPlayerButton->SetFgColor(m_pGraphs->GetPlayersColor());
ivgui()->AddTickSignal(GetVPanel());
m_flNextStatsUpdateTime = 0;
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CGraphPanel::~CGraphPanel()
{
}
void CGraphPanel::ApplySchemeSettings( IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
m_pGraphsPanel->SetBorder( pScheme->GetBorder("ButtonDepressedBorder"));
m_pGraphs->SetBgColor(GetSchemeColor("WindowBG", pScheme));
m_pGraphs->SetAxisColor(Color(76,88,68,255));
}
//-----------------------------------------------------------------------------
// Purpose: Activates the page
//-----------------------------------------------------------------------------
void CGraphPanel::OnPageShow()
{
BaseClass::OnPageShow();
}
//-----------------------------------------------------------------------------
// Purpose: Hides the page
//-----------------------------------------------------------------------------
void CGraphPanel::OnPageHide()
{
BaseClass::OnPageHide();
}
//-----------------------------------------------------------------------------
// Purpose: called every frame to update stats page
//-----------------------------------------------------------------------------
void CGraphPanel::OnTick()
{
if (m_flNextStatsUpdateTime > system()->GetFrameTime())
return;
m_flNextStatsUpdateTime = (float)system()->GetFrameTime() + STATS_UPDATE_RATE;
RemoteServer().RequestValue(this, "stats");
}
//-----------------------------------------------------------------------------
// Purpose: tells the image about the new size
//-----------------------------------------------------------------------------
void CGraphPanel::PerformLayout()
{
BaseClass::PerformLayout();
int w,h,x,y;
m_pGraphsPanel->GetBounds(x,y,w,h);
m_pGraphs->SaveSize(w,h); // tell the image about the resize
// push the mid axis label to the middle of the image
Label *entry = dynamic_cast<Label *>(FindChildByName("AxisMid"));
if (entry)
{
int entry_x,entry_y;
entry->GetPos(entry_x,entry_y);
entry->SetPos(entry_x,y+(h/2)-8);
}
}
//-----------------------------------------------------------------------------
// Purpose: Handles stats command returns
//-----------------------------------------------------------------------------
void CGraphPanel::OnServerDataResponse(const char *value, const char *response)
{
if (!stricmp(value, "stats"))
{
// parse the stats out of the response
Points_t p;
float uptime, users;
sscanf(response, "%f %f %f %f %f %f %f", &p.cpu, &p.in, &p.out, &uptime, &users, &p.fps, &p.players);
p.cpu = p.cpu / 100; // its given as a value between 0<x<100, we want 0<x<1
p.ping = 0;
p.time = (float)system()->GetCurrentTime();
m_pGraphs->AddPoint(p);
// days:hours:minutes:seconds
char timeText[64];
_snprintf(timeText, sizeof(timeText), "%i", (int)p.players);
SetControlString("TotalUsersLabel", timeText);
// mark the vert combo has changed to force it to update graph ranges
m_pVertCombo->GetText(timeText, 64);
OnTextChanged(m_pVertCombo, timeText);
}
}
//-----------------------------------------------------------------------------
// Purpose: the paint routine for the graph image. Handles the layout and drawing of the graph image
//-----------------------------------------------------------------------------
void CGraphPanel::CGraphsImage::Paint()
{
int x,y;
float distPoints; // needs to be a float, rounding errors cause problems with lots of points
int bottom=5; // be 5 pixels above the bottom
int left=2;
int *pCpuX=NULL, *pCpuY=NULL;
int *pInX=NULL, *pInY=NULL;
int *pOutX=NULL, *pOutY=NULL;
int *pFPSX=NULL, *pFPSY=NULL;
int *pPingX=NULL, *pPingY=NULL;
int *pPlayersX=NULL, *pPlayersY=NULL;
GetSize(x,y);
SetColor(bgColor);
SetBkColor(bgColor);
DrawFilledRect(0,0,x,y);
y-=4; // borders
x-=4;
if(!cpu && !fps && !net_i && !net_o && !ping && !players) // no graphs selected
return;
if(points.Count()<2)
return; // not enough points yet...
if(x<=200 || y<=100)
return; // to small
distPoints= static_cast<float>(x)/static_cast<float>(points.Count()-1);
if(distPoints<=0)
{
distPoints=1;
}
SetColor(lineColor);
SetBkColor(lineColor);
//DrawLine(4,5,x,5);
DrawLine(4,y/2,x,y/2);
//DrawLine(4,y,x,y);
float RangePing=maxPing;
float RangeFPS=maxFPS;
float Range=0;
float RangePlayers=maxPlayers;
if(ping)
{
RangePing+=static_cast<float>(maxPing*0.1); // don't let the top of the range touch the top of the panel
if(RangePing<=1)
{ // don't let the zero be at the top of the screen
RangePing=1.0;
}
pPingX = new int[points.Count()];
pPingY = new int[points.Count()];
}
if(cpu)
{
pCpuX = new int[points.Count()];
pCpuY = new int[points.Count()];
}
if(fps)
{
RangeFPS+=static_cast<float>(maxFPS*0.1); // don't let the top of the range touch the top of the panel
if(RangeFPS<=1)
{ // don't let the zero be at the top of the screen
RangeFPS=1.0;
}
pFPSX = new int[points.Count()];
pFPSY = new int[points.Count()];
}
if(net_i)
{
// put them on a common scale, base it at zero
Range = max(maxIn,maxOut);
Range+=static_cast<float>(Range*0.1); // don't let the top of the range touch the top of the panel
if(Range<=1)
{ // don't let the zero be at the top of the screen
Range=1.0;
}
pInX = new int[points.Count()];
pInY = new int[points.Count()];
}
if(net_o)
{
// put them on a common scale, base it at zero
Range = max(maxIn,maxOut);
Range+=static_cast<float>(Range*0.1); // don't let the top of the range touch the top of the panel
if(Range<=1)
{ // don't let the zero be at the top of the screen
Range=1.0;
}
pOutX = new int[points.Count()];
pOutY = new int[points.Count()];
}
if(players)
{
RangePlayers+=static_cast<float>(maxPlayers*0.1); // don't let the top of the range touch the top of the panel
pPlayersX = new int[points.Count()];
pPlayersY = new int[points.Count()];
}
for(int i=0;i<points.Count();i++)
// draw the graphs, left to right
{
if(cpu)
{
pCpuX[i] = left+static_cast<int>(i*distPoints);
pCpuY[i] = static_cast<int>((1-points[i].cpu)*y);
}
if(net_i)
{
pInX[i] = left+static_cast<int>(i*distPoints);
pInY[i] = static_cast<int>(( (Range-points[i].in)/Range)*y-bottom);
}
if(net_o)
{
pOutX[i] = left+static_cast<int>(i*distPoints);
pOutY[i] = static_cast<int>(((Range-points[i].out)/Range)*y-bottom);
}
if(fps)
{
pFPSX[i] = left+static_cast<int>(i*distPoints);
pFPSY[i] = static_cast<int>(( (RangeFPS-points[i].fps)/RangeFPS)*y-bottom);
}
if(ping)
{
pPingX[i] = left+static_cast<int>(i*distPoints);
pPingY[i] = static_cast<int>(( (RangePing-points[i].ping)/RangePing)*y-bottom);
}
if(players)
{
pPlayersX[i] = left+static_cast<int>(i*distPoints);
pPlayersY[i] = static_cast<int>(( (RangePlayers-points[i].players)/RangePlayers)*y-bottom);
}
}
// we use DrawPolyLine, its much, much, much more efficient than calling lots of DrawLine()'s
if(cpu)
{
SetColor(CPUColor); // green
DrawPolyLine(pCpuX, pCpuY, points.Count());
delete [] pCpuX;
delete [] pCpuY;
}
if(net_i)
{
SetColor(NetInColor); // red
DrawPolyLine(pInX, pInY, points.Count());
delete [] pInX;
delete [] pInY;
}
if(net_o)
{
SetColor(NetOutColor); //yellow
DrawPolyLine(pOutX, pOutY, points.Count());
delete [] pOutX;
delete [] pOutY;
}
if(fps)
{
SetColor(FPSColor);
DrawPolyLine(pFPSX, pFPSY, points.Count());
delete [] pFPSX;
delete [] pFPSY;
}
if(ping)
{
SetColor(PingColor);
DrawPolyLine(pPingX, pPingY, points.Count());
delete [] pPingX;
delete [] pPingY;
}
if(players)
{
SetColor(PlayersColor);
DrawPolyLine(pPlayersX, pPlayersY, points.Count());
delete [] pPlayersX;
delete [] pPlayersY;
}
}
//-----------------------------------------------------------------------------
// Purpose: constructor for the graphs image
//-----------------------------------------------------------------------------
CGraphPanel::CGraphsImage::CGraphsImage(): vgui::Image(), points()
{
maxIn=maxOut=minIn=minOut=minFPS=maxFPS=minPing=maxPing=0;
net_i=net_o=fps=cpu=ping=players=false;
numAvgs=0;
memset(&avgPoint,0x0,sizeof(Points_t));
}
//-----------------------------------------------------------------------------
// Purpose: sets which graph to draw, true means draw it
//-----------------------------------------------------------------------------
void CGraphPanel::CGraphsImage::SetDraw(bool cpu_in,bool fps_in,bool net_in,bool net_out,bool ping_in,bool players_in)
{
cpu=cpu_in;
fps=fps_in;
net_i=net_in;
net_o=net_out;
ping=ping_in;
players=players_in;
}
//-----------------------------------------------------------------------------
// Purpose: used to average points over a period of time
//-----------------------------------------------------------------------------
void CGraphPanel::CGraphsImage::AvgPoint(Points_t p)
{
avgPoint.cpu += p.cpu;
avgPoint.fps += p.fps;
avgPoint.in += p.in;
avgPoint.out += p.out;
avgPoint.ping += p.ping;
avgPoint.players += p.players;
numAvgs++;
}
//-----------------------------------------------------------------------------
// Purpose: updates the current bounds of the points based on this new point
//-----------------------------------------------------------------------------
void CGraphPanel::CGraphsImage::CheckBounds(Points_t p)
{
if(p.in>maxIn)
{
maxIn=avgPoint.in;
}
if(p.out>maxOut)
{
maxOut=avgPoint.out;
}
if(p.in<minIn)
{
minIn=avgPoint.in;
}
if(p.out<minOut)
{
minOut=avgPoint.out;
}
if(p.fps>maxFPS)
{
maxFPS=avgPoint.fps;
}
if(p.fps<minFPS)
{
minFPS=avgPoint.fps;
}
if(p.ping>maxPing)
{
maxPing=avgPoint.ping;
}
if(p.ping<minPing)
{
minPing=avgPoint.ping;
}
if(p.players>maxPlayers)
{
maxPlayers=avgPoint.players;
}
if(p.players<minPlayers)
{
minPlayers=avgPoint.players;
}
}
//-----------------------------------------------------------------------------
// Purpose: adds a point to the graph image.
//-----------------------------------------------------------------------------
bool CGraphPanel::CGraphsImage::AddPoint(Points_t p)
{
int x,y;
bool recalcBounds=false;
GetSize(x,y);
if(avgPoint.cpu>1) // cpu is a percent !
{
return false;
}
if(timeBetween==SECONDS) // most recent minute
{
while(points.Count() && (p.time-points[0].time)>60)
{
points.Remove(0);
}
}
else if(timeBetween==HOURS) // most recent hour
{
while(points.Count() && (p.time-points[0].time)>60*60)
{
points.Remove(0);
}
}
else if ( timeBetween==MINUTES) // most recent day
{
while(points.Count() && (p.time-points[0].time)>60*60*24)
{
points.Remove(0);
}
}
AvgPoint(p);
// now work out the average of all the values
avgPoint.cpu /= numAvgs;
avgPoint.fps /= numAvgs;
avgPoint.in /= numAvgs;
avgPoint.out /= numAvgs;
avgPoint.ping /= numAvgs;
avgPoint.players /= numAvgs;
avgPoint.time = p.time;
numAvgs=0;
int k=0;
if(x!=0 && points.Count()> x/2)
// there are more points than pixels so thin them out
{
while(points.Count()> x/2)
{
// check that the bounds don't move
if(points[0].in==maxIn ||
points[0].out==maxOut ||
points[0].fps==maxFPS ||
points[0].ping==maxPing ||
points[0].players==maxPlayers)
{
recalcBounds=true;
}
points.Remove(k); // remove the head node
k+=2;
if(k>points.Count())
{
k=0;
}
}
}
if(recalcBounds)
{
for(int i=0;i<points.Count();i++)
{
CheckBounds(points[i]);
}
}
CheckBounds(avgPoint);
points.AddToTail(avgPoint);
memset(&avgPoint,0x0,sizeof(Points_t));
return true;
}
void CGraphPanel::CGraphsImage::SetScale(intervals time)
{
timeBetween=time;
// scale is reset so remove all the points
points.RemoveAll();
// and reset the maxes
maxIn=maxOut=minIn=minOut=minFPS=maxFPS=minPing=maxPing=maxPlayers=minPlayers=0;
}
//-----------------------------------------------------------------------------
// Purpose: clear button handler, clears the current points
//-----------------------------------------------------------------------------
void CGraphPanel::OnClearButton()
{
m_pGraphs->RemovePoints();
}
//-----------------------------------------------------------------------------
// Purpose: passes the state of the check buttons (for graph line display) through to the graph image
//-----------------------------------------------------------------------------
void CGraphPanel::OnCheckButton()
{
m_pGraphs->SetDraw(m_pCPUButton->IsSelected(), m_pFPSButton->IsSelected(), m_pInButton->IsSelected(), m_pOutButton->IsSelected(), m_pPINGButton->IsSelected(), m_pPlayerButton->IsSelected());
}
//-----------------------------------------------------------------------------
// Purpose:Handles the scale radio buttons, passes the scale to use through to the graph image
//-----------------------------------------------------------------------------
void CGraphPanel::OnTextChanged(Panel *panel, const char *text)
{
if (panel == m_pTimeCombo)
{
if (strstr(text, "Hour"))
{
m_pGraphs->SetScale(MINUTES);
}
else if (strstr(text, "Day"))
{
m_pGraphs->SetScale(HOURS);
}
else
{
m_pGraphs->SetScale(SECONDS);
}
}
else if (panel == m_pVertCombo)
{
float maxVal, minVal;
char minText[20], midText[20], maxText[20];
if (strstr(text, "CPU"))
{
SetAxisLabels(m_pGraphs->GetCPUColor(), "100%", "50%", "0%");
}
else if (strstr(text, "FPS"))
{
m_pGraphs->GetFPSLimits(maxVal, minVal);
sprintf(maxText,"%0.2f", maxVal);
sprintf(midText,"%0.2f", (maxVal - minVal) / 2);
sprintf(minText,"%0.2f", minVal);
SetAxisLabels(m_pGraphs->GetFPSColor(), maxText, midText, minText);
}
else if (strstr(text, "In"))
{
m_pGraphs->GetInLimits(maxVal, minVal);
sprintf(maxText,"%0.2f", maxVal);
sprintf(midText,"%0.2f", (maxVal - minVal) / 2);
sprintf(minText,"%0.2f", minVal);
SetAxisLabels(m_pGraphs->GetInColor(), maxText, midText, minText);
}
else if (strstr(text, "Out"))
{
m_pGraphs->GetOutLimits(maxVal, minVal);
sprintf(maxText,"%0.2f", maxVal);
sprintf(midText,"%0.2f", (maxVal - minVal) / 2);
sprintf(minText,"%0.2f", minVal);
SetAxisLabels(m_pGraphs->GetOutColor(), maxText, midText, minText);
}
else if (strstr(text, "Ping"))
{
m_pGraphs->GetPingLimits(maxVal, minVal);
sprintf(maxText,"%0.2f", maxVal);
sprintf(midText,"%0.2f", (maxVal - minVal) / 2);
sprintf(minText,"%0.2f", minVal);
SetAxisLabels(m_pGraphs->GetPingColor(), maxText, midText, minText);
}
else if (strstr(text, "Players"))
{
m_pGraphs->GetPlayerLimits(maxVal, minVal);
sprintf(maxText,"%0.2f", maxVal);
sprintf(midText,"%0.2f", (maxVal - minVal) / 2);
sprintf(minText,"%0.2f", minVal);
SetAxisLabels(m_pGraphs->GetPlayersColor(), maxText, midText, minText);
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CGraphPanel::SetAxisLabels(Color c, char *max, char *mid, char *min)
{
Label *lab;
lab= GetLabel("AxisMax");
if(lab)
{
lab->SetFgColor(c);
lab->SetText(max);
}
lab = GetLabel("AxisMid");
if(lab)
{
lab->SetFgColor(c);
lab->SetText(mid);
}
lab = GetLabel("AxisMin");
if(lab)
{
lab->SetFgColor(c);
lab->SetText(min);
}
}
Label *CGraphPanel::GetLabel(const char *name)
{
Label *lab = dynamic_cast<Label *>(FindChildByName(name));
return lab;
}