Print done when done.

1 files changed, 1084 insertions, 0 deletions

diff --git a/indra/newview/llfasttimerview.cpp b/indra/newview/llfasttimerview.cpp
new file mode 100644
index 0000000000..c8c1d0d878
--- /dev/null
+++ b/indra/newview/llfasttimerview.cpp
@@ -0,0 +1,1084 @@
+/** 
+ * @file llfasttimerview.cpp
+ * @brief LLFastTimerView class implementation
+ *
+ * Copyright (c) 2004-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "indra_constants.h"
+#include "llfasttimerview.h"
+#include "llviewerwindow.h"
+#include "llrect.h"
+#include "llerror.h"
+#include "llgl.h"
+#include "llmath.h"
+#include "llfontgl.h"
+
+#include "viewer.h"
+#include "llviewerimagelist.h"
+#include "llui.h"
+#include "llviewercontrol.h"
+#include "llstat.h"
+
+#include "llfasttimer.h"
+
+//////////////////////////////////////////////////////////////////////////////
+
+static const S32 MAX_VISIBLE_HISTORY = 10;
+static const S32 LINE_GRAPH_HEIGHT = 240;
+
+struct ft_display_info {
+	int timer;
+	const char *desc;
+	LLColor4 *color;
+	S32 disabled; // initialized to 0
+	int level; // calculated based on desc
+	int parent; // calculated
+};
+
+static LLColor4 red0(0.5f, 0.0f, 0.0f, 1.0f);
+static LLColor4 green0(0.0f, 0.5f, 0.0f, 1.0f);
+static LLColor4 blue0(0.0f, 0.0f, 0.5f, 1.0f);
+static LLColor4 blue7(0.0f, 0.0f, 0.5f, 1.0f);
+
+static LLColor4 green7(0.6f, 1.0f, 0.4f, 1.0f);
+static LLColor4 green8(0.4f, 1.0f, 0.6f, 1.0f);
+static LLColor4 green9(0.6f, 1.0f, 0.6f, 1.0f);
+
+// green(6), blue, yellow, orange, pink(2), cyan
+// red (5) magenta (4)
+static struct ft_display_info ft_display_table[] =
+{
+	{ LLFastTimer::FTM_FRAME,				"Frame",			&LLColor4::white, 0 },
+	{ LLFastTimer::FTM_MESSAGES,			" Messages",		&LLColor4::grey1, 0 },
+	{ LLFastTimer::FTM_SLEEP,				" Sleep",			&LLColor4::grey2, 0 },
+	{ LLFastTimer::FTM_IDLE,				" Idle",			&blue0, 0 },
+	{ LLFastTimer::FTM_INVENTORY,			"  Inventory Update",			&LLColor4::purple6, 1 },
+	{ LLFastTimer::FTM_AUTO_SELECT,			"   Open and Select",		&LLColor4::red, 0 },
+	{ LLFastTimer::FTM_FILTER,				"   Filter",			&LLColor4::red2, 0 },
+	{ LLFastTimer::FTM_ARRANGE,				"   Arrange",			&LLColor4::red3, 0 },
+	{ LLFastTimer::FTM_REFRESH,				"   Refresh",			&LLColor4::red4, 0 },
+	{ LLFastTimer::FTM_SORT,				"   Sort",				&LLColor4::red5, 0 },
+	{ LLFastTimer::FTM_RESET_DRAWORDER,		"  ResetDrawOrder",	&LLColor4::pink1, 0 },
+	{ LLFastTimer::FTM_WORLD_UPDATE,		"  World Update",	&LLColor4::blue1, 1 },
+	{ LLFastTimer::FTM_UPDATE_MOVE,			"   Move Objects",	&LLColor4::pink2, 0 },
+	{ LLFastTimer::FTM_OCTREE_BALANCE,		"    Octree Balance",	&LLColor4::red3, 0 },
+	{ LLFastTimer::FTM_CULL,				"   Object Cull",	&LLColor4::blue2, 0 },
+	{ LLFastTimer::FTM_CULL_REBOUND,		"    Rebound",		&LLColor4::blue3, 0 },
+	{ LLFastTimer::FTM_HUD_EFFECTS,			"   HUD Effects",	&LLColor4::orange1, 0 },
+	{ LLFastTimer::FTM_HUD_UPDATE,			"   HUD Update",	&LLColor4::orange2, 0 },
+	{ LLFastTimer::FTM_OCCLUSION,			"   Object Occlude",&LLColor4::pink1, 0 },
+	{ LLFastTimer::FTM_OCCLUSION_READBACK,	"   Occlusion Read",&LLColor4::red2, 0 },
+	{ LLFastTimer::FTM_GEO_UPDATE,			"   Geo Update",	&LLColor4::blue3, 0 },
+	{ LLFastTimer::FTM_UPDATE_PRIMITIVES,	"    Volumes",		&LLColor4::blue4, 0 },
+	{ LLFastTimer::FTM_GEN_VOLUME,			"     Gen Volume",	&LLColor4::yellow3, 0 },
+	{ LLFastTimer::FTM_GEN_FLEX,			"     Flexible",	&LLColor4::yellow4, 0 },
+	{ LLFastTimer::FTM_GEN_TRIANGLES,		"     Triangles",	&LLColor4::yellow5, 0 },
+	{ LLFastTimer::FTM_GEO_LIGHT,			"    Lighting",		&LLColor4::yellow1, 0 },
+	{ LLFastTimer::FTM_GEO_SHADOW,			"    Shadow",		&LLColor4::black, 0 },
+	{ LLFastTimer::FTM_UPDATE_PARTICLES,	"    Particles",	&LLColor4::blue5, 0 },
+	{ LLFastTimer::FTM_GEO_RESERVE,			"    Reserve",		&LLColor4::blue6, 0 },
+	{ LLFastTimer::FTM_UPDATE_LIGHTS,		"    Lights",		&LLColor4::yellow2, 0 },
+	{ LLFastTimer::FTM_UPDATE_SKY,			"  Sky Update",		&LLColor4::cyan1, 0 },
+	{ LLFastTimer::FTM_OBJECTLIST_UPDATE,	"  Object Update",	&LLColor4::purple1, 1 },
+	{ LLFastTimer::FTM_AVATAR_UPDATE,		"   Avatars",		&LLColor4::purple2, 0 },
+	{ LLFastTimer::FTM_JOINT_UPDATE,		"    Joints",		&LLColor4::purple3, 0 },
+	{ LLFastTimer::FTM_ATTACHMENT_UPDATE,	"    Attachments",	&LLColor4::purple4, 0 },
+	{ LLFastTimer::FTM_UPDATE_ANIMATION,	"    Animation",	&LLColor4::purple5, 0 },
+	{ LLFastTimer::FTM_FLEXIBLE_UPDATE,		"   Flex Update",	&LLColor4::pink2, 0 },
+	{ LLFastTimer::FTM_LOD_UPDATE,			"   LOD Update",	&LLColor4::magenta1, 0 },
+	{ LLFastTimer::FTM_REGION_UPDATE,		"  Region Update",	&LLColor4::cyan2, 0 },
+	{ LLFastTimer::FTM_NETWORK,				"  Network",		&LLColor4::orange1, 1 },
+	{ LLFastTimer::FTM_IDLE_NETWORK,		"   Decode Msgs",	&LLColor4::orange2, 0 },
+	{ LLFastTimer::FTM_PROCESS_MESSAGES,	"    Process Msgs", &LLColor4::orange3, 0 },
+	{ LLFastTimer::FTM_PROCESS_OBJECTS,		"     Object Updates",&LLColor4::orange4, 0 },
+	{ LLFastTimer::FTM_CREATE_OBJECT,		"      Create Obj",	 &LLColor4::orange5, 0 },
+//	{ LLFastTimer::FTM_LOAD_AVATAR,			"       Load Avatar", &LLColor4::pink2, 0 },
+	{ LLFastTimer::FTM_PROCESS_IMAGES,		"     Image Updates",&LLColor4::orange6, 0 },
+	{ LLFastTimer::FTM_PIPELINE,			"     Pipeline",	&LLColor4::magenta4, 0 },
+	{ LLFastTimer::FTM_CLEANUP,				"  Cleanup",		&LLColor4::cyan3, 0 },
+	{ LLFastTimer::FTM_AUDIO_UPDATE,		"  Audio Update",	&LLColor4::yellow3, 0 },
+	{ LLFastTimer::FTM_IMAGE_UPDATE,		"  Image Update",	&LLColor4::yellow4, 1 },
+	{ LLFastTimer::FTM_IMAGE_CREATE,		"   Image CreateGL",&LLColor4::yellow5, 0 },
+	{ LLFastTimer::FTM_IMAGE_DECODE,		"   Image Decode",	&LLColor4::yellow6, 0 },
+	{ LLFastTimer::FTM_VFILE_WAIT,			"  VFile Wait",		&LLColor4::cyan6, 0 },
+//	{ LLFastTimer::FTM_IDLE_CB,				"  Callbacks",		&LLColor4::pink1, 0 },
+	{ LLFastTimer::FTM_RENDER,				" Render",			&green0, 0 },
+	{ LLFastTimer::FTM_REBUILD,				"  Rebuild",		&LLColor4::green1, 1 },
+	{ LLFastTimer::FTM_STATESORT,			"   State Sort",	&LLColor4::orange1, 1 },
+	{ LLFastTimer::FTM_RENDER_GEOMETRY,		"  Geometry",		&LLColor4::green2, 1 },
+	{ LLFastTimer::FTM_POOLS,				"   Pools",			&LLColor4::green3, 0 },
+	{ LLFastTimer::FTM_POOLRENDER,			"    RenderPool",	&LLColor4::green4, 0 },
+	{ LLFastTimer::FTM_RENDER_TERRAIN,		"     Terrain",		&LLColor4::green6, 0 },
+	{ LLFastTimer::FTM_RENDER_CHARACTERS,	"     Avatars",		&LLColor4::yellow1, 0 },
+	{ LLFastTimer::FTM_RENDER_SIMPLE,		"     Simple",		&LLColor4::yellow2, 0 },
+	{ LLFastTimer::FTM_RENDER_SHINY,		"     Shiny",		&LLColor4::yellow3, 0 },
+	{ LLFastTimer::FTM_RENDER_BUMP,			"     Bump",		&LLColor4::yellow4, 0 },
+	{ LLFastTimer::FTM_RENDER_TREES,		"     Trees",		&LLColor4::yellow8, 0 },
+	{ LLFastTimer::FTM_RENDER_OCCLUSION,	"     Occlusion",	&LLColor4::red1, 0 },
+	{ LLFastTimer::FTM_RENDER_CLOUDS,		"     Clouds",		&LLColor4::yellow5, 0 },
+	{ LLFastTimer::FTM_RENDER_ALPHA,		"     Alpha",		&LLColor4::yellow6, 0 },
+	{ LLFastTimer::FTM_RENDER_HUD,			"     HUD",			&LLColor4::yellow7, 0 },
+	{ LLFastTimer::FTM_RENDER_WATER,		"     Water",		&LLColor4::yellow9, 0 },
+	{ LLFastTimer::FTM_RENDER_UI,			"  UI",				&LLColor4::cyan4, 1 },
+	{ LLFastTimer::FTM_RENDER_TIMER,		"   Timers",		&LLColor4::cyan5, 1, 0 },
+//	{ LLFastTimer::FTM_RENDER_FONTS,		"   Fonts",			&LLColor4::pink1, 0 },
+//	{ LLFastTimer::FTM_UPDATE_TEXTURES,		"  Textures",		&LLColor4::pink2, 0 },
+	{ LLFastTimer::FTM_SWAP,				"  Swap",			&LLColor4::pink1, 0 },
+	
+//	{ LLFastTimer::FTM_TEMP1,				"  Temp1",			&LLColor4::red1, 0 },
+// 	{ LLFastTimer::FTM_TEMP2,				"  Temp2",			&LLColor4::magenta1, 0 },
+// 	{ LLFastTimer::FTM_TEMP3,				"  Temp3",			&LLColor4::red2, 0 },
+// 	{ LLFastTimer::FTM_TEMP4,				"  Temp4",			&LLColor4::magenta2, 0 },
+//	{ LLFastTimer::FTM_TEMP5,				"  Temp5",			&LLColor4::red3, 0 },
+//	{ LLFastTimer::FTM_TEMP6,				"  Temp6",			&LLColor4::magenta3, 0 },
+//	{ LLFastTimer::FTM_TEMP7,				"  Temp7",			&LLColor4::red4, 0 },
+//	{ LLFastTimer::FTM_TEMP8,				"  Temp8",			&LLColor4::magenta4, 0 },
+
+	{ LLFastTimer::FTM_OTHER,				" Other",			&red0 }
+};
+static int ft_display_didcalc = 0;
+static const int FTV_DISPLAY_NUM  = (sizeof(ft_display_table)/sizeof(ft_display_table[0]));
+
+S32 ft_display_idx[FTV_DISPLAY_NUM]; // line of table entry for display purposes (for collapse)
+
+LLFastTimerView::LLFastTimerView(const std::string& name, const LLRect& rect)
+:	LLView(name, rect, TRUE)
+{
+	setVisible(FALSE);
+	mDisplayMode = 0;
+	mAvgCountTotal = 0;
+	mMaxCountTotal = 0;
+	mDisplayCenter = 1;
+	mDisplayCalls = 0;
+	mScrollIndex = 0;
+	mHoverIndex = -1;
+	mHoverBarIndex = -1;
+	mBarStart = new S32[(MAX_VISIBLE_HISTORY + 1) * FTV_DISPLAY_NUM];
+	memset(mBarStart, 0, (MAX_VISIBLE_HISTORY + 1) * FTV_DISPLAY_NUM * sizeof(S32));
+	mBarEnd = new S32[(MAX_VISIBLE_HISTORY + 1) * FTV_DISPLAY_NUM];
+	memset(mBarEnd, 0, (MAX_VISIBLE_HISTORY + 1) * FTV_DISPLAY_NUM * sizeof(S32));
+	mSubtractHidden = 0;
+	mPrintStats = -1;	
+
+	// One-time setup
+	if (!ft_display_didcalc)
+	{
+		int pidx[FTV_DISPLAY_NUM];
+		int pdisabled[FTV_DISPLAY_NUM];
+		for (S32 i=0; i < FTV_DISPLAY_NUM; i++)
+		{
+			int level = 0;
+			const char *text = ft_display_table[i].desc;
+			while(text[0] == ' ')
+			{
+				text++;
+				level++;
+			}
+			llassert(level < FTV_DISPLAY_NUM);
+			ft_display_table[i].desc = text;
+			ft_display_table[i].level = level;
+			if (level > 0)
+			{
+				ft_display_table[i].parent = pidx[level-1];
+				if (pdisabled[level-1])
+				{
+					ft_display_table[i].disabled = 3;
+				}
+			}
+			else
+			{
+				ft_display_table[i].parent = -1;
+			}
+			ft_display_idx[i] = i;
+			pidx[level] = i;
+			pdisabled[level] = ft_display_table[i].disabled;
+		}
+		ft_display_didcalc = 1;
+	}
+}
+
+LLFastTimerView::~LLFastTimerView()
+{
+	delete[] mBarStart;
+	delete[] mBarEnd;
+}
+
+EWidgetType LLFastTimerView::getWidgetType() const
+{
+	return WIDGET_TYPE_FAST_TIMER_VIEW;
+}
+
+LLString LLFastTimerView::getWidgetTag() const
+{
+	return LL_FAST_TIMER_VIEW_TAG;
+}
+
+BOOL LLFastTimerView::handleRightMouseDown(S32 x, S32 y, MASK mask)
+{
+	if (mBarRect.pointInRect(x, y))
+	{
+		S32 bar_idx = MAX_VISIBLE_HISTORY - ((y - mBarRect.mBottom) * (MAX_VISIBLE_HISTORY + 2) / mBarRect.getHeight());
+		bar_idx = llclamp(bar_idx, 0, MAX_VISIBLE_HISTORY);
+		mPrintStats = bar_idx;
+// 		return TRUE; // for now, pass all mouse events through
+	}
+	return FALSE;
+}
+
+S32 LLFastTimerView::getLegendIndex(S32 y)
+{
+	S32 idx = (mRect.getHeight() - y) / ((S32) LLFontGL::sMonospace->getLineHeight()+2) - 5;
+	if (idx >= 0 && idx < FTV_DISPLAY_NUM)
+	{
+		return ft_display_idx[idx];
+	}
+	
+	return -1;
+}
+
+BOOL LLFastTimerView::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+	if (x < mBarRect.mLeft) 
+	{
+		S32 legend_index = getLegendIndex(y);
+		if (legend_index >= 0 && legend_index < FTV_DISPLAY_NUM)
+		{
+			S32 disabled = ft_display_table[legend_index].disabled;
+			if (++disabled > 2)
+				disabled = 0;
+			ft_display_table[legend_index].disabled = disabled;
+			S32 level = ft_display_table[legend_index].level;
+
+			// propagate enable/disable to all children
+			legend_index++;
+			while (legend_index < FTV_DISPLAY_NUM && ft_display_table[legend_index].level > level)
+			{
+				ft_display_table[legend_index].disabled = disabled ? 3 : 0;
+				legend_index++;
+			}
+		}
+	}
+	else if (mask & MASK_SHIFT)
+	{
+		if (++mDisplayMode > 3)
+			mDisplayMode = 0;
+	}
+	else if (mask & MASK_CONTROL)
+	{
+		if (++mDisplayCenter > 2)
+			mDisplayCenter = 0;
+	}
+	else
+	{
+		// pause/unpause
+		LLFastTimer::sPauseHistory = !LLFastTimer::sPauseHistory;
+		// reset scroll to bottom when unpausing
+		if (!LLFastTimer::sPauseHistory)
+		{
+			mScrollIndex = 0;
+		}
+	}
+	// RN: for now, pass all mouse events through
+	return FALSE;
+}
+
+BOOL LLFastTimerView::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+	return FALSE;
+}
+
+
+BOOL LLFastTimerView::handleHover(S32 x, S32 y, MASK mask)
+{
+	if(LLFastTimer::sPauseHistory && mBarRect.pointInRect(x, y))
+	{
+		mHoverIndex = -1;
+		mHoverBarIndex = MAX_VISIBLE_HISTORY - ((y - mBarRect.mBottom) * (MAX_VISIBLE_HISTORY + 2) / mBarRect.getHeight());
+		if (mHoverBarIndex == 0)
+		{
+			return TRUE;
+		}
+		else if (mHoverBarIndex == -1)
+		{
+			mHoverBarIndex = 0;
+		}
+		for (S32 i = 0; i < FTV_DISPLAY_NUM; i++)
+		{
+			if (x > mBarStart[mHoverBarIndex * FTV_DISPLAY_NUM + i] &&
+				x < mBarEnd[mHoverBarIndex * FTV_DISPLAY_NUM + i] &&
+				ft_display_table[i].disabled <= 1)
+			{
+				mHoverIndex = i;
+			}
+		}
+	}
+	else if (x < mBarRect.mLeft) 
+	{
+		S32 legend_index = getLegendIndex(y);
+		if (legend_index >= 0 && legend_index < FTV_DISPLAY_NUM)
+		{
+			mHoverIndex = legend_index;
+		}
+	}
+	
+	return FALSE;
+}
+
+BOOL LLFastTimerView::handleScrollWheel(S32 x, S32 y, S32 clicks)
+{
+	if (getVisible() && pointInView(x, y))
+	{
+		LLFastTimer::sPauseHistory = TRUE;
+		mScrollIndex = llclamp(mScrollIndex - clicks, 
+								0, llmin(LLFastTimer::sLastFrameIndex, (S32)LLFastTimer::FTM_HISTORY_NUM-MAX_VISIBLE_HISTORY));
+		return TRUE;
+	}
+	return FALSE;
+}
+
+BOOL LLFastTimerView::handleKey(KEY key, MASK mask, BOOL called_from_parent)
+{
+	// Otherwise space key gets eaten from the rest of the UI. JC
+	if (getVisible())
+	{
+		switch (key)
+		{
+		  case '=':
+			mDisplayCalls = !mDisplayCalls;
+			return TRUE;
+		  case '-':
+			mSubtractHidden = !mSubtractHidden;
+			return TRUE;
+		  case ' ':
+			// pause/unpause
+			LLFastTimer::sPauseHistory = !LLFastTimer::sPauseHistory;
+			// reset scroll to bottom when unpausing
+			if (!LLFastTimer::sPauseHistory)
+			{
+				mScrollIndex = 0;
+			}
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
+
+void LLFastTimerView::draw()
+{
+	LLFastTimer t(LLFastTimer::FTM_RENDER_TIMER);
+	
+	std::string tdesc;
+
+	F64 clock_freq = (F64)LLFastTimer::countsPerSecond();
+	F64 iclock_freq = 1000.0 / clock_freq;
+	
+	S32 margin = 10;
+	S32 height = (S32) (gViewerWindow->getVirtualWindowRect().getHeight()*0.75f);
+	S32 width = (S32) (gViewerWindow->getVirtualWindowRect().getWidth() * 0.75f);
+	
+	mRect.setLeftTopAndSize(mRect.mLeft, mRect.mTop, width, height);
+
+	S32 left, top, right, bottom;
+	S32 x, y, barw, barh, dx, dy;
+	S32 texth, textw;
+	LLViewerImage* box_imagep = gImageList.getImage(LLUUID(gViewerArt.getString("rounded_square.tga")), MIPMAP_FALSE, TRUE);
+
+	// Make sure all timers are accounted for
+	// Set 'FTM_OTHER' to unaccounted ticks last frame
+	{
+		S32 display_timer[LLFastTimer::FTM_NUM_TYPES];
+		S32 hidx = LLFastTimer::sLastFrameIndex % LLFastTimer::FTM_HISTORY_NUM;
+		for (S32 i=0; i < LLFastTimer::FTM_NUM_TYPES; i++)
+		{
+			display_timer[i] = 0;
+		}
+		for (S32 i=0; i < FTV_DISPLAY_NUM; i++)
+		{
+			S32 tidx = ft_display_table[i].timer;
+			display_timer[tidx] = 1;
+		}
+		LLFastTimer::sCountHistory[hidx][LLFastTimer::FTM_OTHER] = 0;
+		LLFastTimer::sCallHistory[hidx][LLFastTimer::FTM_OTHER] = 0;
+		for (S32 tidx = 0; tidx < LLFastTimer::FTM_NUM_TYPES; tidx++)
+		{
+			U64 counts = LLFastTimer::sCountHistory[hidx][tidx];
+			if (counts > 0 && display_timer[tidx] == 0)
+			{
+				LLFastTimer::sCountHistory[hidx][LLFastTimer::FTM_OTHER] += counts;
+				LLFastTimer::sCallHistory[hidx][LLFastTimer::FTM_OTHER] += 1;
+			}
+		}
+		LLFastTimer::sCountAverage[LLFastTimer::FTM_OTHER] = 0;
+		LLFastTimer::sCallAverage[LLFastTimer::FTM_OTHER] = 0;
+		for (S32 h = 0; h < LLFastTimer::FTM_HISTORY_NUM; h++)
+		{
+			LLFastTimer::sCountAverage[LLFastTimer::FTM_OTHER] += LLFastTimer::sCountHistory[h][LLFastTimer::FTM_OTHER];
+			LLFastTimer::sCallAverage[LLFastTimer::FTM_OTHER] += LLFastTimer::sCallHistory[h][LLFastTimer::FTM_OTHER];
+		}
+		LLFastTimer::sCountAverage[LLFastTimer::FTM_OTHER] /= LLFastTimer::FTM_HISTORY_NUM;
+		LLFastTimer::sCallAverage[LLFastTimer::FTM_OTHER] /= LLFastTimer::FTM_HISTORY_NUM;
+	}
+	
+	// Draw the window background
+	{
+		LLGLSNoTexture gls_ui_no_texture;
+		gl_rect_2d(0, mRect.getHeight(), mRect.getWidth(), 0, LLColor4(0.f, 0.f, 0.f, 0.25f));
+	}
+	
+	S32 xleft = margin;
+	S32 ytop = margin;
+	
+	// Draw some help
+	{
+		
+		x = xleft;
+		y = height - ytop;
+		texth = (S32)LLFontGL::sMonospace->getLineHeight();
+
+		char modedesc[][32] = {
+			"2 x Average ",
+			"Max         ",
+			"Recent Max  ",
+			"100 ms      "
+		};
+		char centerdesc[][32] = {
+			"Left      ",
+			"Centered  ",
+			"Ordered   "
+		};
+
+		tdesc = llformat("Full bar = %s [Click to pause/reset] [SHIFT-Click to toggle]",modedesc[mDisplayMode]);
+		LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, LLColor4::white, LLFontGL::LEFT, LLFontGL::TOP);
+
+		textw = LLFontGL::sMonospace->getWidth(tdesc);
+
+		x = xleft, y -= (texth + 2);
+		tdesc = llformat("Justification = %s [CTRL-Click to toggle]",centerdesc[mDisplayCenter]);
+		LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, LLColor4::white, LLFontGL::LEFT, LLFontGL::TOP);
+		y -= (texth + 2);
+
+		LLFontGL::sMonospace->renderUTF8("[Right-click to log selected] [= to toggle counts] [- to subtract hidden]",
+										 0, x, y, LLColor4::white, LLFontGL::LEFT, LLFontGL::TOP);
+		y -= (texth + 2);
+	}
+
+	// Calc the total ticks
+	S32 histmax = llmin(LLFastTimer::sLastFrameIndex+1, MAX_VISIBLE_HISTORY);
+	U64 ticks_sum[LLFastTimer::FTM_HISTORY_NUM+1][FTV_DISPLAY_NUM];
+	for (S32 j=-1; j<LLFastTimer::FTM_HISTORY_NUM; j++)
+	{
+		S32 hidx;
+		if (j >= 0)
+			hidx = (LLFastTimer::sLastFrameIndex+j) % LLFastTimer::FTM_HISTORY_NUM;
+		else
+			hidx = -1;
+
+		// calculate tick info by adding child ticks to parents
+		for (S32 i=0; i < FTV_DISPLAY_NUM; i++)
+		{
+			if (mSubtractHidden && ft_display_table[i].disabled > 1)
+			{
+				continue;
+			}
+			// Get ticks
+			S32 tidx = ft_display_table[i].timer;
+			if (hidx >= 0)
+				 ticks_sum[j+1][i] = LLFastTimer::sCountHistory[hidx][tidx];
+			else
+				 ticks_sum[j+1][i] = LLFastTimer::sCountAverage[tidx];
+			S32 pidx = ft_display_table[i].parent;
+			// Add ticks to parents
+			while (pidx >= 0)
+			{
+				ticks_sum[j+1][pidx] += ticks_sum[j+1][i];
+				pidx = ft_display_table[pidx].parent;
+			}
+		}
+	}
+		
+	// Draw the legend
+
+	S32 legendwidth = 0;
+	xleft = margin;
+	ytop = y;
+
+	y -= (texth + 2);
+
+	S32 cur_line = 0;
+	S32 display_line[FTV_DISPLAY_NUM];
+	for (S32 i=0; i<FTV_DISPLAY_NUM; i++)
+	{
+		S32 disabled = ft_display_table[i].disabled;
+		if (disabled == 3)
+		{
+			continue; // skip row
+		}
+		display_line[i] = cur_line;
+		ft_display_idx[cur_line] = i;
+		cur_line++;
+		S32 level = ft_display_table[i].level;
+		S32 parent = ft_display_table[i].parent;
+		
+		x = xleft;
+
+		left = x; right = x + texth;
+		top = y; bottom = y - texth;
+		S32 scale_offset = 0;
+		if (i == mHoverIndex)
+		{
+			scale_offset = llfloor(sinf(mHighlightTimer.getElapsedTimeF32() * 6.f) * 2.f);
+		}
+		gl_rect_2d(left - scale_offset, top + scale_offset, right + scale_offset, bottom - scale_offset, *ft_display_table[i].color);
+
+		int tidx = ft_display_table[i].timer;
+		F32 ms = 0;
+		S32 calls = 0;
+		if (mHoverBarIndex > 0 && mHoverIndex >= 0)
+		{
+			S32 hidx = (LLFastTimer::sLastFrameIndex + (mHoverBarIndex - 1) - mScrollIndex) % LLFastTimer::FTM_HISTORY_NUM;
+			S32 bidx = LLFastTimer::FTM_HISTORY_NUM - mScrollIndex - mHoverBarIndex;
+			U64 ticks = ticks_sum[bidx+1][i]; // : LLFastTimer::sCountHistory[hidx][tidx];
+			ms = (F32)((F64)ticks * iclock_freq);
+			calls = (S32)LLFastTimer::sCallHistory[hidx][tidx];
+		}
+		else
+		{
+			U64 ticks = disabled >= 1 ? ticks_sum[0][i] : LLFastTimer::sCountAverage[tidx];
+			ms = (F32)((F64)ticks * iclock_freq);
+			calls = (S32)LLFastTimer::sCallAverage[tidx];
+		}
+		if (mDisplayCalls)
+		{
+			tdesc = llformat("%s (%d)",ft_display_table[i].desc,calls);
+		}
+		else
+		{
+			tdesc = llformat("%s [%.1f]",ft_display_table[i].desc,ms);
+		}
+		dx = (texth+4) + level*8;
+
+		LLColor4 color = disabled > 1 ? LLColor4::grey : LLColor4::white;
+		if (level > 0)
+		{
+			S32 line_start_y = (top + bottom) / 2;
+			S32 line_end_y = line_start_y + ((texth + 2) * (display_line[i] - display_line[parent])) - (texth / 2);
+			gl_line_2d(x + dx - 8, line_start_y, x + dx, line_start_y, color);
+			S32 line_x = x + (texth + 4) + ((level - 1) * 8);
+			gl_line_2d(line_x, line_start_y, line_x, line_end_y, color);
+			if (disabled == 1)
+			{
+				gl_line_2d(line_x+4, line_start_y-3, line_x+4, line_start_y+4, color);
+			}
+		}
+
+		x += dx;
+		BOOL is_child_of_hover_item = (i == mHoverIndex);
+		S32 next_parent = ft_display_table[i].parent;
+		while(!is_child_of_hover_item && next_parent >= 0)
+		{
+			is_child_of_hover_item = (mHoverIndex == next_parent);
+			next_parent = ft_display_table[next_parent].parent;
+		}
+
+		if (is_child_of_hover_item)
+		{
+			LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, color, LLFontGL::LEFT, LLFontGL::TOP, LLFontGL::BOLD);
+		}
+		else
+		{
+			LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, color, LLFontGL::LEFT, LLFontGL::TOP);
+		}
+		y -= (texth + 2);
+
+		textw = dx + LLFontGL::sMonospace->getWidth(ft_display_table[i].desc) + 40;
+		if (textw > legendwidth)
+			legendwidth = textw;
+	}
+	for (S32 i=cur_line; i<FTV_DISPLAY_NUM; i++)
+	{
+		ft_display_idx[i] = -1;
+	}
+	xleft += legendwidth + 8;
+	// ytop = ytop;
+
+	// update rectangle that includes timer bars
+	mBarRect.mLeft = xleft;
+	mBarRect.mRight = mRect.mRight - xleft;
+	mBarRect.mTop = ytop - ((S32)LLFontGL::sMonospace->getLineHeight() + 4);
+	mBarRect.mBottom = margin + LINE_GRAPH_HEIGHT;
+
+	y = ytop;
+	barh = (ytop - margin - LINE_GRAPH_HEIGHT) / (MAX_VISIBLE_HISTORY + 2);
+	dy = barh>>2; // spacing between bars
+	if (dy < 1) dy = 1;
+	barh -= dy;
+	barw = width - xleft - margin;
+
+	// Draw the history bars
+	if (LLFastTimer::sLastFrameIndex >= 0)
+	{	
+		U64 totalticks;
+		if (!LLFastTimer::sPauseHistory)
+		{
+			U64 ticks = 0;
+			int hidx = (LLFastTimer::sLastFrameIndex - mScrollIndex) % LLFastTimer::FTM_HISTORY_NUM;
+			for (S32 i=0; i<FTV_DISPLAY_NUM; i++)
+			{
+				if (mSubtractHidden && ft_display_table[i].disabled > 1)
+				{
+					continue;
+				}
+				int tidx = ft_display_table[i].timer;
+				ticks += LLFastTimer::sCountHistory[hidx][tidx];
+			}
+			if (LLFastTimer::sCurFrameIndex >= 10)
+			{
+				U64 framec = LLFastTimer::sCurFrameIndex;
+				U64 avg = (U64)mAvgCountTotal;
+				mAvgCountTotal = (avg*framec + ticks) / (framec + 1);
+				if (ticks > mMaxCountTotal)
+				{
+					mMaxCountTotal = ticks;
+				}
+			}
+#if 1
+			if (ticks < mAvgCountTotal/100 || ticks > mAvgCountTotal*100)
+				LLFastTimer::sResetHistory = 1;
+#endif
+			if (LLFastTimer::sCurFrameIndex < 10 || LLFastTimer::sResetHistory)
+			{
+				mAvgCountTotal = ticks;
+				mMaxCountTotal = ticks;
+			}
+		}
+
+		if (mDisplayMode == 0)
+		{
+			totalticks = mAvgCountTotal*2;
+		}
+		else if (mDisplayMode == 1)
+		{
+			totalticks = mMaxCountTotal;
+		}
+		else if (mDisplayMode == 2)
+		{
+			// Calculate the max total ticks for the current history
+			totalticks = 0;
+			for (S32 j=0; j<histmax; j++)
+			{
+				U64 ticks = 0;
+				for (S32 i=0; i<FTV_DISPLAY_NUM; i++)
+				{
+					if (mSubtractHidden && ft_display_table[i].disabled > 1)
+					{
+						continue;
+					}
+					int tidx = ft_display_table[i].timer;
+					ticks += LLFastTimer::sCountHistory[j][tidx];
+				}
+				if (ticks > totalticks)
+					totalticks = ticks;
+			}
+		}
+		else
+		{
+			totalticks = (U64)(clock_freq * .1); // 100 ms
+		}
+		
+		// Draw MS ticks
+		{
+			U32 ms = (U32)((F64)totalticks * iclock_freq) ;
+
+			tdesc = llformat("%.1f ms |", (F32)ms*.25f);
+			x = xleft + barw/4 - LLFontGL::sMonospace->getWidth(tdesc);
+			LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, LLColor4::white,
+										 LLFontGL::LEFT, LLFontGL::TOP);
+			
+			tdesc = llformat("%.1f ms |", (F32)ms*.50f);
+			x = xleft + barw/2 - LLFontGL::sMonospace->getWidth(tdesc);
+			LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, LLColor4::white,
+										 LLFontGL::LEFT, LLFontGL::TOP);
+			
+			tdesc = llformat("%.1f ms |", (F32)ms*.75f);
+			x = xleft + (barw*3)/4 - LLFontGL::sMonospace->getWidth(tdesc);
+			LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, LLColor4::white,
+										 LLFontGL::LEFT, LLFontGL::TOP);
+			
+			tdesc = llformat( "%d ms |", ms);
+			x = xleft + barw - LLFontGL::sMonospace->getWidth(tdesc);
+			LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, LLColor4::white,
+										 LLFontGL::LEFT, LLFontGL::TOP);
+		}
+
+		LLRect graph_rect;
+		// Draw borders
+		{
+			LLGLSNoTexture gls_ui_no_texture;
+			glColor4f(0.5f,0.5f,0.5f,0.5f);
+
+			S32 by = y + 2;
+			
+			y -= ((S32)LLFontGL::sMonospace->getLineHeight() + 4);
+
+			//heading
+			gl_rect_2d(xleft-5, by, mRect.getWidth()-5, y+5, FALSE);
+
+			//tree view
+			gl_rect_2d(5, by, xleft-10, 5, FALSE);
+
+			by = y + 5;
+			//average bar
+			gl_rect_2d(xleft-5, by, mRect.getWidth()-5, by-barh-dy-5, FALSE);
+			
+			by -= barh*2+dy;
+			
+			//current frame bar
+			gl_rect_2d(xleft-5, by, mRect.getWidth()-5, by-barh-dy-2, FALSE);
+			
+			by -= barh+dy+1;
+			
+			//history bars
+			gl_rect_2d(xleft-5, by, mRect.getWidth()-5, LINE_GRAPH_HEIGHT-barh-dy-2, FALSE);			
+			
+			by = LINE_GRAPH_HEIGHT-barh-dy-7;
+			
+			//line graph
+			graph_rect = LLRect(xleft-5, by, mRect.getWidth()-5, 5);
+			
+			gl_rect_2d(graph_rect, FALSE);
+		}
+		
+		// Draw bars for each history entry
+		// Special: -1 = show running average
+		LLViewerImage::bindTexture(box_imagep);
+		for (S32 j=-1; j<histmax && y > LINE_GRAPH_HEIGHT; j++)
+		{
+			int sublevel_dx[FTV_DISPLAY_NUM+1];
+			int sublevel_left[FTV_DISPLAY_NUM+1];
+			int sublevel_right[FTV_DISPLAY_NUM+1];
+			S32 tidx;
+			if (j >= 0)
+			{
+				tidx = LLFastTimer::FTM_HISTORY_NUM - j - 1 - mScrollIndex;
+			}
+			else
+			{
+				tidx = -1;
+			}
+			
+			x = xleft;
+			
+			// draw the bars for each stat
+			int xpos[FTV_DISPLAY_NUM+1];
+			int deltax[FTV_DISPLAY_NUM+1];
+			xpos[0] = xleft;
+
+			for (S32 i = 0; i < FTV_DISPLAY_NUM; i++)
+			{
+				if (ft_display_table[i].disabled > 1)
+				{
+					continue;
+				}
+
+				F32 frac = (F32)ticks_sum[tidx+1][i] / (F32)totalticks;
+		
+				dx = llround(frac * (F32)barw);
+				deltax[i] = dx;
+				
+				int level = ft_display_table[i].level;
+				int parent = ft_display_table[i].parent;
+				llassert(level < FTV_DISPLAY_NUM);
+				llassert(parent < FTV_DISPLAY_NUM);
+				
+				left = xpos[level];
+				
+				S32 prev_idx = i - 1;
+				while (prev_idx > 0)
+				{
+					if (ft_display_table[prev_idx].disabled <= 1)
+					{
+						break;
+					}
+					prev_idx--;
+				}
+				S32 next_idx = i + 1;
+				while (next_idx < FTV_DISPLAY_NUM)
+				{
+					if (ft_display_table[next_idx].disabled <= 1)
+					{
+						break;
+					}
+					next_idx++;
+				}
+
+				if (level == 0)
+						{
+					sublevel_left[level] = xleft;
+					sublevel_dx[level] = dx;
+					sublevel_right[level] = sublevel_left[level] + sublevel_dx[level];
+					}
+				else if (i==0 || ft_display_table[prev_idx].level < level)
+				{
+					// If we are the first entry at a new sublevel block, calc the
+					//   total width of this sublevel and modify left to align block.
+						U64 sublevelticks = ticks_sum[tidx+1][i];
+						for (S32 k=i+1; k<FTV_DISPLAY_NUM; k++)
+						{
+							if (ft_display_table[k].level < level)
+								break;
+							if (ft_display_table[k].disabled <= 1 && ft_display_table[k].level == level)
+								sublevelticks += ticks_sum[tidx+1][k];
+						}
+						F32 subfrac = (F32)sublevelticks / (F32)totalticks;
+					sublevel_dx[level] = (int)(subfrac * (F32)barw + .5f);
+
+					if (mDisplayCenter == 1) // center aligned
+					{
+						left += (deltax[parent] - sublevel_dx[level])/2;
+					}
+					else if (mDisplayCenter == 2) // right aligned
+					{
+						left += (deltax[parent] - sublevel_dx[level]);
+				}
+
+					sublevel_left[level] = left;
+					sublevel_right[level] = sublevel_left[level] + sublevel_dx[level];
+				}				
+
+				right = left + dx;
+				xpos[level] = right;
+				xpos[level+1] = left;
+				
+				mBarStart[(j + 1) * FTV_DISPLAY_NUM + i] = left;
+				mBarEnd[(j + 1) * FTV_DISPLAY_NUM + i] = right;
+
+				top = y;
+				bottom = y - barh;
+
+				if (right > left)
+				{
+					//U32 rounded_edges = 0;
+					LLColor4 color = *ft_display_table[i].color;
+					S32 scale_offset = 0;
+
+					BOOL is_child_of_hover_item = (i == mHoverIndex);
+					S32 next_parent = ft_display_table[i].parent;
+					while(!is_child_of_hover_item && next_parent >= 0)
+					{
+						is_child_of_hover_item = (mHoverIndex == next_parent);
+						next_parent = ft_display_table[next_parent].parent;
+					}
+
+					if (i == mHoverIndex)
+					{
+						scale_offset = llfloor(sinf(mHighlightTimer.getElapsedTimeF32() * 6.f) * 3.f);
+						//color = lerp(color, LLColor4::black, -0.4f);
+					}
+					else if (mHoverIndex >= 0 && !is_child_of_hover_item)
+					{
+						color = lerp(color, LLColor4::grey, 0.8f);
+					}
+
+					glColor4fv(color.mV);
+					F32 start_fragment = llclamp((F32)(left - sublevel_left[level]) / (F32)sublevel_dx[level], 0.f, 1.f);
+					F32 end_fragment = llclamp((F32)(right - sublevel_left[level]) / (F32)sublevel_dx[level], 0.f, 1.f);
+					gl_segmented_rect_2d_fragment_tex(sublevel_left[level], top - level + scale_offset, sublevel_right[level], bottom + level - scale_offset, box_imagep->getWidth(), box_imagep->getHeight(), 16, start_fragment, end_fragment);
+
+				}
+					
+			}
+			y -= (barh + dy);
+			if (j < 0)
+				y -= barh;
+		}
+		
+		//draw line graph history
+		{
+			LLGLSNoTexture no_texture;
+			LLGLEnable scissor(GL_SCISSOR_TEST);
+			LLUI::setScissorRegionLocal(graph_rect);
+			
+			//normalize based on last frame's maximum
+			static U64 last_max = 0;
+			static F32 alpha_interp = 0.f;
+			U64 max_ticks = llmax(last_max, (U64) 1);			
+			F32 ms = (F32)((F64)max_ticks * iclock_freq);
+			
+			//display y-axis range
+			LLString tdesc = llformat("%4.2f ms", ms);
+			x = graph_rect.mRight - LLFontGL::sMonospace->getWidth(tdesc)-5;
+			y = graph_rect.mTop - ((S32)LLFontGL::sMonospace->getLineHeight());
+ 
+			LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, LLColor4::white,
+										 LLFontGL::LEFT, LLFontGL::TOP);
+			
+			//highlight visible range
+			{
+				S32 first_frame = LLFastTimer::FTM_HISTORY_NUM - mScrollIndex;
+				S32 last_frame = first_frame - MAX_VISIBLE_HISTORY;
+				
+				F32 frame_delta = ((F32) (graph_rect.getWidth()))/(LLFastTimer::FTM_HISTORY_NUM-1);
+				
+				F32 right = (F32) graph_rect.mLeft + frame_delta*first_frame;
+				F32 left = (F32) graph_rect.mLeft + frame_delta*last_frame;
+				
+				glColor4f(0.5f,0.5f,0.5f,0.3f);
+				gl_rect_2d((S32) left, graph_rect.mTop, (S32) right, graph_rect.mBottom);
+				
+				if (mHoverBarIndex >= 0)
+				{
+					S32 bar_frame = first_frame - mHoverBarIndex;
+					F32 bar = (F32) graph_rect.mLeft + frame_delta*bar_frame;
+
+					glColor4f(0.5f,0.5f,0.5f,1);
+				
+					glBegin(GL_LINES);
+					glVertex2i((S32)bar, graph_rect.mBottom);
+					glVertex2i((S32)bar, graph_rect.mTop);
+					glEnd();
+				}
+			}
+			
+			U64 cur_max = 0;
+			for (S32 idx = 0; idx < FTV_DISPLAY_NUM; ++idx)
+			{
+				if (ft_display_table[idx].disabled > 1)
+				{	//skip disabled timers
+					continue;
+				}
+				
+				//fatten highlighted timer
+				if (mHoverIndex == idx)
+				{
+					glLineWidth(3);
+				}
+			
+				F32* col = ft_display_table[idx].color->mV;
+				
+				F32 alpha = 1.f;
+				
+				if (mHoverIndex >= 0 &&
+					idx != mHoverIndex)
+				{	//fade out non-hihglighted timers
+					if (ft_display_table[idx].parent != mHoverIndex)
+					{
+						alpha = alpha_interp;
+					}
+				}
+
+				glColor4f(col[0], col[1], col[2], alpha);				
+				glBegin(GL_LINE_STRIP);
+				for (U32 j = 0; j < LLFastTimer::FTM_HISTORY_NUM; j++)
+				{
+					U64 ticks = ticks_sum[j+1][idx];
+					if (alpha == 1.f)
+					{ //normalize to highlighted timer
+						cur_max = llmax(cur_max, ticks);
+					}
+					F32 x = graph_rect.mLeft + ((F32) (graph_rect.getWidth()))/(LLFastTimer::FTM_HISTORY_NUM-1)*j;
+					F32 y = graph_rect.mBottom + (F32) graph_rect.getHeight()/max_ticks*ticks;
+					glVertex2f(x,y);
+				}
+				glEnd();
+				
+				if (mHoverIndex == idx)
+				{
+					glLineWidth(1);
+				}
+			}
+			
+			//interpolate towards new maximum
+			F32 dt = gFrameIntervalSeconds*3.f;
+			last_max = (U64) ((F32) last_max + ((F32) cur_max- (F32) last_max) * dt);
+			F32 alpha_target = last_max > cur_max ?
+								llmin((F32) last_max/ (F32) cur_max - 1.f,1.f) :
+								llmin((F32) cur_max/ (F32) last_max - 1.f,1.f);
+			
+			alpha_interp = alpha_interp + (alpha_target-alpha_interp) * dt;
+								
+		}
+	}
+
+	// Output stats for clicked bar to log
+	if (mPrintStats >= 0)
+	{
+		LLString legend_stat;
+		S32 stat_num;
+		S32 first = 1;
+		for (stat_num = 0; stat_num < FTV_DISPLAY_NUM; stat_num++)
+		{
+			if (ft_display_table[stat_num].disabled > 1)
+				continue;
+			if (!first)
+				legend_stat += ", ";
+			first=0;
+			legend_stat += ft_display_table[stat_num].desc;
+		}
+		llinfos << legend_stat << llendl;
+
+		LLString timer_stat;
+		first = 1;
+		for (stat_num = 0; stat_num < FTV_DISPLAY_NUM; stat_num++)
+		{
+			S32 disabled = ft_display_table[stat_num].disabled;
+			if (disabled > 1)
+				continue;
+			if (!first)
+				timer_stat += ", ";
+			first=0;
+			U64 ticks;
+			S32 tidx = ft_display_table[stat_num].timer;
+			if (mPrintStats > 0)
+			{
+				S32 hidx = (LLFastTimer::sLastFrameIndex+(mPrintStats-1)-mScrollIndex) % LLFastTimer::FTM_HISTORY_NUM;
+				ticks = disabled >= 1 ? ticks_sum[mPrintStats][stat_num] : LLFastTimer::sCountHistory[hidx][tidx];
+			}
+			else
+			{
+				ticks = disabled >= 1 ? ticks_sum[0][stat_num] : LLFastTimer::sCountAverage[tidx];
+			}
+			F32 ms = (F32)((F64)ticks * iclock_freq);
+
+			timer_stat += llformat("%.1f",ms);
+		}
+		llinfos << timer_stat << llendl;
+		mPrintStats = -1;
+	}
+		
+	mHoverIndex = -1;
+	mHoverBarIndex = -1;
+
+	LLView::draw();
+}
+
+F64 LLFastTimerView::getTime(LLFastTimer::EFastTimerType tidx)
+{
+	// Find table index
+	S32 i;
+	for (i=0; i<FTV_DISPLAY_NUM; i++)
+	{
+		if (tidx == ft_display_table[i].timer)
+		{
+			break;
+		}
+	}
+	S32 table_idx = i;
+	
+	// Add child ticks to parent
+	U64 ticks = LLFastTimer::sCountAverage[tidx];
+	S32 level = ft_display_table[table_idx].level;
+	for (i=table_idx+1; i<FTV_DISPLAY_NUM; i++)
+	{
+		if (ft_display_table[i].level <= level)
+		{
+			break;
+		}
+		ticks += LLFastTimer::sCountAverage[ft_display_table[i].timer];
+	}
+
+	return (F64)ticks / (F64)LLFastTimer::countsPerSecond();
+}