Initial commit: AIGame Unity client with URP, HybridCLR, YooAsset and tooling.
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
udx
@@ -0,0 +1,224 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Reflection;
|
||||
using UnityEngine;
|
||||
|
||||
namespace Unity.Pipeline.Editor.Console
|
||||
{
|
||||
/// <summary>
|
||||
/// Reads the Editor console's own entry store through UnityEditor.LogEntries.
|
||||
///
|
||||
/// This is the only way to see entries the package's log-callback capture never received.
|
||||
/// Editor compile errors are logged with a sticky flag, and the console's Clear skips sticky
|
||||
/// entries, so they survive the Clear button, Clear on Play, Clear on Build and Clear on
|
||||
/// Recompile — only the next completed compile removes them. They can therefore stand in the
|
||||
/// console long after the callback-fed buffer evicted them or was never subscribed.
|
||||
///
|
||||
/// Reflection rather than a direct reference, because LogEntries is internal. Any failure
|
||||
/// disables this permanently for the session and callers report the console as unseeded.
|
||||
/// </summary>
|
||||
static class EditorConsoleEntries
|
||||
{
|
||||
// ConsoleMode bits from Unity's native EditorMonoConsole (mirrored by the internal
|
||||
// ConsoleWindow.ConsoleFlags): the three level toggles the console filter checks, and
|
||||
// Collapse, which folds identical entries into a single row.
|
||||
const int LevelFlags = (1 << 7) | (1 << 8) | (1 << 9);
|
||||
const int CollapseFlag = 1 << 0;
|
||||
|
||||
// LogMessageFlags bits, grouped exactly as Unity's own LogModeToLogType groups them.
|
||||
const int ModeScriptingException = 1 << 17;
|
||||
const int ModeErrors = (1 << 0) | (1 << 4) | (1 << 8) | (1 << 11) | (1 << 6);
|
||||
const int ModeAsserts = (1 << 1) | (1 << 21);
|
||||
const int ModeWarnings = (1 << 9) | (1 << 12) | (1 << 7);
|
||||
|
||||
static readonly MethodInfo k_StartGettingEntries;
|
||||
static readonly MethodInfo k_EndGettingEntries;
|
||||
static readonly MethodInfo k_GetEntryInternal;
|
||||
static readonly MethodInfo k_GetFilteringText;
|
||||
static readonly MethodInfo k_SetFilteringText;
|
||||
static readonly MethodInfo k_GetConsoleFlags;
|
||||
static readonly MethodInfo k_SetConsoleFlags;
|
||||
static readonly Type k_LogEntryType;
|
||||
static readonly FieldInfo k_MessageField;
|
||||
static readonly FieldInfo k_ModeField;
|
||||
static readonly FieldInfo k_CallstackStartField;
|
||||
|
||||
static bool s_Disabled;
|
||||
|
||||
/// <summary>An entry as it stands in the Editor console.</summary>
|
||||
internal struct Entry
|
||||
{
|
||||
public LogType Type;
|
||||
public string Message;
|
||||
public string StackTrace;
|
||||
}
|
||||
|
||||
static EditorConsoleEntries()
|
||||
{
|
||||
// LogEntries and LogEntry are internal, and LogEntries' members are static and
|
||||
// non-public, so NonPublic is mandatory in the binding flags — GetMethod without it
|
||||
// silently returns null.
|
||||
const BindingFlags statics = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static;
|
||||
|
||||
var logEntries = Type.GetType("UnityEditor.LogEntries,UnityEditor");
|
||||
k_LogEntryType = Type.GetType("UnityEditor.LogEntry,UnityEditor");
|
||||
if (logEntries == null || k_LogEntryType == null)
|
||||
return;
|
||||
|
||||
k_StartGettingEntries = logEntries.GetMethod("StartGettingEntries", statics);
|
||||
k_EndGettingEntries = logEntries.GetMethod("EndGettingEntries", statics);
|
||||
k_GetEntryInternal = logEntries.GetMethod("GetEntryInternal", statics);
|
||||
k_GetFilteringText = logEntries.GetMethod("GetFilteringText", statics);
|
||||
k_SetFilteringText = logEntries.GetMethod("SetFilteringText", statics);
|
||||
|
||||
var consoleFlags = logEntries.GetProperty("consoleFlags", statics);
|
||||
k_GetConsoleFlags = consoleFlags?.GetGetMethod(true);
|
||||
k_SetConsoleFlags = consoleFlags?.GetSetMethod(true);
|
||||
|
||||
const BindingFlags fields = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
|
||||
k_MessageField = k_LogEntryType.GetField("message", fields);
|
||||
k_ModeField = k_LogEntryType.GetField("mode", fields);
|
||||
k_CallstackStartField = k_LogEntryType.GetField("callstackTextStartUTF16", fields);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// True when every member this reads was found and no read has failed yet.
|
||||
/// </summary>
|
||||
internal static bool Available =>
|
||||
!s_Disabled
|
||||
&& k_StartGettingEntries != null && k_EndGettingEntries != null && k_GetEntryInternal != null
|
||||
&& k_GetFilteringText != null && k_SetFilteringText != null
|
||||
&& k_GetConsoleFlags != null && k_SetConsoleFlags != null
|
||||
&& k_MessageField != null && k_ModeField != null && k_CallstackStartField != null;
|
||||
|
||||
/// <summary>
|
||||
/// Read up to <paramref name="max"/> most recent console entries, oldest first. Returns
|
||||
/// false when the internal API is unavailable or the read failed, in which case
|
||||
/// <paramref name="into"/> is left untouched. Main thread only.
|
||||
/// </summary>
|
||||
/// <param name="max">Maximum number of entries to read, taken from the end of the console.</param>
|
||||
/// <param name="into">Receives the entries read.</param>
|
||||
/// <returns>True when entries were read.</returns>
|
||||
internal static bool TryReadRecent(int max, List<Entry> into)
|
||||
{
|
||||
if (!Available || max <= 0)
|
||||
return false;
|
||||
|
||||
var flags = 0;
|
||||
var filter = string.Empty;
|
||||
var flagsMutated = false;
|
||||
var filterMutated = false;
|
||||
|
||||
try
|
||||
{
|
||||
flags = (int)k_GetConsoleFlags.Invoke(null, null);
|
||||
filter = (string)k_GetFilteringText.Invoke(null, null) ?? string.Empty;
|
||||
|
||||
// The console's row list is filtered by the level toggles and the search box, and
|
||||
// Collapse folds repeats into one row, so a user who has any of them set would
|
||||
// otherwise hide entries from this read. Open the view only when it is actually
|
||||
// restricted: in the default state this mutates nothing and avoids two native
|
||||
// re-filter passes.
|
||||
//
|
||||
// Collapse matters because the caller counts occurrences to work out what it missed;
|
||||
// a collapsed row reports one where the console holds several.
|
||||
//
|
||||
// Both must happen outside the StartGettingEntries bracket: setting them rebuilds
|
||||
// the filtered index, and reordering it under a live snapshot invalidates the row
|
||||
// indices the read below uses.
|
||||
var opened = (flags | LevelFlags) & ~CollapseFlag;
|
||||
if (opened != flags)
|
||||
{
|
||||
k_SetConsoleFlags.Invoke(null, new object[] { opened });
|
||||
flagsMutated = true;
|
||||
}
|
||||
|
||||
if (!string.IsNullOrEmpty(filter))
|
||||
{
|
||||
k_SetFilteringText.Invoke(null, new object[] { string.Empty });
|
||||
filterMutated = true;
|
||||
}
|
||||
|
||||
// StartGettingEntries returns the row count and pins it for the duration; GetCount
|
||||
// would report that same pinned value, so there is no reason to ask twice.
|
||||
var total = (int)k_StartGettingEntries.Invoke(null, null);
|
||||
try
|
||||
{
|
||||
var entry = Activator.CreateInstance(k_LogEntryType);
|
||||
var args = new object[2];
|
||||
for (var row = Math.Max(0, total - max); row < total; row++)
|
||||
{
|
||||
args[0] = row;
|
||||
args[1] = entry;
|
||||
if (!(bool)k_GetEntryInternal.Invoke(null, args))
|
||||
continue;
|
||||
|
||||
into.Add(ToEntry(entry));
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
// Leaving the snapshot open pins the console's row count for every other reader
|
||||
// and makes Unity warn on the next StartGettingEntries.
|
||||
k_EndGettingEntries.Invoke(null, null);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
s_Disabled = true;
|
||||
Debug.LogWarning($"[Pipeline] Cannot read the Editor console store; console entries logged before capture started will not be reported: {ex.Message}");
|
||||
return false;
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (filterMutated)
|
||||
TryRestore(k_SetFilteringText, filter);
|
||||
if (flagsMutated)
|
||||
TryRestore(k_SetConsoleFlags, flags);
|
||||
}
|
||||
}
|
||||
|
||||
static Entry ToEntry(object logEntry)
|
||||
{
|
||||
var message = (string)k_MessageField.GetValue(logEntry) ?? string.Empty;
|
||||
var mode = (int)k_ModeField.GetValue(logEntry);
|
||||
|
||||
// A console entry stores its message and callstack in one string, split at this index.
|
||||
var split = Mathf.Clamp((int)k_CallstackStartField.GetValue(logEntry), 0, message.Length);
|
||||
|
||||
return new Entry
|
||||
{
|
||||
Type = ToLogType(mode),
|
||||
Message = message.Substring(0, split),
|
||||
StackTrace = message.Substring(split)
|
||||
};
|
||||
}
|
||||
|
||||
static LogType ToLogType(int mode)
|
||||
{
|
||||
if ((mode & ModeScriptingException) != 0)
|
||||
return LogType.Exception;
|
||||
if ((mode & ModeErrors) != 0)
|
||||
return LogType.Error;
|
||||
if ((mode & ModeAsserts) != 0)
|
||||
return LogType.Assert;
|
||||
if ((mode & ModeWarnings) != 0)
|
||||
return LogType.Warning;
|
||||
return LogType.Log;
|
||||
}
|
||||
|
||||
static void TryRestore(MethodInfo setter, object value)
|
||||
{
|
||||
try
|
||||
{
|
||||
setter.Invoke(null, new[] { value });
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
Debug.LogWarning($"[Pipeline] Failed to restore Editor console filtering state: {ex.Message}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user