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;
}
