internal static void UpdateSingleChart(ProfilerChart chart, int firstEmptyFrame, int firstFrame)
{
float totalMaxValue = 1;
int unstackableChartIndex = -1;
var maxValues = new float[chart.m_Series.Length];
for (int i = 0, count = chart.m_Series.Length; i < count; ++i)
{
int identifier = ProfilerDriver.GetStatisticsIdentifierForArea(chart.m_Area, chart.m_Series[i].name);
float maxValue;
ProfilerDriver.GetStatisticsValues(identifier, firstEmptyFrame, 1.0f, chart.m_Series[i].yValues, out maxValue);
chart.m_Series[i].yScale = chart.m_DataScale;
maxValue *= chart.m_DataScale;
// Minimum size so we don't generate nans during drawing
maxValue = Mathf.Max(maxValue, 0.0001F);
if (maxValue > totalMaxValue)
{
totalMaxValue = maxValue;
}
if (chart.m_Type == Chart.ChartType.Line)
{
// Scale line charts so they never hit the top. Scale them slightly differently for each line
// so that in "no stuff changing" case they will not end up being exactly the same.
maxValues[i] = maxValue * (1.05f + i * 0.05f);
chart.m_Series[i].rangeAxis = new Vector2(0f, maxValues[i]);
}
else
{
maxValues[i] = maxValue;
if (chart.m_Area == ProfilerArea.CPU)
{
if (chart.m_Series[i].name == k_CPUUnstackableSeriesName)
{
unstackableChartIndex = i;
break;
}
}
}
}
if (chart.m_Area == ProfilerArea.NetworkMessages || chart.m_Area == ProfilerArea.NetworkOperations)
{
for (int i = 0, count = chart.m_Series.Length; i < count; ++i)
{
chart.m_Series[i].rangeAxis = new Vector2(0f, 0.9f * totalMaxValue);
}
chart.m_Data.maxValue = totalMaxValue;
}
chart.m_Data.Assign(chart.m_Series, unstackableChartIndex, firstEmptyFrame, firstFrame);
ProfilerDriver.GetStatisticsAvailable(chart.m_Area, firstEmptyFrame, chart.m_Data.dataAvailable);
if (chart is UISystemProfilerChart)
{
((UISystemProfilerChart)chart).Update(firstFrame, ProfilerDriver.maxHistoryLength - 1);
}
}
void OnChartClosed(Chart sender)
{
ProfilerChart profilerChart = (ProfilerChart)sender;
profilerChart.active = false;
m_ProfilerModules[(int)profilerChart.m_Area].OnDisable();
m_ProfilerModules[(int)profilerChart.m_Area].OnClosed();
m_CurrentArea = null;
GUIUtility.ExitGUI();
}
ProfilerChart CreateProfilerChart(ProfilerArea i, Chart.ChartType chartType, float scale, int length)
{
ProfilerChart newChart = (i == ProfilerArea.UIDetails)
? new UISystemProfilerChart(chartType, scale, length)
: new ProfilerChart(i, chartType, scale, length);
newChart.selected += OnChartSelected;
newChart.closed += OnChartClosed;
return(newChart);
}
void OnLostFocus()
{
if (GUIUtility.hotControl != 0)
{
// The chart may not have had the chance to release the hot control before we lost focus.
// This happens when changing the selected frame, which may pause the game and switch the focus to another view.
for (int c = 0; c < m_Charts.Length; ++c)
{
ProfilerChart chart = m_Charts[c];
chart.OnLostFocus();
}
}
}
private void ComputeChartScaleValue(ProfilerArea i, int historyLength, int firstEmptyFrame, int firstFrame)
{
ProfilerChart chart = m_Charts[(int)i];
float timeMax = 0.0f;
float timeMaxExcludeFirst = 0.0f;
for (int k = 0; k < historyLength; k++)
{
float timeNow = 0.0F;
for (int j = 0; j < chart.m_Series.Length; j++)
{
var series = chart.m_Data.unstackableSeriesIndex == j && chart.m_Data.hasOverlay ?
chart.m_Data.overlays[j] : chart.m_Series[j];
if (series.enabled)
{
timeNow += series.yValues[k];
}
}
if (timeNow > timeMax)
{
timeMax = timeNow;
}
if (timeNow > timeMaxExcludeFirst && k + firstEmptyFrame >= firstFrame + 1)
{
timeMaxExcludeFirst = timeNow;
}
}
if (timeMaxExcludeFirst != 0.0f)
{
timeMax = timeMaxExcludeFirst;
}
timeMax = Math.Min(timeMax * chart.m_DataScale, m_ChartMaxClamp);
// Do not apply the new scale immediately, but gradually go towards it
if (m_ChartOldMax[(int)i] > 0.0f)
{
timeMax = Mathf.Lerp(m_ChartOldMax[(int)i], timeMax, 0.4f);
}
m_ChartOldMax[(int)i] = timeMax;
for (int k = 0; k < chart.m_Data.numSeries; ++k)
{
chart.m_Data.series[k].rangeAxis = new Vector2(0f, timeMax);
}
UpdateChartGrid(timeMax, chart.m_Data);
}
private void Initialize()
{
int len = ProfilerDriver.maxHistoryLength - 1;
this.m_Charts = new ProfilerChart[7];
Color[] colors = ProfilerColors.colors;
for (ProfilerArea profilerArea = ProfilerArea.CPU; profilerArea < ProfilerArea.AreaCount; profilerArea++)
{
float dataScale = 1f;
Chart.ChartType type = Chart.ChartType.Line;
string[] graphStatisticsPropertiesForArea = ProfilerDriver.GetGraphStatisticsPropertiesForArea(profilerArea);
int num = graphStatisticsPropertiesForArea.Length;
if (profilerArea == ProfilerArea.GPU || profilerArea == ProfilerArea.CPU)
{
type = Chart.ChartType.StackedFill;
dataScale = 0.001f;
}
ProfilerChart profilerChart = new ProfilerChart(profilerArea, type, dataScale, num);
for (int i = 0; i < num; i++)
{
profilerChart.m_Series[i] = new ChartSeries(graphStatisticsPropertiesForArea[i], len, colors[i]);
}
this.m_Charts[(int)profilerArea] = profilerChart;
}
if (this.m_ReferenceListView == null)
{
this.m_ReferenceListView = new MemoryTreeList(this, null);
}
if (this.m_MemoryListView == null)
{
this.m_MemoryListView = new MemoryTreeListClickable(this, this.m_ReferenceListView);
}
this.UpdateCharts();
this.BuildColumns();
ProfilerChart[] charts = this.m_Charts;
for (int j = 0; j < charts.Length; j++)
{
ProfilerChart profilerChart2 = charts[j];
profilerChart2.LoadAndBindSettings();
}
}
private void UpdateCharts()
{
int historyLength = ProfilerDriver.maxHistoryLength - 1;
int firstEmptyFrame = ProfilerDriver.lastFrameIndex - historyLength;
int firstFrame = Mathf.Max(ProfilerDriver.firstFrameIndex, firstEmptyFrame);
// Collect chart values
foreach (var chart in m_Charts)
{
UpdateSingleChart(chart, firstEmptyFrame, firstFrame);
}
// CPU chart overlay values
string selectedName = ProfilerDriver.selectedPropertyPath;
bool hasCPUOverlay = (selectedName != string.Empty) && m_CurrentArea == ProfilerArea.CPU;
ProfilerChart cpuChart = m_Charts[(int)ProfilerArea.CPU];
if (hasCPUOverlay)
{
cpuChart.m_Data.hasOverlay = true;
int numCharts = cpuChart.m_Data.numSeries;
for (int i = 0; i < numCharts; ++i)
{
var chart = cpuChart.m_Data.series[i];
cpuChart.m_Data.overlays[i] = new ChartSeriesViewData(chart.name, chart.yValues.Length, chart.color);
for (int frameIdx = 0; frameIdx < chart.yValues.Length; ++frameIdx)
{
cpuChart.m_Data.overlays[i].xValues[frameIdx] = (float)frameIdx;
}
int identifier = ProfilerDriver.GetStatisticsIdentifierForArea(cpuChart.m_Area, UnityString.Format("Selected{0}", chart.name));
float maxValue;
ProfilerDriver.GetStatisticsValues(identifier, firstEmptyFrame, 1.0f, cpuChart.m_Data.overlays[i].yValues, out maxValue);
cpuChart.m_Data.overlays[i].yScale = cpuChart.m_DataScale;
}
}
else
{
cpuChart.m_Data.hasOverlay = false;
}
// CPU, GPU & UI chart scale value
for (int i = 0; i < ms_StackedAreas.Length; i++)
{
ComputeChartScaleValue(ms_StackedAreas[i], historyLength, firstEmptyFrame, firstFrame);
}
// Is GPU Profiling supported warning
string warning = null;
if (!ProfilerDriver.isGPUProfilerSupported)
{
warning = "GPU profiling is not supported by the graphics card driver. Please update to a newer version if available.";
if (Application.platform == RuntimePlatform.OSXEditor)
{
if (!ProfilerDriver.isGPUProfilerSupportedByOS)
{
warning = "GPU profiling requires Mac OS X 10.7 (Lion) and a capable video card. GPU profiling is currently not supported on mobile.";
}
else
{
warning = "GPU profiling is not supported by the graphics card driver (or it was disabled because of driver bugs).";
}
}
}
m_Charts[(int)ProfilerArea.GPU].m_NotSupportedWarning = warning;
}
void Initialize()
{
// When reinitializing (e.g. because Colorblind mode or PlatformModule changed) we don't need a new state
if (m_AttachProfilerState == null)
{
m_AttachProfilerState = ConnectionUtility.GetAttachToPlayerState(this, (player) => ClearFramesCallback());
}
int historySize = ProfilerUserSettings.frameCount;
m_Charts = new ProfilerChart[Profiler.areaCount];
Color[] chartAreaColors = ProfilerColors.chartAreaColors;
for (int i = 0; i < Profiler.areaCount; i++)
{
float scale = 1.0f;
Chart.ChartType chartType = Chart.ChartType.Line;
string[] statisticsNames = ProfilerDriver.GetGraphStatisticsPropertiesForArea((ProfilerArea)i);
int length = statisticsNames.Length;
if (Array.IndexOf(ms_StackedAreas, (ProfilerArea)i) != -1)
{
chartType = Chart.ChartType.StackedFill;
scale = 1.0f / 1000.0f;
}
ProfilerChart chart = CreateProfilerChart((ProfilerArea)i, chartType, scale, length);
if (chart.m_Area == ProfilerArea.CPU)
{
chart.SetOnSeriesToggleCallback(OnToggleCPUChartSeries);
}
for (int s = 0; s < length; s++)
{
chart.m_Series[s] = new ChartSeriesViewData(statisticsNames[s], historySize, chartAreaColors[s % chartAreaColors.Length]);
for (int frameIdx = 0; frameIdx < historySize; ++frameIdx)
{
chart.m_Series[s].xValues[frameIdx] = (float)frameIdx;
}
}
m_Charts[(int)i] = chart;
}
if (m_VertSplit == null || m_VertSplit.relativeSizes == null || m_VertSplit.relativeSizes.Length == 0)
{
m_VertSplit = new SplitterState(new[] { 50f, 50f }, new[] { k_VertSplitterMinSizes, k_VertSplitterMinSizes }, null);
}
// 2 times the min splitter size plus one line height for the toolbar up top
minSize = new Vector2(Chart.kSideWidth + k_RightPaneMinSize, k_VertSplitterMinSizes * m_VertSplit.minSizes.Length + k_LineHeight);
// TODO: only create modules for active charts and otherwise lazy initialize them.
if (m_ProfilerModules == null)
{
m_ProfilerModules = new ProfilerModuleBase[]
{
new CPUProfilerModule(), //CPU
new GPUProfilerModule(), //GPU
new RenderingProfilerModule(), //Rendering
new MemoryProfilerModule(), //Memory
new AudioProfilerModule(), //Audio
new VideoProfilerModule(), //Video
new PhysicsProfilerModule(), //Physics
new Physics2DProfilerModule(), //Physics2D
new NetworkingMessagesProfilerModule(), //NetworkMessages
new NetworkingOperationsProfilerModule(), //NetworkOperations
new UIProfilerModule(), //UI
new UIDetailsProfilerModule(), //UIDetails
new GlobalIlluminationProfilerModule(), //GlobalIllumination
};
}
foreach (var module in m_ProfilerModules)
{
module?.OnEnable(this);
}
UpdateCharts();
foreach (var chart in m_Charts)
{
chart.LoadAndBindSettings();
}
m_Initialized = true;
}
private void UpdateCharts()
{
int num = ProfilerDriver.maxHistoryLength - 1;
int num2 = ProfilerDriver.lastFrameIndex - num;
int num3 = Mathf.Max(ProfilerDriver.firstFrameIndex, num2);
ProfilerChart[] charts = this.m_Charts;
for (int i = 0; i < charts.Length; i++)
{
ProfilerChart profilerChart = charts[i];
float[] array = new float[profilerChart.m_Series.Length];
for (int j = 0; j < profilerChart.m_Series.Length; j++)
{
int statisticsIdentifier = ProfilerDriver.GetStatisticsIdentifier(profilerChart.m_Series[j].identifierName);
float num4;
ProfilerDriver.GetStatisticsValues(statisticsIdentifier, num2, profilerChart.m_DataScale, profilerChart.m_Series[j].data, out num4);
num4 = Mathf.Max(num4, 0.0001f);
float num5;
if (profilerChart.m_Type == Chart.ChartType.Line)
{
num5 = 1f / (num4 * (1.05f + (float)j * 0.05f));
}
else
{
num5 = 1f / num4;
}
array[j] = num5;
}
if (profilerChart.m_Type == Chart.ChartType.Line)
{
profilerChart.m_Data.AssignScale(array);
}
profilerChart.m_Data.Assign(profilerChart.m_Series, num2, num3);
}
string selectedPropertyPath = ProfilerDriver.selectedPropertyPath;
bool flag = selectedPropertyPath != string.Empty && this.m_CurrentArea == ProfilerArea.CPU;
ProfilerChart profilerChart2 = this.m_Charts[0];
if (flag)
{
profilerChart2.m_Data.hasOverlay = true;
ChartSeries[] series = profilerChart2.m_Series;
for (int k = 0; k < series.Length; k++)
{
ChartSeries chartSeries = series[k];
int statisticsIdentifier2 = ProfilerDriver.GetStatisticsIdentifier("Selected" + chartSeries.identifierName);
chartSeries.CreateOverlayData();
float num6;
ProfilerDriver.GetStatisticsValues(statisticsIdentifier2, num2, profilerChart2.m_DataScale, chartSeries.overlayData, out num6);
}
}
else
{
profilerChart2.m_Data.hasOverlay = false;
}
for (ProfilerArea profilerArea = ProfilerArea.CPU; profilerArea <= ProfilerArea.GPU; profilerArea++)
{
ProfilerChart profilerChart3 = this.m_Charts[(int)profilerArea];
float num7 = 0f;
float num8 = 0f;
for (int l = 0; l < num; l++)
{
float num9 = 0f;
for (int m = 0; m < profilerChart3.m_Series.Length; m++)
{
if (profilerChart3.m_Series[m].enabled)
{
num9 += profilerChart3.m_Series[m].data[l];
}
}
if (num9 > num7)
{
num7 = num9;
}
if (num9 > num8 && l + num2 >= num3 + 1)
{
num8 = num9;
}
}
if (num8 != 0f)
{
num7 = num8;
}
num7 = Math.Min(num7, this.m_ChartMaxClamp);
if (this.m_ChartOldMax[(int)profilerArea] > 0f)
{
num7 = Mathf.Lerp(this.m_ChartOldMax[(int)profilerArea], num7, 0.4f);
}
this.m_ChartOldMax[(int)profilerArea] = num7;
profilerChart3.m_Data.AssignScale(new float[]
{
1f / num7
});
ProfilerWindow.UpdateChartGrid(num7, profilerChart3.m_Data);
}
string notSupportedWarning = null;
if (ProfilerDriver.isGPUProfilerBuggyOnDriver)
{
notSupportedWarning = "Graphics card driver returned invalid timing information. Please update to a newer version if available.";
}
else
{
if (!ProfilerDriver.isGPUProfilerSupported)
{
notSupportedWarning = "GPU profiling is not supported by the graphics card driver. Please update to a newer version if available.";
if (Application.platform == RuntimePlatform.OSXEditor)
{
if (!ProfilerDriver.isGPUProfilerSupportedByOS)
{
notSupportedWarning = "GPU profiling requires Mac OS X 10.7 (Lion) and a capable video card. GPU profiling is currently not supported on mobile.";
}
else
{
notSupportedWarning = "GPU profiling is not supported by the graphics card driver (or it was disabled because of driver bugs).";
}
}
}
}
this.m_Charts[1].m_Chart.m_NotSupportedWarning = notSupportedWarning;
}
private void OnGUI()
{
this.CheckForPlatformModuleChange();
if (ProfilerWindow.ms_Styles == null)
{
ProfilerWindow.ms_Styles = new ProfilerWindow.Styles();
}
if (!this.m_HasProfilerLicense)
{
GUILayout.Label(ProfilerWindow.ms_Styles.noLicense, EditorStyles.largeLabel, new GUILayoutOption[0]);
return;
}
this.DrawMainToolbar();
SplitterGUILayout.BeginVerticalSplit(this.m_VertSplit, new GUILayoutOption[0]);
this.m_GraphPos = EditorGUILayout.BeginScrollView(this.m_GraphPos, ProfilerWindow.ms_Styles.profilerGraphBackground, new GUILayoutOption[0]);
if (this.m_PrevLastFrame != ProfilerDriver.lastFrameIndex)
{
this.UpdateCharts();
this.m_PrevLastFrame = ProfilerDriver.lastFrameIndex;
}
int num = this.m_CurrentFrame;
Chart.ChartAction[] array = new Chart.ChartAction[this.m_Charts.Length];
for (int i = 0; i < this.m_Charts.Length; i++)
{
ProfilerChart profilerChart = this.m_Charts[i];
if (profilerChart.active)
{
num = profilerChart.DoChartGUI(num, this.m_CurrentArea, out array[i]);
}
}
bool flag = false;
if (num != this.m_CurrentFrame)
{
this.SetCurrentFrame(num);
flag = true;
}
for (int j = 0; j < this.m_Charts.Length; j++)
{
ProfilerChart profilerChart2 = this.m_Charts[j];
if (profilerChart2.active)
{
if (array[j] == Chart.ChartAction.Closed)
{
if (this.m_CurrentArea == (ProfilerArea)j)
{
this.m_CurrentArea = ProfilerArea.CPU;
}
profilerChart2.active = false;
}
else
{
if (array[j] == Chart.ChartAction.Activated)
{
this.m_CurrentArea = (ProfilerArea)j;
if (this.m_CurrentArea != ProfilerArea.CPU && this.m_CPUHierarchyGUI.selectedIndex != -1)
{
this.ClearSelectedPropertyPath();
}
flag = true;
}
}
}
}
if (flag)
{
base.Repaint();
GUIUtility.ExitGUI();
}
GUILayout.EndScrollView();
GUILayout.BeginVertical(new GUILayoutOption[0]);
switch (this.m_CurrentArea)
{
case ProfilerArea.CPU:
this.DrawCPUOrRenderingPane(this.m_CPUHierarchyGUI, this.m_CPUDetailHierarchyGUI, this.m_CPUTimelineGUI);
goto IL_255;
case ProfilerArea.GPU:
this.DrawCPUOrRenderingPane(this.m_GPUHierarchyGUI, this.m_GPUDetailHierarchyGUI, null);
goto IL_255;
case ProfilerArea.Memory:
this.DrawMemoryPane(this.m_ViewSplit);
goto IL_255;
case ProfilerArea.Audio:
this.DrawAudioPane();
goto IL_255;
}
this.DrawPane(this.m_CurrentArea);
IL_255:
GUILayout.EndVertical();
SplitterGUILayout.EndVerticalSplit();
}
