CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plStatGather/plProfileManagerFull.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "plProfileManagerFull.h"
#include "plProfileManager.h"

#include "../plPipeline/plDebugText.h"
#include "../plPipeline/plPlates.h"

#include "plCalculatedProfiles.h"

#include "hsStream.h"
#include "../pnUtils/pnUtils.h"
#include "../plUnifiedTime/plUnifiedTime.h"
#include "../plFile/plFileUtils.h"

plProfileManagerFull::plProfileManagerFull() :
	fVars(plProfileManager::Instance().fVars),
	fLogStats(false),
	fShowLaps(nil),
	fMinLap(0),
	fDetailGraph(nil)
{
}

plProfileManagerFull& plProfileManagerFull::Instance()
{
	static plProfileManagerFull theInstance;
	return theInstance;
}

void plProfileManagerFull::GetGroups(GroupSet& groups)
{
	groups.clear();
	for (int i = 0; i < fVars.size(); i++)
		groups.insert(fVars[i]->GetGroup());
}

void plProfileManagerFull::ShowGroup(const char* groupName)
{
	if (!groupName)
		groupName = "General";

	// If we're already showing this group, stop
	if (fShowGroups.find(groupName) != fShowGroups.end())
	{
		CreateStandardGraphs(groupName, false);
		fShowGroups.erase(groupName);
		ISetActive(groupName, false);
	}
	else
	{
		const char* shareGroupName = nil;
		for (int i = 0; i < fVars.size(); i++)
		{
			if (stricmp(fVars[i]->GetGroup(), groupName) == 0)
			{
				shareGroupName = fVars[i]->GetGroup();
			}
		}

		// We do have a group with this name, so insert one of the variable's
		// pointers to the name into our list (we can hang on to those pointers)
		if (shareGroupName)
		{
			ISetActive(shareGroupName, true);
			CreateStandardGraphs(shareGroupName, true);
			fShowGroups.insert(shareGroupName);
		}
	}
}

void plProfileManagerFull::ShowNextGroup()
{
	const char* curGroup = nil;
	if (fShowGroups.begin() != fShowGroups.end())
		curGroup = *(fShowGroups.begin());

	GroupSet groups;
	GetGroups(groups);

	const char* nextGroup = nil;
	if (curGroup)
	{
		CreateStandardGraphs(curGroup, false);

		GroupSet::iterator it = groups.find(curGroup);
		it++;
		if (it != groups.end())
		{
			nextGroup = *it;
		}
		ISetActive(curGroup,false);
	}
	else
	{
		nextGroup = *(groups.begin());
	}

	fShowGroups.clear();
	if (nextGroup)
	{
		ISetActive(nextGroup, true);
		CreateStandardGraphs(nextGroup, true);
		fShowGroups.insert(nextGroup);
	}
}

plProfileVar* plProfileManagerFull::IFindTimer(const char *name)
{
	for (int i = 0; i < fVars.size(); i++)
	{
		if (stricmp(fVars[i]->GetName(), name) == 0)
			return fVars[i];
	}

	return nil;
}

void plProfileManagerFull::GetLaps(LapNames& lapNames)
{
	for (int i = 0; i < fVars.size(); i++)
	{
		plProfileVar* var = fVars[i];
		if (var->GetLaps())
		{
			LapPair lapPair;
			lapPair.group = var->GetGroup();
			lapPair.varName = var->GetName();
			lapNames.push_back(lapPair);
		}
	}
}


enum
{
	kColName,
	kColValue,
	kColAvg,
	kColMax,
	kColIndex,
};

typedef std::vector<plProfileBase*> ProfileGroup;

static void PrintColumn(ProfileGroup& group, const char* groupName, int column, int x, int y, int& width, int& height, int off =0)
{
	plDebugText& txt = plDebugText::Instance();
	int yInc = txt.GetFontHeight() + 2;

	height = 0;
	width = 0;

	width = hsMaximum(width, txt.CalcStringWidth(groupName) + 1);
	txt.DrawString(x, y+height, groupName, 255, 255, 255, 255, plDebugText::kStyleBold);
	height += yInc;

	UInt32 samplesWidth = txt.CalcStringWidth("[000]");

	for (int i = 0; i < group.size(); i++)
	{
		char str[1024];

		switch (column)
		{
		case kColName:
			strcpy(str, group[i]->GetName());

			// Since we don't draw the samples text for stats that only have 1 sample, 
			// if the stat with the longest name is fluctuating between 1 and more than
			// 1 sample the width of the column will jump around.  So we calculate the
			// width based on the stat name plus the width of the widest sample we should
			// get
			width = hsMaximum(width, txt.CalcStringWidth(str) + samplesWidth + 1);

			// Now add on the samples text, if we have any
			if (group[i]->GetTimerSamples())
			{
				char cnt[20];
				sprintf(cnt, "[%d]", group[i]->GetTimerSamples());
				strcat(str, cnt);
			}
			break;
		case kColValue:
			group[i]->PrintValue(str);
			break;
		case kColAvg:
			group[i]->PrintAvg(str);
			break;
		case kColMax:
			group[i]->PrintMax(str);
			break;
		case kColIndex:
			sprintf(str,"[%3d]",i+off);
			break;
		}

		txt.DrawString(x, y+height, str);
		if (column != kColName)
			width = hsMaximum(width, txt.CalcStringWidth(str) + 1);
		height += yInc;
	}

	// So the columns don't jump around as much as values change, pad them out to a certain width
	width = hsMaximum(width, txt.CalcStringWidth("000.0 ms") + 1);
}

static void PrintGroup(ProfileGroup& group, const char* groupName, int& x, int& y)
{
	int width, height;

	PrintColumn(group, groupName, kColName, x, y, width, height);
	x += width + 10;

	PrintColumn(group, "Avg", kColAvg, x, y, width, height);
	x += width + 10;

	PrintColumn(group, "Cur", kColValue, x, y, width, height);
	x += width + 10;

	PrintColumn(group, "Max", kColMax, x, y, width, height);
	x += width + 10;

	y += height;
}


static void PrintLapGroup(ProfileGroup& group, const char* groupName, int& x, int& y, int min)
{
	int width, height;

	if(min > 0)
	{
		PrintColumn(group, "Index", kColIndex, x, y, width, height, min);
		x += width + 10;
	}

	PrintColumn(group, "Avg", kColAvg, x, y, width, height);
	x += width + 10;
	
	PrintColumn(group, groupName, kColName, x, y, width, height);
	x += width + 10;

	PrintColumn(group, "Cur", kColValue, x, y, width, height);
	x += width + 10;

	y += height;
}

void plProfileManagerFull::EndFrame()
{
	CalculateProfiles();
}

void plProfileManagerFull::Update()
{
	if (fLogStats)
		ILogStats();

	//
	// Print the groups we're showing
	//
	int maxX = 0;

	int y = 10;
	GroupSet::iterator it;
	for (it = fShowGroups.begin(); it != fShowGroups.end(); it++)
	{
		const char* groupName = *it;

		std::vector<plProfileBase*> group;

		for (int i = 0; i < fVars.size(); i++)
			if (hsStrEQ(fVars[i]->GetGroup(), groupName))
				group.push_back(fVars[i]);

		int x = 10;
		PrintGroup(group, groupName, x, y);

		maxX = hsMaximum(maxX, x);
		y += 10;
	}

	//
	// Print the laps we're showing
	//
	if (fShowLaps && fShowLaps->GetLaps())
	{
		plProfileLaps* laps = fShowLaps->GetLaps();

		std::vector<plProfileBase*> group;
		int numLaps = laps->GetNumLaps();
		
		if(numLaps < fMinLap)
			fMinLap = 0;
		for (int i = 0; i < numLaps; i++)
		{
			if(i >= fMinLap && i < (fMinLap + 40))
				group.push_back(laps->GetLap(i));
		}
		y = 10;
		char buf[256];
		sprintf(buf, "%s - %s", fShowLaps->GetGroup(), fShowLaps->GetName());
		PrintLapGroup(group, buf, maxX, y, fMinLap);
	}

	//
	// Update the graphs
	//
	float size = 0.25;
	float xPos = 1 - size / 2;
	float yPos = -1 + size / 2;

	for (int i = 0; i < fGraphs.size(); i++)
	{
		plGraphPlate* graph = fGraphs[i];
		plProfileVar* var = IFindTimer(graph->GetTitle());

		if (var)
		{
			graph->SetPosition(xPos, yPos);
			graph->AddData(var->GetValue());
			graph->SetVisible(true);

			yPos += size;
		}
	}

	UpdateStandardGraphs(xPos, yPos);

	float detailSize = 0.9;
	float detailX = 1 - detailSize / 2;
	float detailY = 1 - detailSize / 2;
	if (fDetailGraph)
	{
		fDetailGraph->SetPosition(detailX,detailY);
		double value;
		double scale;
		int i;
		std::vector<Int32> values;
		for (i=0; i<fDetailVars.size(); i++)
		{
			value = (double)fDetailVars[i].var->GetValue();
			scale = 100.0/((double)(fDetailVars[i].max-fDetailVars[i].min));
			value = scale*value-fDetailVars[i].min;
			values.push_back((Int32)value);
		}
		fDetailGraph->AddData(values);
		fDetailGraph->SetVisible(true);
	}
}

void plProfileManagerFull::ActivateAllStats()
{
	for (int i = 0; i < fVars.size(); i++)
	{
		fVars[i]->SetActive(true);
		fVars[i]->Start();
	}
}

void plProfileManagerFull::IPrintGroup(hsStream* s, const char* groupName, bool printTitle)
{
	char buf[256];

	for (int i = 0; i < fVars.size(); i++)
	{
		plProfileVar* var = fVars[i];
		if (hsStrEQ(var->GetGroup(), groupName))
		{
			if (printTitle)
				sprintf(buf, "%s:%s", var->GetGroup(), var->GetName());
			else
				var->PrintAvg(buf, false);

			s->Write(strlen(buf), buf);
			s->WriteByte(',');
		}
	}
}

void plProfileManagerFull::LogStats(const char* ageName, const char* spawnName)
{
	fLogStats = true;
	wchar* temp = hsStringToWString(ageName);
	fLogAgeName = temp;
	delete [] temp;
	fLogSpawnName = spawnName;
}

const wchar* plProfileManagerFull::GetProfilePath()
{
	static wchar profilePath[MAX_PATH];
	static bool initialized = false;

	if (!initialized)
	{
		initialized = true;

		plUnifiedTime curTime = plUnifiedTime::GetCurrentTime(plUnifiedTime::kLocal);

		PathGetUserDirectory(profilePath, arrsize(profilePath));
		PathAddFilename(profilePath, profilePath, L"Profile", arrsize(profilePath));
		plFileUtils::CreateDir(profilePath);
	
		wchar buff[256];
		swprintf(buff, L"%02d-%02d-%04d_%02d-%02d//",
			curTime.GetMonth(),
			curTime.GetDay(),
			curTime.GetYear(),
			curTime.GetHour(),
			curTime.GetMinute());

		PathAddFilename(profilePath, profilePath, buff, arrsize(profilePath));
		plFileUtils::CreateDir(profilePath);
	}

	return profilePath;
}

void plProfileManagerFull::ILogStats()
{
	wchar statFilename[256];
	swprintf(statFilename, L"%s%s.csv", GetProfilePath(), fLogAgeName.c_str());

	bool exists = plFileUtils::FileExists(statFilename);

	hsUNIXStream s;
	if (s.Open(statFilename, L"ab"))
	{
		GroupSet groups;
		GetGroups(groups);

		GroupSet::iterator it;

		if (!exists)
		{
			const char* kSpawn = "Spawn";
			s.Write(strlen(kSpawn), kSpawn);
			s.WriteByte(',');

			for (it = groups.begin(); it != groups.end(); it++)
			{
				const char* groupName = *it;
				IPrintGroup(&s, groupName, true);
			}
			s.WriteByte('\r');
			s.WriteByte('\n');
		}

		s.Write(fLogSpawnName.length(), fLogSpawnName.c_str());
		s.WriteByte(',');

		for (it = groups.begin(); it != groups.end(); it++)
		{
			const char* groupName = *it;
			IPrintGroup(&s, groupName);
		}
		s.WriteByte('\r');
		s.WriteByte('\n');

		s.Close();
	}

	fLogStats = false;
	fLogAgeName = L"";
	fLogSpawnName = "";
}


void plProfileManagerFull::ShowLaps(const char* groupName, const char* varName)
{
	plProfileVar* var = nil;


	if(fShowLaps)
		fShowLaps->SetLapsActive(false);

	for (int i = 0; i < fVars.size(); i++)
	{
		int j = 0;
		while(fVars[i]->GetName()[j++] == ' ') {}
		if (stricmp(&(fVars[i]->GetName()[j-1]), varName) == 0 &&
			stricmp(fVars[i]->GetGroup(), groupName) == 0)
		{
			var = fVars[i];
			break;
		}
	}

	if (var)
	{
		if (var == fShowLaps)
		{
	
			fShowLaps = nil;
		}
		else 
		{
			fShowLaps = var;
		}
	}
	if(fShowLaps)
		fShowLaps->SetLapsActive(true);
}

void plProfileManagerFull::CreateGraph(const char* varName, UInt32 min, UInt32 max)
{
	// If the graph is already created, destroy it
	for (int i = 0; i < fGraphs.size(); i++)
	{
		if (strcmp(fGraphs[i]->GetTitle(), varName) == 0)
		{
			plPlateManager::Instance().DestroyPlate(fGraphs[i]);
			fGraphs.erase(fGraphs.begin()+i);
			return;
		}
	}

	plProfileVar* var = IFindTimer(varName);
	if (var)
	{
		plGraphPlate* graph = nil;
		plPlateManager::Instance().CreateGraphPlate(&graph);
		graph->SetSize(0.25, 0.25);
		graph->SetDataRange(min, max, 100);
		graph->SetTitle(var->GetName());

		fGraphs.push_back(graph);
	}
}

void plProfileManagerFull::ResetDefaultDetailVars()
{
	fDetailVars.clear();
	AddDetailVar("ApplyAnimation",0,50);
	AddDetailVar("AnimatingPhysicals",0,50);
	AddDetailVar("StoppedAnimPhysicals",0,50);
	AddDetailVar("DrawableTime",0,50);
	AddDetailVar("Polys",0,150000);
	AddDetailVar("Step",0,50);
	AddDetailVar("LineOfSight",0,50);
	AddDetailVar("  PhysicsUpdates",0,50);
	AddDetailVar("Stream Shove Time",0,50);
	AddDetailVar("RenderSetup",0,50);
}

void plProfileManagerFull::ShowDetailGraph()
{
	// if graph is already created, kill it
	if (fDetailGraph)
		HideDetailGraph();
	if (fDetailVars.size() == 0)
		ResetDefaultDetailVars();
	
	plPlateManager::Instance().CreateGraphPlate(&fDetailGraph);
	fDetailGraph->SetSize(0.9,0.9);
	fDetailGraph->SetDataRange(0,500,500);
	fDetailGraph->SetDataLabels(0,100); // should be relatively simple to cast everything to a 0-100 range
	fDetailGraph->SetTitle("Detail");
	UpdateDetailLabels();
}

void plProfileManagerFull::HideDetailGraph()
{
	if (fDetailGraph)
	{
		plPlateManager::Instance().DestroyPlate(fDetailGraph);
		fDetailGraph = nil;
	}
}

void plProfileManagerFull::AddDetailVar(const char* varName, UInt32 min, UInt32 max)
{
	int i=0;
	for (i=0; i<fDetailVars.size(); i++)
	{
		if (stricmp(fDetailVars[i].var->GetName(), varName) == 0)
			return; // don't add it again
	}

	plProfileVar* var = IFindTimer(varName);
	if (!var)
		return;
	var->SetActive(true);

	if (fDetailVars.size() == 10)
		fDetailVars.erase(fDetailVars.begin()); // we don't want any more then 10 at this point, so drop the oldest one
	detailVar temp;
	temp.var = var;
	temp.min = min;
	temp.max = max;
	fDetailVars.push_back(temp);
	UpdateDetailLabels();
}

void plProfileManagerFull::RemoveDetailVar(const char* varName)
{
	int i=0;
	for (i=0; i<fDetailVars.size(); i++)
	{
		if (stricmp(fDetailVars[i].var->GetName(), varName) == 0)
		{
			fDetailVars.erase(fDetailVars.begin()+i);
		}
	}
	UpdateDetailLabels();
}

void plProfileManagerFull::UpdateDetailLabels()
{
	if (fDetailGraph)
	{
		int i;
		std::vector<std::string> labels;
		for (i=0; i<fDetailVars.size(); i++)
			labels.push_back(fDetailVars[i].var->GetName());

		fDetailGraph->SetLabelText(labels);

		// update the colors as well, just in case
		std::vector<UInt32> colors;
		colors.push_back(0xff00ff00); // green
		colors.push_back(0xff0000ff); // blue
		colors.push_back(0xffffff00); // yellow
		colors.push_back(0xffff00ff); // pink
		colors.push_back(0xffffffff); // white
		colors.push_back(0xff00ffff); // cyan
		colors.push_back(0xffff8000); // orange
		colors.push_back(0xff8000ff); // purple
		colors.push_back(0xffff0080); // fuscha
		colors.push_back(0xff808080); // grey

		fDetailGraph->SetDataColors(colors);
	}
}

void plProfileManagerFull::ResetMax()
{
	for (int i = 0; i < fVars.size(); i++)
		fVars[i]->ResetMax();
}

void plProfileManagerFull::ISetActive(const char* groupName, bool active)
{
	for (int i = 0; i < fVars.size(); i++)
	{
		if (stricmp(fVars[i]->GetGroup(), groupName) == 0)
		{
			fVars[i]->SetActive(active);
		}
	}
}