/// <summary> /// Loads a memory snapshot from the specified 'filePath' and stores the result in 'snapshot'. /// </summary> /// <param name="filePath">Absolute file path</param> public bool LoadFromFile(string filePath) { busyString = "Loading"; using (var fileStream = new System.IO.FileStream(filePath, System.IO.FileMode.Open)) { using (var reader = new System.IO.BinaryReader(fileStream)) { try { PackedMemorySnapshotHeader.Read(reader, out header, out busyString); if (!header.isValid) { throw new Exception("Invalid header."); } PackedNativeType.Read(reader, out nativeTypes, out busyString); PackedNativeUnityEngineObject.Read(reader, out nativeObjects, out busyString); PackedGCHandle.Read(reader, out gcHandles, out busyString); PackedConnection.Read(reader, out connections, out busyString); PackedMemorySection.Read(reader, out managedHeapSections, out busyString); PackedManagedType.Read(reader, out managedTypes, out busyString); PackedVirtualMachineInformation.Read(reader, out virtualMachineInformation, out busyString); } catch (System.Exception e) { Debug.LogException(e); return(false); } } } return(true); }
public static PackedNativeUnityEngineObject[] FromMemoryProfiler(UnityEditor.MemoryProfiler.PackedNativeUnityEngineObject[] source) { var value = new PackedNativeUnityEngineObject[source.Length]; for (int n = 0, nend = source.Length; n < nend; ++n) { value[n] = new PackedNativeUnityEngineObject { isPersistent = source[n].isPersistent, isDontDestroyOnLoad = source[n].isDontDestroyOnLoad, isManager = source[n].isManager, name = source[n].name, instanceId = source[n].instanceId, size = source[n].size, nativeTypesArrayIndex = source[n].nativeTypeArrayIndex, hideFlags = source[n].hideFlags, nativeObjectAddress = source[n].nativeObjectAddress, nativeObjectsArrayIndex = n, managedObjectsArrayIndex = -1, }; } return(value); }
public void Inspect(PackedMemorySnapshot snapshot, PackedNativeUnityEngineObject nativeObject) { m_Snapshot = snapshot; m_Object = nativeObject; Reload(); }
public bool CanAdd(PackedNativeUnityEngineObject no) { if (!addAssetObjects && no.isPersistent) { return(false); } if (!addSceneObjects && !no.isPersistent && no.instanceId >= 0) { return(false); } if (!addRuntimeObjects && !no.isPersistent && no.instanceId < 0) { return(false); } var dontDestroy = false; if (no.isDontDestroyOnLoad || no.isManager || ((no.hideFlags & HideFlags.DontUnloadUnusedAsset) != 0)) { dontDestroy = true; } if (!addDestroyOnLoad && !dontDestroy) { return(false); } if (!addDontDestroyOnLoad && dontDestroy) { return(false); } return(true); }
public static void NativeObjectIcon(Rect position, PackedNativeUnityEngineObject obj) { var warningMsg = ""; var showWarning = false; if (obj.isDontDestroyOnLoad || obj.isManager || ((obj.hideFlags & HideFlags.DontUnloadUnusedAsset) != 0)) { warningMsg = "\n\nThe object does not unload automatically during scene changes, because of 'isDontDestroyOnLoad' or 'isManager' or 'hideFlags'."; showWarning = true; } if (obj.isPersistent) { GUI.Box(position, new GUIContent(HeEditorStyles.assetImage, "Object is an asset." + warningMsg), HeEditorStyles.iconStyle); } else if (obj.instanceId < 0) { var c = GUI.color; GUI.color = new Color(1, 0.75f, 1, c.a); GUI.Box(position, new GUIContent(HeEditorStyles.instanceImage, "Object created at runtime." + warningMsg), HeEditorStyles.iconStyle); GUI.color = c; } else { GUI.Box(position, new GUIContent(HeEditorStyles.sceneImage, "Object is stored in scene." + warningMsg), HeEditorStyles.iconStyle); } if (showWarning) { var r = position; r.x += 5; r.y += 4; GUI.Box(r, new GUIContent(HeEditorStyles.warnImage), HeEditorStyles.iconStyle); } }
public static void Read(System.IO.BinaryReader reader, out PackedNativeUnityEngineObject[] value, out string stateString) { value = new PackedNativeUnityEngineObject[0]; stateString = ""; var version = reader.ReadInt32(); if (version >= 1) { var length = reader.ReadInt32(); stateString = string.Format("Loading {0} Native Objects", length); value = new PackedNativeUnityEngineObject[length]; for (int n = 0, nend = value.Length; n < nend; ++n) { value[n].isPersistent = reader.ReadBoolean(); value[n].isDontDestroyOnLoad = reader.ReadBoolean(); value[n].isManager = reader.ReadBoolean(); value[n].name = reader.ReadString(); value[n].instanceId = reader.ReadInt32(); value[n].size = reader.ReadInt32(); value[n].nativeTypesArrayIndex = reader.ReadInt32(); value[n].hideFlags = (HideFlags)reader.ReadInt32(); value[n].nativeObjectAddress = reader.ReadInt64(); value[n].nativeObjectsArrayIndex = n; value[n].managedObjectsArrayIndex = -1; } } }
public void Initialize(NativeObjectsControl owner, PackedNativeUnityEngineObject nativeObject) { m_Owner = owner; m_Object = new RichNativeObject(owner.m_Snapshot, nativeObject.nativeObjectsArrayIndex); #if HEAPEXPLORER_DISPLAY_REFS m_Object.GetConnectionsCount(out m_ReferencesCount, out m_ReferencedByCount); #endif }
public void GetConnections(PackedNativeUnityEngineObject nativeObj, List <PackedConnection> references, List <PackedConnection> referencedBy) { var index = nativeObj.nativeObjectsArrayIndex; if (index == -1) { return; } GetConnectionsInternal(PackedConnection.Kind.Native, index, references, referencedBy); }
public static PackedNativeUnityEngineObject[] FromMemoryProfiler(UnityEditor.Profiling.Memory.Experimental.PackedMemorySnapshot snapshot) { var source = snapshot.nativeObjects; var value = new PackedNativeUnityEngineObject[source.GetNumEntries()]; var sourceFlags = new ObjectFlags[source.flags.GetNumEntries()]; source.flags.GetEntries(0, source.flags.GetNumEntries(), ref sourceFlags); var sourceObjectNames = new string[source.objectName.GetNumEntries()]; source.objectName.GetEntries(0, source.objectName.GetNumEntries(), ref sourceObjectNames); var sourceInstanceIds = new int[source.instanceId.GetNumEntries()]; source.instanceId.GetEntries(0, source.instanceId.GetNumEntries(), ref sourceInstanceIds); var sourceSizes = new ulong[source.size.GetNumEntries()]; source.size.GetEntries(0, source.size.GetNumEntries(), ref sourceSizes); var sourceNativeTypeArrayIndex = new int[source.nativeTypeArrayIndex.GetNumEntries()]; source.nativeTypeArrayIndex.GetEntries(0, source.nativeTypeArrayIndex.GetNumEntries(), ref sourceNativeTypeArrayIndex); var sourceHideFlags = new HideFlags[source.hideFlags.GetNumEntries()]; source.hideFlags.GetEntries(0, source.hideFlags.GetNumEntries(), ref sourceHideFlags); var sourceNativeObjectAddress = new ulong[source.nativeObjectAddress.GetNumEntries()]; source.nativeObjectAddress.GetEntries(0, source.nativeObjectAddress.GetNumEntries(), ref sourceNativeObjectAddress); for (int n = 0, nend = value.Length; n < nend; ++n) { value[n] = new PackedNativeUnityEngineObject { isPersistent = (sourceFlags[n] & ObjectFlags.IsPersistent) != 0, isDontDestroyOnLoad = (sourceFlags[n] & ObjectFlags.IsDontDestroyOnLoad) != 0, isManager = (sourceFlags[n] & ObjectFlags.IsManager) != 0, name = sourceObjectNames[n], instanceId = sourceInstanceIds[n], size = (int)sourceSizes[n], // TODO: should be ulong nativeTypesArrayIndex = sourceNativeTypeArrayIndex[n], hideFlags = sourceHideFlags[n], nativeObjectAddress = (long)sourceNativeObjectAddress[n], // TODO: should be ulong nativeObjectsArrayIndex = n, managedObjectsArrayIndex = -1, }; } return(value); }
void AddNativeUnityObject(TreeViewItem parent, PackedNativeUnityEngineObject nativeObject) { var item = new NativeObjectItem { id = m_UniqueId++, depth = parent.depth + 1, }; item.Initialize(this, m_Snapshot, nativeObject); parent.AddChild(item); }
public void Inspect(PackedNativeUnityEngineObject obj) { Clear(); m_PreviewTime = Time.realtimeSinceStartup; m_Object = new RichNativeObject(snapshot, obj.nativeObjectsArrayIndex); if (autoLoad && m_Object.isValid && m_Object.isPersistent) { LoadAssetPreviews(); } }
/// <summary> /// Converts an Unity PackedMemorySnapshot to our own format. /// </summary> public static PackedMemorySnapshot FromMemoryProfiler(MemorySnapshotProcessingArgs args) { var source = args.source; var value = new PackedMemorySnapshot(); try { VerifyMemoryProfilerSnapshot(source); value.busyString = "Loading Header"; value.header = PackedMemorySnapshotHeader.FromMemoryProfiler(); value.busyString = string.Format("Loading {0} Native Types", source.nativeTypes.Length); value.nativeTypes = PackedNativeType.FromMemoryProfiler(source.nativeTypes); value.busyString = string.Format("Loading {0} Native Objects", source.nativeObjects.Length); value.nativeObjects = PackedNativeUnityEngineObject.FromMemoryProfiler(source.nativeObjects); value.busyString = string.Format("Loading {0} GC Handles", source.gcHandles.Length); value.gcHandles = PackedGCHandle.FromMemoryProfiler(source.gcHandles); value.busyString = string.Format("Loading {0} Object Connections", source.connections.Length); if (args.excludeNativeFromConnections) { value.connections = ConnectionsFromMemoryProfilerWithoutNativeHACK(value, source); } else { value.connections = PackedConnection.FromMemoryProfiler(source.connections); } value.busyString = string.Format("Loading {0} Managed Heap Sections", source.managedHeapSections.Length); value.managedHeapSections = PackedMemorySection.FromMemoryProfiler(source.managedHeapSections); value.busyString = string.Format("Loading {0} Managed Types", source.typeDescriptions.Length); value.managedTypes = PackedManagedType.FromMemoryProfiler(source.typeDescriptions); value.busyString = "Loading VM Information"; value.virtualMachineInformation = PackedVirtualMachineInformation.FromMemoryProfiler(source.virtualMachineInformation); } catch (System.Exception e) { Debug.LogException(e); value = null; throw; } return(value); }
/// <summary> /// Saves the specfified memory snapshot as a file, using the specified 'filePath'. /// </summary> public void SaveToFile(string filePath) { using (var fileStream = new System.IO.FileStream(filePath, System.IO.FileMode.OpenOrCreate)) { using (var writer = new System.IO.BinaryWriter(fileStream)) { PackedMemorySnapshotHeader.Write(writer, header); PackedNativeType.Write(writer, nativeTypes); PackedNativeUnityEngineObject.Write(writer, nativeObjects); PackedGCHandle.Write(writer, gcHandles); PackedConnection.Write(writer, connections); PackedMemorySection.Write(writer, managedHeapSections); PackedManagedType.Write(writer, managedTypes); PackedVirtualMachineInformation.Write(writer, virtualMachineInformation); } } }
public void Initialize(ConnectionsControl owner, PackedMemorySnapshot snapshot, PackedNativeUnityEngineObject nativeObject) { m_Owner = owner; m_Snapshot = snapshot; m_NativeObject = new RichNativeObject(snapshot, nativeObject.nativeObjectsArrayIndex); m_Value = m_NativeObject.name; address = m_NativeObject.address; displayName = m_NativeObject.type.name; // If it's a MonoBehaviour or ScriptableObject, use the C# typename instead // It makes it easier to understand what it is, otherwise everything displays 'MonoBehaviour' only. if (m_NativeObject.type.IsSubclassOf(m_Snapshot.coreTypes.nativeMonoBehaviour) || m_NativeObject.type.IsSubclassOf(m_Snapshot.coreTypes.nativeScriptableObject)) { string monoScriptName; if (m_Snapshot.FindNativeMonoScriptType(m_NativeObject.packed.nativeObjectsArrayIndex, out monoScriptName) != -1) { if (!string.IsNullOrEmpty(monoScriptName)) { displayName = monoScriptName; } } } }
public void Select(PackedNativeUnityEngineObject obj) { var item = FindItemByAddressRecursive(rootItem, (ulong)obj.nativeObjectAddress); SelectItem(item); }
public ObjectProxy(PackedMemorySnapshot snp, PackedNativeUnityEngineObject packed) { snapshot = snp; native = new RichNativeObject(snp, packed.nativeObjectsArrayIndex); }
public void Inspect(PackedNativeUnityEngineObject item) { ScheduleJob(new ObjectProxy(snapshot, item)); }