void ConnectionChanged(string playerName)
{
if (m_ConnectionState != null)
{
UIElementsHelper.SetVisibility(m_UIState.EditorWarningLabel, m_ConnectionState.connectionName == "Editor");
}
}
void SetBarElements()
{
UIElementsHelper.SetVisibility(m_UsedElement, ShowUsed);
m_UsedElement.style.width = new Length(PercentageUsed, LengthUnit.Percent);
UIElementsHelper.SetVisibility(m_SelectedElement, ShowSelected);
m_SelectedElement.style.width = new Length(PercentageSelected, LengthUnit.Percent);
}
void OpenLinkRequest(Database.LinkRequestTable link, bool focus)
{
//TODO this code is the same as the one inSpreadsheetPane, should be put together
UIElementsHelper.SetVisibility(VisualElements[2], m_ActiveMode.snapshot.nativeAllocationSites.Count > 0 && m_CurrentTableView == TableDisplayMode.Allocations);
var tableRef = new Database.TableReference(link.LinkToOpen.TableName, link.Parameters);
var table = m_ActiveMode.SchemaToDisplay.GetTableByReference(tableRef);
if (table == null)
{
UnityEngine.Debug.LogError("No table named '" + link.LinkToOpen.TableName + "' found.");
return;
}
if (link.LinkToOpen.RowWhere != null && link.LinkToOpen.RowWhere.Count > 0)
{
Database.Table filteredTable = table;
if (table.GetMetaData().defaultFilter != null)
{
filteredTable = table.GetMetaData().defaultFilter.CreateFilter(table);
}
Database.Operation.ExpressionParsingContext expressionParsingContext = null;
if (link.SourceView != null)
{
expressionParsingContext = link.SourceView.ExpressionParsingContext;
}
var whereUnion = new Database.View.WhereUnion(link.LinkToOpen.RowWhere, null, null, null, null, m_ActiveMode.SchemaToDisplay, filteredTable, expressionParsingContext);
var indices = whereUnion.GetMatchingIndices(link.SourceRow);
var newTab = new Database.Operation.IndexedTable(table, new ArrayRange(indices));
OpenTable(tableRef, newTab, focus);
}
else
{
OpenTable(tableRef, table, new Database.CellPosition(0, 0), focus);
}
}
void ViewChanged(ProfilerMemoryView view)
{
m_UIState.ViewArea.Clear();
m_MemoryModule.m_ShowDetailedMemoryPane = view;
if (view == ProfilerMemoryView.Simple)
{
var frameIndex = ProfilerWindow.selectedFrameIndex;
var dataAvailable = CheckMemoryStatsAvailablity(frameIndex);
m_UIState.DetailedMenuLabel.text = "Simple";
UIElementsHelper.SetVisibility(m_UIState.DetailedToolbarSection, false);
if (dataAvailable)
{
m_UIState.ViewArea.Add(m_UIState.SimpleView);
m_AddedSimpleDataView = true;
UpdateContent(frameIndex);
}
else
{
m_UIState.ViewArea.Add(m_UIState.NoDataView);
m_AddedSimpleDataView = false;
}
}
else
{
m_UIState.DetailedMenuLabel.text = "Detailed";
UIElementsHelper.SetVisibility(m_UIState.DetailedToolbarSection, true);
// Detailed View doesn't differentiate between there being frame data or not because
// 1. Clear doesn't clear out old snapshots so there totally could be data here
// 2. Take Snapshot also doesn't require there to be any frame data
// this special case will disappear together with the detailed view eventually
m_UIState.ViewArea.Add(m_UIState.DetailedView);
m_AddedSimpleDataView = false;
}
}
public SerializedBehaviorTreeNode([NotNull] SerializedBehavior_Base dependedSerializedBehavior,
[NotNull] SerializedBehaviorTreeGraph treeGraph)
{
m_dependedSerializedBehavior = dependedSerializedBehavior;
m_treeGraph = treeGraph;
Type type = m_dependedSerializedBehavior.serializedBehaviorType;
title = TypeHelper.GetUIName(type);
m_isComposite = type.IsSubclassOf(typeof(Composite));
Port input = InstantiatePort(Orientation.Horizontal, Direction.Input, Port.Capacity.Single,
typeof(BehaviorConnection));
input.portName = "Parent";
inputContainer.Add(input);
if (m_isComposite)
{
var addButton = new Button(AddOutputPortAndNotify)
{
text = "+"
};
titleButtonContainer.Add(addButton);
}
UIElementsHelper.CreatePropertyElements(new SerializedObject(m_dependedSerializedBehavior),
extensionContainer);
}
private void highlightSubstring()
{
var label = Element as CustomLabel;
UIElementsHelper.HighlightSubstring((Element as CustomLabel)?.BoldText, Element as CustomLabel);
// UIElementsHelper.HighlightText(label, label.BoldText, Color.Green, Color.Brown);
}
private void setupText(TTTAttributedLabel attributedLabel, CustomLinkLabel label)
{
if ((attributedLabel != null) && (label != null))
{
NSMutableParagraphStyle paragraphStyle = new NSMutableParagraphStyle();
paragraphStyle.LineBreakMode = UILineBreakMode.WordWrap;
if (label.LineSpacing > 0)
{
paragraphStyle.LineHeightMultiple = (float)label.LineSpacing;
}
UIElementsHelper.SetCustomLabelParagraphStyle(paragraphStyle, label);
string text = string.Empty;
if (!string.IsNullOrEmpty(label.Text))
{
text = label.Text;
}
var attString = new NSMutableAttributedString(text, new UIStringAttributes
{
ForegroundColor = label.TextColor.ToUIColor(),
Font = UIFont.SystemFontOfSize((nfloat)label.FontSize),
ParagraphStyle = paragraphStyle,
KerningAdjustment = null
});
attributedLabel.LineBreakMode = UILineBreakMode.WordWrap;
attributedLabel.Lines = 0;
attributedLabel.TextAlignment = paragraphStyle.Alignment;
if (!string.IsNullOrEmpty(label.UrlText) && !string.IsNullOrEmpty(label.Url) && !string.IsNullOrEmpty(label.Text) && label.Text.Contains(label.UrlText))
{
attributedLabel.AddLinkToURL(new NSUrl(label.Url), new NSRange(label.Text.IndexOf(label.UrlText), label.UrlText.Length));
attributedLabel.Delegate = new LabelDelegate();
attString.AddAttribute(UIStringAttributeKey.ForegroundColor, label.LinkColor.ToUIColor(), new NSRange(label.Text.IndexOf(label.UrlText), label.UrlText.Length));
}
attributedLabel.AttributedText = attString;
}
}
void Init(string text, bool showUsed, ulong used, ulong total, bool showSelected, ulong selected, string backgroundColorClass)
{
Text = text;
ShowUsed = showUsed;
m_UsedBytes = used;
m_TotalBytes = total;
ShowSelected = showSelected;
m_SelectedBytes = selected;
BackgroundColorClass = backgroundColorClass;
m_ReservedElement.AddToClassList(backgroundColorClass);
m_BackgroundElement.style.backgroundColor = Color.black;
UIElementsHelper.SetVisibility(m_UsedElement, ShowUsed);
RegisterCallback <GeometryChangedEvent>(OnGeometryChangedEvent);
m_UsedElement.style.width = new Length(PercentageUsed, LengthUnit.Percent);
m_UsedElement.AddToClassList(BackgroundColorClass);
UIElementsHelper.SetVisibility(m_SelectedElement, ShowSelected);
m_SelectedElement.style.width = new Length(m_SelectedBytes, LengthUnit.Percent);
}
void UpdatePackageInstallButton()
{
if (m_UIState != null)
{
switch (m_MemoryModule.m_MemoryProfilerPackageStage)
{
case PackageStage.Experimental:
m_UIState.InstallPackageButton.text = Styles.experimentalPackageHint.text;
break;
case PackageStage.PreviewOrReleased:
m_UIState.InstallPackageButton.text = Styles.packageInstallSuggestionButton.text;
break;
case PackageStage.Installed:
UIElementsHelper.SetVisibility(m_UIState.InstallPackageButton, false);
break;
default:
break;
}
}
}
private void setLineSpacing()
{
CustomLabel label = (Element as CustomLabel);
if ((Control != null) && (label != null) && (label.LineSpacing > 0))
{
NSAttributedString controlText = UIElementsHelper.GetUILabelAttributedText(Control);
if (controlText != null)
{
var labelString = new NSMutableAttributedString(controlText);
var paragraphStyle = new NSMutableParagraphStyle {
LineHeightMultiple = (nfloat)label.LineSpacing
};
UIElementsHelper.SetCustomLabelParagraphStyle(paragraphStyle, label);
var style = UIStringAttributeKey.ParagraphStyle;
var range = new NSRange(0, labelString.Length);
labelString.AddAttribute(style, paragraphStyle, range);
Control.AttributedText = labelString;
}
}
}
protected override VisualElement CreateView()
{
VisualTreeAsset memoryModuleViewTree = EditorGUIUtility.Load(ResourcePaths.MemoryModuleUxmlPath) as VisualTreeAsset;
var root = memoryModuleViewTree.CloneTree();
m_UIState = new UIState();
var toolbar = root.Q("memory-module__toolbar");
m_UIState.DetailedToolbarSection = toolbar.Q("memory-module__toolbar__detailed-controls");
m_UIState.DetailedMenu = toolbar.Q <UnityEngine.UIElements.Button>("memory-module__toolbar__detail-view-menu");
m_UIState.DetailedMenuLabel = m_UIState.DetailedMenu.Q <Label>("memory-module__toolbar__detail-view-menu__label");
var menu = new GenericMenu();
menu.AddItem(new GUIContent("Simple"), false, () => ViewChanged(ProfilerMemoryView.Simple));
menu.AddItem(new GUIContent("Detailed"), false, () => ViewChanged(ProfilerMemoryView.Detailed));
m_UIState.DetailedMenu.clicked += () =>
{
menu.DropDown(UIElementsHelper.GetRect(m_UIState.DetailedMenu));
};
var takeCapture = toolbar.Q <UnityEngine.UIElements.Button>("memory-module__toolbar__take-sample-button");
takeCapture.clicked += () => m_MemoryModule.RefreshMemoryData();
var gatherObjectReferencesToggle = toolbar.Q <Toggle>("memory-module__toolbar__gather-references-toggle");
gatherObjectReferencesToggle.RegisterValueChangedCallback((evt) => m_MemoryModule.m_GatherObjectReferences = evt.newValue);
gatherObjectReferencesToggle.SetValueWithoutNotify(m_MemoryModule.m_GatherObjectReferences);
m_UIState.InstallPackageButton = toolbar.Q <UnityEngine.UIElements.Button>("memory-module__toolbar__install-package-button");
// in the main code base, this button offers to install the memory profiler package, here it is swapped to be one that opens it.
if (m_InitiatedPackageSearchQuery)
{
m_UIState.InstallPackageButton.schedule.Execute(CheckPackageAvailabilityStatus).Until(() => !m_InitiatedPackageSearchQuery);
}
m_UIState.InstallPackageButton.clicked += PackageInstallButtonClicked;
UpdatePackageInstallButton();
m_UIState.EditorWarningLabel = toolbar.Q("memory-module__toolbar__editor-warning");
m_ConnectionState = PlayerConnectionGUIUtility.GetConnectionState(ProfilerWindow, ConnectionChanged);
UIElementsHelper.SetVisibility(m_UIState.EditorWarningLabel, m_ConnectionState.connectionName == "Editor");
m_UIState.ViewArea = root.Q("memory-module__view-area");
m_UIState.SimpleView = m_UIState.ViewArea.Q("memory-module__simple-area");
m_UIState.CounterBasedUI = m_UIState.SimpleView.Q("memory-module__simple-area__counter-based-ui");
var normalizedToggle = m_UIState.CounterBasedUI.Q <Toggle>("memory-module__simple-area__breakdown__normalized-toggle");
normalizedToggle.value = m_MemoryModule.m_Normalized;
normalizedToggle.RegisterValueChangedCallback((evt) =>
{
m_MemoryModule.m_Normalized = evt.newValue;
UpdateContent(ProfilerWindow.selectedFrameIndex);
});
m_UIState.TopLevelBreakdown = m_UIState.CounterBasedUI.Q <MemoryUsageBreakdown>("memory-usage-breakdown__top-level");
m_UIState.TopLevelBreakdown.Setup();
m_UIState.Breakdown = m_UIState.CounterBasedUI.Q <MemoryUsageBreakdown>("memory-usage-breakdown");
m_UIState.Breakdown.Setup();
var m_ObjectStatsTable = m_UIState.CounterBasedUI.Q("memory-usage-breakdown__object-stats_list");
SetupObjectTableRow(m_ObjectStatsTable.Q("memory-usage-breakdown__object-stats__textures"), ref m_UIState.TexturesRow, Content.Textures);
SetupObjectTableRow(m_ObjectStatsTable.Q("memory-usage-breakdown__object-stats__meshes"), ref m_UIState.MeshesRow, Content.Meshes);
SetupObjectTableRow(m_ObjectStatsTable.Q("memory-usage-breakdown__object-stats__materials"), ref m_UIState.MaterialsRow, Content.Materials);
SetupObjectTableRow(m_ObjectStatsTable.Q("memory-usage-breakdown__object-stats__animation-clips"), ref m_UIState.AnimationClipsRow, Content.AnimationClips);
SetupObjectTableRow(m_ObjectStatsTable.Q("memory-usage-breakdown__object-stats__assets"), ref m_UIState.AssetsRow, Content.Assets, true);
SetupObjectTableRow(m_ObjectStatsTable.Q("memory-usage-breakdown__object-stats__game-objects"), ref m_UIState.GameObjectsRow, Content.GameObjects, true);
SetupObjectTableRow(m_ObjectStatsTable.Q("memory-usage-breakdown__object-stats__scene-objects"), ref m_UIState.SceneObjectsRow, Content.SceneObjects, true);
var m_GCAllocExtraRow = m_UIState.CounterBasedUI.Q <VisualElement>("memory-usage-breakdown__object-stats__gc");
SetupObjectTableRow(m_GCAllocExtraRow, ref m_UIState.GCAllocRow, Content.GCAlloc);
m_UIState.Text = m_UIState.SimpleView.Q <TextField>("memory-module__simple-area__label");
var detailedView = m_UIState.ViewArea.Q <IMGUIContainer>("memory-module__detaile-snapshot-area");// new IMGUIContainer();
detailedView.onGUIHandler = () => m_MemoryModule.DrawDetailedMemoryPane();
m_UIState.DetailedView = detailedView;
m_UIState.NoDataView = m_UIState.ViewArea.Q("memory-module__no-frame-data__area");
m_UIState.NoDataView.Q <Label>("memory-module__no-frame-data__label").text = Content.NoFrameDataAvailable;
ViewChanged(m_MemoryModule.m_ShowDetailedMemoryPane);
return(root);
}
void UpdateContent(long frame)
{
if (m_MemoryModule.m_ShowDetailedMemoryPane != ProfilerMemoryView.Simple)
{
return;
}
var dataAvailable = CheckMemoryStatsAvailablity(frame);
if (m_AddedSimpleDataView != dataAvailable)
{
// refresh the view structure
ViewChanged(ProfilerMemoryView.Simple);
return;
}
if (!dataAvailable)
{
return;
}
if (m_UIState != null)
{
using (var data = ProfilerDriver.GetRawFrameDataView((int)frame, 0))
{
m_SimplePaneStringBuilder.Clear();
if (data.valid && data.GetMarkerId("Total Reserved Memory") != FrameDataView.invalidMarkerId)
{
var systemUsedMemoryId = data.GetMarkerId("System Used Memory");
var systemUsedMemory = (ulong)data.GetCounterValueAsLong(systemUsedMemoryId);
var systemUsedMemoryIsKnown = (systemUsedMemoryId != FrameDataView.invalidMarkerId && systemUsedMemory > 0);
var maxSystemUsedMemory = m_MaxSystemUsedMemory = systemUsedMemory;
if (!m_MemoryModule.m_Normalized)
{
UpdateMaxSystemUsedMemory(ProfilerWindow.firstAvailableFrameIndex, ProfilerWindow.lastAvailableFrameIndex);
maxSystemUsedMemory = m_MaxSystemUsedMemory;
}
var totalUsedId = data.GetMarkerId("Total Used Memory");
var totalUsed = (ulong)data.GetCounterValueAsLong(totalUsedId);
var totalReservedId = data.GetMarkerId("Total Reserved Memory");
var totalReserved = (ulong)data.GetCounterValueAsLong(totalReservedId);
m_TotalUsed[0] = totalUsed;
m_TotalReserved[0] = totalReserved;
if (!systemUsedMemoryIsKnown)
{
systemUsedMemory = totalReserved;
}
m_UIState.TopLevelBreakdown.SetVaules(systemUsedMemory, m_TotalReserved, m_TotalUsed, m_MemoryModule.m_Normalized, maxSystemUsedMemory, systemUsedMemoryIsKnown);
m_Used[4] = totalUsed;
m_Reserved[4] = totalReserved;
var gfxReservedId = data.GetMarkerId("Gfx Reserved Memory");
m_Reserved[1] = m_Used[1] = (ulong)data.GetCounterValueAsLong(gfxReservedId);
var managedUsedId = data.GetMarkerId("GC Used Memory");
m_Used[0] = (ulong)data.GetCounterValueAsLong(managedUsedId);
var managedReservedId = data.GetMarkerId("GC Reserved Memory");
m_Reserved[0] = (ulong)data.GetCounterValueAsLong(managedReservedId);
var audioReservedId = data.GetMarkerId("Audio Used Memory");
m_Reserved[2] = m_Used[2] = (ulong)data.GetCounterValueAsLong(audioReservedId);
var videoReservedId = data.GetMarkerId("Video Used Memory");
m_Reserved[3] = m_Used[3] = (ulong)data.GetCounterValueAsLong(videoReservedId);
var profilerUsedId = data.GetMarkerId("Profiler Used Memory");
m_Used[5] = (ulong)data.GetCounterValueAsLong(profilerUsedId);
var profilerReservedId = data.GetMarkerId("Profiler Reserved Memory");
m_Reserved[5] = (ulong)data.GetCounterValueAsLong(profilerReservedId);
m_Used[4] -= Math.Min(m_Used[0] + m_Used[1] + m_Used[2] + m_Used[3] + m_Used[5], m_Used[4]);
m_Reserved[4] -= Math.Min(m_Reserved[0] + m_Reserved[1] + m_Reserved[2] + m_Reserved[3] + m_Reserved[5], m_Reserved[4]);
m_UIState.Breakdown.SetVaules(systemUsedMemory, m_Reserved, m_Used, m_MemoryModule.m_Normalized, maxSystemUsedMemory, systemUsedMemoryIsKnown);
UpdateObjectRow(data, ref m_UIState.TexturesRow, "Texture Count", "Texture Memory");
UpdateObjectRow(data, ref m_UIState.MeshesRow, "Mesh Count", "Mesh Memory");
UpdateObjectRow(data, ref m_UIState.MaterialsRow, "Material Count", "Material Memory");
UpdateObjectRow(data, ref m_UIState.AnimationClipsRow, "AnimationClip Count", "AnimationClip Memory");
UpdateObjectRow(data, ref m_UIState.AssetsRow, "Asset Count");
UpdateObjectRow(data, ref m_UIState.GameObjectsRow, "Game Object Count");
UpdateObjectRow(data, ref m_UIState.SceneObjectsRow, "Scene Object Count");
UpdateObjectRow(data, ref m_UIState.GCAllocRow, "GC Allocation In Frame Count", "GC Allocated In Frame");
if (!m_UIState.CounterBasedUI.visible)
{
UIElementsHelper.SetVisibility(m_UIState.CounterBasedUI, true);
}
var platformSpecifics = MemoryProfilerModule.GetPlatformSpecificText(data, ProfilerWindow);
if (!string.IsNullOrEmpty(platformSpecifics))
{
m_SimplePaneStringBuilder.Append(platformSpecifics);
}
}
else
{
if (m_UIState.CounterBasedUI.visible)
{
UIElementsHelper.SetVisibility(m_UIState.CounterBasedUI, false);
}
m_SimplePaneStringBuilder.Append(MemoryProfilerModule.GetSimpleMemoryPaneText(data, ProfilerWindow, false));
}
if (m_SimplePaneStringBuilder.Length > 0)
{
UIElementsHelper.SetVisibility(m_UIState.Text, true);
m_UIState.Text.value = m_SimplePaneStringBuilder.ToString();
}
else
{
UIElementsHelper.SetVisibility(m_UIState.Text, false);
}
}
}
}
private void highlightSubstring()
{
UIElementsHelper.HighlightSubstring((Element as CustomLabel)?.BoldText, Control);
}
void SetTotalUsed(ulong totalBytes, bool normalized, ulong maxTotalBytesToNormalizeTo, bool force = false, bool totalIsKnown = true)
{
if (!force && m_TotalBytes == totalBytes && normalized == m_Normalized && maxTotalBytesToNormalizeTo == m_MaxTotalBytesToNormalizeTo)
{
return;
}
m_TotalBytes = totalBytes;
m_Normalized = normalized;
m_MaxTotalBytesToNormalizeTo = Math.Max(m_TotalBytes, maxTotalBytesToNormalizeTo);
UpdateTotalSizeText();
var knownBytes = 0ul;
for (int i = 0; i < m_Elements.Count; i++)
{
knownBytes += (ulong)m_Elements[i].TotalBytes;
}
var unknownUnknown = !totalIsKnown;
var unknownSize = m_TotalBytes;
for (int i = 0; i < m_Elements.Count; i++)
{
var percentage = (m_Elements[i].TotalBytes / (float)knownBytes) * 100;
m_Elements[i].style.width = new Length(percentage, LengthUnit.Percent);
var elementSize = (ulong)m_Elements[i].TotalBytes;
if (elementSize > unknownSize)
{
unknownSize = 0ul;
unknownUnknown = true;
}
else
{
unknownSize -= Math.Min(elementSize, unknownSize);
}
}
var totalBarByteAmount = knownBytes;
if (!ShowUnknown && m_Normalized)
{
totalBarByteAmount = m_TotalBytes;
}
if (!m_Normalized && m_MaxTotalBytesToNormalizeTo > totalBarByteAmount)
{
totalBarByteAmount = m_MaxTotalBytesToNormalizeTo;
}
if (ShowUnknown || !m_Normalized)
{
var percentage = totalBarByteAmount > 0 ? knownBytes / (float)totalBarByteAmount * 100 : 100;
m_Content.style.width = new Length(Mathf.RoundToInt(percentage), LengthUnit.Percent);
}
else
{
m_Content.style.width = new Length(100, LengthUnit.Percent);
}
if (m_UnknownBar.visible != ShowUnknown)
{
UIElementsHelper.SetVisibility(m_UnknownBar, ShowUnknown);
}
if (ShowUnknown)
{
var percentage = totalBarByteAmount > 0 ? unknownSize / (float)totalBarByteAmount * 100 : 100;
m_UnknownBar.style.width = new Length(Mathf.RoundToInt(percentage), LengthUnit.Percent);
m_UnknownBar.tooltip = MemoryUsageBreakdownElement.BuildTooltipText(HeaderText, UnknownName, (ulong)TotalBytes, unknownSize);
m_UnknownRow.Root.tooltip = m_UnknownBar.tooltip;
if (unknownUnknown)
{
m_UnknownRow.RowSize.text = Content.UnknownkSizeLabel;
}
else
{
m_UnknownRow.RowSize.text = MemoryUsageBreakdownElement.BuildRowSizeText(unknownSize, unknownSize, false);
}
}
if (m_UnknownRow.Root != null && m_UnknownRow.Root.visible != ShowUnknown)
{
UIElementsHelper.SetVisibility(m_UnknownRow.Root, ShowUnknown);
}
}
private void highlightSubstring()
{
UIElementsHelper.HighlightSubstring((Element as ImageButton)?.BoldText, Control?.TitleLabel);
}