forked from Crockan/MercuryToolbox
873 lines
30 KiB
C#
873 lines
30 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.IO.Pipes;
|
|
using System.Reflection;
|
|
using System.Security.AccessControl;
|
|
using System.Security.Principal;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using BepInEx;
|
|
using UnityEngine;
|
|
using UnityEngine.SceneManagement;
|
|
|
|
namespace Mercury.UnityProbe
|
|
{
|
|
[BepInPlugin(MercuryUnityProbeBuild.PluginGuid, MercuryUnityProbeBuild.PluginName, MercuryUnityProbeBuild.PluginVersion)]
|
|
public sealed class MercuryUnityProbePlugin : BaseUnityPlugin
|
|
{
|
|
private Thread pipeThread;
|
|
private NamedPipeServerStream activeServer;
|
|
private SynchronizationContext unityContext;
|
|
private int mainThreadId;
|
|
private volatile bool stopRequested;
|
|
|
|
private void Awake()
|
|
{
|
|
unityContext = SynchronizationContext.Current;
|
|
mainThreadId = Thread.CurrentThread.ManagedThreadId;
|
|
pipeThread = new Thread(PipeServerMain);
|
|
pipeThread.Name = "MercuryUnityProbePipe";
|
|
pipeThread.IsBackground = true;
|
|
pipeThread.Start();
|
|
Logger.LogInfo("Mercury Unity Probe pipe server thread started.");
|
|
Logger.LogInfo("Mercury Unity Probe ready on pipe " + MercuryUnityProbeBuild.PipeName + ".");
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
Logger.LogInfo("Mercury Unity Probe BaseUnityPlugin OnDestroy fired; keeping pipe backend alive.");
|
|
}
|
|
|
|
private void OnApplicationQuit()
|
|
{
|
|
stopRequested = true;
|
|
Logger.LogInfo("Mercury Unity Probe stopping pipe backend for application quit.");
|
|
TryDisposeActiveServer();
|
|
}
|
|
|
|
private void PipeServerMain()
|
|
{
|
|
while (!stopRequested)
|
|
{
|
|
NamedPipeServerStream server = null;
|
|
try
|
|
{
|
|
server = CreatePipeServer();
|
|
activeServer = server;
|
|
server.WaitForConnection();
|
|
ServeConnection(server);
|
|
}
|
|
catch (ObjectDisposedException)
|
|
{
|
|
if (!stopRequested)
|
|
{
|
|
Logger.LogWarning("Named pipe server disposed unexpectedly.");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (!stopRequested)
|
|
{
|
|
Logger.LogError("Named pipe server failed: " + ex);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
TryDisposeServer(server);
|
|
|
|
if (ReferenceEquals(activeServer, server))
|
|
{
|
|
activeServer = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static NamedPipeServerStream CreatePipeServer()
|
|
{
|
|
PipeSecurity pipeSecurity = CreateCurrentUserPipeSecurity();
|
|
return new NamedPipeServerStream(
|
|
MercuryUnityProbeBuild.PipeName,
|
|
PipeDirection.InOut,
|
|
1,
|
|
PipeTransmissionMode.Byte,
|
|
PipeOptions.None,
|
|
4096,
|
|
4096,
|
|
pipeSecurity);
|
|
}
|
|
|
|
private static PipeSecurity CreateCurrentUserPipeSecurity()
|
|
{
|
|
WindowsIdentity identity = WindowsIdentity.GetCurrent();
|
|
SecurityIdentifier user = identity == null ? null : identity.User;
|
|
if (user == null)
|
|
{
|
|
throw new InvalidOperationException("Could not resolve the current Windows user for Mercury Unity Probe pipe security.");
|
|
}
|
|
|
|
PipeSecurity pipeSecurity = new PipeSecurity();
|
|
pipeSecurity.AddAccessRule(new PipeAccessRule(
|
|
user,
|
|
PipeAccessRights.ReadWrite | PipeAccessRights.CreateNewInstance,
|
|
AccessControlType.Allow));
|
|
return pipeSecurity;
|
|
}
|
|
|
|
private void TryDisposeActiveServer()
|
|
{
|
|
TryDisposeServer(activeServer);
|
|
}
|
|
|
|
private static void TryDisposeServer(NamedPipeServerStream server)
|
|
{
|
|
if (server == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
server.Dispose();
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
private void ServeConnection(NamedPipeServerStream server)
|
|
{
|
|
StreamReader reader = null;
|
|
StreamWriter writer = null;
|
|
try
|
|
{
|
|
reader = new StreamReader(server, Encoding.UTF8, false, 4096, true);
|
|
writer = new StreamWriter(server, new UTF8Encoding(false), 4096, true);
|
|
writer.AutoFlush = true;
|
|
string requestJson = ReadBoundedRequestLine(reader);
|
|
Dictionary<string, object> response = HandleRequest(requestJson);
|
|
writer.WriteLine(MercuryUnityProbeProtocol.Serialize(response));
|
|
}
|
|
catch (FormatException ex)
|
|
{
|
|
if (writer != null)
|
|
{
|
|
Dictionary<string, object> response =
|
|
MercuryUnityProbeProtocol.Error("invalid", ex.Message);
|
|
writer.WriteLine(MercuryUnityProbeProtocol.Serialize(response));
|
|
}
|
|
}
|
|
catch (IOException ex)
|
|
{
|
|
if (!IsBrokenPipe(ex))
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (writer != null)
|
|
{
|
|
try
|
|
{
|
|
writer.Dispose();
|
|
}
|
|
catch (IOException ex)
|
|
{
|
|
if (!IsBrokenPipe(ex))
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (reader != null)
|
|
{
|
|
reader.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
private static string ReadBoundedRequestLine(TextReader reader)
|
|
{
|
|
StringBuilder builder = new StringBuilder();
|
|
while (true)
|
|
{
|
|
int value = reader.Read();
|
|
if (value < 0)
|
|
{
|
|
return builder.ToString();
|
|
}
|
|
|
|
char current = (char)value;
|
|
if (current == '\n')
|
|
{
|
|
return builder.ToString();
|
|
}
|
|
|
|
if (current == '\r')
|
|
{
|
|
if (reader.Peek() == '\n')
|
|
{
|
|
reader.Read();
|
|
}
|
|
return builder.ToString();
|
|
}
|
|
|
|
if (builder.Length >= MercuryUnityProbeProtocol.MaxRequestChars)
|
|
{
|
|
throw new FormatException("JSON request exceeds the maximum request length.");
|
|
}
|
|
|
|
builder.Append(current);
|
|
}
|
|
}
|
|
|
|
private Dictionary<string, object> HandleRequest(string requestJson)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(requestJson))
|
|
{
|
|
return MercuryUnityProbeProtocol.Error("invalid", "Received an empty JSON request.");
|
|
}
|
|
|
|
try
|
|
{
|
|
Dictionary<string, object> request =
|
|
MercuryUnityProbeProtocol.DeserializeRequest(requestJson);
|
|
if (request == null)
|
|
{
|
|
return MercuryUnityProbeProtocol.Error("invalid", "Failed to deserialize the JSON request.");
|
|
}
|
|
|
|
string command = MercuryUnityProbeProtocol.ReadString(request, "command");
|
|
if (string.IsNullOrWhiteSpace(command))
|
|
{
|
|
return MercuryUnityProbeProtocol.Error("invalid", "JSON request is missing the command field.");
|
|
}
|
|
|
|
return InvokeOnUnityThread(delegate
|
|
{
|
|
return ExecuteCommand(command, request);
|
|
}, command);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return MercuryUnityProbeProtocol.Error("invalid", ex.GetType().Name + ": " + ex.Message);
|
|
}
|
|
}
|
|
|
|
private static bool IsBrokenPipe(IOException error)
|
|
{
|
|
return error != null
|
|
&& error.Message != null
|
|
&& error.Message.IndexOf("pipe is broken", StringComparison.OrdinalIgnoreCase) >= 0;
|
|
}
|
|
|
|
private Dictionary<string, object> InvokeOnUnityThread(Func<Dictionary<string, object>> action, string reason)
|
|
{
|
|
if (Thread.CurrentThread.ManagedThreadId == mainThreadId)
|
|
{
|
|
return action();
|
|
}
|
|
|
|
if (unityContext != null)
|
|
{
|
|
Dictionary<string, object> result = null;
|
|
Exception error = null;
|
|
using (ManualResetEventSlim done = new ManualResetEventSlim(false))
|
|
{
|
|
unityContext.Post(delegate(object _)
|
|
{
|
|
try
|
|
{
|
|
result = action();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
error = ex;
|
|
}
|
|
finally
|
|
{
|
|
done.Set();
|
|
}
|
|
}, null);
|
|
|
|
if (!done.Wait(5000))
|
|
{
|
|
return MercuryUnityProbeProtocol.Error(reason, "Timed out waiting for the Unity SynchronizationContext.");
|
|
}
|
|
}
|
|
|
|
if (error != null)
|
|
{
|
|
return MercuryUnityProbeProtocol.Error(reason, error.GetType().Name + ": " + error.Message);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
if (ThreadingHelper.Instance == null)
|
|
{
|
|
return MercuryUnityProbeProtocol.Error(reason, "No Unity SynchronizationContext or ThreadingHelper is available.");
|
|
}
|
|
|
|
Dictionary<string, object> fallbackResult = null;
|
|
Exception fallbackError = null;
|
|
using (ManualResetEventSlim fallbackDone = new ManualResetEventSlim(false))
|
|
{
|
|
ThreadingHelper.Instance.StartSyncInvoke(delegate
|
|
{
|
|
try
|
|
{
|
|
fallbackResult = action();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
fallbackError = ex;
|
|
}
|
|
finally
|
|
{
|
|
fallbackDone.Set();
|
|
}
|
|
});
|
|
|
|
if (!fallbackDone.Wait(5000))
|
|
{
|
|
return MercuryUnityProbeProtocol.Error(reason, "Timed out waiting for ThreadingHelper.");
|
|
}
|
|
}
|
|
|
|
if (fallbackError != null)
|
|
{
|
|
return MercuryUnityProbeProtocol.Error(reason, fallbackError.GetType().Name + ": " + fallbackError.Message);
|
|
}
|
|
|
|
return fallbackResult;
|
|
}
|
|
|
|
private Dictionary<string, object> ExecuteCommand(string command, IDictionary<string, object> request)
|
|
{
|
|
string normalized = command == null ? string.Empty : command.Trim().ToLowerInvariant();
|
|
if (normalized == "status")
|
|
{
|
|
return BuildStatus();
|
|
}
|
|
|
|
if (normalized == "scenes")
|
|
{
|
|
return BuildScenes();
|
|
}
|
|
|
|
if (normalized == "find")
|
|
{
|
|
return BuildFind(MercuryUnityProbeProtocol.ReadString(request, "query"), MercuryUnityProbeProtocol.ReadLimit(request, 25));
|
|
}
|
|
|
|
if (normalized == "inspect")
|
|
{
|
|
return BuildInspect(MercuryUnityProbeProtocol.ReadInt(request, "instance_id"));
|
|
}
|
|
|
|
if (normalized == "static")
|
|
{
|
|
return BuildStatic(MercuryUnityProbeProtocol.ReadString(request, "type_name"));
|
|
}
|
|
|
|
return MercuryUnityProbeProtocol.Error(command, "Unsupported command.");
|
|
}
|
|
|
|
private Dictionary<string, object> BuildStatus()
|
|
{
|
|
List<string> scenes = new List<string>();
|
|
int sceneCount = SceneManager.sceneCount;
|
|
for (int i = 0; i < sceneCount; i++)
|
|
{
|
|
Scene scene = SceneManager.GetSceneAt(i);
|
|
scenes.Add(scene.name ?? string.Empty);
|
|
}
|
|
|
|
Dictionary<string, object> data = new Dictionary<string, object>(StringComparer.Ordinal);
|
|
data["pipe_name"] = MercuryUnityProbeBuild.PipeName;
|
|
data["plugin_version"] = MercuryUnityProbeBuild.PluginVersion;
|
|
data["unity_version"] = Application.unityVersion ?? string.Empty;
|
|
data["process_id"] = (uint)System.Diagnostics.Process.GetCurrentProcess().Id;
|
|
data["scene_count"] = sceneCount;
|
|
data["loaded_scene_names"] = scenes;
|
|
return MercuryUnityProbeProtocol.Success("status", data);
|
|
}
|
|
|
|
private Dictionary<string, object> BuildScenes()
|
|
{
|
|
List<Dictionary<string, object>> scenes = new List<Dictionary<string, object>>();
|
|
int sceneCount = SceneManager.sceneCount;
|
|
for (int i = 0; i < sceneCount; i++)
|
|
{
|
|
Scene scene = SceneManager.GetSceneAt(i);
|
|
Dictionary<string, object> record = new Dictionary<string, object>(StringComparer.Ordinal);
|
|
record["name"] = scene.name ?? string.Empty;
|
|
record["path"] = scene.path ?? string.Empty;
|
|
record["build_index"] = scene.buildIndex;
|
|
record["loaded"] = scene.isLoaded;
|
|
record["root_count"] = scene.rootCount;
|
|
scenes.Add(record);
|
|
}
|
|
|
|
Dictionary<string, object> data = new Dictionary<string, object>(StringComparer.Ordinal);
|
|
data["scenes"] = scenes;
|
|
return MercuryUnityProbeProtocol.Success("scenes", data);
|
|
}
|
|
|
|
private Dictionary<string, object> BuildFind(string query, int limit)
|
|
{
|
|
string needle = query == null ? string.Empty : query.Trim();
|
|
if (needle.Length == 0)
|
|
{
|
|
return MercuryUnityProbeProtocol.Error("find", "find requires a non-empty query.");
|
|
}
|
|
|
|
List<Dictionary<string, object>> matches = new List<Dictionary<string, object>>();
|
|
UnityEngine.Object[] objects = Resources.FindObjectsOfTypeAll<UnityEngine.Object>();
|
|
for (int i = 0; i < objects.Length; i++)
|
|
{
|
|
UnityEngine.Object obj = objects[i];
|
|
if (obj == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
string typeName = obj.GetType().FullName ?? obj.GetType().Name;
|
|
string objectName = obj.name ?? string.Empty;
|
|
if (!ContainsIgnoreCase(typeName, needle) && !ContainsIgnoreCase(objectName, needle))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
matches.Add(DescribeObjectSummary(obj));
|
|
if (matches.Count >= limit)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
matches.Sort(delegate(Dictionary<string, object> left, Dictionary<string, object> right)
|
|
{
|
|
return string.CompareOrdinal(
|
|
Convert.ToString(left["type_name"]) + "|" + Convert.ToString(left["name"]),
|
|
Convert.ToString(right["type_name"]) + "|" + Convert.ToString(right["name"]));
|
|
});
|
|
|
|
Dictionary<string, object> data = new Dictionary<string, object>(StringComparer.Ordinal);
|
|
data["query"] = needle;
|
|
data["matches"] = matches;
|
|
return MercuryUnityProbeProtocol.Success("find", data);
|
|
}
|
|
|
|
private Dictionary<string, object> BuildInspect(int instanceId)
|
|
{
|
|
if (instanceId == 0)
|
|
{
|
|
return MercuryUnityProbeProtocol.Error("inspect", "inspect requires a non-zero instance id.");
|
|
}
|
|
|
|
UnityEngine.Object obj = FindObjectByInstanceId(instanceId);
|
|
if (obj == null)
|
|
{
|
|
return MercuryUnityProbeProtocol.Error("inspect", "No runtime object matched the requested instance id.");
|
|
}
|
|
|
|
Dictionary<string, object> data = new Dictionary<string, object>(StringComparer.Ordinal);
|
|
data["object"] = DescribeObjectSummary(obj);
|
|
data["components"] = DescribeComponents(obj);
|
|
data["fields"] = DescribeInstanceFields(obj);
|
|
data["properties"] = DescribeInstanceProperties(obj);
|
|
return MercuryUnityProbeProtocol.Success("inspect", data);
|
|
}
|
|
|
|
private Dictionary<string, object> BuildStatic(string typeName)
|
|
{
|
|
string requested = typeName == null ? string.Empty : typeName.Trim();
|
|
if (requested.Length == 0)
|
|
{
|
|
return MercuryUnityProbeProtocol.Error("static", "static requires a managed type name.");
|
|
}
|
|
|
|
Type type = ResolveType(requested);
|
|
if (type == null)
|
|
{
|
|
return MercuryUnityProbeProtocol.Error("static", "Could not resolve the requested managed type.");
|
|
}
|
|
|
|
Dictionary<string, object> data = new Dictionary<string, object>(StringComparer.Ordinal);
|
|
data["type_name"] = type.FullName ?? type.Name;
|
|
data["assembly_name"] = type.Assembly.GetName().Name ?? string.Empty;
|
|
data["fields"] = DescribeStaticFields(type);
|
|
data["properties"] = DescribeStaticProperties(type);
|
|
return MercuryUnityProbeProtocol.Success("static", data);
|
|
}
|
|
|
|
private static bool ContainsIgnoreCase(string haystack, string needle)
|
|
{
|
|
if (string.IsNullOrEmpty(haystack) || string.IsNullOrEmpty(needle))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return haystack.IndexOf(needle, StringComparison.OrdinalIgnoreCase) >= 0;
|
|
}
|
|
|
|
private static UnityEngine.Object FindObjectByInstanceId(int instanceId)
|
|
{
|
|
UnityEngine.Object[] objects = Resources.FindObjectsOfTypeAll<UnityEngine.Object>();
|
|
for (int i = 0; i < objects.Length; i++)
|
|
{
|
|
UnityEngine.Object obj = objects[i];
|
|
if (obj != null && obj.GetInstanceID() == instanceId)
|
|
{
|
|
return obj;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static Dictionary<string, object> DescribeObjectSummary(UnityEngine.Object obj)
|
|
{
|
|
Dictionary<string, object> record = new Dictionary<string, object>(StringComparer.Ordinal);
|
|
record["instance_id"] = obj.GetInstanceID();
|
|
record["name"] = obj.name ?? string.Empty;
|
|
record["type_name"] = obj.GetType().FullName ?? obj.GetType().Name;
|
|
record["scene_name"] = GetSceneName(obj);
|
|
record["hierarchy_path"] = GetHierarchyPath(obj);
|
|
record["active"] = IsObjectActive(obj);
|
|
return record;
|
|
}
|
|
|
|
private static List<Dictionary<string, object>> DescribeComponents(UnityEngine.Object obj)
|
|
{
|
|
List<Dictionary<string, object>> items = new List<Dictionary<string, object>>();
|
|
GameObject gameObject = null;
|
|
if (obj is GameObject)
|
|
{
|
|
gameObject = (GameObject)obj;
|
|
}
|
|
else if (obj is Component)
|
|
{
|
|
gameObject = ((Component)obj).gameObject;
|
|
}
|
|
|
|
if (gameObject == null)
|
|
{
|
|
return items;
|
|
}
|
|
|
|
Component[] components = gameObject.GetComponents<Component>();
|
|
for (int i = 0; i < components.Length; i++)
|
|
{
|
|
Component component = components[i];
|
|
if (component == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
Dictionary<string, object> record = new Dictionary<string, object>(StringComparer.Ordinal);
|
|
record["instance_id"] = component.GetInstanceID();
|
|
record["type_name"] = component.GetType().FullName ?? component.GetType().Name;
|
|
items.Add(record);
|
|
}
|
|
|
|
return items;
|
|
}
|
|
|
|
private static List<Dictionary<string, object>> DescribeInstanceFields(object target)
|
|
{
|
|
return DescribeMembers(
|
|
target.GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance),
|
|
24,
|
|
delegate(FieldInfo field)
|
|
{
|
|
object value = null;
|
|
try
|
|
{
|
|
value = field.GetValue(target);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
|
|
return CreateValueMember(field.Name, field.FieldType, value);
|
|
});
|
|
}
|
|
|
|
private static List<Dictionary<string, object>> DescribeInstanceProperties(object target)
|
|
{
|
|
return DescribeMembers(
|
|
target.GetType().GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance),
|
|
24,
|
|
delegate(PropertyInfo property)
|
|
{
|
|
if (property.GetIndexParameters().Length != 0 || property.GetGetMethod(true) == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
object value = null;
|
|
try
|
|
{
|
|
value = property.GetValue(target, null);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
|
|
return CreateValueMember(property.Name, property.PropertyType, value);
|
|
});
|
|
}
|
|
|
|
private static List<Dictionary<string, object>> DescribeStaticFields(Type type)
|
|
{
|
|
return DescribeMembers(
|
|
type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static),
|
|
32,
|
|
delegate(FieldInfo field)
|
|
{
|
|
object value = null;
|
|
try
|
|
{
|
|
value = field.GetValue(null);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
|
|
return CreateValueMember(field.Name, field.FieldType, value);
|
|
});
|
|
}
|
|
|
|
private static List<Dictionary<string, object>> DescribeStaticProperties(Type type)
|
|
{
|
|
return DescribeMembers(
|
|
type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static),
|
|
32,
|
|
delegate(PropertyInfo property)
|
|
{
|
|
if (property.GetIndexParameters().Length != 0 || property.GetGetMethod(true) == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
object value = null;
|
|
try
|
|
{
|
|
value = property.GetValue(null, null);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
|
|
return CreateValueMember(property.Name, property.PropertyType, value);
|
|
});
|
|
}
|
|
|
|
private delegate Dictionary<string, object> MemberFormatter<TMember>(TMember member);
|
|
|
|
private static List<Dictionary<string, object>> DescribeMembers<TMember>(TMember[] members, int limit, MemberFormatter<TMember> formatter)
|
|
{
|
|
List<Dictionary<string, object>> items = new List<Dictionary<string, object>>();
|
|
Array.Sort(members, delegate(TMember left, TMember right)
|
|
{
|
|
string leftName = GetMemberName(left);
|
|
string rightName = GetMemberName(right);
|
|
return string.CompareOrdinal(leftName, rightName);
|
|
});
|
|
|
|
for (int i = 0; i < members.Length && items.Count < limit; i++)
|
|
{
|
|
Dictionary<string, object> record = formatter(members[i]);
|
|
if (record != null)
|
|
{
|
|
items.Add(record);
|
|
}
|
|
}
|
|
|
|
return items;
|
|
}
|
|
|
|
private static string GetMemberName<TMember>(TMember member)
|
|
{
|
|
MemberInfo info = member as MemberInfo;
|
|
return info == null ? string.Empty : info.Name ?? string.Empty;
|
|
}
|
|
|
|
private static Dictionary<string, object> CreateValueMember(string name, Type declaredType, object value)
|
|
{
|
|
Dictionary<string, object> record = new Dictionary<string, object>(StringComparer.Ordinal);
|
|
record["name"] = name ?? string.Empty;
|
|
record["declared_type"] = declaredType == null ? string.Empty : (declaredType.FullName ?? declaredType.Name ?? string.Empty);
|
|
record["value"] = FormatValue(value);
|
|
return record;
|
|
}
|
|
|
|
private static string FormatValue(object value)
|
|
{
|
|
if (value == null)
|
|
{
|
|
return "null";
|
|
}
|
|
|
|
if (value is string)
|
|
{
|
|
return TrimValue((string)value);
|
|
}
|
|
|
|
if (value is bool || value is byte || value is sbyte || value is short || value is ushort ||
|
|
value is int || value is uint || value is long || value is ulong || value is float ||
|
|
value is double || value is decimal || value is char)
|
|
{
|
|
return Convert.ToString(value) ?? string.Empty;
|
|
}
|
|
|
|
if (value is Enum)
|
|
{
|
|
return value.GetType().Name + "." + value;
|
|
}
|
|
|
|
if (value is UnityEngine.Object)
|
|
{
|
|
UnityEngine.Object obj = (UnityEngine.Object)value;
|
|
return (obj.GetType().FullName ?? obj.GetType().Name) + "#" + obj.GetInstanceID() + ":" + (obj.name ?? string.Empty);
|
|
}
|
|
|
|
if (value is IList)
|
|
{
|
|
IList list = (IList)value;
|
|
return "list[count=" + list.Count + "]";
|
|
}
|
|
|
|
if (value is IEnumerable)
|
|
{
|
|
return "enumerable";
|
|
}
|
|
|
|
return TrimValue(Convert.ToString(value) ?? value.GetType().Name);
|
|
}
|
|
|
|
private static string TrimValue(string text)
|
|
{
|
|
if (text == null)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
string trimmed = text.Replace("\r", "\\r").Replace("\n", "\\n");
|
|
return trimmed.Length <= 160 ? trimmed : trimmed.Substring(0, 157) + "...";
|
|
}
|
|
|
|
private static string GetSceneName(UnityEngine.Object obj)
|
|
{
|
|
if (obj is GameObject)
|
|
{
|
|
return ((GameObject)obj).scene.name ?? string.Empty;
|
|
}
|
|
|
|
if (obj is Component)
|
|
{
|
|
Component component = (Component)obj;
|
|
return component.gameObject == null ? string.Empty : (component.gameObject.scene.name ?? string.Empty);
|
|
}
|
|
|
|
return string.Empty;
|
|
}
|
|
|
|
private static string GetHierarchyPath(UnityEngine.Object obj)
|
|
{
|
|
Transform transform = null;
|
|
if (obj is GameObject)
|
|
{
|
|
transform = ((GameObject)obj).transform;
|
|
}
|
|
else if (obj is Component)
|
|
{
|
|
transform = ((Component)obj).transform;
|
|
}
|
|
|
|
if (transform == null)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
List<string> parts = new List<string>();
|
|
while (transform != null)
|
|
{
|
|
parts.Add(transform.name ?? string.Empty);
|
|
transform = transform.parent;
|
|
}
|
|
|
|
parts.Reverse();
|
|
return "/" + string.Join("/", parts.ToArray());
|
|
}
|
|
|
|
private static bool IsObjectActive(UnityEngine.Object obj)
|
|
{
|
|
if (obj is Behaviour)
|
|
{
|
|
return ((Behaviour)obj).isActiveAndEnabled;
|
|
}
|
|
|
|
if (obj is Component)
|
|
{
|
|
Component component = (Component)obj;
|
|
return component.gameObject != null && component.gameObject.activeInHierarchy;
|
|
}
|
|
|
|
if (obj is GameObject)
|
|
{
|
|
return ((GameObject)obj).activeInHierarchy;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static Type ResolveType(string requested)
|
|
{
|
|
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
|
|
for (int i = 0; i < assemblies.Length; i++)
|
|
{
|
|
Type type = assemblies[i].GetType(requested, false);
|
|
if (type != null)
|
|
{
|
|
return type;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < assemblies.Length; i++)
|
|
{
|
|
Type[] types;
|
|
try
|
|
{
|
|
types = assemblies[i].GetTypes();
|
|
}
|
|
catch
|
|
{
|
|
continue;
|
|
}
|
|
|
|
for (int j = 0; j < types.Length; j++)
|
|
{
|
|
Type type = types[j];
|
|
string fullName = type.FullName ?? string.Empty;
|
|
string name = type.Name ?? string.Empty;
|
|
if (string.Equals(fullName, requested, StringComparison.OrdinalIgnoreCase) ||
|
|
string.Equals(name, requested, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return type;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
}
|