using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using Unity.Burst.LowLevel;
using UnityEditor;
using System.Text.RegularExpressions;
using UnityEditor.IMGUI.Controls;
using UnityEngine;
[assembly: InternalsVisibleTo("Unity.Burst.Editor.Tests")]
[assembly: InternalsVisibleTo("Unity.Burst.Tester.Editor.Tests")]
namespace Unity.Burst.Editor
{
internal class BurstInspectorGUI : EditorWindow
{
private static bool Initialized;
private static void EnsureInitialized()
{
if (Initialized)
{
return;
}
Initialized = true;
BurstLoader.OnBurstShutdown += () =>
{
if (EditorWindow.HasOpenInstances<BurstInspectorGUI>())
{
var window = EditorWindow.GetWindow<BurstInspectorGUI>("Burst Inspector");
window.Close();
}
};
}
private const string FontSizeIndexPref = "BurstInspectorFontSizeIndex";
private static readonly string[] DisassemblyKindNames =
{
"Assembly",
".NET IL",
"LLVM IR (Unoptimized)",
"LLVM IR (Optimized)",
"LLVM IR Optimisation Diagnostics"
};
internal enum AssemblyOptions
{
PlainWithoutDebugInformation = 0,
PlainWithDebugInformation = 1,
EnhancedWithMinimalDebugInformation = 2,
EnhancedWithFullDebugInformation = 3,
ColouredWithMinimalDebugInformation = 4,
ColouredWithFullDebugInformation = 5
}
internal AssemblyOptions? _assemblyKind = null;
private AssemblyOptions? _assemblyKindPrior = null;
private AssemblyOptions _oldAssemblyKind;
private bool SupportsEnhancedRendering => _disasmKind == DisassemblyKind.Asm || _disasmKind == DisassemblyKind.OptimizedIR || _disasmKind == DisassemblyKind.UnoptimizedIR;
private static string[] DisasmOptions;
internal static string[] GetDisasmOptions()
{
if (DisasmOptions == null)
{
// We can't initialize this in BurstInspectorGUI.cctor because BurstCompilerOptions may not yet
// have been initialized by BurstLoader. So we initialize on-demand here. This method doesn't need to
// be thread-safe because it's only called from the UI thread.
DisasmOptions = new[]
{
"\n" + BurstCompilerOptions.GetOption(BurstCompilerOptions.OptionDump, NativeDumpFlags.Asm),
"\n" + BurstCompilerOptions.GetOption(BurstCompilerOptions.OptionDump, NativeDumpFlags.IL),
"\n" + BurstCompilerOptions.GetOption(BurstCompilerOptions.OptionDump, NativeDumpFlags.IR),
"\n" + BurstCompilerOptions.GetOption(BurstCompilerOptions.OptionDump, NativeDumpFlags.IROptimized),
"\n" + BurstCompilerOptions.GetOption(BurstCompilerOptions.OptionDump, NativeDumpFlags.IRPassAnalysis)
};
}
return DisasmOptions;
}
private static readonly SplitterState TreeViewSplitterState = new SplitterState(new float[] { 30, 70 }, new int[] { 128, 128 }, null);
private static readonly string[] TargetCpuNames = Enum.GetNames(typeof(BurstTargetCpu));
private static readonly string[] SIMDSmellTest = { "False", "True" };
private static readonly int[] FontSizes =
{
8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20
};
private static string[] _fontSizesText;
internal const int _scrollbarThickness = 14;
internal float _buttonOverlapInspectorView = 0;
/// <remarks>Used because it's not legal to change layout of GUI in a frame without the users input.</remarks>
private float _buttonBarWidth = -1;
[NonSerialized]
internal readonly BurstDisassembler _burstDisassembler;
private const string BurstSettingText = "Inspector Settings/";
[SerializeField] private BurstTargetCpu _targetCpu = BurstTargetCpu.Auto;
[SerializeField] private DisassemblyKind _disasmKind = DisassemblyKind.Asm;
[SerializeField] private DisassemblyKind _oldDisasmKind = DisassemblyKind.Asm;
[NonSerialized]
internal GUIStyle fixedFontStyle;
[NonSerialized]
internal int fontSizeIndex = -1;
[SerializeField] private int _previousTargetIndex = -1;
[SerializeField] private bool _safetyChecks = false;
[SerializeField] private bool _showBranchMarkers = true;
[SerializeField] private bool _enhancedDisassembly = true;
[SerializeField] private string _searchFilterJobs;
[SerializeField] private bool _showUnityNamespaceJobs = false;
[SerializeField] private bool _showDOTSGeneratedJobs = false;
[SerializeField] private bool _focusTargetJob = true;
[SerializeField] private string _searchFilterAssembly = String.Empty;
[SerializeField] private bool _sameTargetButDifferentAssemblyKind = false;
[SerializeField] internal Vector2 _scrollPos;
internal SearchField _searchFieldJobs;
internal SearchField _searchFieldAssembly;
private bool saveSearchFieldFromEvent = false;
[SerializeField] private bool _searchBarVisible = true;
[SerializeField] private string _selectedItem;
[NonSerialized]
private BurstCompileTarget _target;
[NonSerialized]
private List<BurstCompileTarget> _targets;
// Used as a serialized representation of _targets:
[SerializeField] private List<string> targetNames;
[NonSerialized]
internal LongTextArea _textArea;
internal Rect _inspectorView;
[NonSerialized]
internal Font _font;
[NonSerialized]
internal BurstMethodTreeView _treeView;
// Serialized representation of _treeView:
[SerializeField] private TreeViewState treeViewState;
[NonSerialized]
internal bool _initialized;
[NonSerialized]
private bool _requiresRepaint;
private int FontSize => FontSizes[fontSizeIndex];
private static readonly Regex _rx = new Regex(@"^.*\(\d+,\d+\):\sBurst\serror");
private bool _leftClicked = false;
[SerializeField] private bool _isCompileError = false;
[SerializeField] private bool _prevWasCompileError;
[SerializeField] private bool _smellTest = false;
// Caching GUIContent and style options for button bar
private readonly GUIContent _contentShowUnityNamespaceJobs = new GUIContent("Show Unity Namespace");
private readonly GUIContent _contentShowDOTSGeneratedJobs = new GUIContent("Show \".Generated\"");
private readonly GUIContent _contentDisasm = new GUIContent("Enhanced With Minimal Debug Information");
private readonly GUIContent _contentCollapseToCode = new GUIContent("Focus on Code");
private readonly GUIContent _contentExpandAll = new GUIContent("Expand All");
private readonly GUIContent _contentBranchLines = new GUIContent("Show Branch Flow");
private readonly GUIContent[] _contentsTarget;
private readonly GUIContent[] _contentsFontSize;
private readonly GUIContent[] _contentsSmellTest =
{
new GUIContent("Highlight SIMD Scalar vs Packed (False)"),
new GUIContent("Highlight SIMD Scalar vs Packed (True)")
};
// content for button search bar
private readonly GUIContent _ignoreCase = new GUIContent("Match Case");
private readonly GUIContent _matchWord = new GUIContent("Whole words");
private readonly GUIContent _regexSearch = new GUIContent("Regex");
private readonly GUILayoutOption[] _toolbarStyleOptions = { GUILayout.ExpandWidth(true), GUILayout.MinWidth(5 * 10) };
private readonly string[] _branchMarkerOptions = { "Hide Branch Flow", "Show Branch Flow" };
private readonly string[] _safetyCheckOptions = { "Safety Check On", "Safety Check Off" };
private enum KeyboardOperation
{
SelectAll,
Copy,
MoveLeft,
MoveRight,
MoveUp,
MoveDown,
Search,
Escape,
Enter,
}
private Dictionary<Event, KeyboardOperation> _keyboardEvents;
private void FillKeyboardEvent()
{
if (_keyboardEvents != null)
{
return;
}
_keyboardEvents = new Dictionary<Event, KeyboardOperation>();
_keyboardEvents.Add(Event.KeyboardEvent("#left"), KeyboardOperation.MoveLeft);
_keyboardEvents.Add(Event.KeyboardEvent("#right"), KeyboardOperation.MoveRight);
_keyboardEvents.Add(Event.KeyboardEvent("#down"), KeyboardOperation.MoveDown);
_keyboardEvents.Add(Event.KeyboardEvent("#up"), KeyboardOperation.MoveUp);
_keyboardEvents.Add(Event.KeyboardEvent("escape"), KeyboardOperation.Escape);
_keyboardEvents.Add(Event.KeyboardEvent("return"), KeyboardOperation.Enter);
_keyboardEvents.Add(Event.KeyboardEvent("#return"), KeyboardOperation.Enter);
_keyboardEvents.Add(Event.KeyboardEvent("left"), KeyboardOperation.MoveLeft);
_keyboardEvents.Add(Event.KeyboardEvent("right"), KeyboardOperation.MoveRight);
_keyboardEvents.Add(Event.KeyboardEvent("up"), KeyboardOperation.MoveUp);
_keyboardEvents.Add(Event.KeyboardEvent("down"), KeyboardOperation.MoveDown);
if (SystemInfo.operatingSystemFamily == OperatingSystemFamily.MacOSX)
{
_keyboardEvents.Add(Event.KeyboardEvent("%a"), KeyboardOperation.SelectAll);
_keyboardEvents.Add(Event.KeyboardEvent("%c"), KeyboardOperation.Copy);
_keyboardEvents.Add(Event.KeyboardEvent("%f"), KeyboardOperation.Search);
}
else
{
// windows or linux bindings.
_keyboardEvents.Add(Event.KeyboardEvent("^a"), KeyboardOperation.SelectAll);
_keyboardEvents.Add(Event.KeyboardEvent("^c"), KeyboardOperation.Copy);
_keyboardEvents.Add(Event.KeyboardEvent("^f"), KeyboardOperation.Search);
}
}
public BurstInspectorGUI()
{
_burstDisassembler = new BurstDisassembler();
string[] names = Enum.GetNames(typeof(BurstTargetCpu));
int size = names.Length;
_contentsTarget = new GUIContent[size];
for (int i = 0; i < size; i++)
{
_contentsTarget[i] = new GUIContent($"Target ({names[i]})");
}
size = FontSizes.Length;
_contentsFontSize = new GUIContent[size];
for (int i = 0; i < size; i++)
{
_contentsFontSize[i] = new GUIContent($"Font Size ({FontSizes[i].ToString()})");
}
}
private bool DisplayAssemblyKind(Enum assemblyKind)
{
var assemblyOption = (AssemblyOptions)assemblyKind;
if (_disasmKind != DisassemblyKind.Asm || _isCompileError)
{
return assemblyOption == AssemblyOptions.PlainWithoutDebugInformation;
}
return true;
}
public void OnEnable()
{
EnsureInitialized();
var newTreeState = false;
if (treeViewState is null)
{
treeViewState = new TreeViewState();
newTreeState = true;
}
_treeView ??= _treeView = new BurstMethodTreeView
(
treeViewState,
() => _searchFilterJobs,
() => (_showUnityNamespaceJobs, _showDOTSGeneratedJobs)
);
if (_keyboardEvents == null) FillKeyboardEvent();
var assemblyList = BurstReflection.EditorAssembliesThatCanPossiblyContainJobs;
Task.Run(
() =>
{
// Do this stuff asynchronously.
var result = BurstReflection.FindExecuteMethods(assemblyList, BurstReflectionAssemblyOptions.None);
_targets = result.CompileTargets;
_targets.Sort((left, right) => string.Compare(left.GetDisplayName(), right.GetDisplayName(), StringComparison.Ordinal));
return result;
})
.ContinueWith(t =>
{
// Do this stuff on the main (UI) thread.
if (t.Status == TaskStatus.RanToCompletion)
{
foreach (var logMessage in t.Result.LogMessages)
{
switch (logMessage.LogType)
{
case BurstReflection.LogType.Warning:
Debug.LogWarning(logMessage.Message);
break;
case BurstReflection.LogType.Exception:
Debug.LogException(logMessage.Exception);
break;
default:
throw new InvalidOperationException();
}
}
var newNames = new List<string>(_targets.Count);
foreach (var target in _targets)
{
newNames.Add(target.GetDisplayName());
}
bool identical = !newTreeState && newNames.Count == targetNames.Count;
int len = newNames.Count;
int i = 0;
while (identical && i < len)
{
identical = newNames[i] == targetNames[i];
i++;
}
targetNames = newNames;
_treeView.Initialize(_targets, identical);
if (_selectedItem == null || !_treeView.TrySelectByDisplayName(_selectedItem))
{
_previousTargetIndex = -1;
_scrollPos = Vector2.zero;
}
_requiresRepaint = true;
_initialized = true;
}
else if (t.Exception != null)
{
Debug.LogError($"Could not load Inspector: {t.Exception}");
}
});
}
#if !UNITY_2023_1_OR_NEWER
private void CleanupFont()
{
if (_font != null)
{
DestroyImmediate(_font, true);
_font = null;
}
}
public void OnDisable()
{
CleanupFont();
}
#endif
public void Update()
{
// Need to do this because if we call Repaint from anywhere else,
// it doesn't do anything if this window is not currently focused.
if (_requiresRepaint)
{
Repaint();
_requiresRepaint = false;
}
// Need this because pressing new target, and then not invoking new events,
// will leave the assembly unrendered.
// This is not included in above, to minimize needed calls.
if (_target != null && _target.JustLoaded)
{
Repaint();
}
}
/// <summary>
/// Checks if there is space for given content withs style, and starts new horizontalgroup
/// if there is no space on this line.
/// </summary>
private void FlowToNewLine(ref float remainingWidth, float width, Vector2 size)
{
float sizeX = size.x + _scrollbarThickness / 2;
if (sizeX >= remainingWidth)
{
_buttonOverlapInspectorView += size.y + 2;
remainingWidth = width - sizeX;
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
}
else
{
remainingWidth -= sizeX;
}
}
private bool IsRaw(AssemblyOptions kind)
{
return kind == AssemblyOptions.PlainWithoutDebugInformation || kind == AssemblyOptions.PlainWithDebugInformation;
}
private bool IsEnhanced(AssemblyOptions kind)
{
return !IsRaw(kind);
}
private bool IsColoured(AssemblyOptions kind)
{
return kind == AssemblyOptions.ColouredWithMinimalDebugInformation || kind == AssemblyOptions.ColouredWithFullDebugInformation;
}
/// <summary>
/// Renders buttons bar, and handles saving/loading of _assemblyKind options when changing in inspector settings
/// that disable/enables some options for _assemblyKind.
/// </summary>
private void HandleButtonBars(BurstCompileTarget target, bool targetChanged, out int fontIndex, out bool collapse, out bool focusCode)
{
// We can only make an educated guess for the correct width.
if (_buttonBarWidth == -1)
{
_buttonBarWidth = (position.width * 2) / 3 - _scrollbarThickness;
}
RenderButtonBars(_buttonBarWidth, target, out fontIndex, out collapse, out focusCode);
var disasmKindChanged = _oldDisasmKind != _disasmKind;
// Handles saving and loading _assemblyKind option when going between settings, that disable/enable some options for it
if ((disasmKindChanged && _oldDisasmKind == DisassemblyKind.Asm && !_isCompileError)
|| (targetChanged && !_prevWasCompileError && _isCompileError && _disasmKind == DisassemblyKind.Asm))
{
// save when _disasmKind changed from Asm WHEN we are not looking at a burst compile error,
// or when target changed from non compile error to compile error and current _disasmKind is Asm.
_oldAssemblyKind = (AssemblyOptions)_assemblyKind;
}
else if ((disasmKindChanged && _disasmKind == DisassemblyKind.Asm && !_isCompileError) ||
(targetChanged && _prevWasCompileError && _disasmKind == DisassemblyKind.Asm))
{
// load when _diasmKind changed to Asm and we are not at burst compile error,
// or when target changed from a burst compile error while _disasmKind is Asm.
_assemblyKind = _oldAssemblyKind;
}
// if _assemblyKind is something that is not available, force it up to PlainWithoutDebugInformation.
if ((_disasmKind != DisassemblyKind.Asm && _assemblyKind != AssemblyOptions.PlainWithoutDebugInformation)
|| _isCompileError)
{
_assemblyKind = AssemblyOptions.PlainWithoutDebugInformation;
}
}
private void RenderButtonBars(float width, BurstCompileTarget target, out int fontIndex, out bool collapse, out bool focus)
{
var remainingWidth = width;
GUILayout.BeginHorizontal();
// First button should never call beginHorizontal().
remainingWidth -= (EditorStyles.popup.CalcSize(_contentDisasm).x + _scrollbarThickness / 2f);
EditorGUI.BeginDisabledGroup(target.DisassemblyKind == DisassemblyKind.IRPassAnalysis);
_assemblyKind = (AssemblyOptions)EditorGUILayout.EnumPopup(GUIContent.none, _assemblyKind, DisplayAssemblyKind, true);
EditorGUI.EndDisabledGroup();
FlowToNewLine(ref remainingWidth, width, EditorStyles.popup.CalcSize(_contentBranchLines));
// Reversed "logic" to match the array of options, which has "positive" case on idx 0.
_safetyChecks = EditorGUILayout.Popup(_safetyChecks ? 0 : 1, _safetyCheckOptions) == 0;
EditorGUI.BeginDisabledGroup(!target.HasRequiredBurstCompileAttributes);
GUIContent targetContent = _contentsTarget[(int)_targetCpu];
FlowToNewLine(ref remainingWidth, width, EditorStyles.popup.CalcSize(targetContent));
_targetCpu = (BurstTargetCpu)LabeledPopup.Popup((int)_targetCpu, targetContent, TargetCpuNames);
GUIContent fontSizeContent = _contentsFontSize[fontSizeIndex];
FlowToNewLine(ref remainingWidth, width, EditorStyles.popup.CalcSize(fontSizeContent));
fontIndex = LabeledPopup.Popup(fontSizeIndex, fontSizeContent, _fontSizesText);
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(!IsEnhanced((AssemblyOptions)_assemblyKind) || !SupportsEnhancedRendering || _isCompileError);
FlowToNewLine(ref remainingWidth, width, EditorStyles.miniButton.CalcSize(_contentCollapseToCode));
focus = GUILayout.Button(_contentCollapseToCode, EditorStyles.miniButton);
FlowToNewLine(ref remainingWidth, width, EditorStyles.miniButton.CalcSize(_contentExpandAll));
collapse = GUILayout.Button(_contentExpandAll, EditorStyles.miniButton);
FlowToNewLine(ref remainingWidth, width, EditorStyles.popup.CalcSize(_contentBranchLines));
_showBranchMarkers = EditorGUILayout.Popup(Convert.ToInt32(_showBranchMarkers), _branchMarkerOptions) == 1;
int smellTestIdx = Convert.ToInt32(_smellTest);
GUIContent smellTestContent = _contentsSmellTest[smellTestIdx];
FlowToNewLine(ref remainingWidth, width, EditorStyles.popup.CalcSize(smellTestContent));
_smellTest = LabeledPopup.Popup(smellTestIdx, smellTestContent, SIMDSmellTest) == 1;
EditorGUI.EndDisabledGroup();
GUILayout.EndHorizontal();
_oldDisasmKind = _disasmKind;
_disasmKind = (DisassemblyKind)GUILayout.Toolbar((int)_disasmKind, DisassemblyKindNames, _toolbarStyleOptions);
}
/// <summary>
/// Handles mouse events for selecting text.
/// </summary>
/// <remarks>
/// Must be called after Render(...), as it uses the mouse events, and Render(...)
/// need mouse events for buttons etc.
/// </remarks>
private void HandleMouseEventForSelection(Rect workingArea, int controlID, bool showBranchMarkers)
{
var evt = Event.current;
var mousePos = evt.mousePosition;
if (_textArea.MouseOutsideView(workingArea, mousePos, controlID))
{
return;
}
switch (evt.type)
{
case EventType.MouseDown:
// button 0 is left and 1 is right
if (evt.button == 0)
{
_textArea.MouseClicked(showBranchMarkers, evt.shift, mousePos, controlID);
}
else
{
_leftClicked = true;
}
evt.Use();
break;
case EventType.MouseDrag:
_textArea.DragMouse(mousePos, showBranchMarkers);
evt.Use();
break;
case EventType.MouseUp:
_textArea.MouseReleased();
evt.Use();
break;
case EventType.ScrollWheel:
_textArea.DoScroll(workingArea, evt.delta.y);
// we cannot Use() (consume) scrollWheel events, as they are still needed in EndScrollView.
break;
}
}
private bool AssemblyFocused() => !((_treeView != null && _treeView.HasFocus()) || (_searchFieldAssembly != null && _searchFieldAssembly.HasFocus()));
private void HandleKeyboardEventAssemblyView(Rect workingArea, KeyboardOperation op, Event evt, bool showBranchMarkers)
{
switch (op)
{
case KeyboardOperation.SelectAll:
_textArea.SelectAll();
evt.Use();
break;
case KeyboardOperation.Copy:
_textArea.DoSelectionCopy();
evt.Use();
break;
case KeyboardOperation.MoveLeft:
if (evt.shift)
{
if (_textArea.HasSelection) _textArea.MoveSelectionLeft(workingArea, showBranchMarkers);
}
else
{
_textArea.MoveView(LongTextArea.Direction.Left, workingArea);
}
evt.Use();
break;
case KeyboardOperation.MoveRight:
if (evt.shift)
{
if (_textArea.HasSelection) _textArea.MoveSelectionRight(workingArea, showBranchMarkers);
}
else
{
_textArea.MoveView(LongTextArea.Direction.Right, workingArea);
}
evt.Use();
break;
case KeyboardOperation.MoveUp:
if (evt.shift)
{
if (_textArea.HasSelection) _textArea.MoveSelectionUp(workingArea, showBranchMarkers);
}
else
{
_textArea.MoveView(LongTextArea.Direction.Up, workingArea);
}
evt.Use();
break;
case KeyboardOperation.MoveDown:
if (evt.shift)
{
if (_textArea.HasSelection) _textArea.MoveSelectionDown(workingArea, showBranchMarkers);
}
else
{
_textArea.MoveView(LongTextArea.Direction.Down, workingArea);
}
evt.Use();
break;
case KeyboardOperation.Search:
_searchBarVisible = true;
_searchFieldAssembly?.SetFocus();
evt.Use();
break;
}
}
/// <remarks>
/// Must be called after Render(...) because of depenency on LongTextArea.finalAreaSize.
/// </remarks>
private void HandleKeyboardEventForSelection(Rect workingArea, bool showBranchMarkers)
{
var evt = Event.current;
if (!_keyboardEvents.TryGetValue(evt, out var op))
{
return;
}
if (AssemblyFocused())
{
// Do input handling for assembly view.
HandleKeyboardEventAssemblyView(workingArea, op, evt, showBranchMarkers);
}
else
{
// This amounts to logic for all else.
switch (op)
{
case KeyboardOperation.Escape:
if (_searchFieldAssembly != null && _searchFieldAssembly.HasFocus() && _searchFilterAssembly == "")
{
_searchBarVisible = false;
evt.Use();
}
break;
case KeyboardOperation.Enter:
if (_searchFieldAssembly != null && _searchFieldAssembly.HasFocus())
{
_textArea.NextSearchHit(evt.shift, workingArea);
saveSearchFieldFromEvent = true;
evt.Use();
}
break;
}
}
}
private void RenderCompileTargetsFilters(float width)
{
GUILayout.BeginHorizontal();
// Handle and render filtering toggles:
var newShowUnityTests = GUILayout.Toggle(_showUnityNamespaceJobs, _contentShowUnityNamespaceJobs);
FlowToNewLine(ref width, width, EditorStyles.toggle.CalcSize(_contentShowDOTSGeneratedJobs));
var newShowDOTSGeneratedJobs = GUILayout.Toggle(_showDOTSGeneratedJobs, _contentShowDOTSGeneratedJobs);
GUILayout.EndHorizontal();
if (newShowUnityTests != _showUnityNamespaceJobs || newShowDOTSGeneratedJobs != _showDOTSGeneratedJobs)
{
_showDOTSGeneratedJobs = newShowDOTSGeneratedJobs;
_showUnityNamespaceJobs = newShowUnityTests;
_treeView.Reload();
}
// Handle and render search filter:
var newFilter = _searchFieldJobs.OnGUI(_searchFilterJobs);
if (newFilter != _searchFilterJobs)
{
_searchFilterJobs = newFilter;
_treeView.Reload();
}
}
private void CompileNewTarget(BurstCompileTarget target, BurstCompilerOptions targetOptions)
{
if (target.IsLoading) { return; }
target.IsLoading = true;
target.JustLoaded = false;
// Setup target and it's compilation options.
// This is done here as EditorGUIUtility.isProSkin must be on main thread.
target.TargetCpu = _targetCpu;
target.DisassemblyKind = _disasmKind;
targetOptions.EnableBurstSafetyChecks = _safetyChecks;
target.IsDarkMode = EditorGUIUtility.isProSkin;
// Don't set debug mode, because it disables optimizations.
// Instead we set debug level (None, Full, LineOnly) below.
targetOptions.EnableBurstDebug = false;
Task.Run(() =>
{
var options = new StringBuilder();
if (targetOptions.TryGetOptions(target.IsStaticMethod ? (MemberInfo)target.Method : target.JobType, out var defaultOptions, isForCompilerClient: true))
{
options.AppendLine(defaultOptions);
// Disables the 2 current warnings generated from code (since they clutter up the inspector display)
// BC1370 - throw inside code not guarded with ConditionalSafetyCheck attribute
// BC1322 - loop intrinsic on loop that has been optimized away
options.AppendLine($"{BurstCompilerOptions.GetOption(BurstCompilerOptions.OptionDisableWarnings, "BC1370;BC1322")}");
options.AppendLine($"{BurstCompilerOptions.GetOption(BurstCompilerOptions.OptionTarget, TargetCpuNames[(int)_targetCpu])}");
// For IRPassAnalysis, we always want full debug information.
if (_disasmKind != DisassemblyKind.IRPassAnalysis)
{
switch (_assemblyKind)
{
case AssemblyOptions.EnhancedWithMinimalDebugInformation:
case AssemblyOptions.ColouredWithMinimalDebugInformation:
options.AppendLine($"{BurstCompilerOptions.GetOption(BurstCompilerOptions.OptionDebug, "2")}");
break;
case AssemblyOptions.ColouredWithFullDebugInformation:
case AssemblyOptions.EnhancedWithFullDebugInformation:
case AssemblyOptions.PlainWithDebugInformation:
options.AppendLine($"{BurstCompilerOptions.GetOption(BurstCompilerOptions.OptionDebug, "1")}");
break;
default:
case AssemblyOptions.PlainWithoutDebugInformation:
options.AppendLine($"{BurstCompilerOptions.GetOption(BurstCompilerOptions.OptionDebug, "0")}");
break;
}
}
else
{
options.AppendLine($"{BurstCompilerOptions.GetOption(BurstCompilerOptions.OptionDebug, "1")}");
}
var baseOptions = options.ToString();
target.RawDisassembly = GetDisassembly(target.Method, baseOptions + GetDisasmOptions()[(int)_disasmKind]);
target.FormattedDisassembly = null;
target.IsBurstError = IsBurstError(target.RawDisassembly);
}
target.IsLoading = false;
target.JustLoaded = true;
});
}
private void RenderBurstJobMenu()
{
float width = position.width / 3;
GUILayout.BeginVertical(GUILayout.Width(width));
// Render Treeview showing burst targets:
GUILayout.Label("Compile Targets", EditorStyles.boldLabel);
RenderCompileTargetsFilters(width);
// Does not give proper rect during layout event.
_inspectorView = GUILayoutUtility.GetRect(GUIContent.none, GUIStyle.none, GUILayout.ExpandHeight(true), GUILayout.ExpandWidth(true));
_treeView.OnGUI(_inspectorView);
GUILayout.EndVertical();
}
private void HandleHorizontalFocus(float workingWidth, bool shouldSetupText, bool isTextFormatted)
{
if (!shouldSetupText || !isTextFormatted || !_burstDisassembler.IsInitialized) { return; }
var branchFiller = _textArea.MaxLineDepth * 10;
if (branchFiller < workingWidth / 2f) { return; }
// Do horizontal padding:
_scrollPos.x = _textArea.MaxLineDepth * 10;
}
private static void RenderLoading()
{
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.BeginVertical();
GUILayout.FlexibleSpace();
GUILayout.Label("Loading...");
GUILayout.FlexibleSpace();
GUILayout.EndVertical();
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
public void OnGUI()
{
if (!_initialized)
{
RenderLoading();
return;
}
// used to give hot control to inspector when a mouseDown event has happened.
// This way we can register a mouseUp happening outside inspector.
int controlID = GUIUtility.GetControlID(FocusType.Passive);
// Make sure that editor options are synchronized
BurstEditorOptions.EnsureSynchronized();
if (_fontSizesText == null)
{
_fontSizesText = new string[FontSizes.Length];
for (var i = 0; i < FontSizes.Length; ++i) _fontSizesText[i] = FontSizes[i].ToString();
}
if (fontSizeIndex == -1)
{
fontSizeIndex = EditorPrefs.GetInt(FontSizeIndexPref, 5);
fontSizeIndex = Math.Max(0, fontSizeIndex);
fontSizeIndex = Math.Min(fontSizeIndex, FontSizes.Length - 1);
}
if (fixedFontStyle == null || fixedFontStyle.font == null) // also check .font as it's reset somewhere when going out of play mode.
{
fixedFontStyle = new GUIStyle(GUI.skin.label);
#if UNITY_2023_1_OR_NEWER
_font = EditorGUIUtility.Load("Fonts/RobotoMono/RobotoMono-Regular.ttf") as Font;
#else
string fontName;
if (Application.platform == RuntimePlatform.WindowsEditor)
{
fontName = "Consolas";
}
else
{
fontName = "Courier";
}
CleanupFont();
_font = Font.CreateDynamicFontFromOSFont(fontName, FontSize);
#endif
fixedFontStyle.font = _font;
fixedFontStyle.fontSize = FontSize;
}
if (_searchFieldJobs == null) _searchFieldJobs = new SearchField();
if (_textArea == null) _textArea = new LongTextArea();
GUILayout.BeginHorizontal();
// SplitterGUILayout.BeginHorizontalSplit is internal in Unity but we don't have much choice
SplitterGUILayout.BeginHorizontalSplit(TreeViewSplitterState);
RenderBurstJobMenu();
GUILayout.BeginVertical();
var selection = _treeView.GetSelection();
if (selection.Count == 1)
{
var targetIndex = selection[0];
_target = _targets[targetIndex - 1];
var targetOptions = _target.Options;
var targetChanged = _previousTargetIndex != targetIndex;
_previousTargetIndex = targetIndex;
// Stash selected item name to handle domain reloads more gracefully
_selectedItem = _target.GetDisplayName();
if (_assemblyKind == null)
{
if (_enhancedDisassembly)
{
_assemblyKind = AssemblyOptions.ColouredWithMinimalDebugInformation;
}
else
{
_assemblyKind = AssemblyOptions.PlainWithoutDebugInformation;
}
_oldAssemblyKind = (AssemblyOptions)_assemblyKind;
}
// We are currently formatting only Asm output
var isTextFormatted = IsEnhanced((AssemblyOptions)_assemblyKind) && SupportsEnhancedRendering;
// Depending if we are formatted or not, we don't render the same text
var textToRender = _target.RawDisassembly?.TrimStart('\n');
// Only refresh if we are switching to a new selection that hasn't been disassembled yet
// Or we are changing disassembly settings (safety checks / enhanced disassembly)
var targetRefresh = textToRender == null
|| _target.DisassemblyKind != _disasmKind
|| targetOptions.EnableBurstSafetyChecks != _safetyChecks
|| _target.TargetCpu != _targetCpu
|| _target.IsDarkMode != EditorGUIUtility.isProSkin;
if (_assemblyKindPrior != _assemblyKind)
{
targetRefresh = true;
_assemblyKindPrior = _assemblyKind; // Needs to be refreshed, as we need to change disassembly options
// If the target did not changed but our assembly kind did, we need to remember this.
if (!targetChanged)
{
_sameTargetButDifferentAssemblyKind = true;
}
}
// If the previous target changed the assembly kind and we have a target change, we need to
// refresh the assembly because we'll have cached the previous assembly kinds output rather
// than the one requested.
if (_sameTargetButDifferentAssemblyKind && targetChanged)
{
targetRefresh = true;
_sameTargetButDifferentAssemblyKind = false;
}
if (targetRefresh)
{
CompileNewTarget(_target, targetOptions);
}
_prevWasCompileError = _isCompileError;
_isCompileError = _target.IsBurstError;
_buttonOverlapInspectorView = 0;
var oldSimdSmellTest = _smellTest;
HandleButtonBars(_target, targetChanged, out var fontSize, out var expandAllBlocks, out var focusCode);
var simdSmellTestChanged = oldSimdSmellTest != _smellTest;
// Guard against _textArea being used, as the assembly isn't ready yet.
// Have to test against event so it cannot finish between a Layout event and Repaint event;
// this is necessary as we cannot alter GUI between these events.
if (_target.HasRequiredBurstCompileAttributes && (_target.IsLoading || (_target.JustLoaded && Event.current.type != EventType.Layout)))
{
RenderLoading();
// Need to close the splits we opened.
GUILayout.EndVertical();
SplitterGUILayout.EndHorizontalSplit();
GUILayout.EndHorizontal();
return;
}
var justLoaded = _target.JustLoaded;
_target.JustLoaded = false;
// If ´CompileNewTarget´ finishes before we enter loading screen above `textToRender` might not be set.
textToRender ??= _target.RawDisassembly?.TrimStart('\n');
if (!string.IsNullOrEmpty(textToRender))
{
// we should only call SetDisassembler(...) the first time assemblyKind is changed with same target.
// Otherwise it will kep re-initializing fields such as _folded, meaning we can no longer fold/unfold.
var shouldSetupText = !_textArea.IsTextSet(_selectedItem)
|| justLoaded
|| simdSmellTestChanged;
if (shouldSetupText)
{
_textArea.SetText(
_selectedItem,
textToRender,
_target.IsDarkMode,
_burstDisassembler,
isTextFormatted && _burstDisassembler.Initialize(
textToRender,
FetchAsmKind(_targetCpu, _disasmKind),
_target.IsDarkMode,
IsColoured((AssemblyOptions)_assemblyKind),
_smellTest));
}
if (justLoaded)
{
_scrollPos = Vector2.zero;
}
HandleHorizontalFocus(
_inspectorView.width == 1f ? _buttonBarWidth : _inspectorView.width,
shouldSetupText,
isTextFormatted
);
// Fixing lastRectSize to actually be size of scroll view
_inspectorView.position = _scrollPos;
_inspectorView.width = position.width - (_inspectorView.width + _scrollbarThickness);
_inspectorView.height -= (_buttonOverlapInspectorView + 4); //+4 for alignment.
if (_searchBarVisible) _inspectorView.height -= EditorStyles.searchField.CalcHeight(GUIContent.none, 2); // 2 is just arbitrary, as the width does not alter height
// repaint indicate end of frame, so we can alter width for menu items to new correct.
if (Event.current.type == EventType.Repaint)
{
_buttonBarWidth = _inspectorView.width - _scrollbarThickness;
}
// Do search if we did not try and find assembly and we were actually going to do a search.
if (_focusTargetJob && TryFocusJobInAssemblyView(ref _inspectorView, shouldSetupText, _target))
{
_scrollPos.y = _inspectorView.y - _textArea.fontHeight*10;
}
_scrollPos = GUILayout.BeginScrollView(_scrollPos, true, true);
if (Event.current.type != EventType.Layout) // we always want mouse position feedback
{
_textArea.Interact(_inspectorView, Event.current.type);
}
// Set up search information if it is happening.
Regex regx = default;
SearchCriteria sc = default;
var doSearch = _searchBarVisible && _searchFilterAssembly != "";
var wrongRegx = false;
if (doSearch)
{
sc = new SearchCriteria(_searchFilterAssembly, _doIgnoreCase, _doWholeWordMatch, _doRegex);
if (_doRegex)
{
try
{
var opt = RegexOptions.Compiled | RegexOptions.CultureInvariant;
if (!_doIgnoreCase) opt |= RegexOptions.IgnoreCase;
var filter = _searchFilterAssembly;
if (_doWholeWordMatch) filter = @"\b" + filter + @"\b";
regx = new Regex(filter, opt);
}
catch (Exception)
{
// Regex was invalid
wrongRegx = true;
doSearch = false;
}
}
}
var doRepaint = _textArea.Render(fixedFontStyle, _inspectorView, _showBranchMarkers, doSearch, sc, regx);
// A change in the underlying textArea has happened, that requires the GUI to be repainted during this frame.
if (doRepaint) Repaint();
if (Event.current.type != EventType.Layout)
{
HandleMouseEventForSelection(_inspectorView, controlID, _showBranchMarkers);
HandleKeyboardEventForSelection(_inspectorView, _showBranchMarkers);
}
if (_leftClicked)
{
GenericMenu menu = new GenericMenu();
menu.AddItem(EditorGUIUtility.TrTextContent("Copy Selection"), false, _textArea.DoSelectionCopy);
menu.AddItem(EditorGUIUtility.TrTextContent("Copy Color Tags"), _textArea.CopyColorTags, _textArea.ChangeCopyMode);
menu.AddItem(EditorGUIUtility.TrTextContent("Select All"), false, _textArea.SelectAll);
menu.AddItem(EditorGUIUtility.TrTextContent($"Find in {DisassemblyKindNames[(int)_disasmKind]}"), _searchBarVisible, EnableDisableSearchBar);
menu.ShowAsContext();
_leftClicked = false;
}
GUILayout.EndScrollView();
if (_searchBarVisible)
{
if (_searchFieldAssembly == null)
{
_searchFieldAssembly = new SearchField();
_searchFieldAssembly.autoSetFocusOnFindCommand = false;
}
int hitnumbers = _textArea.NrSearchHits > 0 ? _textArea.ActiveSearchNr + 1 : 0;
var hitNumberContent = new GUIContent(" " + hitnumbers + " of " + _textArea.NrSearchHits + " hits");
GUILayout.BeginHorizontal();
// Makes sure that on "enter" keyboard event, the focus is not taken away from searchField.
if (saveSearchFieldFromEvent) GUI.FocusControl("BurstInspectorGUI");
string newFilterAssembly;
if (wrongRegx)
{
var colb = GUI.contentColor;
GUI.contentColor = Color.red;
newFilterAssembly = _searchFieldAssembly.OnGUI(_searchFilterAssembly);
GUI.contentColor = colb;
}
else
{
newFilterAssembly = _searchFieldAssembly.OnGUI(_searchFilterAssembly);
}
// Give back focus to the searchField, if we took it away.
if (saveSearchFieldFromEvent)
{
_searchFieldAssembly.SetFocus();
saveSearchFieldFromEvent = false;
}
if (newFilterAssembly != _searchFilterAssembly)
{
_searchFilterAssembly = newFilterAssembly;
_textArea.StopSearching();
}
_doIgnoreCase = GUILayout.Toggle(_doIgnoreCase, _ignoreCase);
_doWholeWordMatch = GUILayout.Toggle(_doWholeWordMatch, _matchWord);
_doRegex = GUILayout.Toggle(_doRegex, _regexSearch);
GUILayout.Label(hitNumberContent);
if (GUILayout.Button(GUIContent.none, EditorStyles.searchFieldCancelButton))
{
_searchBarVisible = false;
_textArea.StopSearching();
}
GUILayout.EndHorizontal();
}
}
if (fontSize != fontSizeIndex)
{
_textArea.Invalidate();
fontSizeIndex = fontSize;
EditorPrefs.SetInt(FontSizeIndexPref, fontSize);
fixedFontStyle = null;
}
if (expandAllBlocks)
{
_textArea.ExpandAllBlocks();
}
if (focusCode)
{
_textArea.FocusCodeBlocks();
}
}
GUILayout.EndVertical();
SplitterGUILayout.EndHorizontalSplit();
GUILayout.EndHorizontal();
}
public static bool IsBurstError(string disassembly)
{
return _rx.IsMatch(disassembly ?? "");
}
/// <summary>
/// Focuses the view on the active function if a jump is doable.
/// </summary>
/// <param name="workingArea">Current assembly view.</param>
/// <param name="wasTextSetup">Whether text was set in <see cref="_textArea"/>.</param>
/// <param name="target">Target job to find function in.</param>
/// <returns>Whether a focus was attempted or not.</returns>
private bool TryFocusJobInAssemblyView(ref Rect workingArea, bool wasTextSetup, BurstCompileTarget target)
{
bool TryFindByLabel(ref Rect workingArea)
{
var regx = default(Regex);
var sb = new StringBuilder();
if (target.IsStaticMethod)
{
// Search for fullname as label
// Null reference not a danger, because of target being a static method
sb.Append(target.Method.DeclaringType.ToString().Replace("+", "."));
// Generic labels will be sorounded by "", while standard static methods won't
var genericArguments = target.JobType.GenericTypeArguments;
if (genericArguments.Length > 0)
{
// Need to alter the generic arguments from [] to <> form
// Removing [] form
var idx = sb.ToString().LastIndexOf('[');
sb.Remove(idx, sb.Length - idx);
// Adding <> form
sb.Append('<').Append(BurstCompileTarget.Pretty(genericArguments[0]));
for (var i = 1; i < genericArguments.Length; i++)
{
sb.Append(",").Append(BurstCompileTarget.Pretty(genericArguments[i]));
}
sb.Append('>').Append('.').Append(target.Method.Name);
}
else
{
sb.Append('.').Append(target.Method.Name);
}
const RegexOptions opt = RegexOptions.Compiled | RegexOptions.CultureInvariant;
regx = new Regex(@$"{Regex.Escape(sb.ToString())}[^"":]+"":", opt);
}
else
{
// Append full method name. Using display name for simpler access
var targetName = target.GetDisplayName();
// Remove part that tells about used interface
var idx = 0;
// If generic the argument part must also be removed, as they won't match
if ((idx = targetName.IndexOf('[')) == -1) idx = targetName.IndexOf('-') - 1;
targetName = targetName.Remove(idx);
sb.Append($@""".*<{targetName}.*"":");
const RegexOptions opt = RegexOptions.Compiled | RegexOptions.CultureInvariant;
regx = new Regex(sb.ToString(), opt);
}
var sc = new SearchCriteria(sb.ToString(), false, false, true);
return _textArea.SearchText(sc, regx, ref workingArea, true, true);
}
var foundTarget = false;
// _isTextSetLastEvent used so we call this at the first scroll-able event after text was set.
// We cannot scroll during used or layout events, and the order of events are:
// 1. Used event: text is set in textArea
// 2. Layout event: Cannot do the jump yet
// 3. Repaint event: Now jump is doable
// Hence _isTextSetLastEvent is only set on layout events (during phase 2)
if (wasTextSetup)
{
// Need to call Layout to setup fontsize before searching
_textArea.Layout(fixedFontStyle, _textArea.horizontalPad);
foundTarget = TryFindByLabel(ref workingArea);
_textArea.StopSearching(); // Clear the internals of _textArea from this search; to avoid highlighting
// Clear other possible search, so it won't interfere with this.
_searchFilterAssembly = string.Empty;
// We need to do a Repaint() in order for the view to actually update immediately.
if (foundTarget) Repaint();
}
return foundTarget;
}
private void EnableDisableSearchBar()
{
_searchBarVisible = !_searchBarVisible;
if (_searchBarVisible && _searchFieldAssembly != null)
{
_searchFieldAssembly.SetFocus();
}
else if (!_searchBarVisible)
{
_textArea.StopSearching();
}
}
private bool _doIgnoreCase = false;
private bool _doWholeWordMatch = false;
private bool _doRegex = false;
internal static string GetDisassembly(MethodInfo method, string options)
{
try
{
var result = BurstCompilerService.GetDisassembly(method, options);
if (result.IndexOf('\t') >= 0)
{
result = result.Replace("\t", " ");
}
// Workaround to remove timings
if (result.Contains("Burst timings"))
{
var index = result.IndexOf("While compiling", StringComparison.Ordinal);
if (index > 0)
{
result = result.Substring(index);
}
}
return result;
}
catch (Exception e)
{
return "Failed to compile:\n" + e.Message;
}
}
internal static BurstDisassembler.AsmKind FetchAsmKind(BurstTargetCpu cpu, DisassemblyKind kind)
{
if (kind == DisassemblyKind.Asm)
{
switch (cpu)
{
case BurstTargetCpu.Auto:
string cpuType = BurstCompiler.GetTargetCpuFromHost();
if (cpuType.Contains("Arm"))
{
return BurstDisassembler.AsmKind.ARM;
}
return BurstDisassembler.AsmKind.Intel;
case BurstTargetCpu.ARMV7A_NEON32:
case BurstTargetCpu.ARMV8A_AARCH64:
case BurstTargetCpu.ARMV8A_AARCH64_HALFFP:
case BurstTargetCpu.THUMB2_NEON32:
case BurstTargetCpu.ARMV9A:
return BurstDisassembler.AsmKind.ARM;
case BurstTargetCpu.WASM32:
return BurstDisassembler.AsmKind.Wasm;
default:
return BurstDisassembler.AsmKind.Intel;
}
}
else
{
return BurstDisassembler.AsmKind.LLVMIR;
}
}
}
/// <summary>
/// Important: id for namespaces are negative, and ids for jobs are positive.
/// This lets us use the id for a job as an index directy into <see cref="_targets"/>.
/// Hence before going from <see cref="TreeViewItem"/> to <see cref="_targets"/> index,
/// One should check whether current item has any children (Only jobs are leafs).
/// </summary>
internal class BurstMethodTreeView : TreeView
{
private readonly Func<string> _getFilter;
private readonly Func<(bool,bool)> _getJobListFilterToggles;
private List<BurstCompileTarget> _targets;
public BurstMethodTreeView(TreeViewState state, Func<string> getFilter, Func<(bool,bool)> getJobListFilterToggles) : base(state)
{
_getFilter = getFilter;
_getJobListFilterToggles = getJobListFilterToggles;
showBorder = true;
}
public void Initialize(List<BurstCompileTarget> targets, bool identicalTargets)
{
_targets = targets;
Reload();
if (!identicalTargets) { ExpandAll(); }
}
/// <remarks>
/// Assumes that <see cref="str"/> is derived from <see cref="Type"/>.<see cref="Type.FullName"/>
/// i.e. types are separated by '+'.
/// </remarks>
/// <param name="str">Given type name string.</param>
/// <returns>(List of namespaces/types, index of method name in <see cref="str"/>)</returns>
internal static (List<StringSlice> ns, int nsEndIdx) ExtractNameSpaces(in string str)
{
if (str is null) { throw new ArgumentNullException(nameof(str)); }
var nameSpaces = new List<StringSlice>();
int len = str.Length;
int scope = 0;
int previdx = 0;
for (int i = 0; i < len; i++)
{
bool stop = false;
char c = str[i];
switch (c)
{
case '(':
// Jump out as we just found argument list!!!
stop = true;
break;
// We keep looking, as classes might have these in name:
case '{':
case '<':
case '[':
scope++;
break;
case '}':
case '>':
case ']':
scope--;
break;
case '+' when scope == 0:
nameSpaces.Add(new StringSlice(str, previdx, i - previdx));
previdx = i + 1;
break;
}
if (stop) { break; }
}
return (nameSpaces, previdx);
}
internal static (int idN, List<TreeViewItem> added, List<StringSlice> nameSpace)
ProcessNewItem(int idN, int idJ, BurstCompileTarget newTarget, List<StringSlice> oldNameSpace)
{
// Find all namespaces used for new target:
string fns = newTarget.JobType.FullName;
string dn = newTarget.GetDisplayName();
(List<StringSlice> newNameSpaces, int nameSpaceEndIdx) = ExtractNameSpaces(fns);
int methodNameIdx = nameSpaceEndIdx;
if (newTarget.IsStaticMethod)
{
// Static method does not have the function name in fns, so fix methodNameIdx.
methodNameIdx = dn.IndexOf(newTarget.Method.Name, StringComparison.InvariantCulture);
// Add the last namespace:
newNameSpaces.Add(new StringSlice(dn, nameSpaceEndIdx, methodNameIdx-1 - nameSpaceEndIdx));
}
string methodName = dn.Substring(methodNameIdx);
int iNewNs = 0;
int lNewNs = newNameSpaces.Count;
int iOldNs = 0;
int lOldNs = oldNameSpace.Count;
var added = new List<TreeViewItem>(lNewNs);
int depth = 0;
// Skip all namespaces shared by previous but increase depth accordingly:
for (; iNewNs < lNewNs && iOldNs < lOldNs && newNameSpaces[iNewNs] == oldNameSpace[iOldNs];
depth++, iNewNs++, iOldNs++) {}
// Handle all new namespaces:
for (; iNewNs < lNewNs;
depth++, iNewNs++)
{
added.Add(new TreeViewItem { id = --idN, depth = depth, displayName = newNameSpaces[iNewNs].ToString()});
}
// Add the function name:
added.Add(new TreeViewItem { id = idJ, depth = depth, displayName = methodName });
return (idN, added, newNameSpaces);
}
protected override TreeViewItem BuildRoot()
{
var root = new TreeViewItem {id = 0, depth = -1, displayName = "Root"};
var allItems = new List<TreeViewItem>();
if (_targets != null)
{
var filter = _getFilter();
var (showUnityNamespaceJobs, showDOTSGeneratedJobs) = _getJobListFilterToggles();
// Have two separate ids so "jobs ids == jobs index".
int idJ = 0;
int idN = 0;
var oldNameSpace = new List<StringSlice>();
foreach (BurstCompileTarget target in _targets)
{
// idJ used as index into _targets, which means it should also take hidden targets into account!
idJ++;
string displayName = target.GetDisplayName();
bool filtered =
(!string.IsNullOrEmpty(filter) &&
displayName.IndexOf(filter, 0, displayName.Length,
StringComparison.InvariantCultureIgnoreCase) < 0)
|| (!showUnityNamespaceJobs &&
displayName.StartsWith("Unity.", StringComparison.InvariantCultureIgnoreCase))
|| (!showDOTSGeneratedJobs &&
displayName.Contains(".Generated"));
if (filtered) { continue; }
try
{
var (newIdN, added, nameSpace) =
ProcessNewItem(idN, idJ, target, oldNameSpace);
allItems.AddRange(added);
idN = newIdN;
oldNameSpace = nameSpace;
}
catch (Exception ex)
{
Debug.Log($"Internal error: Could not add {displayName}\n Because: {ex.Message}");
}
}
}
SetupParentsAndChildrenFromDepths(root, allItems);
return root;
}
public new IList<int> GetSelection()
{
IList<int> selection = base.GetSelection();
// selection == non-leaf node => no job selected
if (selection.Count > 0 && selection[0] < 0) { return new List<int>(); }
return selection;
}
internal bool TrySelectByDisplayName(string name)
{
var id = 1;
foreach (var t in _targets)
{
if (t.GetDisplayName() == name)
{
try
{
SetSelection(new[] { id });
FrameItem(id);
return true;
}
catch (ArgumentException)
{
// When a search is made in the job list, such that the job we search for is filtered away
// FrameItem(id) will throw a dictionary error. So we catch this, and tell the caller that
// it cannot be selected.
return false;
}
}
else
{
++id;
}
}
return false;
}
protected override void RowGUI(RowGUIArgs args)
{
if (!args.item.hasChildren)
{
var target = _targets[args.item.id - 1];
var wasEnabled = GUI.enabled;
GUI.enabled = target.HasRequiredBurstCompileAttributes;
base.RowGUI(args);
GUI.enabled = wasEnabled;
}
else
{
// Label GUI:
base.RowGUI(args);
}
}
protected override void SingleClickedItem(int id)
{
// If labeled click try and fold/expand:
if (id < 0)
{
SetExpanded(id, !IsExpanded(id));
SetSelection(new List<int>());
}
}
protected override bool CanMultiSelect(TreeViewItem item)
{
return false;
}
}
}