3934 lines
112 KiB
C#
3934 lines
112 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Reflection;
|
|
using UnityEngine;
|
|
using UnityEngine.SceneManagement;
|
|
|
|
namespace DebuggingEssentials
|
|
{
|
|
public class RuntimeInspector : MonoBehaviour
|
|
{
|
|
public enum DrawMode
|
|
{
|
|
Object = 0,
|
|
Assembly = 1
|
|
}
|
|
|
|
public delegate void FloatMethod(float newValue);
|
|
|
|
public enum WindowType
|
|
{
|
|
Hierarchy = 0,
|
|
Inspector = 1
|
|
}
|
|
|
|
public struct Bool3
|
|
{
|
|
public bool v1;
|
|
|
|
public bool v2;
|
|
|
|
public bool v3;
|
|
|
|
public void Reset()
|
|
{
|
|
v1 = (v2 = (v3 = false));
|
|
}
|
|
}
|
|
|
|
public class DrawInfo : CullItem
|
|
{
|
|
public static DrawInfo empty = new DrawInfo(foldout: false);
|
|
|
|
public bool foldout;
|
|
|
|
public int passSearch;
|
|
|
|
public DrawInfo(bool foldout)
|
|
: base(0)
|
|
{
|
|
this.foldout = foldout;
|
|
}
|
|
}
|
|
|
|
[NonSerialized]
|
|
public bool needHierarchySearch;
|
|
|
|
public bool enableCameraOnStart;
|
|
|
|
private GUIChangeBool pauseGame = new GUIChangeBool();
|
|
|
|
private GUIChangeBool useNavigationCamera = new GUIChangeBool();
|
|
|
|
private GUIChangeBool drawScenes = new GUIChangeBool(value: true);
|
|
|
|
private GUIChangeBool drawAssemblies = new GUIChangeBool();
|
|
|
|
private GUIChangeBool drawMemory = new GUIChangeBool();
|
|
|
|
private GUIChangeBool drawUnityAssemblies = new GUIChangeBool();
|
|
|
|
private GUIChangeBool drawSystemAssemblies = new GUIChangeBool();
|
|
|
|
private GUIChangeBool drawMonoAssemblies = new GUIChangeBool();
|
|
|
|
private GUIChangeBool drawOtherAssemblies = new GUIChangeBool(value: true);
|
|
|
|
private GUIChangeBool drawMonoBehaviourMemory = new GUIChangeBool(value: true);
|
|
|
|
private GUIChangeBool drawScriptableObjectMemory = new GUIChangeBool();
|
|
|
|
private GUIChangeBool drawComponentMemory = new GUIChangeBool();
|
|
|
|
private GUIChangeBool drawOtherMemory = new GUIChangeBool();
|
|
|
|
private GUIChangeBool drawCompareFilter = new GUIChangeBool();
|
|
|
|
private GUIChangeBool drawHideFlags = new GUIChangeBool(value: true);
|
|
|
|
private GUIChangeBool showHelp = new GUIChangeBool();
|
|
|
|
private GUIChangeBool showSettings = new GUIChangeBool();
|
|
|
|
private GUIChangeBool linkSelect = new GUIChangeBool(value: true);
|
|
|
|
private FastList<DrawInfo> selectList = new FastList<DrawInfo>(32);
|
|
|
|
private GameObject lastScreenRayedGO;
|
|
|
|
private static Dictionary<NamespaceTypes, DrawInfo> namespaceTypesLookup = new Dictionary<NamespaceTypes, DrawInfo>();
|
|
|
|
public static FastList<CustomAssembly> customAssemblies = new FastList<CustomAssembly>();
|
|
|
|
private static bool hasInitAssemblies;
|
|
|
|
public Dictionary<string, DrawInfo> memoryLookup = new Dictionary<string, DrawInfo>();
|
|
|
|
public Dictionary<MemoryObject, DrawInfo> memoryObjectLookup = new Dictionary<MemoryObject, DrawInfo>();
|
|
|
|
private SortedFastList<MemorySnapshot> memorySnapshots = new SortedFastList<MemorySnapshot>();
|
|
|
|
private MemorySnapshot selectedMemorySnapshot;
|
|
|
|
private MemorySnapshot difSnapshot = new MemorySnapshot();
|
|
|
|
private CompareMode memoryCompareMode;
|
|
|
|
private bool doMemorySnapshotCompare;
|
|
|
|
private FastList<Transform> transformList = new FastList<Transform>(4096);
|
|
|
|
private FastList<Transform> searchPassedList = new FastList<Transform>(4096);
|
|
|
|
private FastList<DrawInfo> searchFailedList = new FastList<DrawInfo>(4096);
|
|
|
|
private List<GameObject> searchRootList = new List<GameObject>(1024);
|
|
|
|
private bool isSearchingScenes;
|
|
|
|
private FastList<CustomType> searchTypePassedList = new FastList<CustomType>(4096);
|
|
|
|
private FastList<CustomType> searchTypeFailedList = new FastList<CustomType>(4096);
|
|
|
|
private int totalCount;
|
|
|
|
private bool isSearchingAssemblies;
|
|
|
|
private HashSet<DrawInfo> searchMemoryObjectPassedList = new HashSet<DrawInfo>();
|
|
|
|
private HashSet<DrawInfo> searchMemoryObjectFailedList = new HashSet<DrawInfo>();
|
|
|
|
private bool isSearchingMemory;
|
|
|
|
private int searchGameObjectsPerFrame;
|
|
|
|
private Vector2 settingsScrollView;
|
|
|
|
private float refreshHierarchySearch;
|
|
|
|
private bool scrollToSelected;
|
|
|
|
private const int prefix = 150;
|
|
|
|
public const BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy;
|
|
|
|
private Dictionary<Type, TypeData> typeDataLookup = new Dictionary<Type, TypeData>();
|
|
|
|
private Dictionary<MethodInfo, string> methodArgumentsLookup = new Dictionary<MethodInfo, string>();
|
|
|
|
private Dictionary<MemberInfo, MemberData> memberDataLookup = new Dictionary<MemberInfo, MemberData>();
|
|
|
|
private FastQueue<string> methodArgs = new FastQueue<string>(4);
|
|
|
|
private ScrollViewCullDrawOnce scrollViewCull = new ScrollViewCullDrawOnce();
|
|
|
|
private GUIChangeBool showFields = new GUIChangeBool(value: true);
|
|
|
|
private GUIChangeBool showProperties = new GUIChangeBool(value: true);
|
|
|
|
private GUIChangeBool showMethods = new GUIChangeBool(value: true);
|
|
|
|
private GUIChangeBool showInherited = new GUIChangeBool(value: true);
|
|
|
|
private GUIChangeBool showDeclared = new GUIChangeBool(value: true);
|
|
|
|
private GUIChangeBool showStatic = new GUIChangeBool(value: true);
|
|
|
|
private GUIChangeBool showInstance = new GUIChangeBool(value: true);
|
|
|
|
private GUIChangeBool showPublic = new GUIChangeBool(value: true);
|
|
|
|
private GUIChangeBool showPrivate = new GUIChangeBool(value: true);
|
|
|
|
private GUIChangeBool showProtected = new GUIChangeBool(value: true);
|
|
|
|
private FastList<object> searchObjectList = new FastList<object>(1024);
|
|
|
|
private List<Component> searchComponentList = new List<Component>(1024);
|
|
|
|
private FastList<SearchMember> searchMemberList = new FastList<SearchMember>(4096);
|
|
|
|
private FastList<SearchMember> searchMemberPassedList = new FastList<SearchMember>(4096);
|
|
|
|
private FastList<SearchMember> searchMemberFailedList = new FastList<SearchMember>(4096);
|
|
|
|
private HashSet<object> searchDoubles = new HashSet<object>();
|
|
|
|
private HashSet<object> skip = new HashSet<object>();
|
|
|
|
private HashSet<Type> searchTypes = new HashSet<Type>();
|
|
|
|
private bool isSearchingInspector;
|
|
|
|
private bool needInspectorSearch;
|
|
|
|
private float refreshInspectorSearch;
|
|
|
|
private int inspectorSearchLevel = 1;
|
|
|
|
private int localTotalSearched;
|
|
|
|
private int searchInspectorPerFrame;
|
|
|
|
private EditField editField = new EditField();
|
|
|
|
private string editText;
|
|
|
|
private int selectAllEditText;
|
|
|
|
private GameObject oldSelectedGO;
|
|
|
|
private object oldDrawObject;
|
|
|
|
private DrawMode drawMode;
|
|
|
|
private float fieldWidth;
|
|
|
|
private Type selectedStaticType;
|
|
|
|
private UnityEngine.Object selectedObject;
|
|
|
|
private float memberSeparationHeight = 15f;
|
|
|
|
private int totalSearched;
|
|
|
|
private int totalFound;
|
|
|
|
public static RuntimeInspector instance;
|
|
|
|
public static GameObject selectionIndicatorGO;
|
|
|
|
public static GameObject selectedGO;
|
|
|
|
public static NavigationCamera navigationCamera;
|
|
|
|
public static bool show;
|
|
|
|
public bool showOnStart;
|
|
|
|
public bool useSameEditorAsBuildShowKey = true;
|
|
|
|
public AdvancedKey showToggleKeyEditor = new AdvancedKey(KeyCode.F10);
|
|
|
|
public AdvancedKey showToggleKeyBuild = new AdvancedKey(KeyCode.F10);
|
|
|
|
public AdvancedKey gamePauseKey = new AdvancedKey(KeyCode.P, shift: true);
|
|
|
|
public AdvancedKey focusCameraKey = new AdvancedKey(KeyCode.F);
|
|
|
|
public AdvancedKey alignWithViewKey = new AdvancedKey(KeyCode.F, shift: true, control: true);
|
|
|
|
public AdvancedKey moveToViewKey = new AdvancedKey(KeyCode.F, shift: true, control: false, alt: true);
|
|
|
|
public AdvancedKey followCameraKey = new AdvancedKey(KeyCode.G);
|
|
|
|
public LayerMask selectLayerMask = 1;
|
|
|
|
public bool unfoldMultipleScenesOnStart;
|
|
|
|
public SO_Window windowData;
|
|
|
|
public SO_NavigationCamera navigationCameraData;
|
|
|
|
private Dictionary<CustomAssembly, DrawInfo> assemblyLookup = new Dictionary<CustomAssembly, DrawInfo>();
|
|
|
|
private Dictionary<CustomType, DrawInfo> typeLookup = new Dictionary<CustomType, DrawInfo>();
|
|
|
|
private Dictionary<Scene, DrawInfo> sceneLookup = new Dictionary<Scene, DrawInfo>();
|
|
|
|
private Dictionary<Transform, DrawInfo> tLookup = new Dictionary<Transform, DrawInfo>();
|
|
|
|
private static Dictionary<string, FastList<Type>> typeNameLookup = new Dictionary<string, FastList<Type>>(30000);
|
|
|
|
private FastList<Dictionary<object, DrawInfo>> memberLookups = new FastList<Dictionary<object, DrawInfo>>();
|
|
|
|
private List<GameObject> rootList = new List<GameObject>(1024);
|
|
|
|
private List<Component> components = new List<Component>(1024);
|
|
|
|
private Texture texArrowFolded;
|
|
|
|
private Texture texArrowUnfolded;
|
|
|
|
private GUISkin skin;
|
|
|
|
private const int memberLookupsCapacity = 128;
|
|
|
|
private Camera mainCam;
|
|
|
|
private Vector3 selectionIndicatorLocalPos;
|
|
|
|
private Quaternion selectionIndicatorLocalRot;
|
|
|
|
private Vector2 lastMousePos;
|
|
|
|
private Vector2 mousePos;
|
|
|
|
private Color colorInherited = new Color(1f, 0.5f, 0.2f, 1f);
|
|
|
|
private Color colorStatic = new Color(0.5f, 0.5f, 1f);
|
|
|
|
private Color colorPublic = new Color(0.25f, 1f, 0.25f, 1f);
|
|
|
|
private Color colorProtected = new Color(1f, 1f, 0.25f);
|
|
|
|
private Color colorPrivate = new Color(1f, 0.25f, 0.25f, 1f);
|
|
|
|
private Event currentEvent;
|
|
|
|
private float oldTimeScale;
|
|
|
|
private WindowSettings inspectorWindow;
|
|
|
|
private WindowSettings hierarchyWindow;
|
|
|
|
private ScrollViewCullData hierarchyCull;
|
|
|
|
private GUIStyle wrapButton;
|
|
|
|
private GUIStyle wrapTextField;
|
|
|
|
private DrawEnum drawEnum;
|
|
|
|
private int ActiveMemorySnapshotCount
|
|
{
|
|
get
|
|
{
|
|
int num = 0;
|
|
for (int i = 0; i < memorySnapshots.Count; i++)
|
|
{
|
|
if (memorySnapshots.items[i].selected.Value)
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
}
|
|
|
|
public static event FloatMethod onTimeScaleChanged;
|
|
|
|
public static event SetActiveMethod onSetActive;
|
|
|
|
private void Pause()
|
|
{
|
|
if (pauseGame.RealValue)
|
|
{
|
|
oldTimeScale = Time.timeScale;
|
|
Time.timeScale = float.Epsilon;
|
|
}
|
|
else
|
|
{
|
|
if (oldTimeScale == float.Epsilon)
|
|
{
|
|
oldTimeScale = 1f;
|
|
}
|
|
Time.timeScale = oldTimeScale;
|
|
}
|
|
if (RuntimeInspector.onTimeScaleChanged != null)
|
|
{
|
|
RuntimeInspector.onTimeScaleChanged(Time.timeScale);
|
|
}
|
|
}
|
|
|
|
private void DrawHierarchy(int windowId)
|
|
{
|
|
WindowManager.BeginRenderTextureGUI();
|
|
GUI.backgroundColor = new Color(1f, 1f, 1f, 1f);
|
|
GUI.color = Color.white;
|
|
DrawWindowTitle(Helper.GetGUIContent("Hierarchy", windowData.texHierarchy), hierarchyWindow);
|
|
if (hierarchyWindow.isMinimized)
|
|
{
|
|
GUILayout.Space(-2f);
|
|
HierarchyDragAndTooltip(windowId);
|
|
return;
|
|
}
|
|
BeginVerticalBox();
|
|
GUILayout.BeginHorizontal();
|
|
skin.button.fontSize = 10;
|
|
GUILayout.Label("Time Scale", GUILayout.Width(75f));
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Pause", windowData.texPause, "Toggles Time-Scale to 0 and before"), pauseGame, Color.green, 65f))
|
|
{
|
|
Pause();
|
|
}
|
|
float timeScale = Time.timeScale;
|
|
GUILayout.Label(Time.timeScale.ToString("F2"), GUILayout.Width(30f));
|
|
Time.timeScale = GUILayout.HorizontalSlider(Time.timeScale, float.Epsilon, 3f);
|
|
if (Time.timeScale == float.Epsilon)
|
|
{
|
|
pauseGame.Value = true;
|
|
}
|
|
else
|
|
{
|
|
pauseGame.Value = false;
|
|
}
|
|
if (GUILayout.Button(Helper.GetGUIContent("R", "Reset Time-Scale to 1"), GUILayout.Width(20f)))
|
|
{
|
|
Time.timeScale = 1f;
|
|
}
|
|
if (Time.timeScale != timeScale && RuntimeInspector.onTimeScaleChanged != null)
|
|
{
|
|
RuntimeInspector.onTimeScaleChanged(Time.timeScale);
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
GUILayout.BeginHorizontal();
|
|
if (useNavigationCamera.Value)
|
|
{
|
|
GUILayout.Label("Fov " + NavigationCamera.fov.ToString("F0"), GUILayout.Width(55f));
|
|
NavigationCamera.fov = GUILayout.HorizontalSlider(NavigationCamera.fov, 2f, 90f);
|
|
if (GUILayout.Button(Helper.GetGUIContent("R", "Reset fov to 60"), GUILayout.Width(20f)))
|
|
{
|
|
NavigationCamera.fov = 60f;
|
|
}
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
GUILayout.BeginHorizontal();
|
|
Helper.DrawShowButton(windowData, Helper.GetGUIContent("Help", windowData.texHelp, "Show Controls"), showHelp, Color.green);
|
|
Helper.DrawShowButton(windowData, Helper.GetGUIContent("Settings", windowData.texSettings, "Change tooltip, search and Camera settings"), showSettings, Color.green);
|
|
Texture image = (NavigationCamera.followTarget ? windowData.texCameraFollow : windowData.texCamera);
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Camera", image, "Toggle navigation camera\n\nWhen enabled use:\n" + focusCameraKey?.ToString() + " to focus on the selected object\n" + followCameraKey?.ToString() + " to follow the selected object"), useNavigationCamera, Color.green))
|
|
{
|
|
if (useNavigationCamera.RealValue)
|
|
{
|
|
EnableCamControl();
|
|
}
|
|
else
|
|
{
|
|
DisableCamControl();
|
|
}
|
|
}
|
|
if (navigationCamera == null || NavigationCamera.cam == null)
|
|
{
|
|
navigationCamera = null;
|
|
useNavigationCamera.Value = false;
|
|
}
|
|
if (Application.isEditor)
|
|
{
|
|
Helper.DrawShowButton(windowData, Helper.GetGUIContent("Link Select", "Link selected to Unity's hierarchy window"), linkSelect, Color.green);
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
GUILayout.BeginHorizontal();
|
|
Helper.DrawShowButton(windowData, Helper.GetGUIContent("Child Count", "Shows the child count for each GameObject"), windowData.showChildCount, Color.green);
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Scenes", windowData.texScene, "Scene Mode"), drawScenes, Color.green, -1f, onlyActivate: true))
|
|
{
|
|
GUIChangeBool gUIChangeBool = drawAssemblies;
|
|
bool value = (drawMemory.Value = false);
|
|
gUIChangeBool.Value = value;
|
|
if (selectedGO != null)
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
}
|
|
}
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Assemblies", windowData.texAssembly, "Assembly Mode"), drawAssemblies, Color.green, -1f, onlyActivate: true))
|
|
{
|
|
GUIChangeBool gUIChangeBool2 = drawMemory;
|
|
bool value = (drawScenes.Value = false);
|
|
gUIChangeBool2.Value = value;
|
|
if (needHierarchySearch)
|
|
{
|
|
refreshHierarchySearch = 1f;
|
|
}
|
|
if (selectedStaticType != null)
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
}
|
|
}
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Memory", windowData.texMemory, "Memory Mode"), drawMemory, Color.green, -1f, onlyActivate: true))
|
|
{
|
|
drawScenes.Value = false;
|
|
drawAssemblies.Value = false;
|
|
if (selectedObject != null)
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
}
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
if (drawAssemblies.Value)
|
|
{
|
|
GUILayout.BeginHorizontal();
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Unity", "Show/Hide Unity Assemblies\nShift click to multi select"), drawUnityAssemblies, Color.green))
|
|
{
|
|
if (!currentEvent.shift)
|
|
{
|
|
GUIChangeBool gUIChangeBool3 = drawSystemAssemblies;
|
|
GUIChangeBool gUIChangeBool4 = drawMonoAssemblies;
|
|
bool flag3 = (drawOtherAssemblies.Value = false);
|
|
bool value = (gUIChangeBool4.Value = flag3);
|
|
gUIChangeBool3.Value = value;
|
|
}
|
|
refreshHierarchySearch = 1f;
|
|
}
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("System", "Show/Hide System Assemblies\nShift click to multi select"), drawSystemAssemblies, Color.green))
|
|
{
|
|
if (!currentEvent.shift)
|
|
{
|
|
GUIChangeBool gUIChangeBool5 = drawUnityAssemblies;
|
|
GUIChangeBool gUIChangeBool6 = drawMonoAssemblies;
|
|
bool flag3 = (drawOtherAssemblies.Value = false);
|
|
bool value = (gUIChangeBool6.Value = flag3);
|
|
gUIChangeBool5.Value = value;
|
|
}
|
|
refreshHierarchySearch = 1f;
|
|
}
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Mono", "Show/Hide Mono Assemblies\nShift click to multi select"), drawMonoAssemblies, Color.green))
|
|
{
|
|
if (!currentEvent.shift)
|
|
{
|
|
GUIChangeBool gUIChangeBool7 = drawUnityAssemblies;
|
|
GUIChangeBool gUIChangeBool8 = drawSystemAssemblies;
|
|
bool flag3 = (drawOtherAssemblies.Value = false);
|
|
bool value = (gUIChangeBool8.Value = flag3);
|
|
gUIChangeBool7.Value = value;
|
|
}
|
|
refreshHierarchySearch = 1f;
|
|
}
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Other", "Show/Hide All Other Assemblies\nShift click to multi select"), drawOtherAssemblies, Color.green))
|
|
{
|
|
if (!currentEvent.shift)
|
|
{
|
|
GUIChangeBool gUIChangeBool9 = drawUnityAssemblies;
|
|
GUIChangeBool gUIChangeBool10 = drawSystemAssemblies;
|
|
bool flag3 = (drawMonoAssemblies.Value = false);
|
|
bool value = (gUIChangeBool10.Value = flag3);
|
|
gUIChangeBool9.Value = value;
|
|
}
|
|
refreshHierarchySearch = 1f;
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
else if (drawMemory.Value)
|
|
{
|
|
bool flag12 = selectedMemorySnapshot == difSnapshot;
|
|
if (currentEvent.type == EventType.Layout)
|
|
{
|
|
if (doMemorySnapshotCompare)
|
|
{
|
|
doMemorySnapshotCompare = false;
|
|
DoMemorySnapshotCompare();
|
|
flag12 = selectedMemorySnapshot == difSnapshot;
|
|
}
|
|
if (flag12)
|
|
{
|
|
if (drawCompareFilter.Value)
|
|
{
|
|
if (!difSnapshot.hasCleanedDifCompare)
|
|
{
|
|
difSnapshot.CleanDifSnapshot(memoryCompareMode);
|
|
}
|
|
}
|
|
else if (difSnapshot.hasCleanedDifCompare)
|
|
{
|
|
doMemorySnapshotCompare = true;
|
|
}
|
|
}
|
|
}
|
|
GUILayout.BeginHorizontal();
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("MonoBehaviour", "Show/Hide Memory Objects that are MonoBehaviours\nShift click to multi select"), drawMonoBehaviourMemory, Color.green, -1f, !currentEvent.shift))
|
|
{
|
|
if (!currentEvent.shift)
|
|
{
|
|
GUIChangeBool gUIChangeBool11 = drawComponentMemory;
|
|
GUIChangeBool gUIChangeBool12 = drawScriptableObjectMemory;
|
|
bool flag3 = (drawOtherMemory.Value = false);
|
|
bool value = (gUIChangeBool12.Value = flag3);
|
|
gUIChangeBool11.Value = value;
|
|
}
|
|
refreshHierarchySearch = 1f;
|
|
}
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("ScriptableObject", "Show/Hide Memory Objects that are ScriptableObjects\nShift click to multi select"), drawScriptableObjectMemory, Color.green, -1f, !currentEvent.shift))
|
|
{
|
|
if (!currentEvent.shift)
|
|
{
|
|
GUIChangeBool gUIChangeBool13 = drawMonoBehaviourMemory;
|
|
GUIChangeBool gUIChangeBool14 = drawComponentMemory;
|
|
bool flag3 = (drawOtherMemory.Value = false);
|
|
bool value = (gUIChangeBool14.Value = flag3);
|
|
gUIChangeBool13.Value = value;
|
|
}
|
|
refreshHierarchySearch = 1f;
|
|
}
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Component", "Show/Hide Memory Objects that are Components\nShift click to multi select"), drawComponentMemory, Color.green, -1f, !currentEvent.shift))
|
|
{
|
|
if (!currentEvent.shift)
|
|
{
|
|
GUIChangeBool gUIChangeBool15 = drawMonoBehaviourMemory;
|
|
GUIChangeBool gUIChangeBool16 = drawScriptableObjectMemory;
|
|
bool flag3 = (drawOtherMemory.Value = false);
|
|
bool value = (gUIChangeBool16.Value = flag3);
|
|
gUIChangeBool15.Value = value;
|
|
}
|
|
refreshHierarchySearch = 1f;
|
|
}
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Other", "Show/Hide other Memory Objects\nShift click to multi select"), drawOtherMemory, Color.green, -1f, !currentEvent.shift))
|
|
{
|
|
if (!currentEvent.shift)
|
|
{
|
|
GUIChangeBool gUIChangeBool17 = drawMonoBehaviourMemory;
|
|
GUIChangeBool gUIChangeBool18 = drawScriptableObjectMemory;
|
|
bool flag3 = (drawComponentMemory.Value = false);
|
|
bool value = (gUIChangeBool18.Value = flag3);
|
|
gUIChangeBool17.Value = value;
|
|
}
|
|
refreshHierarchySearch = 1f;
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
GUILayout.BeginHorizontal();
|
|
if (GUILayout.Button(Helper.GetGUIContent("Take Snapshot", "Take Memory Snapshot"), GUILayout.Width(85f), GUILayout.Height(20f)))
|
|
{
|
|
ScanMemory();
|
|
}
|
|
if (GUILayout.Button(Helper.GetGUIContent("Sort", (memoryCompareMode == CompareMode.Key) ? windowData.texAlphabeticSort : windowData.texCountSort, "Toggle sorting between alphabetic and child count"), GUILayout.Width(50f), GUILayout.Height(20f)))
|
|
{
|
|
if (memoryCompareMode == CompareMode.Key)
|
|
{
|
|
memoryCompareMode = CompareMode.Value;
|
|
}
|
|
else
|
|
{
|
|
memoryCompareMode = CompareMode.Key;
|
|
}
|
|
if (flag12)
|
|
{
|
|
difSnapshot.memoryTypesLookup.Sort(memoryCompareMode);
|
|
}
|
|
else if (selectedMemorySnapshot != null)
|
|
{
|
|
selectedMemorySnapshot.memoryTypesLookup.Sort(memoryCompareMode);
|
|
}
|
|
}
|
|
Helper.DrawShowButton(windowData, Helper.GetGUIContent("Filter Compare", "Toggle Filter Compare\nRemoves 'added' and 'removed' Objects from a compare, when they have the same name"), drawCompareFilter, Color.green, 85f);
|
|
Helper.DrawShowButton(windowData, Helper.GetGUIContent("HideFlags", "Show HideFlags icons"), drawHideFlags, Color.green, 60f);
|
|
GUILayout.EndHorizontal();
|
|
int activeMemorySnapshotCount = ActiveMemorySnapshotCount;
|
|
if (memorySnapshots.Count > 0)
|
|
{
|
|
GUILayout.BeginHorizontal();
|
|
int num = 0;
|
|
for (int i = 0; i < memorySnapshots.Count; i++)
|
|
{
|
|
MemorySnapshot memorySnapshot = memorySnapshots.items[i];
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent(memorySnapshot.tStamp.ToString("F1"), "Shift Click => Compare\nControl Click => Delete"), memorySnapshot.selected, Color.green, 54.65f, onlyActivate: true))
|
|
{
|
|
refreshHierarchySearch = 1f;
|
|
if (currentEvent.shift)
|
|
{
|
|
if (activeMemorySnapshotCount == 1)
|
|
{
|
|
doMemorySnapshotCompare = true;
|
|
}
|
|
else if (memorySnapshot.selected.Value)
|
|
{
|
|
memorySnapshot.selected.Value = false;
|
|
}
|
|
else
|
|
{
|
|
SelectMemorySnapshot(i);
|
|
}
|
|
}
|
|
else if (currentEvent.control)
|
|
{
|
|
memorySnapshots.RemoveAt(i--);
|
|
if (memorySnapshot.selected.Value)
|
|
{
|
|
SelectFirstSelectedMemorySnapshot();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SelectMemorySnapshot(i);
|
|
}
|
|
}
|
|
if (++num >= 5)
|
|
{
|
|
num = 0;
|
|
GUILayout.EndHorizontal();
|
|
if (i < memorySnapshots.Count - 1)
|
|
{
|
|
GUILayout.BeginHorizontal();
|
|
}
|
|
}
|
|
}
|
|
if (num > 0)
|
|
{
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
}
|
|
}
|
|
skin.button.fontSize = 0;
|
|
bool flag21 = showHelp.Value || showSettings.Value;
|
|
if (flag21)
|
|
{
|
|
float num2 = (showHelp.Value ? 252 : 0) + (showSettings.Value ? 372 : 0);
|
|
if (num2 > windowData.hierarchyWindow.rect.height - 250f)
|
|
{
|
|
num2 = windowData.hierarchyWindow.rect.height - 250f;
|
|
}
|
|
settingsScrollView = GUILayout.BeginScrollView(settingsScrollView, GUILayout.Height(num2));
|
|
}
|
|
if (showHelp.Value)
|
|
{
|
|
DrawHelp();
|
|
}
|
|
if (showSettings.Value)
|
|
{
|
|
DrawSettings();
|
|
}
|
|
if (flag21)
|
|
{
|
|
GUILayout.EndScrollView();
|
|
}
|
|
if (DrawSearch(hierarchyWindow, changeText2: false))
|
|
{
|
|
refreshHierarchySearch = 1f;
|
|
}
|
|
skin.button.alignment = TextAnchor.MiddleLeft;
|
|
if (currentEvent.type == EventType.Layout)
|
|
{
|
|
hierarchyWindow.UpdateScrollView();
|
|
}
|
|
hierarchyWindow.rectStartScroll = GUILayoutUtility.GetLastRect();
|
|
hierarchyWindow.scrollView = GUILayout.BeginScrollView(hierarchyWindow.scrollView);
|
|
hierarchyCull.Start(hierarchyWindow);
|
|
if (drawScenes.Value)
|
|
{
|
|
DrawScenes();
|
|
}
|
|
else if (drawAssemblies.Value)
|
|
{
|
|
DrawAssemblies();
|
|
}
|
|
else if (drawMemory.Value)
|
|
{
|
|
DrawMemory(selectedMemorySnapshot);
|
|
}
|
|
hierarchyCull.End();
|
|
GUILayout.EndScrollView();
|
|
GUILayout.EndVertical();
|
|
HierarchyDragAndTooltip(windowId);
|
|
WindowManager.EndRenderTextureGUI();
|
|
}
|
|
|
|
private void HierarchyDragAndTooltip(int windowId)
|
|
{
|
|
if (Helper.Drag(hierarchyWindow, inspectorWindow, hierarchyWindow, titleDrag: false) && inspectorWindow.isDocked.Value)
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
}
|
|
WindowManager.SetToolTip(windowId);
|
|
}
|
|
|
|
private void DrawHelp()
|
|
{
|
|
BeginVerticalBox();
|
|
DrawPrefixLabel("Shift Click '>' button", "Foldout one level", 150);
|
|
DrawPrefixLabel("Control Click '>' button", "Fold one level", 150);
|
|
DrawPrefixLabel("Alt Click '>' button", "Foldout all up/down", 150);
|
|
DrawPrefixLabel("Shift Click GameObject", "Toggle Active", 150);
|
|
DrawPrefixLabel("Shift Click Inspector", "Dock", 150);
|
|
DrawPrefixLabel("Click Component in Inspector", "Search inside it", 150);
|
|
DrawPrefixLabel("Right Click Scene", "Set Active Scene", 150);
|
|
DrawPrefixLabel("Control Click 'D'", "Duplicate GameObject", 150);
|
|
DrawPrefixLabel("'Del'", "Delete GameObject", 150);
|
|
GUILayout.EndVertical();
|
|
}
|
|
|
|
private void DrawSettings()
|
|
{
|
|
WindowManager windowManager = WindowManager.instance;
|
|
BeginVerticalBox();
|
|
DrawToggleField("Show Tooltips", ref windowData.showTooltip);
|
|
GUILayout.Space(5f);
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Label(Helper.GetGUIContent("Selection Sphere " + windowData.selectionSphereRadius.ToString("F2"), "The radius of the Selection Sphere"), GUILayout.Width(150f));
|
|
GUI.changed = false;
|
|
windowData.selectionSphereRadius = GUILayout.HorizontalSlider(windowData.selectionSphereRadius, 0.02f, 1f);
|
|
if (GUI.changed)
|
|
{
|
|
SetSelectionSphereRadius();
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
GUILayout.Space(5f);
|
|
DrawInputField("GUI Scale", windowManager.windowData.guiScale);
|
|
if (windowManager.windowData.guiScale.value < 0.55f)
|
|
{
|
|
windowManager.windowData.guiScale.value = 0.55f;
|
|
}
|
|
if (windowManager.windowData.guiScale.value > 10f)
|
|
{
|
|
windowManager.windowData.guiScale.value = 10f;
|
|
}
|
|
GUILayout.Space(5f);
|
|
DrawBoldLabel(skin, "Search", 0f);
|
|
DrawInputField("GameObjects Per Frame", windowData.searchGameObjectsPerFrame);
|
|
DrawInputField("Assembly Per Frame", windowData.searchAssemblyPerFrame);
|
|
DrawInputField("Inspector Per Frame", windowData.searchInspectorPerFrame);
|
|
GUILayout.Space(5f);
|
|
DrawBoldLabel(skin, "Camera", 0f);
|
|
DrawInputField("Mouse Sensivity", navigationCameraData.mouseSensitity);
|
|
DrawInputField("Acceleration Multi", navigationCameraData.accelMulti);
|
|
DrawInputField("Deceleration Multi", navigationCameraData.decelMulti);
|
|
DrawInputField("Speed Slow", navigationCameraData.speedSlow);
|
|
DrawInputField("Speed Normal", navigationCameraData.speedNormal);
|
|
DrawInputField("Speed Fast", navigationCameraData.speedFast);
|
|
DrawInputField("Mouse ScrollWheel Multi", navigationCameraData.mouseScrollWheelMulti);
|
|
DrawInputField("Mouse Strafe Multi", navigationCameraData.mouseStrafeMulti);
|
|
GUILayout.EndVertical();
|
|
}
|
|
|
|
public static void InitAssemblies()
|
|
{
|
|
if (!hasInitAssemblies)
|
|
{
|
|
CustomAssembly.InitAssemblies(ref hasInitAssemblies, customAssemblies, namespaceTypesLookup, typeNameLookup);
|
|
}
|
|
}
|
|
|
|
private void DrawAssemblies()
|
|
{
|
|
for (int i = 0; i < customAssemblies.Count; i++)
|
|
{
|
|
CustomAssembly customAssembly = customAssemblies.items[i];
|
|
string text = customAssembly.name;
|
|
AssemblyType type = customAssembly.type;
|
|
if ((type == AssemblyType.Unity && !drawUnityAssemblies.Value) || (type == AssemblyType.System && !drawSystemAssemblies.Value) || (type == AssemblyType.Mono && !drawMonoAssemblies.Value) || (type == AssemblyType.Other && !drawOtherAssemblies.Value))
|
|
{
|
|
continue;
|
|
}
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(assemblyLookup, customAssembly);
|
|
if (needHierarchySearch && objectDrawInfo.passSearch == 0)
|
|
{
|
|
continue;
|
|
}
|
|
if (!Helper.IsCulled(ref hierarchyCull))
|
|
{
|
|
GUI.backgroundColor = new Color(0.4f, 0.5f, 1f, 1f);
|
|
skin.button.fontStyle = FontStyle.Bold;
|
|
Bool3 @bool = DrawElement(hierarchyWindow, objectDrawInfo, customAssembly.namespaceLookup.list.Count + customAssembly.types.Count, text);
|
|
skin.button.fontStyle = FontStyle.Normal;
|
|
if (@bool.v3)
|
|
{
|
|
objectDrawInfo.foldout = !objectDrawInfo.foldout;
|
|
}
|
|
}
|
|
if (PassedFoldout(objectDrawInfo, needHierarchySearch, hasSearchPass: true, hierarchyWindow.showSearchNonFound, isChild: false))
|
|
{
|
|
DrawAssembly(customAssembly, objectDrawInfo.foldout);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DrawAssembly(CustomAssembly assembly, bool hasSearchPass)
|
|
{
|
|
int num = 15;
|
|
FastList<ItemHolder<string, NamespaceTypes>> list = assembly.namespaceLookup.list;
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
NamespaceTypes value = list.items[i].value;
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(namespaceTypesLookup, value);
|
|
if (!PassedFoldout(objectDrawInfo, needHierarchySearch, hasSearchPass, hierarchyWindow.showSearchNonFound, isChild: true))
|
|
{
|
|
continue;
|
|
}
|
|
if (!Helper.IsCulled(ref hierarchyCull))
|
|
{
|
|
GUI.backgroundColor = new Color(1f, 1f, 0.5f, 1f);
|
|
skin.button.fontStyle = FontStyle.Bold;
|
|
Bool3 @bool = DrawElement(hierarchyWindow, objectDrawInfo, value.types.Count, value.name, null, string.Empty, isActive: true, num);
|
|
skin.button.fontStyle = FontStyle.Normal;
|
|
if (@bool.v3)
|
|
{
|
|
objectDrawInfo.foldout = !objectDrawInfo.foldout;
|
|
}
|
|
}
|
|
if (PassedFoldout(objectDrawInfo, needHierarchySearch, hasSearchPass, hierarchyWindow.showSearchNonFound, isChild: false))
|
|
{
|
|
DrawAssemblyTypes(value.types, num + 15, objectDrawInfo.foldout);
|
|
}
|
|
}
|
|
if (assembly.types.Count > 0)
|
|
{
|
|
DrawAssemblyTypes(assembly.types, num, hasSearchPass);
|
|
}
|
|
}
|
|
|
|
private void DrawAssemblyTypes(FastList<CustomType> customTypes, int indent, bool hasSearchPass)
|
|
{
|
|
for (int i = 0; i < customTypes.Count; i++)
|
|
{
|
|
CustomType customType = customTypes.items[i];
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(typeLookup, customType);
|
|
if (!PassedFoldout(objectDrawInfo, needHierarchySearch, hasSearchPass, hierarchyWindow.showSearchNonFound, isChild: true) || Helper.IsCulled(ref hierarchyCull))
|
|
{
|
|
continue;
|
|
}
|
|
GUI.backgroundColor = GetColor(customType.type, selectedStaticType, needHierarchySearch, objectDrawInfo);
|
|
Bool3 @bool = DrawElement(hierarchyWindow, objectDrawInfo, 0, customType.type.Name, null, string.Empty, isActive: true, indent);
|
|
GUI.backgroundColor = GetColor(Color.white);
|
|
if (@bool.v3)
|
|
{
|
|
if (selectedStaticType == customType.type)
|
|
{
|
|
selectedStaticType = null;
|
|
}
|
|
else
|
|
{
|
|
selectedStaticType = customType.type;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SelectMemorySnapshot(int snapshotIndex)
|
|
{
|
|
for (int i = 0; i < memorySnapshots.Count; i++)
|
|
{
|
|
memorySnapshots.items[i].selected.Value = false;
|
|
}
|
|
selectedMemorySnapshot = memorySnapshots.items[snapshotIndex];
|
|
selectedMemorySnapshot.selected.Value = true;
|
|
}
|
|
|
|
private void SelectFirstSelectedMemorySnapshot()
|
|
{
|
|
bool flag = false;
|
|
for (int i = 0; i < memorySnapshots.Count; i++)
|
|
{
|
|
MemorySnapshot memorySnapshot = memorySnapshots.items[i];
|
|
if (memorySnapshot.selected.Value)
|
|
{
|
|
selectedMemorySnapshot = memorySnapshot;
|
|
flag = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
selectedMemorySnapshot = null;
|
|
}
|
|
}
|
|
|
|
private void DoMemorySnapshotCompare()
|
|
{
|
|
MemorySnapshot memorySnapshot = null;
|
|
MemorySnapshot memorySnapshot2 = null;
|
|
for (int i = 0; i < memorySnapshots.Count; i++)
|
|
{
|
|
if (memorySnapshots.items[i].selected.Value)
|
|
{
|
|
if (memorySnapshot != null)
|
|
{
|
|
memorySnapshot2 = memorySnapshots.items[i];
|
|
break;
|
|
}
|
|
memorySnapshot = memorySnapshots.items[i];
|
|
}
|
|
}
|
|
if (memorySnapshot != null && memorySnapshot2 != null)
|
|
{
|
|
MemorySnapshot.CompareMemorySnapshots(memorySnapshot, memorySnapshot2, difSnapshot, memoryCompareMode);
|
|
selectedMemorySnapshot = difSnapshot;
|
|
}
|
|
}
|
|
|
|
private void ScanMemory()
|
|
{
|
|
refreshHierarchySearch = 1f;
|
|
MemorySnapshot memorySnapshot = new MemorySnapshot();
|
|
memorySnapshots.Add(memorySnapshot);
|
|
SelectMemorySnapshot(memorySnapshots.Count - 1);
|
|
memorySnapshot.ScanMemory(memoryCompareMode);
|
|
selectedMemorySnapshot = memorySnapshot;
|
|
}
|
|
|
|
private void DrawMemory(MemorySnapshot memorySnapshot)
|
|
{
|
|
if (memorySnapshot == null)
|
|
{
|
|
return;
|
|
}
|
|
FastSortedDictionary<string, MemoryInstanceType> memoryTypesLookup = memorySnapshot.memoryTypesLookup;
|
|
for (int i = 0; i < memoryTypesLookup.list.Count; i++)
|
|
{
|
|
ItemHolder<string, MemoryInstanceType> itemHolder = memoryTypesLookup.list.items[i];
|
|
string key = itemHolder.key;
|
|
MemoryInstanceType value = itemHolder.value;
|
|
if ((value.memoryType == MemoryType.MonoBehaviour && !drawMonoBehaviourMemory.Value) || (value.memoryType == MemoryType.Component && !drawComponentMemory.Value) || (value.memoryType == MemoryType.ScriptableObject && !drawScriptableObjectMemory.Value) || (value.memoryType == MemoryType.Other && !drawOtherMemory.Value))
|
|
{
|
|
continue;
|
|
}
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(memoryLookup, key);
|
|
if (needHierarchySearch && objectDrawInfo.passSearch == 0)
|
|
{
|
|
continue;
|
|
}
|
|
bool num = Helper.IsCulled(ref hierarchyCull);
|
|
Texture icon = windowData.componentIcons.GetIcon(value.type);
|
|
if (!num)
|
|
{
|
|
GUI.backgroundColor = new Color(0.4f, 0.5f, 1f, 1f);
|
|
skin.button.fontStyle = FontStyle.Bold;
|
|
Bool3 @bool = DrawElement(hierarchyWindow, objectDrawInfo, value.instances.list.Count, key, icon);
|
|
skin.button.fontStyle = FontStyle.Normal;
|
|
GUI.backgroundColor = Color.white;
|
|
if (@bool.v3)
|
|
{
|
|
objectDrawInfo.foldout = !objectDrawInfo.foldout;
|
|
}
|
|
}
|
|
if (PassedFoldout(objectDrawInfo, needHierarchySearch, hasSearchPass: true, hierarchyWindow.showSearchNonFound, isChild: false))
|
|
{
|
|
DrawMemoryInstances(memorySnapshot, value, objectDrawInfo.foldout, icon);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DrawMemoryInstances(MemorySnapshot memorySnapshot, MemoryInstanceType memoryInstanceType, bool hasSearchPass, Texture icon)
|
|
{
|
|
int num = 15;
|
|
FastList<MemoryObject> list = memoryInstanceType.instances.list;
|
|
if (!memoryInstanceType.isSorted)
|
|
{
|
|
memoryInstanceType.Sort();
|
|
}
|
|
bool flag = memorySnapshot == difSnapshot;
|
|
if (flag)
|
|
{
|
|
num += 15;
|
|
}
|
|
bool value = drawHideFlags.Value;
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
MemoryObject memoryObject = list.items[i];
|
|
UnityEngine.Object obj = Helper.FindObjectFromInstanceID(memoryObject.instanceId);
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(memoryObjectLookup, memoryObject);
|
|
if (!PassedFoldout(objectDrawInfo, needHierarchySearch, hasSearchPass, hierarchyWindow.showSearchNonFound, isChild: true))
|
|
{
|
|
continue;
|
|
}
|
|
bool num2 = Helper.IsCulled(ref hierarchyCull);
|
|
string tooltip = string.Empty;
|
|
if (num2)
|
|
{
|
|
continue;
|
|
}
|
|
if (obj == null)
|
|
{
|
|
tooltip = "Object is Destroyed";
|
|
}
|
|
GUI.backgroundColor = GetColor(obj, selectedObject, needHierarchySearch, objectDrawInfo);
|
|
Bool3 @bool = DrawElement(hierarchyWindow, objectDrawInfo, 0, memoryObject.name, icon, tooltip, isActive: true, num);
|
|
if (memoryObject.hideFlags != HideFlags.None || memoryObject.isPrefab || obj == null)
|
|
{
|
|
DrawHideFlagsIcons(obj, value ? memoryObject.hideFlags : HideFlags.None, memoryObject.isPrefab, memoryObject.name);
|
|
}
|
|
GUI.backgroundColor = Color.white;
|
|
GUI.color = Color.white;
|
|
if (flag)
|
|
{
|
|
Rect lastRect = GUILayoutUtility.GetLastRect();
|
|
lastRect.x = 37 + (windowData.showChildCount.Value ? 29 : 0);
|
|
lastRect.width = 20f;
|
|
if (memoryObject.compareResult == CompareResult.Removed)
|
|
{
|
|
GUI.backgroundColor = Color.red;
|
|
tooltip = "Compare Result => Object is removed";
|
|
}
|
|
else
|
|
{
|
|
GUI.backgroundColor = Color.green;
|
|
tooltip = "Compare Result => Object is new";
|
|
}
|
|
GUI.Button(lastRect, Helper.GetGUIContent(string.Empty, null, tooltip));
|
|
GUI.backgroundColor = Color.white;
|
|
}
|
|
if (@bool.v3 && obj != null)
|
|
{
|
|
if (selectedObject == obj)
|
|
{
|
|
selectedObject = null;
|
|
}
|
|
else
|
|
{
|
|
selectedObject = obj;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DrawScenes()
|
|
{
|
|
Scene activeScene = SceneManager.GetActiveScene();
|
|
int sceneCount = SceneManager.sceneCount;
|
|
for (int i = 0; i < sceneCount; i++)
|
|
{
|
|
Scene sceneAt = SceneManager.GetSceneAt(i);
|
|
DrawScene(sceneAt, activeScene, sceneCount);
|
|
}
|
|
if (WindowManager.instance.useDontDestroyOnLoadScene)
|
|
{
|
|
Scene sceneAt = WindowManager.instance.gameObject.scene;
|
|
DrawScene(sceneAt, activeScene, sceneCount);
|
|
}
|
|
}
|
|
|
|
private void DrawScene(Scene scene, Scene activeScene, int sceneCount)
|
|
{
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(sceneLookup, scene, unfoldMultipleScenesOnStart || sceneCount == 1);
|
|
scene.GetRootGameObjects(rootList);
|
|
if (!Helper.IsCulled(ref hierarchyCull))
|
|
{
|
|
GUI.backgroundColor = ((scene == activeScene) ? GetColor(new Color(0.25f, 1f, 0.25f)) : GetColor(Color.yellow));
|
|
GUI.skin.button.fontStyle = FontStyle.Bold;
|
|
string text = scene.name;
|
|
if (text == string.Empty)
|
|
{
|
|
text = "Untitled";
|
|
}
|
|
if (DrawElement(hierarchyWindow, objectDrawInfo, rootList.Count, text, windowData.texScene).v3)
|
|
{
|
|
if (currentEvent.button == 1)
|
|
{
|
|
SceneManager.SetActiveScene(scene);
|
|
}
|
|
else if (currentEvent.shift)
|
|
{
|
|
FoldOutScene(scene, rootList);
|
|
}
|
|
else if (currentEvent.control)
|
|
{
|
|
FoldInScene(scene, rootList);
|
|
}
|
|
else if (currentEvent.alt)
|
|
{
|
|
FoldScene(scene, rootList, !objectDrawInfo.foldout);
|
|
}
|
|
else
|
|
{
|
|
objectDrawInfo.foldout = !objectDrawInfo.foldout;
|
|
}
|
|
}
|
|
GUI.skin.button.fontStyle = FontStyle.Normal;
|
|
GUI.backgroundColor = GetColor(Color.white);
|
|
}
|
|
if (PassedFoldout(objectDrawInfo, needHierarchySearch, hasSearchPass: false, hierarchyWindow.showSearchNonFound, isChild: false))
|
|
{
|
|
DrawSceneGameObjects(rootList, objectDrawInfo.foldout);
|
|
}
|
|
}
|
|
|
|
private bool PassedFoldout(DrawInfo info, bool needSearch, bool hasSearchPass, bool showSearchNonFound, bool isChild)
|
|
{
|
|
if (!needSearch)
|
|
{
|
|
return info.foldout || isChild;
|
|
}
|
|
if (info.passSearch <= 0 && !(hasSearchPass && showSearchNonFound))
|
|
{
|
|
if (info.foldout)
|
|
{
|
|
return info.passSearch > 0;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void DrawSceneGameObjects(List<GameObject> goList, bool hasSearchPass)
|
|
{
|
|
int indent = 20;
|
|
for (int i = 0; i < goList.Count; i++)
|
|
{
|
|
DrawGameObject(goList[i], ref indent, hasSearchPass);
|
|
}
|
|
}
|
|
|
|
private void DrawGameObjects(Transform t, int indent, bool hasSearchPass)
|
|
{
|
|
indent += 15;
|
|
int childCount = t.childCount;
|
|
for (int i = 0; i < childCount; i++)
|
|
{
|
|
DrawGameObject(t.GetChild(i).gameObject, ref indent, hasSearchPass);
|
|
}
|
|
}
|
|
|
|
private void DrawGameObject(GameObject go, ref int indent, bool hasSearchPass)
|
|
{
|
|
Transform transform = go.transform;
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(tLookup, transform);
|
|
if (!PassedFoldout(objectDrawInfo, needHierarchySearch, hasSearchPass, hierarchyWindow.showSearchNonFound, isChild: true))
|
|
{
|
|
return;
|
|
}
|
|
int childCount = transform.childCount;
|
|
bool flag = childCount > 0;
|
|
bool flag2 = Helper.IsCulled(ref hierarchyCull);
|
|
if (scrollToSelected && go == selectedGO)
|
|
{
|
|
scrollToSelected = false;
|
|
hierarchyWindow.newScrollViewY = Mathf.Max(hierarchyCull.scrollWindowPosY - (hierarchyWindow.rect.height / 2f - (hierarchyWindow.rectStartScroll.y + 42f)), 0f);
|
|
}
|
|
if (!(!flag2 || flag))
|
|
{
|
|
return;
|
|
}
|
|
if (!flag2)
|
|
{
|
|
GUI.backgroundColor = GetColor(go, selectedGO, needHierarchySearch, objectDrawInfo);
|
|
Bool3 @bool = DrawElement(hierarchyWindow, objectDrawInfo, childCount, transform.name, windowData.componentIcons.gameObjectIcon, string.Empty, go.activeInHierarchy, indent);
|
|
GUI.backgroundColor = GetColor(Color.white);
|
|
if (@bool.v1)
|
|
{
|
|
if (currentEvent.shift)
|
|
{
|
|
go.SetActive(!go.activeInHierarchy);
|
|
}
|
|
else if (selectedGO == go)
|
|
{
|
|
SelectGameObject(null);
|
|
}
|
|
else
|
|
{
|
|
SelectGameObject(go);
|
|
}
|
|
}
|
|
else if (@bool.v2)
|
|
{
|
|
if (currentEvent.shift)
|
|
{
|
|
FoldOutGameObjects(transform);
|
|
}
|
|
else if (currentEvent.control)
|
|
{
|
|
FoldInGameObjects(transform);
|
|
}
|
|
else if (currentEvent.alt)
|
|
{
|
|
FoldGameObject(transform, !objectDrawInfo.foldout);
|
|
}
|
|
else
|
|
{
|
|
objectDrawInfo.foldout = !objectDrawInfo.foldout;
|
|
}
|
|
}
|
|
}
|
|
if (flag && PassedFoldout(objectDrawInfo, needHierarchySearch, hasSearchPass, hierarchyWindow.showSearchNonFound, isChild: false))
|
|
{
|
|
DrawGameObjects(transform, indent, objectDrawInfo.foldout);
|
|
}
|
|
}
|
|
|
|
private void FoldScene(Scene scene, List<GameObject> rootList, bool foldout)
|
|
{
|
|
int count = rootList.Count;
|
|
if (count != 0)
|
|
{
|
|
GetObjectDrawInfo(sceneLookup, scene).foldout = foldout;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
FoldGameObject(rootList[i].transform, foldout);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool FoldOutScene(Scene scene, List<GameObject> rootList)
|
|
{
|
|
int count = rootList.Count;
|
|
if (count == 0)
|
|
{
|
|
return false;
|
|
}
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(sceneLookup, scene);
|
|
if (objectDrawInfo.foldout)
|
|
{
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
FoldOutGameObjects(rootList[i].transform);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
objectDrawInfo.foldout = true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private bool FoldInScene(Scene scene, List<GameObject> rootList)
|
|
{
|
|
int count = rootList.Count;
|
|
if (count == 0)
|
|
{
|
|
return false;
|
|
}
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(sceneLookup, scene);
|
|
if (objectDrawInfo.foldout)
|
|
{
|
|
bool flag = false;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
if (FoldInGameObjects(rootList[i].transform))
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
objectDrawInfo.foldout = false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void FoldGameObject(Transform t, bool foldout)
|
|
{
|
|
int childCount = t.childCount;
|
|
if (childCount != 0)
|
|
{
|
|
GetObjectDrawInfo(tLookup, t).foldout = foldout;
|
|
for (int i = 0; i < childCount; i++)
|
|
{
|
|
FoldGameObject(t.GetChild(i), foldout);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool FoldOutGameObjects(Transform t)
|
|
{
|
|
int childCount = t.childCount;
|
|
if (childCount == 0)
|
|
{
|
|
return false;
|
|
}
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(tLookup, t);
|
|
if (objectDrawInfo.foldout)
|
|
{
|
|
for (int i = 0; i < childCount; i++)
|
|
{
|
|
FoldOutGameObjects(t.GetChild(i));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
objectDrawInfo.foldout = true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private bool FoldInGameObjects(Transform t)
|
|
{
|
|
int childCount = t.childCount;
|
|
if (childCount == 0)
|
|
{
|
|
return false;
|
|
}
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(tLookup, t);
|
|
if (objectDrawInfo.foldout)
|
|
{
|
|
bool flag = false;
|
|
for (int i = 0; i < childCount; i++)
|
|
{
|
|
if (FoldInGameObjects(t.GetChild(i)))
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
objectDrawInfo.foldout = false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void SearchMemory()
|
|
{
|
|
if (refreshHierarchySearch != 0f && !isSearchingMemory && selectedMemorySnapshot != null)
|
|
{
|
|
StartCoroutine(SearchMemoryCR());
|
|
}
|
|
}
|
|
|
|
private IEnumerator SearchMemoryCR()
|
|
{
|
|
yield return null;
|
|
refreshHierarchySearch = 0f;
|
|
isSearchingMemory = true;
|
|
searchMemoryObjectPassedList.Clear();
|
|
searchMemoryObjectFailedList.Clear();
|
|
int count = 0;
|
|
totalCount = 0;
|
|
FastList<ItemHolder<string, MemoryInstanceType>> list = selectedMemorySnapshot.memoryTypesLookup.list;
|
|
int i = 0;
|
|
while (true)
|
|
{
|
|
if (i < list.Count)
|
|
{
|
|
MemoryInstanceType mit = list.items[i].value;
|
|
if ((mit.memoryType != MemoryType.Component || drawComponentMemory.RealValue) && (mit.memoryType != MemoryType.MonoBehaviour || drawMonoBehaviourMemory.RealValue) && (mit.memoryType != MemoryType.ScriptableObject || drawScriptableObjectMemory.RealValue) && (mit.memoryType != MemoryType.Other || drawOtherMemory.RealValue))
|
|
{
|
|
DrawInfo mitInfo = GetObjectDrawInfo(memoryLookup, mit.type.Name);
|
|
FastList<MemoryObject> instances = mit.instances.list;
|
|
for (int j = 0; j < instances.Count; j++)
|
|
{
|
|
if (!needHierarchySearch)
|
|
{
|
|
goto end_IL_0284;
|
|
}
|
|
MemoryObject memoryObject = instances.items[j];
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(memoryObjectLookup, memoryObject);
|
|
if (PassSearch(WindowType.Hierarchy, null, memoryObject.name, mit.type))
|
|
{
|
|
objectDrawInfo.passSearch = 2;
|
|
searchMemoryObjectPassedList.Add(mitInfo);
|
|
}
|
|
else
|
|
{
|
|
objectDrawInfo.passSearch = 0;
|
|
searchMemoryObjectFailedList.Add(mitInfo);
|
|
}
|
|
if (count++ > windowData.searchGameObjectsPerFrame.value)
|
|
{
|
|
count = 0;
|
|
yield return null;
|
|
}
|
|
}
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
foreach (DrawInfo searchMemoryObjectFailed in searchMemoryObjectFailedList)
|
|
{
|
|
searchMemoryObjectFailed.passSearch = 0;
|
|
}
|
|
foreach (DrawInfo searchMemoryObjectPassed in searchMemoryObjectPassedList)
|
|
{
|
|
searchMemoryObjectPassed.passSearch = 1;
|
|
}
|
|
break;
|
|
continue;
|
|
end_IL_0284:
|
|
break;
|
|
}
|
|
isSearchingMemory = false;
|
|
}
|
|
|
|
private void SearchAssemblies()
|
|
{
|
|
if (hasInitAssemblies && refreshHierarchySearch != 0f && !isSearchingAssemblies)
|
|
{
|
|
StartCoroutine(SearchAssembliesCR());
|
|
}
|
|
}
|
|
|
|
private IEnumerator SearchAssembliesCR()
|
|
{
|
|
refreshHierarchySearch = 0f;
|
|
isSearchingAssemblies = true;
|
|
searchTypePassedList.Clear();
|
|
searchTypeFailedList.Clear();
|
|
int count = 0;
|
|
totalCount = 0;
|
|
int i = 0;
|
|
while (true)
|
|
{
|
|
if (i < customAssemblies.Count)
|
|
{
|
|
CustomAssembly customAssembly = customAssemblies.items[i];
|
|
if ((customAssembly.type != AssemblyType.Unity || drawUnityAssemblies.RealValue) && (customAssembly.type != AssemblyType.System || drawSystemAssemblies.RealValue) && (customAssembly.type != AssemblyType.Mono || drawMonoAssemblies.RealValue) && (customAssembly.type != AssemblyType.Other || drawOtherAssemblies.RealValue))
|
|
{
|
|
int startIndex = 0;
|
|
while (startIndex >= 0)
|
|
{
|
|
startIndex = SearchThroughTypes(customAssembly.types, startIndex, ref count);
|
|
if (startIndex >= 0)
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
if (startIndex == -2)
|
|
{
|
|
break;
|
|
}
|
|
FastList<ItemHolder<string, NamespaceTypes>> namespaceList = customAssembly.namespaceLookup.list;
|
|
for (int j = 0; j < namespaceList.Count; j++)
|
|
{
|
|
NamespaceTypes namespaceTypes = namespaceList.items[j].value;
|
|
startIndex = 0;
|
|
while (startIndex >= 0)
|
|
{
|
|
startIndex = SearchThroughTypes(namespaceTypes.types, startIndex, ref count);
|
|
if (startIndex >= 0)
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
if (startIndex == -2)
|
|
{
|
|
goto end_IL_024b;
|
|
}
|
|
}
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
for (int k = 0; k < searchTypeFailedList.Count; k++)
|
|
{
|
|
SetFound(searchTypeFailedList.items[k], found: false);
|
|
}
|
|
for (int l = 0; l < searchTypePassedList.Count; l++)
|
|
{
|
|
SetFound(searchTypePassedList.items[l], found: true);
|
|
}
|
|
break;
|
|
continue;
|
|
end_IL_024b:
|
|
break;
|
|
}
|
|
isSearchingAssemblies = false;
|
|
}
|
|
|
|
private void SetFound(CustomType customType, bool found)
|
|
{
|
|
CustomAssembly obj;
|
|
DrawInfo objectDrawInfo;
|
|
if (customType.parent is NamespaceTypes namespaceTypes)
|
|
{
|
|
objectDrawInfo = GetObjectDrawInfo(namespaceTypesLookup, namespaceTypes);
|
|
if (found)
|
|
{
|
|
if (objectDrawInfo.passSearch == 0)
|
|
{
|
|
objectDrawInfo.passSearch = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
objectDrawInfo.passSearch = 0;
|
|
}
|
|
obj = (CustomAssembly)namespaceTypes.parent;
|
|
}
|
|
else
|
|
{
|
|
obj = (CustomAssembly)customType.parent;
|
|
}
|
|
objectDrawInfo = GetObjectDrawInfo(assemblyLookup, obj);
|
|
if (found)
|
|
{
|
|
if (objectDrawInfo.passSearch == 0)
|
|
{
|
|
objectDrawInfo.passSearch = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
objectDrawInfo.passSearch = 0;
|
|
}
|
|
}
|
|
|
|
private int SearchThroughTypes(FastList<CustomType> types, int startIndex, ref int count)
|
|
{
|
|
for (int i = startIndex; i < types.Count; i++)
|
|
{
|
|
if (!needHierarchySearch)
|
|
{
|
|
return -2;
|
|
}
|
|
CustomType customType = types.items[i];
|
|
totalCount++;
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(typeLookup, customType);
|
|
if (PassSearch(WindowType.Hierarchy, null, customType.type.Name, customType.type))
|
|
{
|
|
objectDrawInfo.passSearch = 2;
|
|
searchTypePassedList.Add(customType);
|
|
}
|
|
else
|
|
{
|
|
objectDrawInfo.passSearch = 0;
|
|
searchTypeFailedList.Add(customType);
|
|
}
|
|
if (count++ > windowData.searchAssemblyPerFrame.value)
|
|
{
|
|
count = 0;
|
|
return i + 1;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
private void SearchScenes()
|
|
{
|
|
if (!isSearchingScenes)
|
|
{
|
|
StartCoroutine(SearchScenesCR());
|
|
}
|
|
}
|
|
|
|
private void SetSearchObjectsPerFrame()
|
|
{
|
|
searchGameObjectsPerFrame = Mathf.Max(Mathf.CeilToInt((float)windowData.searchGameObjectsPerFrame.value * refreshHierarchySearch), 1);
|
|
}
|
|
|
|
private IEnumerator SearchScenesCR()
|
|
{
|
|
isSearchingScenes = true;
|
|
searchPassedList.Clear();
|
|
searchFailedList.Clear();
|
|
transformList.Clear();
|
|
int count = 0;
|
|
SetSearchObjectsPerFrame();
|
|
int i = 0;
|
|
while (true)
|
|
{
|
|
if (i < SceneManager.sceneCount)
|
|
{
|
|
SceneManager.GetSceneAt(i).GetRootGameObjects(searchRootList);
|
|
for (int j = 0; j < searchRootList.Count; j++)
|
|
{
|
|
transformList.Add(searchRootList[j].transform);
|
|
}
|
|
yield return null;
|
|
for (int k = 0; k < transformList.Count; k++)
|
|
{
|
|
if (!needHierarchySearch)
|
|
{
|
|
goto end_IL_029a;
|
|
}
|
|
Transform t = transformList.items[k];
|
|
if (t == null)
|
|
{
|
|
continue;
|
|
}
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(tLookup, t);
|
|
if (PassSearch(WindowType.Hierarchy, t, null, null))
|
|
{
|
|
objectDrawInfo.passSearch = 2;
|
|
searchPassedList.Add(t);
|
|
}
|
|
else
|
|
{
|
|
searchFailedList.Add(objectDrawInfo);
|
|
}
|
|
if (t.childCount > 0)
|
|
{
|
|
for (int l = 0; l < t.childCount; l++)
|
|
{
|
|
transformList.Add(t.GetChild(l));
|
|
if (count++ > searchGameObjectsPerFrame)
|
|
{
|
|
count = 0;
|
|
yield return null;
|
|
SetSearchObjectsPerFrame();
|
|
if (t == null)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (count++ > searchGameObjectsPerFrame)
|
|
{
|
|
count = 0;
|
|
yield return null;
|
|
SetSearchObjectsPerFrame();
|
|
}
|
|
}
|
|
transformList.Clear();
|
|
i++;
|
|
continue;
|
|
}
|
|
for (int m = 0; m < searchFailedList.Count; m++)
|
|
{
|
|
searchFailedList.items[m].passSearch = 0;
|
|
}
|
|
for (int n = 0; n < searchPassedList.Count; n++)
|
|
{
|
|
Transform transform = searchPassedList.items[n];
|
|
if (transform == null)
|
|
{
|
|
continue;
|
|
}
|
|
DrawInfo objectDrawInfo2;
|
|
while (transform.parent != null)
|
|
{
|
|
transform = transform.parent;
|
|
objectDrawInfo2 = GetObjectDrawInfo(tLookup, transform);
|
|
if (objectDrawInfo2.passSearch == 0)
|
|
{
|
|
objectDrawInfo2.passSearch = 1;
|
|
}
|
|
}
|
|
objectDrawInfo2 = GetObjectDrawInfo(sceneLookup, transform.gameObject.scene);
|
|
objectDrawInfo2.passSearch = 1;
|
|
}
|
|
break;
|
|
continue;
|
|
end_IL_029a:
|
|
break;
|
|
}
|
|
isSearchingScenes = false;
|
|
refreshHierarchySearch = 0.5f;
|
|
}
|
|
|
|
private void DrawInspector(int windowId)
|
|
{
|
|
WindowManager.BeginRenderTextureGUI();
|
|
DrawWindowTitle(Helper.GetGUIContent("Deep Inspector", windowData.texInspector), inspectorWindow);
|
|
if (inspectorWindow.drag == 1)
|
|
{
|
|
inspectorWindow.isDocked.Value = false;
|
|
}
|
|
Rect lastRect = GUILayoutUtility.GetLastRect();
|
|
lastRect.position += inspectorWindow.rect.position;
|
|
if (currentEvent.type == EventType.MouseDown && currentEvent.shift && lastRect.Contains(mousePos))
|
|
{
|
|
inspectorWindow.isDocked.Value = true;
|
|
inspectorWindow.position = new Vector2((hierarchyWindow.rect.xMax + 0f) / (float)Screen.width, hierarchyWindow.position.y);
|
|
}
|
|
if (inspectorWindow.isMinimized)
|
|
{
|
|
GUILayout.Space(-2f);
|
|
InspectorDragAndTooltip(windowId);
|
|
return;
|
|
}
|
|
fieldWidth = (inspectorWindow.rect.width - 150f) / 3f;
|
|
BeginVerticalBox();
|
|
GUILayout.BeginHorizontal();
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Fields", "Show/Hide Fields"), showFields, Color.green))
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
}
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Properties", "Show/Hide Properties"), showProperties, Color.green))
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
}
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Methods", "Show/Hide Methods"), showMethods, Color.green))
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
GUILayout.BeginHorizontal();
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Inherited", "Show/Hide Inherited Members"), showInherited, colorInherited))
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
}
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Declared", "Show/Hide Declared Members"), showDeclared, Color.green))
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
}
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Static", "Show/Hide Static Members"), showStatic, colorStatic))
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
}
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Instance", "Show/Hide Instance Members"), showInstance, Color.green))
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
GUILayout.BeginHorizontal();
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Public", "Show/Hide Public Members"), showPublic, colorPublic))
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
}
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Protected", "Show/Hide Protected Members"), showProtected, colorProtected))
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
}
|
|
if (Helper.DrawShowButton(windowData, Helper.GetGUIContent("Private", "Sow/Hide Private Members"), showPrivate, colorPrivate))
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
if (DrawSearch(inspectorWindow, changeText2: true))
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
refreshInspectorSearch = 1f;
|
|
}
|
|
if (needInspectorSearch)
|
|
{
|
|
GUILayout.Space(-2f);
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Space(6f);
|
|
GUILayout.Label("Search Level " + inspectorSearchLevel, GUILayout.Width(90f));
|
|
GUI.changed = false;
|
|
int num = inspectorSearchLevel;
|
|
inspectorSearchLevel = (int)GUILayout.HorizontalSlider(inspectorSearchLevel, 1f, 7f, GUILayout.Width(82f));
|
|
if (GUI.changed && inspectorSearchLevel != num)
|
|
{
|
|
if (inspectorSearchLevel > num)
|
|
{
|
|
refreshInspectorSearch = 1f;
|
|
}
|
|
ClearMemberLookups(inspectorSearchLevel + 1);
|
|
}
|
|
if (searchTypes.Count == 0 && drawScenes.Value)
|
|
{
|
|
GUI.color = GetColor(Helper.AnimateColor(Color.magenta, 2f));
|
|
GUILayout.Label("Click on a Component to search inside it");
|
|
GUI.color = GetColor(Color.white);
|
|
}
|
|
else
|
|
{
|
|
GUILayout.Label("Found " + totalFound + " / " + totalSearched);
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
else
|
|
{
|
|
totalFound = (totalSearched = 0);
|
|
}
|
|
GUILayout.Space(3f);
|
|
if (selectedStaticType != null && drawAssemblies.Value)
|
|
{
|
|
DrawSelected(selectedStaticType, DrawMode.Assembly);
|
|
}
|
|
else if (selectedObject != null && drawMemory.Value)
|
|
{
|
|
DrawSelected(selectedObject, DrawMode.Object);
|
|
}
|
|
else if ((bool)selectedGO)
|
|
{
|
|
DrawGameObject(selectedGO);
|
|
}
|
|
GUILayout.EndVertical();
|
|
InspectorDragAndTooltip(windowId);
|
|
WindowManager.EndRenderTextureGUI();
|
|
}
|
|
|
|
private void InspectorDragAndTooltip(int windowId)
|
|
{
|
|
if (Helper.Drag(inspectorWindow, inspectorWindow, hierarchyWindow, titleDrag: false))
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
}
|
|
if (!DrawEnum.draw)
|
|
{
|
|
WindowManager.SetToolTip(windowId);
|
|
}
|
|
}
|
|
|
|
private void ClearMemberLookups(int startLevel)
|
|
{
|
|
for (int i = startLevel; i < memberLookups.Count; i++)
|
|
{
|
|
memberLookups.items[i].Clear();
|
|
}
|
|
}
|
|
|
|
private void DrawSelected(object obj, DrawMode drawMode)
|
|
{
|
|
if (obj != oldDrawObject)
|
|
{
|
|
oldDrawObject = obj;
|
|
scrollViewCull.ResetAndRecalc();
|
|
}
|
|
this.drawMode = drawMode;
|
|
GameObject gameObject = obj as GameObject;
|
|
if ((bool)gameObject)
|
|
{
|
|
DrawGameObject(gameObject);
|
|
return;
|
|
}
|
|
DrawObject(obj, (drawMode == DrawMode.Assembly) ? windowData.componentIcons.csScriptIcon : null);
|
|
BeginVerticalBox(0.75f);
|
|
scrollViewCull.BeginScrollView();
|
|
DrawObjectMembers(null, obj, 1, needInspectorSearch, hasSearchPass: false, drawMode == DrawMode.Assembly, 15f);
|
|
scrollViewCull.EndScrollView();
|
|
GUILayout.EndVertical();
|
|
}
|
|
|
|
private void ClearEdit()
|
|
{
|
|
editField.Reset();
|
|
}
|
|
|
|
private bool SubmitEdit()
|
|
{
|
|
if (currentEvent.type == EventType.Layout)
|
|
{
|
|
return false;
|
|
}
|
|
if (currentEvent.keyCode == KeyCode.Escape)
|
|
{
|
|
ClearEdit();
|
|
}
|
|
if (currentEvent.keyCode != KeyCode.Return)
|
|
{
|
|
return currentEvent.keyCode == KeyCode.KeypadEnter;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void DrawObject(object obj, Texture icon = null)
|
|
{
|
|
float num = 0f;
|
|
float num2 = 0f;
|
|
Texture texture = obj as Texture;
|
|
string text;
|
|
if (texture != null)
|
|
{
|
|
text = obj.ToString();
|
|
icon = texture;
|
|
num = Mathf.Clamp(icon.height, 23, 150);
|
|
num2 = (float)(icon.width / icon.height) * num - 8f;
|
|
if (num2 > 256f)
|
|
{
|
|
num2 = 256f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool flag = false;
|
|
GameObject gameObject = obj as GameObject;
|
|
text = (gameObject ? gameObject.name : ((!flag) ? obj.ToString() : obj.GetType().Name));
|
|
num = 23f;
|
|
num2 = 16f;
|
|
}
|
|
if (icon == null)
|
|
{
|
|
icon = windowData.componentIcons.GetIcon(obj);
|
|
num = 23f;
|
|
num2 = 16f;
|
|
}
|
|
GUI.backgroundColor = new Color(0.25f, 0.25f, 0.25f, windowData.boxAlpha);
|
|
GUILayout.BeginVertical("Box");
|
|
GUILayout.Space(-4f);
|
|
GUI.backgroundColor = Color.white;
|
|
GUILayout.BeginHorizontal();
|
|
if (icon != null)
|
|
{
|
|
GUILayout.Label(Helper.GetGUIContent(icon), GUILayout.Width(num2), GUILayout.Height(num));
|
|
}
|
|
skin.label.fontStyle = FontStyle.Bold;
|
|
float y = skin.label.CalcSize(Helper.GetGUIContent(text)).y;
|
|
GUILayout.Label(text, GUILayout.Height(Mathf.Max(num, y)));
|
|
skin.label.fontStyle = FontStyle.Normal;
|
|
GUILayout.EndHorizontal();
|
|
GUILayout.Space(-4f);
|
|
GUILayout.EndVertical();
|
|
}
|
|
|
|
private void DrawGameObject(GameObject go)
|
|
{
|
|
if (go != oldSelectedGO)
|
|
{
|
|
scrollViewCull.recalc = true;
|
|
oldSelectedGO = go;
|
|
}
|
|
DrawObject(go);
|
|
GUILayout.Space(-26f);
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Space(6f);
|
|
GUILayout.Label(string.Empty);
|
|
string text = LayerMask.LayerToName(go.layer);
|
|
skin.button.alignment = TextAnchor.MiddleCenter;
|
|
skin.button.fontStyle = FontStyle.Bold;
|
|
if (GUILayout.Button(text, GUILayout.Width(150f)))
|
|
{
|
|
drawEnum.InitEnumWindow(go, mousePos);
|
|
}
|
|
skin.button.fontStyle = FontStyle.Normal;
|
|
skin.button.alignment = TextAnchor.MiddleLeft;
|
|
GUILayout.Space(6f);
|
|
skin.label.fontStyle = FontStyle.Normal;
|
|
GUILayout.EndHorizontal();
|
|
skin.box.alignment = TextAnchor.MiddleCenter;
|
|
BeginVerticalBox(0.75f);
|
|
scrollViewCull.BeginScrollView();
|
|
go.GetComponents(components);
|
|
for (int i = 0; i < components.Count; i++)
|
|
{
|
|
Component component = components[i];
|
|
if ((bool)component)
|
|
{
|
|
DrawComponent(component, 0);
|
|
}
|
|
}
|
|
scrollViewCull.EndScrollView();
|
|
GUILayout.EndVertical();
|
|
}
|
|
|
|
private void DrawComponent(Component component, int level)
|
|
{
|
|
if (memberLookups.Count == 0)
|
|
{
|
|
memberLookups.Add(new Dictionary<object, DrawInfo>(128));
|
|
}
|
|
int num = -1;
|
|
Behaviour behaviour = null;
|
|
Renderer renderer = null;
|
|
Collider collider = null;
|
|
behaviour = component as Behaviour;
|
|
if (behaviour != null)
|
|
{
|
|
num = (behaviour.enabled ? 1 : 0);
|
|
}
|
|
else
|
|
{
|
|
renderer = component as Renderer;
|
|
if (renderer != null)
|
|
{
|
|
num = (renderer.enabled ? 1 : 0);
|
|
}
|
|
else
|
|
{
|
|
collider = component as Collider;
|
|
if (collider != null)
|
|
{
|
|
num = (collider.enabled ? 1 : 0);
|
|
}
|
|
}
|
|
}
|
|
float num2 = ((num != 0) ? 1f : 0.5f);
|
|
Type type = component.GetType();
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(memberLookups.items[level], type);
|
|
bool flag = searchTypes.Contains(type);
|
|
if (scrollViewCull.StartCull())
|
|
{
|
|
GUI.backgroundColor = ((component is MonoBehaviour) ? GetColor(new Color(0.5f, 0.75f, 1f) * num2) : GetColor(new Color(1f, 1f, 1f) * num2));
|
|
skin.button.fontStyle = FontStyle.Bold;
|
|
GUILayout.BeginHorizontal();
|
|
if (flag)
|
|
{
|
|
GUI.backgroundColor = GetColor(Color.magenta);
|
|
}
|
|
string tooltip = (flag ? "Click to stop searching inside\nControl click to stop searching in all\nShift click to enable/disable" : "Click to search inside\nShift click to enable/disable");
|
|
Bool3 @bool = DrawElement(inspectorWindow, objectDrawInfo, -1, component.GetType().Name, windowData.componentIcons.GetIcon(component), tooltip, num != 0);
|
|
if (@bool.v2)
|
|
{
|
|
objectDrawInfo.foldout = !objectDrawInfo.foldout;
|
|
scrollViewCull.recalc = true;
|
|
return;
|
|
}
|
|
if (@bool.v1)
|
|
{
|
|
if (currentEvent.control)
|
|
{
|
|
searchTypes.Clear();
|
|
}
|
|
else if (currentEvent.shift)
|
|
{
|
|
if (behaviour != null)
|
|
{
|
|
behaviour.enabled = !behaviour.enabled;
|
|
}
|
|
else if (renderer != null)
|
|
{
|
|
renderer.enabled = !renderer.enabled;
|
|
}
|
|
else if (collider != null)
|
|
{
|
|
collider.enabled = !collider.enabled;
|
|
}
|
|
}
|
|
else if (!searchTypes.Contains(type))
|
|
{
|
|
refreshInspectorSearch = 1f;
|
|
searchTypes.Add(type);
|
|
}
|
|
else
|
|
{
|
|
searchTypes.Remove(type);
|
|
}
|
|
}
|
|
GUI.backgroundColor = GetColor(Color.white);
|
|
GUILayout.EndHorizontal();
|
|
skin.button.fontStyle = FontStyle.Normal;
|
|
GUI.backgroundColor = GetColor(Color.white);
|
|
}
|
|
scrollViewCull.EndCull();
|
|
if (!needInspectorSearch)
|
|
{
|
|
flag = false;
|
|
}
|
|
if (PassedFoldout(objectDrawInfo, flag, hasSearchPass: false, inspectorWindow.showSearchNonFound, isChild: false))
|
|
{
|
|
DrawObjectMembers(null, component, level + 1, flag, objectDrawInfo.foldout, isType: false, 15f);
|
|
}
|
|
}
|
|
|
|
private bool DrawObjectMembers(MemberInfo parentMember, object obj, int level, bool needSearch, bool hasSearchPass, bool isType, float indent)
|
|
{
|
|
if (level >= memberLookups.Count)
|
|
{
|
|
memberLookups.Add(new Dictionary<object, DrawInfo>(128));
|
|
}
|
|
Type objType = ((!isType) ? obj.GetType() : ((Type)obj));
|
|
TypeData typeData = GetTypeData(objType);
|
|
FastList<SubTypeData> subTypeDatas = typeData.subTypeDatas;
|
|
bool flag = false;
|
|
bool didDraw = false;
|
|
bool flag2 = false;
|
|
bool flag3 = false;
|
|
if (showFields.Value)
|
|
{
|
|
for (int i = 0; i < subTypeDatas.Count && (showInherited.Value || i < 1); i++)
|
|
{
|
|
SubTypeData subTypeData = subTypeDatas.items[i];
|
|
FieldInfo[] fields = subTypeData.fields;
|
|
if (fields.Length != 0)
|
|
{
|
|
bool num = flag;
|
|
MemberInfo[] members = fields;
|
|
flag = num | DrawMembers(parentMember, obj, typeData, subTypeData, members, MemberType.Field, level, needSearch, hasSearchPass, indent, out didDraw);
|
|
flag2 = true;
|
|
}
|
|
}
|
|
}
|
|
bool flag4 = false;
|
|
if (showProperties.Value)
|
|
{
|
|
for (int j = 0; j < subTypeDatas.Count && (showInherited.Value || j < 1); j++)
|
|
{
|
|
SubTypeData subTypeData2 = subTypeDatas.items[j];
|
|
PropertyInfo[] properties = subTypeData2.properties;
|
|
if (properties.Length == 0)
|
|
{
|
|
continue;
|
|
}
|
|
if (!flag4 && showFields.Value && flag2 && !needSearch && didDraw)
|
|
{
|
|
flag4 = true;
|
|
if (scrollViewCull.StartCull())
|
|
{
|
|
GUILayout.Space(memberSeparationHeight);
|
|
}
|
|
scrollViewCull.EndCull();
|
|
}
|
|
bool num2 = flag;
|
|
MemberInfo[] members = properties;
|
|
flag = num2 | DrawMembers(parentMember, obj, typeData, subTypeData2, members, MemberType.Property, level, needSearch, hasSearchPass, indent, out didDraw);
|
|
flag3 = true;
|
|
}
|
|
}
|
|
if (showMethods.Value)
|
|
{
|
|
flag4 = false;
|
|
for (int k = 0; k < subTypeDatas.Count && (showInherited.Value || k < 1); k++)
|
|
{
|
|
SubTypeData subTypeData3 = subTypeDatas.items[k];
|
|
MethodInfo[] methods = subTypeData3.methods;
|
|
if (methods.Length == 0)
|
|
{
|
|
continue;
|
|
}
|
|
if (!flag4 && ((showFields.Value && flag2) || (showProperties.Value && flag3)) && !needSearch && didDraw)
|
|
{
|
|
flag4 = true;
|
|
if (scrollViewCull.StartCull())
|
|
{
|
|
GUILayout.Space(memberSeparationHeight);
|
|
}
|
|
scrollViewCull.EndCull();
|
|
}
|
|
bool num3 = flag;
|
|
MemberInfo[] members = methods;
|
|
flag = num3 | DrawMembers(parentMember, obj, typeData, subTypeData3, members, MemberType.Method, level, needSearch, hasSearchPass, indent, out didDraw);
|
|
}
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
private bool DrawMembers(MemberInfo parentMember, object obj, TypeData typeData, SubTypeData subTypeData, MemberInfo[] members, MemberType memberType, int level, bool needSearch, bool hasSearchPass, float indent, out bool didDraw)
|
|
{
|
|
if (!needSearch)
|
|
{
|
|
string text = memberType switch
|
|
{
|
|
MemberType.Field => "Fields ",
|
|
MemberType.Property => "Properties ",
|
|
MemberType.Method => "Methods ",
|
|
_ => "",
|
|
};
|
|
if (scrollViewCull.StartCull())
|
|
{
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Space(indent);
|
|
GUI.backgroundColor = GetColor(new Color(0.2f, 0.2f, 0.2f, 0.5f));
|
|
GUI.skin.box.alignment = TextAnchor.MiddleLeft;
|
|
GUILayout.Box(text + members.Length + " " + subTypeData.typeName);
|
|
GUI.backgroundColor = GetColor(Color.white);
|
|
GUI.skin.box.alignment = TextAnchor.MiddleCenter;
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
scrollViewCull.EndCull();
|
|
}
|
|
didDraw = false;
|
|
bool flag = false;
|
|
for (int i = 0; i < members.Length; i++)
|
|
{
|
|
MemberInfo memberInfo = members[i];
|
|
if (memberInfo != null)
|
|
{
|
|
flag |= DrawMember(parentMember, obj, typeData, subTypeData, memberInfo, memberType, level, needSearch, hasSearchPass, ref didDraw, i == members.Length - 1, indent);
|
|
}
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
private TypeData GetTypeData(Type objType)
|
|
{
|
|
if (!typeDataLookup.TryGetValue(objType, out var value))
|
|
{
|
|
value = new TypeData(objType, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
|
|
typeDataLookup.Add(objType, value);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
private MemberData GetMemberData(Type objType, MemberInfo member, MemberType memberType)
|
|
{
|
|
if (!memberDataLookup.TryGetValue(member, out var value))
|
|
{
|
|
value = new MemberData(objType, member, memberType, colorPublic, colorProtected, colorPrivate);
|
|
memberDataLookup.Add(member, value);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
private bool DrawMember(MemberInfo parentMember, object obj, TypeData typeData, SubTypeData subTypeData, MemberInfo member, MemberType memberType, int level, bool needSearch, bool hasSearchPass, ref bool didDraw, bool isLastMember, float indent, Array array = null, int arrayIndex = -1)
|
|
{
|
|
while (level >= memberLookups.Count)
|
|
{
|
|
memberLookups.Add(new Dictionary<object, DrawInfo>(128));
|
|
}
|
|
DrawInfo drawInfo = GetObjectDrawInfo(obj: (!(member == null)) ? member : ((arrayIndex == -1) ? obj : ((object)arrayIndex)), lookup: memberLookups.items[level]);
|
|
if (!PassedFoldout(drawInfo, needSearch, hasSearchPass, inspectorWindow.showSearchNonFound, isChild: true))
|
|
{
|
|
return false;
|
|
}
|
|
Type type = subTypeData.type;
|
|
MemberData memberData = ((arrayIndex != -1) ? null : GetMemberData(type, member, memberType));
|
|
FieldInfo fieldInfo;
|
|
PropertyInfo propertyInfo;
|
|
MethodInfo key;
|
|
Type type2;
|
|
bool flag;
|
|
bool flag2;
|
|
bool flag3;
|
|
Scope scope;
|
|
if (arrayIndex == -1)
|
|
{
|
|
fieldInfo = memberData.field;
|
|
propertyInfo = memberData.prop;
|
|
key = memberData.method;
|
|
type2 = memberData.type;
|
|
flag = memberData.isStatic;
|
|
flag2 = subTypeData.index > 0;
|
|
flag3 = memberData.isConstant;
|
|
scope = memberData.scope;
|
|
typeData = null;
|
|
}
|
|
else
|
|
{
|
|
fieldInfo = null;
|
|
propertyInfo = null;
|
|
key = null;
|
|
flag3 = false;
|
|
flag = false;
|
|
flag2 = false;
|
|
type2 = type;
|
|
scope = Scope.Public;
|
|
}
|
|
bool result = false;
|
|
if (arrayIndex == -1)
|
|
{
|
|
if ((!flag2 && !showDeclared.Value) || (!flag && !showInstance.Value))
|
|
{
|
|
return result;
|
|
}
|
|
if ((flag2 && !showInherited.Value) || (flag && !showStatic.Value))
|
|
{
|
|
return result;
|
|
}
|
|
if ((scope == Scope.Public && !showPublic.Value) || (scope == Scope.Protected && !showProtected.Value) || (scope == Scope.Private && !showPrivate.Value))
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
bool isString;
|
|
bool isClass;
|
|
bool isStruct;
|
|
bool isArray;
|
|
bool isInterface;
|
|
string text;
|
|
string typeName;
|
|
if (arrayIndex == -1)
|
|
{
|
|
isString = memberData.isString;
|
|
isClass = memberData.isClass;
|
|
isStruct = memberData.isStruct;
|
|
isArray = memberData.isArray;
|
|
isInterface = memberData.isInterface;
|
|
text = memberData.name;
|
|
typeName = memberData.typeName;
|
|
}
|
|
else
|
|
{
|
|
isString = typeData.isString;
|
|
isClass = typeData.isClass;
|
|
isStruct = typeData.isStruct;
|
|
isArray = typeData.isArray;
|
|
isInterface = typeData.isInterface;
|
|
text = string.Empty;
|
|
typeName = subTypeData.typeName;
|
|
}
|
|
object obj2 = null;
|
|
switch (memberType)
|
|
{
|
|
case MemberType.Field:
|
|
if (drawMode == DrawMode.Object || flag || level >= 1)
|
|
{
|
|
try
|
|
{
|
|
obj2 = fieldInfo.GetValue(obj);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
skip.Add(fieldInfo);
|
|
}
|
|
}
|
|
break;
|
|
case MemberType.Property:
|
|
{
|
|
if (propertyInfo.IsDefined(typeof(ObsoleteAttribute), inherit: true))
|
|
{
|
|
return false;
|
|
}
|
|
if (propertyInfo.GetIndexParameters().Length != 0)
|
|
{
|
|
break;
|
|
}
|
|
PropertyInfo propertyInfo2 = (PropertyInfo)member;
|
|
if (skip.Contains(propertyInfo2))
|
|
{
|
|
break;
|
|
}
|
|
try
|
|
{
|
|
bool flag4 = true;
|
|
if (type == typeof(MeshFilter) && text == "mesh")
|
|
{
|
|
flag4 = false;
|
|
}
|
|
else if (type == typeof(MeshRenderer) && (text == "material" || text == "materials"))
|
|
{
|
|
flag4 = false;
|
|
}
|
|
if (flag4)
|
|
{
|
|
obj2 = propertyInfo2.GetValue(obj, null);
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
skip.Add(propertyInfo2);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
if (arrayIndex != -1)
|
|
{
|
|
text = "Element " + arrayIndex;
|
|
obj2 = obj;
|
|
}
|
|
break;
|
|
}
|
|
if (isArray && obj2 != null && !obj2.Equals(null))
|
|
{
|
|
array = (Array)obj2;
|
|
text = text + " [" + array.Length + "]";
|
|
}
|
|
bool flag5 = arrayIndex == -1 && obj2 == obj;
|
|
bool flag6 = memberType != MemberType.Method && (isClass || isArray || isStruct || isInterface) && obj2 != null && !flag5;
|
|
bool flag7 = false;
|
|
didDraw = true;
|
|
Color backgroundColor;
|
|
string tooltip;
|
|
if (arrayIndex != -1)
|
|
{
|
|
backgroundColor = Color.white;
|
|
tooltip = string.Empty;
|
|
}
|
|
else
|
|
{
|
|
backgroundColor = memberData.scopeColor;
|
|
tooltip = memberData.scopeToolTip;
|
|
}
|
|
UnityEngine.Object obj3;
|
|
string text2;
|
|
if (scrollViewCull.StartCull())
|
|
{
|
|
if (needSearch && drawInfo.passSearch == 2)
|
|
{
|
|
GUI.skin.box.overflow.left -= (int)indent - 8;
|
|
GUI.color = Color.magenta * windowData.boxAlpha * 0.85f;
|
|
GUILayout.BeginVertical("Box");
|
|
GUI.skin.box.overflow.left += (int)indent - 8;
|
|
GUI.color = Color.white;
|
|
}
|
|
GUILayout.BeginHorizontal();
|
|
if (needSearch && drawInfo.passSearch == 2)
|
|
{
|
|
indent -= 8f;
|
|
}
|
|
GUILayout.Space(indent);
|
|
if (needSearch && drawInfo.passSearch == 2)
|
|
{
|
|
indent += 8f;
|
|
}
|
|
GUI.backgroundColor = backgroundColor;
|
|
if (memberType == MemberType.Method)
|
|
{
|
|
if (flag2)
|
|
{
|
|
DrawDot(colorInherited, "Is Inherited", windowData.texDot2, minusSpace: true);
|
|
}
|
|
else
|
|
{
|
|
GUILayout.Space(10f);
|
|
}
|
|
if (flag)
|
|
{
|
|
DrawDot(colorStatic, "Is Static", windowData.texDot2, minusSpace: true);
|
|
}
|
|
else
|
|
{
|
|
GUILayout.Space(10f);
|
|
}
|
|
GUILayout.Space(-3f);
|
|
DrawElement(inspectorWindow, drawInfo, flag6 ? 1 : 0, text, -1f, windowData.texDot2, tooltip);
|
|
ParameterInfo[] parameters = memberData.parameters;
|
|
if (memberData.validInvokeParameters && (bool)RuntimeConsole.instance)
|
|
{
|
|
string value = string.Empty;
|
|
if (parameters.Length != 0)
|
|
{
|
|
if (!methodArgumentsLookup.TryGetValue(key, out value))
|
|
{
|
|
value = string.Empty;
|
|
}
|
|
float num = 15f;
|
|
if (value.Length > 0)
|
|
{
|
|
num += skin.textField.CalcSize(Helper.GetGUIContent(value)).x;
|
|
if (num > 200f)
|
|
{
|
|
num = 200f;
|
|
}
|
|
}
|
|
value = GUILayout.TextField(value, GUILayout.Width(num));
|
|
methodArgumentsLookup[key] = value;
|
|
}
|
|
if (GUILayout.Button("Invoke", GUILayout.Width(55f)))
|
|
{
|
|
string argumentString = value.Replace(',', ' ');
|
|
if (parameters.Length != 0)
|
|
{
|
|
RuntimeConsole.GetArguments(argumentString, methodArgs);
|
|
}
|
|
string logString = obj.ToString() + " => " + text + " " + value;
|
|
if (RuntimeConsole.instance.showConsoleWhenInvokingMethod)
|
|
{
|
|
RuntimeConsole.SetActive(active: true);
|
|
}
|
|
RuntimeConsole.Log(new LogEntry(logString, null, LogType.Log, EntryType.Command, Color.green, RuntimeConsole.instance.logFontSize, FontStyle.Bold));
|
|
if ((bool)HtmlDebug.instance)
|
|
{
|
|
HtmlDebug.instance.UnityDebugLog(logString, null, LogType.Log, isMainThread: true, -1, null, EntryType2.Command, closeLi: false);
|
|
}
|
|
new RuntimeConsole.CommandData(null, obj, "", RuntimeConsole.MemberType.Method, member, parameters, isStatic: true).Execute(methodArgs, argumentString);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (DrawElement(inspectorWindow, drawInfo, flag6 ? 1 : 0, text, fieldWidth, windowData.texDot, tooltip).v2)
|
|
{
|
|
drawInfo.foldout = !drawInfo.foldout;
|
|
scrollViewCull.recalc = true;
|
|
return false;
|
|
}
|
|
GUI.backgroundColor = GetColor(Color.white);
|
|
if (flag2)
|
|
{
|
|
DrawDot(colorInherited, "Is Inherited", windowData.texDot2, minusSpace: true);
|
|
}
|
|
else
|
|
{
|
|
GUILayout.Space(10f);
|
|
}
|
|
if (flag)
|
|
{
|
|
DrawDot(colorStatic, "Is Static", windowData.texDot2, minusSpace: true);
|
|
}
|
|
else
|
|
{
|
|
GUILayout.Space(10f);
|
|
}
|
|
GUILayout.Space(3f);
|
|
GUILayout.Label(typeName, GUILayout.Width(fieldWidth));
|
|
}
|
|
GUI.backgroundColor = GetColor(Color.white);
|
|
if (memberType == MemberType.Property)
|
|
{
|
|
if (propertyInfo.CanRead)
|
|
{
|
|
GUI.color = Color.green;
|
|
GUILayout.Toggle(true, Helper.GetGUIContent(string.Empty, "Has a Getter"), GUILayout.Width(10f));
|
|
}
|
|
else
|
|
{
|
|
GUILayout.Space(14f);
|
|
}
|
|
if (propertyInfo.CanWrite)
|
|
{
|
|
GUI.color = Color.red;
|
|
GUILayout.Toggle(true, Helper.GetGUIContent(string.Empty, "Has a Setter"), GUILayout.Width(10f));
|
|
}
|
|
else
|
|
{
|
|
GUILayout.Space(14f);
|
|
}
|
|
GUI.color = Color.white;
|
|
}
|
|
text2 = string.Empty;
|
|
if (obj2 != null)
|
|
{
|
|
bool isEnum = type2.IsEnum;
|
|
if (!(type2.IsPrimitive || isString || isEnum) || (memberType == MemberType.Property && !propertyInfo.CanWrite) || flag3)
|
|
{
|
|
obj3 = obj2 as UnityEngine.Object;
|
|
if (obj3 != null)
|
|
{
|
|
text2 = obj3.name;
|
|
}
|
|
else
|
|
{
|
|
if (memberType == MemberType.Field)
|
|
{
|
|
FieldInfo field = obj2.GetType().GetField("name", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
|
|
if (field != null)
|
|
{
|
|
object value2 = field.GetValue(obj2);
|
|
if (value2 != null)
|
|
{
|
|
text2 = value2.ToString();
|
|
goto IL_0b95;
|
|
}
|
|
}
|
|
}
|
|
if (type2.IsGenericType)
|
|
{
|
|
Type[] genericArguments = type2.GetGenericArguments();
|
|
text2 += "<";
|
|
for (int i = 0; i < genericArguments.Length; i++)
|
|
{
|
|
text2 = ((i >= genericArguments.Length - 1) ? (text2 + type2.GetGenericArguments()[i].Name) : (text2 + type2.GetGenericArguments()[i].Name + ", "));
|
|
}
|
|
text2 += ">";
|
|
}
|
|
else if (!isClass)
|
|
{
|
|
text2 = obj2.ToString();
|
|
}
|
|
}
|
|
goto IL_0b95;
|
|
}
|
|
if (editField.IsThisEdit(parentMember, member, arrayIndex))
|
|
{
|
|
GUI.SetNextControlName("InspectorEditText");
|
|
editText = GUILayout.TextField(editText, wrapTextField);
|
|
if (selectAllEditText > 0)
|
|
{
|
|
GUI.FocusControl("InspectorEditText");
|
|
((TextEditor)GUIUtility.GetStateObject(typeof(TextEditor), GUIUtility.keyboardControl)).SelectAll();
|
|
selectAllEditText = 0;
|
|
}
|
|
if (SubmitEdit())
|
|
{
|
|
ClearEdit();
|
|
object value3;
|
|
if (isEnum)
|
|
{
|
|
int.TryParse(editText, out var result2);
|
|
value3 = Enum.ToObject(type2, result2);
|
|
}
|
|
else
|
|
{
|
|
value3 = Convert.ChangeType(editText, type2);
|
|
}
|
|
if (arrayIndex != -1)
|
|
{
|
|
array.SetValue(value3, arrayIndex);
|
|
}
|
|
else if (memberType == MemberType.Field)
|
|
{
|
|
fieldInfo.SetValue(obj, value3);
|
|
}
|
|
else
|
|
{
|
|
propertyInfo.SetValue(obj, value3, null);
|
|
}
|
|
result = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (isEnum)
|
|
{
|
|
GUI.backgroundColor = GetColor(new Color(1f, 1f, 0.55f, 1f));
|
|
}
|
|
GUILayout.Space(-1f);
|
|
if (GUILayout.Button(obj2.ToString(), wrapButton))
|
|
{
|
|
if (isEnum)
|
|
{
|
|
drawEnum.InitEnumWindow(obj, member, (Enum)obj2, mousePos);
|
|
}
|
|
else if (type2 == typeof(bool))
|
|
{
|
|
if (arrayIndex != -1)
|
|
{
|
|
array.SetValue(true, arrayIndex);
|
|
}
|
|
else if (memberType == MemberType.Field)
|
|
{
|
|
fieldInfo.SetValue(obj, !(bool)obj2);
|
|
}
|
|
else
|
|
{
|
|
propertyInfo.SetValue(obj, !(bool)obj2, null);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
editField.Set(parentMember, member, arrayIndex);
|
|
editText = obj2.ToString();
|
|
selectAllEditText = 200;
|
|
}
|
|
}
|
|
GUI.backgroundColor = GetColor(Color.white);
|
|
}
|
|
}
|
|
else if (memberType != MemberType.Method)
|
|
{
|
|
GUI.color = Color.red;
|
|
GUILayout.Label("null");
|
|
GUI.color = Color.white;
|
|
}
|
|
goto IL_0d3b;
|
|
}
|
|
goto IL_0dc0;
|
|
IL_0d3b:
|
|
GUILayout.EndHorizontal();
|
|
if (needSearch && drawInfo.passSearch == 2)
|
|
{
|
|
GUILayout.EndVertical();
|
|
}
|
|
if (!isLastMember)
|
|
{
|
|
Rect lastRect = GUILayoutUtility.GetLastRect();
|
|
lastRect.x += indent;
|
|
lastRect.y += lastRect.height + 1f;
|
|
lastRect.height = 2f;
|
|
GUI.color = new Color(0.1f, 0.1f, 0.1f, 1f);
|
|
GUI.DrawTexture(lastRect, Texture2D.whiteTexture);
|
|
GUI.color = Color.white;
|
|
}
|
|
goto IL_0dc0;
|
|
IL_0b95:
|
|
if (flag5)
|
|
{
|
|
GUI.color = Color.green;
|
|
GUILayout.Label(Helper.GetGUIContent("this", null, "value references to itself"));
|
|
GUI.color = Color.white;
|
|
}
|
|
else if (obj3 != null && (obj3 is Component || obj3 is GameObject))
|
|
{
|
|
GUI.backgroundColor = GetColor(new Color(0.25f, 0.75f, 1f, 1f));
|
|
GUILayout.Space(-1f);
|
|
if (Helper.DrawButton(Helper.GetGUIContent(text2, windowData.componentIcons.GetIcon(obj3)), wrapButton))
|
|
{
|
|
if (obj3 is GameObject)
|
|
{
|
|
SelectGameObject((GameObject)obj3, unfold: true);
|
|
}
|
|
else if (obj3 is Component)
|
|
{
|
|
SelectGameObject(((Component)obj3).gameObject, unfold: true);
|
|
}
|
|
}
|
|
GUI.backgroundColor = GetColor(Color.white);
|
|
}
|
|
else if (flag7 && text2.Length > 0)
|
|
{
|
|
GUILayout.EndHorizontal();
|
|
if (text2.Length > 8192)
|
|
{
|
|
text2 = text2.Substring(0, 8192);
|
|
}
|
|
GUILayout.Label(text2);
|
|
}
|
|
else if (flag3)
|
|
{
|
|
GUI.color = Color.yellow;
|
|
GUILayout.Label(Helper.GetGUIContent(text2, null, "is Constant"));
|
|
GUI.color = Color.white;
|
|
}
|
|
else
|
|
{
|
|
GUILayout.Label(text2);
|
|
}
|
|
goto IL_0d3b;
|
|
IL_0dc0:
|
|
scrollViewCull.EndCull();
|
|
if (flag6 && obj2 != null)
|
|
{
|
|
hasSearchPass = drawInfo.foldout && (hasSearchPass || drawInfo.passSearch == 2);
|
|
if (PassedFoldout(drawInfo, needSearch, hasSearchPass, inspectorWindow.showSearchNonFound, isChild: false))
|
|
{
|
|
if (isArray)
|
|
{
|
|
DrawArray(member, array, level + 1, needSearch, hasSearchPass, indent + 15f);
|
|
}
|
|
else if (DrawObjectMembers(member, obj2, level + 1, needSearch, drawInfo.foldout, isType: false, indent + 15f))
|
|
{
|
|
if (arrayIndex != -1)
|
|
{
|
|
array.SetValue(obj2, arrayIndex);
|
|
}
|
|
else if (memberType == MemberType.Field)
|
|
{
|
|
fieldInfo.SetValue(obj, obj2);
|
|
}
|
|
else
|
|
{
|
|
propertyInfo.SetValue(obj, obj2, null);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private void DrawArray(MemberInfo parentMember, Array array, int level, bool needSearch, bool hasSearchPass, float indent)
|
|
{
|
|
int num = 0;
|
|
int num2 = 0;
|
|
bool didDraw = false;
|
|
if (array.GetType().GetArrayRank() == 1)
|
|
{
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
object value = array.GetValue(i);
|
|
if (value != null)
|
|
{
|
|
if (num2 > num)
|
|
{
|
|
if (scrollViewCull.StartCull())
|
|
{
|
|
DrawLabelIndent(num + " .. " + num2 + " = null", indent);
|
|
}
|
|
scrollViewCull.EndCull();
|
|
}
|
|
Type type = value.GetType();
|
|
TypeData typeData = GetTypeData(type);
|
|
SubTypeData subTypeData = typeData.subTypeDatas.items[0];
|
|
DrawMember(parentMember, value, typeData, subTypeData, null, MemberType.ArrayElement, level + 1, needSearch, hasSearchPass, ref didDraw, isLastMember: false, indent, array, i);
|
|
num2 = ++num;
|
|
}
|
|
else
|
|
{
|
|
num2++;
|
|
}
|
|
}
|
|
if (num2 > num)
|
|
{
|
|
didDraw = true;
|
|
if (scrollViewCull.StartCull())
|
|
{
|
|
DrawLabelIndent(num + " .. " + num2 + " = null", indent);
|
|
}
|
|
scrollViewCull.EndCull();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
didDraw = true;
|
|
if (scrollViewCull.StartCull())
|
|
{
|
|
DrawLabelIndent("Multi dimensional arrays will be supported soon", indent);
|
|
}
|
|
scrollViewCull.EndCull();
|
|
}
|
|
if (didDraw)
|
|
{
|
|
if (scrollViewCull.StartCull())
|
|
{
|
|
GUILayout.Space(memberSeparationHeight);
|
|
}
|
|
scrollViewCull.EndCull();
|
|
}
|
|
DrawObjectMembers(parentMember, array, level++, needSearch, hasSearchPass, isType: false, indent);
|
|
}
|
|
|
|
private void DrawLabelIndent(string text, float indent)
|
|
{
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Space(indent);
|
|
GUILayout.Label(text);
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
|
|
private void SearchInsideGameObject(GameObject go)
|
|
{
|
|
if (refreshInspectorSearch != 0f && !isSearchingInspector)
|
|
{
|
|
go.GetComponents(searchComponentList);
|
|
searchObjectList.Clear();
|
|
for (int i = 0; i < searchComponentList.Count; i++)
|
|
{
|
|
searchObjectList.Add(searchComponentList[i]);
|
|
}
|
|
StartCoroutine(SearchInspectorCR(checkSearchType: true));
|
|
}
|
|
}
|
|
|
|
private void SearchInspector(object obj)
|
|
{
|
|
if (refreshInspectorSearch != 0f && !isSearchingInspector)
|
|
{
|
|
searchObjectList.Clear();
|
|
searchObjectList.Add(obj);
|
|
StartCoroutine(SearchInspectorCR(checkSearchType: false));
|
|
}
|
|
}
|
|
|
|
private void AddSearchMembers(object obj, Type objType, SearchMember searchMember, MemberInfo[] members, MemberType memberType, int level)
|
|
{
|
|
for (int i = 0; i < members.Length; i++)
|
|
{
|
|
searchMemberList.Add(new SearchMember(searchMember, obj, objType, members[i], memberType, null, level));
|
|
}
|
|
}
|
|
|
|
private void AddAllSearchMembers(object searchObj, Type objType, SearchMember searchMember, int level)
|
|
{
|
|
FastList<SubTypeData> subTypeDatas = GetTypeData(objType).subTypeDatas;
|
|
for (int i = 0; i < subTypeDatas.Count; i++)
|
|
{
|
|
SubTypeData subTypeData = subTypeDatas.items[i];
|
|
if (showFields.Value)
|
|
{
|
|
MemberInfo[] fields = subTypeData.fields;
|
|
AddSearchMembers(searchObj, objType, searchMember, fields, MemberType.Field, level);
|
|
}
|
|
if (showProperties.Value)
|
|
{
|
|
MemberInfo[] fields = subTypeData.properties;
|
|
AddSearchMembers(searchObj, objType, searchMember, fields, MemberType.Property, level);
|
|
}
|
|
if (showMethods.Value)
|
|
{
|
|
MemberInfo[] fields = subTypeData.methods;
|
|
AddSearchMembers(searchObj, objType, searchMember, fields, MemberType.Method, level);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SetSearchInspectorPerFrame()
|
|
{
|
|
searchInspectorPerFrame = Mathf.CeilToInt((float)windowData.searchInspectorPerFrame.value * refreshInspectorSearch);
|
|
}
|
|
|
|
private IEnumerator SearchInspectorCR(bool checkSearchType)
|
|
{
|
|
isSearchingInspector = true;
|
|
searchMemberList.Clear();
|
|
searchMemberPassedList.Clear();
|
|
searchMemberFailedList.Clear();
|
|
searchDoubles.Clear();
|
|
int oldInspectorSearchLevel = inspectorSearchLevel;
|
|
if (memberLookups.Count == 0)
|
|
{
|
|
memberLookups.Add(new Dictionary<object, DrawInfo>(128));
|
|
}
|
|
localTotalSearched = 0;
|
|
int count = 0;
|
|
SetSearchInspectorPerFrame();
|
|
int i = 0;
|
|
while (true)
|
|
{
|
|
if (i < searchObjectList.Count)
|
|
{
|
|
object obj = searchObjectList.items[i];
|
|
if (searchDoubles.Add(obj))
|
|
{
|
|
Type type = ((!(obj is Type)) ? obj.GetType() : ((Type)obj));
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(memberLookups.items[0], type);
|
|
if (!checkSearchType || searchTypes.Contains(type))
|
|
{
|
|
SearchMember searchMember = new SearchMember(null, obj, type, null, (!(obj is Behaviour)) ? MemberType.Property : MemberType.Field, objectDrawInfo, 0);
|
|
searchMemberFailedList.Add(searchMember);
|
|
AddAllSearchMembers(obj, type, searchMember, 1);
|
|
if (count++ > windowData.searchInspectorPerFrame.value)
|
|
{
|
|
count = 0;
|
|
yield return null;
|
|
SetSearchInspectorPerFrame();
|
|
}
|
|
if (oldInspectorSearchLevel != inspectorSearchLevel)
|
|
{
|
|
break;
|
|
}
|
|
for (int j = 0; j < searchMemberList.Count; j++)
|
|
{
|
|
searchMember = searchMemberList.items[j];
|
|
object obj2 = searchMember.obj;
|
|
if (skip.Contains(searchMember.member))
|
|
{
|
|
continue;
|
|
}
|
|
MemberInfo member = searchMember.member;
|
|
int level = searchMember.level;
|
|
if (level >= memberLookups.Count)
|
|
{
|
|
memberLookups.Add(new Dictionary<object, DrawInfo>(128));
|
|
}
|
|
MemberType memberType = searchMember.memberType;
|
|
MemberData memberData = GetMemberData(searchMember.objType, member, memberType);
|
|
FieldInfo field = null;
|
|
PropertyInfo prop = null;
|
|
if (searchMember.memberType == MemberType.Field)
|
|
{
|
|
field = memberData.field;
|
|
}
|
|
else if (searchMember.memberType == MemberType.Property)
|
|
{
|
|
prop = memberData.prop;
|
|
}
|
|
Type type2 = memberData.type;
|
|
string name = memberData.name;
|
|
localTotalSearched++;
|
|
if (count++ > searchInspectorPerFrame)
|
|
{
|
|
count = 0;
|
|
yield return null;
|
|
SetSearchInspectorPerFrame();
|
|
}
|
|
if (oldInspectorSearchLevel != inspectorSearchLevel)
|
|
{
|
|
goto end_IL_0582;
|
|
}
|
|
object obj3 = null;
|
|
switch (memberType)
|
|
{
|
|
case MemberType.Field:
|
|
try
|
|
{
|
|
obj3 = field.GetValue(obj2);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
skip.Add(searchMember.member);
|
|
}
|
|
break;
|
|
case MemberType.Property:
|
|
if (prop.IsDefined(typeof(ObsoleteAttribute), inherit: true))
|
|
{
|
|
continue;
|
|
}
|
|
if (prop.GetIndexParameters().Length != 0)
|
|
{
|
|
break;
|
|
}
|
|
try
|
|
{
|
|
if (prop.GetGetMethod(nonPublic: true) != null)
|
|
{
|
|
obj3 = prop.GetValue(obj2, null);
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
skip.Add(searchMember.member);
|
|
}
|
|
break;
|
|
}
|
|
bool isClass = memberData.isClass;
|
|
bool isStruct = memberData.isStruct;
|
|
bool isArray = memberData.isArray;
|
|
bool flag = (isClass || isStruct || isArray) && obj3 != null && !obj3.Equals(null);
|
|
objectDrawInfo = GetObjectDrawInfo(memberLookups.items[level], member);
|
|
searchMember.info = objectDrawInfo;
|
|
if (!needInspectorSearch)
|
|
{
|
|
goto end_IL_0582;
|
|
}
|
|
if (PassSearch(WindowType.Inspector, null, name, type2))
|
|
{
|
|
searchMemberPassedList.Add(searchMember);
|
|
}
|
|
else
|
|
{
|
|
searchMemberFailedList.Add(searchMember);
|
|
}
|
|
if (level < inspectorSearchLevel && (!(flag && isClass) || searchDoubles.Add(obj3)) && flag)
|
|
{
|
|
Type type3 = obj3.GetType();
|
|
AddAllSearchMembers(obj3, type3, searchMember, level + 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
for (int k = 0; k < searchMemberFailedList.Count; k++)
|
|
{
|
|
searchMemberFailedList.items[k].info.passSearch = 0;
|
|
}
|
|
for (int l = 0; l < searchMemberPassedList.Count; l++)
|
|
{
|
|
SearchMember searchMember2 = searchMemberPassedList.items[l];
|
|
searchMember2.info.passSearch = 2;
|
|
while (searchMember2.parent != null)
|
|
{
|
|
searchMember2 = (SearchMember)searchMember2.parent;
|
|
if (searchMember2.info.passSearch == 0)
|
|
{
|
|
searchMember2.info.passSearch = 1;
|
|
}
|
|
}
|
|
}
|
|
scrollViewCull.recalc = true;
|
|
totalFound = searchMemberPassedList.Count;
|
|
totalSearched = localTotalSearched;
|
|
break;
|
|
continue;
|
|
end_IL_0582:
|
|
break;
|
|
}
|
|
isSearchingInspector = false;
|
|
if (inspectorSearchLevel > 1)
|
|
{
|
|
refreshInspectorSearch = 0.25f;
|
|
}
|
|
else
|
|
{
|
|
refreshInspectorSearch = 0f;
|
|
}
|
|
}
|
|
|
|
public static void ResetStatic()
|
|
{
|
|
RuntimeInspector.onTimeScaleChanged = null;
|
|
selectionIndicatorGO = null;
|
|
selectedGO = null;
|
|
navigationCamera = null;
|
|
namespaceTypesLookup.Clear();
|
|
typeNameLookup.Clear();
|
|
show = false;
|
|
}
|
|
|
|
private void Awake()
|
|
{
|
|
instance = this;
|
|
selectionIndicatorGO = base.transform.GetChild(0).gameObject;
|
|
SetSelectionSphereRadius();
|
|
skin = windowData.skin;
|
|
texArrowFolded = windowData.texArrowFolded;
|
|
texArrowUnfolded = windowData.texArrowUnfolded;
|
|
inspectorWindow = windowData.inspectorWindow;
|
|
hierarchyWindow = windowData.hierarchyWindow;
|
|
SetActive(showOnStart);
|
|
if (enableCameraOnStart)
|
|
{
|
|
useNavigationCamera.Value = true;
|
|
EnableCamControl();
|
|
}
|
|
wrapButton = new GUIStyle(skin.button);
|
|
wrapButton.wordWrap = true;
|
|
wrapTextField = new GUIStyle(skin.textField);
|
|
wrapTextField.wordWrap = true;
|
|
drawEnum = new DrawEnum(skin);
|
|
RuntimeConsole.Register(this);
|
|
refreshHierarchySearch = 1f;
|
|
refreshInspectorSearch = 1f;
|
|
}
|
|
|
|
private void OnEnable()
|
|
{
|
|
instance = this;
|
|
}
|
|
|
|
private void OnDisable()
|
|
{
|
|
isSearchingScenes = (isSearchingAssemblies = (isSearchingMemory = (isSearchingInspector = false)));
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
RuntimeConsole.Unregister(this);
|
|
if (instance == this)
|
|
{
|
|
instance = null;
|
|
}
|
|
}
|
|
|
|
[ConsoleCommand("search.HiearchyType", "", AccessLevel.Admin)]
|
|
public static void SearchHierarchyType(string type)
|
|
{
|
|
SetSearch(instance.hierarchyWindow, type, SearchMode.Type, 0, setActive: true);
|
|
}
|
|
|
|
[ConsoleCommand("search.HierarchyName", "", AccessLevel.Admin)]
|
|
public static void SearchHierarchyName(string name)
|
|
{
|
|
SetSearch(instance.hierarchyWindow, name, SearchMode.Name, 0, setActive: true);
|
|
}
|
|
|
|
public static void SetSearch(WindowSettings window, string text, SearchMode searchMode, int searchIndex, bool setActive)
|
|
{
|
|
if (setActive)
|
|
{
|
|
instance.SetActive(active: true);
|
|
}
|
|
window.searchList[searchIndex].useSearch = true;
|
|
window.searchList[searchIndex].text = text;
|
|
window.searchList[searchIndex].mode = searchMode;
|
|
}
|
|
|
|
private void SetSelectionSphereRadius()
|
|
{
|
|
float selectionSphereRadius = windowData.selectionSphereRadius;
|
|
selectionIndicatorGO.transform.localScale = new Vector3(selectionSphereRadius, selectionSphereRadius, selectionSphereRadius);
|
|
}
|
|
|
|
private void EnableCamControl()
|
|
{
|
|
if (mainCam == null)
|
|
{
|
|
mainCam = Camera.main;
|
|
}
|
|
if (mainCam == null)
|
|
{
|
|
Debug.LogError("Cannot find the Main Camera. Please tag your Main Camera with the 'MainCamera' tag.");
|
|
useNavigationCamera.Value = false;
|
|
}
|
|
else
|
|
{
|
|
navigationCamera = mainCam.gameObject.AddComponent<NavigationCamera>();
|
|
navigationCamera.data = navigationCameraData;
|
|
}
|
|
}
|
|
|
|
private void DisableCamControl()
|
|
{
|
|
UnityEngine.Object.Destroy(navigationCamera);
|
|
}
|
|
|
|
public void SetActive(bool active)
|
|
{
|
|
hierarchyWindow.drag = (inspectorWindow.drag = 0);
|
|
if (RuntimeConsole.accessLevel != AccessLevel.Admin)
|
|
{
|
|
active = false;
|
|
}
|
|
show = active;
|
|
selectionIndicatorGO.SetActive(show);
|
|
base.gameObject.SetActive(show);
|
|
if (RuntimeInspector.onSetActive != null)
|
|
{
|
|
RuntimeInspector.onSetActive(active);
|
|
}
|
|
WindowManager.CheckMouseCursorState();
|
|
}
|
|
|
|
public void ManualUpdate()
|
|
{
|
|
if (!WindowManager.instance.onlyUseViewToggleKeys && EventInput.isGamePauseKeyDown)
|
|
{
|
|
pauseGame.Value = !pauseGame.Value;
|
|
Pause();
|
|
}
|
|
if (!show)
|
|
{
|
|
return;
|
|
}
|
|
if (mainCam == null)
|
|
{
|
|
mainCam = Camera.main;
|
|
}
|
|
selectionIndicatorGO.SetActive(show && selectedGO != null);
|
|
if (useNavigationCamera.Value && EventInput.isMouseButtonDown0)
|
|
{
|
|
SelectGameObjectFromScreenRay();
|
|
}
|
|
if (EventInput.isMouseButtonUp0)
|
|
{
|
|
hierarchyWindow.drag = (inspectorWindow.drag = 0);
|
|
}
|
|
needHierarchySearch = NeedSearch(hierarchyWindow.searchList);
|
|
if (needHierarchySearch)
|
|
{
|
|
if (drawAssemblies.Value)
|
|
{
|
|
SearchAssemblies();
|
|
}
|
|
else if (drawMemory.Value)
|
|
{
|
|
SearchMemory();
|
|
}
|
|
else
|
|
{
|
|
SearchScenes();
|
|
}
|
|
}
|
|
needInspectorSearch = NeedSearch(inspectorWindow.searchList);
|
|
if (needInspectorSearch)
|
|
{
|
|
if (drawScenes.Value)
|
|
{
|
|
if ((bool)selectedGO)
|
|
{
|
|
SearchInsideGameObject(selectedGO);
|
|
}
|
|
}
|
|
else if (drawAssemblies.Value)
|
|
{
|
|
if (selectedStaticType != null)
|
|
{
|
|
SearchInspector(selectedStaticType);
|
|
}
|
|
}
|
|
else if (drawMemory.Value && selectedObject != null)
|
|
{
|
|
SearchInspector(selectedObject);
|
|
}
|
|
}
|
|
if ((bool)selectedGO && !WindowManager.instance.onlyUseViewToggleKeys)
|
|
{
|
|
if (EventInput.isControlKey && EventInput.isKeyDownD)
|
|
{
|
|
UnityEngine.Object.Instantiate(selectedGO, selectedGO.transform.position, selectedGO.transform.rotation, selectedGO.transform.parent);
|
|
}
|
|
if (EventInput.isKeyDownDelete)
|
|
{
|
|
UnityEngine.Object.Destroy(selectedGO);
|
|
selectedGO = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void LateUpdate()
|
|
{
|
|
if (selectedGO != null)
|
|
{
|
|
UpdateSelectedIndicatorTransform();
|
|
}
|
|
}
|
|
|
|
public static void UpdateSelectedIndicatorTransform()
|
|
{
|
|
if (selectedGO != null)
|
|
{
|
|
selectionIndicatorGO.transform.position = selectedGO.transform.TransformPoint(instance.selectionIndicatorLocalPos);
|
|
selectionIndicatorGO.transform.rotation = selectedGO.transform.rotation * instance.selectionIndicatorLocalRot;
|
|
}
|
|
}
|
|
|
|
private bool NeedSearch(List<Search> searchList)
|
|
{
|
|
bool result = false;
|
|
for (int i = 0; i < searchList.Count; i++)
|
|
{
|
|
Search search = searchList[i];
|
|
if (search.useSearch && search.hasSearch)
|
|
{
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public void MyOnGUI()
|
|
{
|
|
currentEvent = Event.current;
|
|
if (Helper.IsShowKeyPressed(currentEvent, useSameEditorAsBuildShowKey, showToggleKeyEditor, showToggleKeyBuild))
|
|
{
|
|
if (show || RuntimeConsole.accessLevel == AccessLevel.Admin)
|
|
{
|
|
SetActive(!show);
|
|
}
|
|
}
|
|
else if (show)
|
|
{
|
|
GUI.skin = skin;
|
|
mousePos = currentEvent.mousePosition;
|
|
skin.box.fontStyle = FontStyle.Bold;
|
|
if (WindowManager.instance.useCanvas)
|
|
{
|
|
GUI.backgroundColor = new Color(1f, 1f, 1f, 0f);
|
|
}
|
|
else
|
|
{
|
|
GUI.backgroundColor = windowData.color;
|
|
}
|
|
hierarchyWindow.Update(311f, 260f);
|
|
inspectorWindow.Update(270f, 260f);
|
|
if (inspectorWindow.isDocked.Value)
|
|
{
|
|
inspectorWindow.rect.yMax = hierarchyWindow.rect.yMax;
|
|
inspectorWindow.rect.yMin = hierarchyWindow.rect.yMin;
|
|
inspectorWindow.position.y = hierarchyWindow.position.y;
|
|
inspectorWindow.position.x = hierarchyWindow.position.x + hierarchyWindow.rect.width / (float)Screen.width;
|
|
}
|
|
Helper.DrawWindow(3242340, hierarchyWindow, DrawHierarchy);
|
|
if (ShouldInspectorWindowShow())
|
|
{
|
|
Helper.DrawWindow(2342341, inspectorWindow, DrawInspector);
|
|
}
|
|
drawEnum.Draw(windowData.boxAlpha, windowData.backgroundAlpha);
|
|
}
|
|
}
|
|
|
|
public static bool ShouldInspectorWindowShow()
|
|
{
|
|
if ((!selectedGO || !instance.drawScenes.Value) && (!(instance.selectedStaticType != null) || !instance.drawAssemblies.Value))
|
|
{
|
|
if (instance.selectedObject != null)
|
|
{
|
|
return instance.drawMemory.Value;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private bool DrawSearch(WindowSettings window, bool changeText2)
|
|
{
|
|
List<Search> searchList = window.searchList;
|
|
if (searchList.Count == 0)
|
|
{
|
|
searchList.Add(new Search());
|
|
}
|
|
bool result = false;
|
|
for (int i = 0; i < searchList.Count; i++)
|
|
{
|
|
Search search = searchList[i];
|
|
SearchMode mode = search.mode;
|
|
if (!search.useSearch)
|
|
{
|
|
GUI.color = Color.grey;
|
|
}
|
|
else if (search.hasSearch)
|
|
{
|
|
GUI.backgroundColor = GetColor(Color.magenta);
|
|
}
|
|
GUILayout.BeginHorizontal();
|
|
if (GUILayout.Button(Helper.GetGUIContent("Search", windowData.texSearch, "Toggle Search On/Off"), GUILayout.Width(75f), GUILayout.Height(21f)))
|
|
{
|
|
search.useSearch = !search.useSearch;
|
|
result = true;
|
|
}
|
|
GUI.backgroundColor = GetColor(Color.white);
|
|
if (i == 0)
|
|
{
|
|
if (GUILayout.Button(Helper.GetGUIContent("+", "Add another Search Condition"), GUILayout.Width(20f)))
|
|
{
|
|
searchList.Add(new Search());
|
|
}
|
|
}
|
|
else if (GUILayout.Button(Helper.GetGUIContent("-", "Remove this Search Condition"), GUILayout.Width(20f)))
|
|
{
|
|
if (search.useSearch && search.hasSearch)
|
|
{
|
|
result = true;
|
|
}
|
|
searchList.RemoveAt(i--);
|
|
continue;
|
|
}
|
|
if (GUILayout.Button(Helper.GetGUIContent(mode.ToString(), "Toggle between searching for Names/Types"), GUILayout.Width(47f)))
|
|
{
|
|
if (mode == SearchMode.Name)
|
|
{
|
|
search.mode = SearchMode.Type;
|
|
}
|
|
else
|
|
{
|
|
search.mode = SearchMode.Name;
|
|
}
|
|
if (search.useSearch && search.hasSearch)
|
|
{
|
|
result = true;
|
|
}
|
|
}
|
|
if (i == 0)
|
|
{
|
|
if (GUILayout.Button(Helper.GetGUIContent(window.showSearchNonFound ? windowData.texVisible : windowData.texInvisible, "Enabled: Shows all if parent object is unfolded.\n\nDisabled: Shows only found results."), GUILayout.Width(25f)))
|
|
{
|
|
window.showSearchNonFound = !window.showSearchNonFound;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
skin.button.alignment = TextAnchor.MiddleCenter;
|
|
if (GUILayout.Button(Helper.GetGUIContent((search.condition == SearchCondition.Or) ? "||" : "&", "|| = Or\n& = And"), GUILayout.Width(25f)))
|
|
{
|
|
if (search.useSearch && search.hasSearch)
|
|
{
|
|
result = true;
|
|
}
|
|
if (search.condition == SearchCondition.Or)
|
|
{
|
|
search.condition = SearchCondition.And;
|
|
}
|
|
else
|
|
{
|
|
search.condition = SearchCondition.Or;
|
|
}
|
|
}
|
|
skin.button.alignment = TextAnchor.MiddleLeft;
|
|
}
|
|
if (GUILayout.Button(Helper.GetGUIContent("X", "Delete search text"), GUILayout.Width(22f)))
|
|
{
|
|
search.text = string.Empty;
|
|
search.hasSearch = false;
|
|
}
|
|
if (search.hasSearch && search.mode == SearchMode.Type && search.types.Count == 0)
|
|
{
|
|
GUI.color = Color.red;
|
|
}
|
|
GUI.changed = false;
|
|
search.text = GUILayout.TextField(search.text);
|
|
if (search.useSearch || GUI.changed)
|
|
{
|
|
if (GUI.changed)
|
|
{
|
|
result = true;
|
|
}
|
|
search.hasSearch = search.text != string.Empty;
|
|
if (search.mode == SearchMode.Type)
|
|
{
|
|
FastList<Type> value;
|
|
if (search.text.Contains("[]"))
|
|
{
|
|
if (typeNameLookup.TryGetValue(search.text.Replace("[]", ""), out value))
|
|
{
|
|
search.types.FastClear();
|
|
search.types.AddRange(value);
|
|
search.MakeArrayTypes();
|
|
}
|
|
}
|
|
else if (typeNameLookup.TryGetValue(search.text, out value))
|
|
{
|
|
search.types.FastClear();
|
|
search.types.AddRange(value);
|
|
}
|
|
else
|
|
{
|
|
search.types.FastClear();
|
|
}
|
|
if (search.types.Count > 0 && window == hierarchyWindow && !drawAssemblies.Value && !drawMemory.Value)
|
|
{
|
|
for (int j = 0; j < search.types.Count; j++)
|
|
{
|
|
if (!search.types.items[j].IsSubclassOf(typeof(Component)))
|
|
{
|
|
search.types.RemoveAt(j--);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
GUI.color = Color.white;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private bool PassSearch(WindowType windowType, Transform t, string name, Type type)
|
|
{
|
|
int num = 0;
|
|
List<Search> list = ((windowType != WindowType.Hierarchy) ? inspectorWindow.searchList : hierarchyWindow.searchList);
|
|
bool flag = false;
|
|
bool flag2 = true;
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
Search search = list[i];
|
|
if (search.useSearch && search.hasSearch)
|
|
{
|
|
bool flag3 = false;
|
|
if (search.mode == SearchMode.Name)
|
|
{
|
|
if (t != null)
|
|
{
|
|
name = t.name;
|
|
}
|
|
flag3 = name.IndexOf(search.text, 0, StringComparison.CurrentCultureIgnoreCase) != -1;
|
|
}
|
|
else if (t != null)
|
|
{
|
|
for (int j = 0; j < search.types.Count; j++)
|
|
{
|
|
Type type2 = search.types.items[j];
|
|
flag3 = type2 != null && type2.IsSubclassOf(typeof(Component)) && t.GetComponent(type2) != null;
|
|
if (flag3)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int k = 0; k < search.types.Count; k++)
|
|
{
|
|
Type type3 = search.types.items[k];
|
|
flag3 = type3 != null && type3 == type;
|
|
if (flag3)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
flag = ((!(search.condition == SearchCondition.Or || flag2)) ? (flag && flag3) : (flag || flag3));
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
return num == list.Count;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public DrawInfo GetObjectDrawInfo<T>(Dictionary<T, DrawInfo> lookup, T obj, bool defaultFoldout = false)
|
|
{
|
|
if (!lookup.TryGetValue(obj, out var value))
|
|
{
|
|
value = (lookup[obj] = new DrawInfo(defaultFoldout));
|
|
}
|
|
return value;
|
|
}
|
|
|
|
public void DrawDot(Color color, string tooltip, Texture tex, bool minusSpace = false)
|
|
{
|
|
GUI.color = color;
|
|
GUILayout.Space(10f);
|
|
Rect lastRect = GUILayoutUtility.GetLastRect();
|
|
lastRect.y += 7f;
|
|
lastRect.width = 16f;
|
|
lastRect.height = 16f;
|
|
GUI.Label(lastRect, Helper.GetGUIContent(string.Empty, tex, tooltip));
|
|
GUI.color = GetColor(Color.white);
|
|
}
|
|
|
|
public Bool3 DrawElement(WindowSettings window, DrawInfo info, int childCount, string name, float width, Texture tex, string tooltip = "")
|
|
{
|
|
Bool3 result = default(Bool3);
|
|
if (childCount > 0)
|
|
{
|
|
GUILayout.Space(-1f);
|
|
result.v2 = GUILayout.Button(Helper.GetGUIContent(string.Empty, tooltip), GUILayout.Width(21f), GUILayout.Height(21f));
|
|
Rect lastRect = GUILayoutUtility.GetLastRect();
|
|
lastRect.x += (info.foldout ? 4 : 5);
|
|
lastRect.y += (info.foldout ? 7 : 6);
|
|
float width2 = (lastRect.height = 8f);
|
|
lastRect.width = width2;
|
|
GUI.DrawTexture(lastRect, info.foldout ? texArrowUnfolded : texArrowFolded);
|
|
GUILayout.Space(-4f);
|
|
}
|
|
else
|
|
{
|
|
GUILayout.Space(5f);
|
|
DrawDot(GUI.backgroundColor, tooltip, tex);
|
|
GUILayout.Space(5f);
|
|
}
|
|
GUILayout.Space(2f);
|
|
if (width == -1f)
|
|
{
|
|
GUILayout.Label(name);
|
|
}
|
|
else
|
|
{
|
|
GUILayout.Label(name, GUILayout.Width(width));
|
|
}
|
|
result.v3 = result.v1 || result.v2;
|
|
return result;
|
|
}
|
|
|
|
public Bool3 DrawElement(WindowSettings window, DrawInfo info, int childCount, string text = "", Texture image = null, string tooltip = "", bool isActive = true, int prefix = 0)
|
|
{
|
|
Bool3 result = default(Bool3);
|
|
GUI.color = (isActive ? Color.white : new Color(0.25f, 0.25f, 0.25f, 1f));
|
|
GUILayout.BeginHorizontal();
|
|
if (prefix != 0)
|
|
{
|
|
GUILayout.Space(prefix);
|
|
}
|
|
if (childCount > 0 || childCount == -1)
|
|
{
|
|
if (windowData.showChildCount.Value && childCount > 0)
|
|
{
|
|
result.v2 = GUILayout.Button(Helper.GetGUIContent(childCount.ToString(), info.foldout ? texArrowUnfolded : texArrowFolded), GUILayout.Width(55f), GUILayout.Height(21f));
|
|
}
|
|
else
|
|
{
|
|
result.v2 = GUILayout.Button(Helper.GetGUIContent(string.Empty, info.foldout ? texArrowUnfolded : texArrowFolded), GUILayout.Width(25f), GUILayout.Height(21f));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
GUILayout.Label(string.Empty, GUILayout.Width(windowData.showChildCount.Value ? 55 : 25), GUILayout.Height(21f));
|
|
}
|
|
result.v1 = GUILayout.Button(Helper.GetGUIContent(text, image, tooltip), GUILayout.Height(21f));
|
|
GUILayout.EndHorizontal();
|
|
GUI.color = Color.white;
|
|
result.v3 = result.v1 || result.v2;
|
|
return result;
|
|
}
|
|
|
|
private Color GetColor(Color color)
|
|
{
|
|
color.a *= windowData.backgroundAlpha;
|
|
return color;
|
|
}
|
|
|
|
private Color GetColor(object obj, object selectedObj, bool needSearch, DrawInfo info)
|
|
{
|
|
if (obj == selectedObj && obj != null)
|
|
{
|
|
return GetColor(Color.green);
|
|
}
|
|
if (needSearch && info.passSearch == 2)
|
|
{
|
|
return GetColor(Color.magenta);
|
|
}
|
|
return GetColor(Color.white);
|
|
}
|
|
|
|
public void DrawBoldLabel(GUISkin skin, string name, float space = -3f)
|
|
{
|
|
if (space != 0f)
|
|
{
|
|
GUILayout.Space(space);
|
|
}
|
|
skin.label.fontStyle = FontStyle.Bold;
|
|
GUILayout.Label(name);
|
|
skin.label.fontStyle = FontStyle.Normal;
|
|
if (space != 0f)
|
|
{
|
|
GUILayout.Space(space);
|
|
}
|
|
}
|
|
|
|
public void DrawBoldLabel(GUISkin skin, string name)
|
|
{
|
|
skin.label.fontStyle = FontStyle.Bold;
|
|
GUILayout.Label(name);
|
|
skin.label.fontStyle = FontStyle.Normal;
|
|
}
|
|
|
|
private void DrawPrefixLabel(string prefixName, string name, int prefix)
|
|
{
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Label(prefixName, GUILayout.Width(prefix));
|
|
GUILayout.Label(name);
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
|
|
private void DrawInputField<T>(string prefixName, T inputField) where T : BaseInputField
|
|
{
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Label(prefixName, GUILayout.Width(150f));
|
|
GUI.changed = false;
|
|
inputField.text = GUILayout.TextField(inputField.text);
|
|
if (GUI.changed)
|
|
{
|
|
inputField.TryParse(logError: false);
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
|
|
private void DrawToggleField(string prefixName, ref bool toggle)
|
|
{
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Label(prefixName, GUILayout.Width(150f));
|
|
GUI.changed = false;
|
|
toggle = GUILayout.Toggle(toggle, GUIContent.none);
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
|
|
private void DrawLastRectOffset(string name, int offset)
|
|
{
|
|
Rect lastRect = GUILayoutUtility.GetLastRect();
|
|
lastRect.xMin += offset;
|
|
GUI.Label(lastRect, name);
|
|
}
|
|
|
|
private Texture2D ReadBackTexture(Texture2D tex)
|
|
{
|
|
RenderTexture temporary = RenderTexture.GetTemporary(tex.width, tex.height, 0, RenderTextureFormat.Default, RenderTextureReadWrite.Linear);
|
|
Graphics.Blit(tex, temporary);
|
|
RenderTexture active = RenderTexture.active;
|
|
RenderTexture.active = temporary;
|
|
Texture2D texture2D = new Texture2D(tex.width, tex.height);
|
|
texture2D.ReadPixels(new Rect(0f, 0f, temporary.width, temporary.height), 0, 0);
|
|
texture2D.Apply();
|
|
RenderTexture.active = active;
|
|
RenderTexture.ReleaseTemporary(temporary);
|
|
return texture2D;
|
|
}
|
|
|
|
private Texture2D CopyAndRemoveAlphaFromTexture(Texture2D texRead, float colorMulti = 1f)
|
|
{
|
|
Texture2D texture2D = ReadBackTexture(texRead);
|
|
Color[] pixels = texture2D.GetPixels();
|
|
for (int i = 0; i < pixels.Length; i++)
|
|
{
|
|
if (pixels[i].a > 0f)
|
|
{
|
|
pixels[i].a = 1f;
|
|
}
|
|
pixels[i].r *= colorMulti;
|
|
pixels[i].g *= colorMulti;
|
|
pixels[i].b *= colorMulti;
|
|
}
|
|
texture2D.SetPixels(pixels);
|
|
texture2D.Apply();
|
|
return texture2D;
|
|
}
|
|
|
|
private void DrawBox(GUIContent guiContent, Color color)
|
|
{
|
|
color.a *= windowData.boxAlpha;
|
|
GUI.backgroundColor = color;
|
|
GUILayout.Box(guiContent);
|
|
color.a = 1f;
|
|
GUI.backgroundColor = Color.white;
|
|
}
|
|
|
|
private void BeginVerticalBox(float alphaMulti = 1f)
|
|
{
|
|
GUI.backgroundColor = new Color(0f, 0f, 0f, windowData.boxAlpha * alphaMulti);
|
|
GUILayout.BeginVertical("Box");
|
|
GUI.backgroundColor = GetColor(Color.white);
|
|
}
|
|
|
|
private void SelectGameObjectFromScreenRay()
|
|
{
|
|
if (!WindowManager.DoWindowsContainMousePos())
|
|
{
|
|
navigationCamera.SetCam();
|
|
Ray ray = mainCam.ScreenPointToRay(EventInput.mousePosInvY);
|
|
navigationCamera.RestoreCam();
|
|
if (Physics.Raycast(ray, out var hitInfo, 10000f, selectLayerMask))
|
|
{
|
|
SelectGameObject(hitInfo.transform.gameObject, unfold: true);
|
|
selectionIndicatorLocalPos = hitInfo.transform.InverseTransformPoint(hitInfo.point);
|
|
selectionIndicatorLocalRot = Quaternion.LookRotation(hitInfo.transform.InverseTransformDirection(-hitInfo.normal));
|
|
UpdateSelectedIndicatorTransform();
|
|
navigationCamera.ResetFollowPosRot();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SelectGameObject(GameObject go, bool unfold = false)
|
|
{
|
|
if (selectedGO == lastScreenRayedGO && unfold)
|
|
{
|
|
RevertSelectionFoldout();
|
|
}
|
|
else
|
|
{
|
|
selectList.Clear();
|
|
}
|
|
if ((bool)go)
|
|
{
|
|
selectionIndicatorLocalPos = Vector3.zero;
|
|
selectionIndicatorLocalRot = Quaternion.LookRotation(Vector3.forward);
|
|
}
|
|
selectedGO = (lastScreenRayedGO = go);
|
|
if (!unfold)
|
|
{
|
|
return;
|
|
}
|
|
Transform parent = go.transform;
|
|
while (true)
|
|
{
|
|
parent = parent.parent;
|
|
if (parent == null)
|
|
{
|
|
break;
|
|
}
|
|
DrawInfo objectDrawInfo = GetObjectDrawInfo(tLookup, parent);
|
|
if (!objectDrawInfo.foldout)
|
|
{
|
|
selectList.Add(objectDrawInfo);
|
|
}
|
|
objectDrawInfo.foldout = true;
|
|
}
|
|
GetObjectDrawInfo(sceneLookup, go.scene).foldout = true;
|
|
scrollToSelected = true;
|
|
}
|
|
|
|
private void RevertSelectionFoldout()
|
|
{
|
|
for (int i = 0; i < selectList.Count; i++)
|
|
{
|
|
selectList.items[i].foldout = false;
|
|
}
|
|
selectList.Clear();
|
|
}
|
|
|
|
private void DrawWindowTitle(GUIContent guiContent, WindowSettings window)
|
|
{
|
|
GUILayout.BeginHorizontal();
|
|
DrawBox(guiContent, Color.black);
|
|
Helper.Drag(window, inspectorWindow, hierarchyWindow, titleDrag: true);
|
|
skin.button.fontStyle = FontStyle.Bold;
|
|
if (GUILayout.Button(window.isMinimized ? "[]" : "_", GUILayout.Width(21f)))
|
|
{
|
|
window.isMinimized = !window.isMinimized;
|
|
}
|
|
if (GUILayout.Button("X", GUILayout.Width(21f)))
|
|
{
|
|
SetActive(active: false);
|
|
}
|
|
skin.button.fontStyle = FontStyle.Normal;
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
|
|
private void DrawHideFlagsIcons(object obj, HideFlags hideFlags, bool isPrefab, string name)
|
|
{
|
|
Rect lastRect = GUILayoutUtility.GetLastRect();
|
|
lastRect.x = lastRect.xMax - 24f;
|
|
lastRect.width = 24f;
|
|
GUI.color = Color.red * 20f;
|
|
float num = -24f;
|
|
if (hideFlags != HideFlags.None)
|
|
{
|
|
if ((hideFlags & HideFlags.DontUnloadUnusedAsset) != HideFlags.None)
|
|
{
|
|
DrawIcon(lastRect, Helper.GetGUIContent(windowData.texLoad, "DontUnloadUnusedAsset"), Color.white);
|
|
lastRect.x += num;
|
|
}
|
|
if ((hideFlags & HideFlags.NotEditable) != HideFlags.None)
|
|
{
|
|
DrawIcon(lastRect, Helper.GetGUIContent(windowData.texEdit, "NotEditable"), Color.white);
|
|
lastRect.x += num;
|
|
}
|
|
HideFlags hideFlags2 = hideFlags & HideFlags.HideAndDontSave & ~(HideFlags.HideInHierarchy | HideFlags.HideInInspector | HideFlags.NotEditable);
|
|
if (hideFlags2 != HideFlags.None)
|
|
{
|
|
DrawIcon(lastRect, Helper.GetGUIContent(windowData.texSave, hideFlags2.ToString()), Color.white);
|
|
lastRect.x += num;
|
|
}
|
|
if ((hideFlags & HideFlags.HideInInspector) != HideFlags.None)
|
|
{
|
|
DrawIcon(lastRect, Helper.GetGUIContent(windowData.texInspector, "HideInInspector"), Color.white);
|
|
lastRect.x += num;
|
|
}
|
|
if ((hideFlags & HideFlags.HideInHierarchy) != HideFlags.None)
|
|
{
|
|
DrawIcon(lastRect, Helper.GetGUIContent(windowData.texHierarchy, "HideInHierarchy"), Color.white);
|
|
lastRect.x += num;
|
|
}
|
|
}
|
|
if (isPrefab)
|
|
{
|
|
DrawIcon(lastRect, Helper.GetGUIContent(windowData.texPrefab, "Is Prefab"), Color.white);
|
|
lastRect.x += num;
|
|
}
|
|
if (obj == null)
|
|
{
|
|
DrawIcon(lastRect, Helper.GetGUIContent(windowData.texDestroyed, "Object is Destroyed"), Color.red);
|
|
lastRect.x += num;
|
|
}
|
|
else
|
|
{
|
|
Texture texture = obj as Texture;
|
|
if (texture != null)
|
|
{
|
|
lastRect.y++;
|
|
lastRect.height -= 2f;
|
|
lastRect.width = lastRect.height / (float)texture.height * (float)texture.width;
|
|
if (lastRect.width > 64f)
|
|
{
|
|
lastRect.width = 64f;
|
|
}
|
|
float num2 = lastRect.width - lastRect.height;
|
|
lastRect.x -= num2;
|
|
DrawIcon(lastRect, Helper.GetGUIContent(texture), Color.white, label: false);
|
|
lastRect.x += num;
|
|
}
|
|
}
|
|
GUI.color = Color.white;
|
|
}
|
|
|
|
private void DrawIcon(Rect rect, GUIContent guiContent, Color color, bool label = true)
|
|
{
|
|
GUI.color = color;
|
|
GUI.backgroundColor = new Color(0.1f, 0.1f, 0.1f, 0.85f);
|
|
if (label)
|
|
{
|
|
GUI.Label(rect, guiContent, skin.box);
|
|
}
|
|
else
|
|
{
|
|
GUI.DrawTexture(rect, guiContent.image);
|
|
}
|
|
}
|
|
}
|
|
}
|