void OnListViewTypeSelected(PackedManagedType?type) { if (!type.HasValue) { m_Selected = RichManagedType.invalid; m_ConnectionsView.Clear(); m_PropertyGridView.Clear(); return; } m_Selected = new RichManagedType(snapshot, type.Value.managedTypesArrayIndex); var staticClass = m_Selected.packed; var staticFields = new List <PackedManagedStaticField>(); // Find all static fields of selected type foreach (var sf in snapshot.managedStaticFields) { if (sf.managedTypesArrayIndex == staticClass.managedTypesArrayIndex) { staticFields.Add(sf); } } m_ConnectionsView.Inspect(staticFields.ToArray()); m_PropertyGridView.Inspect(m_Selected); }
public void Clear() { m_ManagedObject = RichManagedObject.invalid; m_ManagedType = RichManagedType.invalid; m_PropertyGrid.Clear(); m_HexView.Clear(); m_DataVisualizer = null; }
public void Inspect(RichManagedType managedType) { m_ManagedObject = RichManagedObject.invalid; m_ManagedType = managedType; m_PropertyGrid.InspectStaticType(snapshot, m_ManagedType.packed); m_HexView.Inspect(snapshot, 0, new ArraySegment64 <byte>(managedType.packed.staticFieldBytes, 0, (ulong)managedType.packed.staticFieldBytes.LongLength)); m_DataVisualizer = null; }
void RunTest() { // Find the test type RichManagedType classType = RichManagedType.invalid; foreach (var type in m_snapshot.managedTypes) { if (type.name != "HeapExplorer.Test_Editor") { continue; } classType = new RichManagedType(m_snapshot, type.managedTypesArrayIndex); break; } Assert.IsTrue(classType.isValid); // Find the test object instance RichManagedObject managedObject = RichManagedObject.invalid; foreach (var obj in m_snapshot.managedObjects) { if (obj.managedTypesArrayIndex != classType.packed.managedTypesArrayIndex) { continue; } managedObject = new RichManagedObject(m_snapshot, obj.managedObjectsArrayIndex); } Assert.IsTrue(managedObject.isValid); AssertInt("m_intOne", 1, managedObject); AssertInt("m_intTwo", 2, managedObject); AssertInt("m_intThree", 3, managedObject); AssertInt("m_intFour", 4, managedObject); AssertDecimal("m_decimal", new decimal(1234567.89), managedObject); AssertDecimal("m_decimalNegative", new decimal(-1234567.89), managedObject); AssertVector2("m_vector2", new Vector2(1, 2), managedObject); AssertVector3("m_vector3", new Vector3(1, 2, 3), managedObject); AssertQuaternion("m_quaternion", Quaternion.identity, managedObject); AssertQuaternion("m_quaternion1", Quaternion.AngleAxis(90, Vector3.up), managedObject); AssertMatrix4x4("m_matrix", Matrix4x4.identity, managedObject); AssertLong("m_long", -1234567890, managedObject); AssertULong("m_ulong", 0x11_22_33_44_55_66_77_88, managedObject); AssertDateTime("m_dateTime_1999_11_22", new DateTime(1999, 11, 22, 1, 2, 3), managedObject); }
public void Inspect(PackedManagedObject managedObject) { m_ManagedObject = new RichManagedObject(snapshot, managedObject.managedObjectsArrayIndex); m_ManagedType = m_ManagedObject.type; m_PropertyGrid.Inspect(snapshot, m_ManagedObject.packed); m_DataVisualizer = null; if (AbstractDataVisualizer.HasVisualizer(m_ManagedObject.type.name)) { m_DataVisualizer = AbstractDataVisualizer.CreateVisualizer(m_ManagedObject.type.name); m_DataVisualizer.Initialize(snapshot, new MemoryReader(snapshot), m_ManagedObject.address, m_ManagedObject.type.packed); } m_HexView.Inspect(snapshot, managedObject.address, (ulong)managedObject.size); }
public void Initialize(PackedMemorySnapshot snapshot, int managedTypesArrayIndex) { m_Type = new RichManagedType(snapshot, managedTypesArrayIndex); }
public GotoCommand(RichManagedType value) : this() { toManagedType = value; }
public void Initialize(ManagedTypesControl owner, PackedMemorySnapshot snapshot, int arrayIndex) { m_Owner = owner; m_Type = new RichManagedType(snapshot, arrayIndex); }
protected override void OnBuildTree(TreeViewItem root) { progress.value = 0; var lookup = new Dictionary <string, AbstractItem>(); var memoryReader = new MemoryReader(m_Snapshot); for (int n = 0, nend = m_Snapshot.managedObjects.Length; n < nend; ++n) { progress.value = (n + 1.0f) / nend; var obj = m_Snapshot.managedObjects[n]; if (obj.address == 0) { continue; // points to null } if (obj.nativeObjectsArrayIndex != -1) { continue; // has a native object, thus can't be an empty shell object } var type = m_Snapshot.managedTypes[obj.managedTypesArrayIndex]; // Only UnityEngine.Object objects can have a m_CachedPtr connection to a native object. if (!type.isUnityEngineObject) { continue; } // Could be an array of an UnityEngine.Object, such as Texture[] if (type.isArray) { continue; } // Get type as a "higher level" representation that is easier to work with var richType = new RichManagedType(m_Snapshot, obj.managedTypesArrayIndex); // Try to get the m_InstanceID field (only exists in editor, not in built players) PackedManagedField packedField; if (richType.FindField("m_InstanceID", out packedField)) { // The editor contains various empty shell objects whose instanceID all contain 0. // I guess it's some kind of special object? In this case we just ignore them. var instanceID = memoryReader.ReadInt32(obj.address + (ulong)packedField.offset); if (instanceID == 0) { continue; } } // Check if we already have a grouping node for that type. // Create a new node if we don't have it. AbstractItem parent; if (!lookup.TryGetValue(type.name, out parent)) { var group = new GroupItem() { id = m_UniqueId++, depth = root.depth + 1, displayName = "" }; group.Initialize(m_Snapshot, type); lookup[type.name] = parent = group; root.AddChild(group); } // Create and add the managed object item var item = new ManagedObjectItem { id = m_UniqueId++, depth = parent.depth + 1, displayName = "" }; item.Initialize(this, m_Snapshot, obj); parent.AddChild(item); m_ManagedObjectCount++; m_ManagedObjectSize += item.size; } progress.value = 1; }