Add Unity Pipeline package support

2026-07-31 17:34:04 +08:00
parent d1a526094e
commit 786b7ffff9
590 changed files with 51995 additions and 2 deletions
@@ -0,0 +1,67 @@
+using System;
+using UnityEngine;
+
+namespace Unity.Pipeline.Console
+{
+    /// <summary>
+    /// Captures Unity console output into a process-wide <see cref="ConsoleLogBuffer"/> so the
+    /// <c>console</c> command can serve it to CLI clients. This type lives in the runtime
+    /// assembly, so it ships in player builds as well as the Editor.
+    ///
+    /// Lifecycle:
+    ///  - In a Player, the <c>[RuntimeInitializeOnLoadMethod]</c> hook starts capture as the app boots.
+    ///  - In the Editor, the editor-only <c>EditorConsoleCaptureBootstrap</c> starts capture on every
+    ///    domain reload and layers on persistence so entries survive reloads (e.g. after a recompile).
+    ///    Both paths funnel through <see cref="EnsureCapturing"/>, which is idempotent — entering Play
+    ///    mode in the Editor fires the runtime hook too, and the guard makes that a no-op.
+    ///  - <see cref="Application.logMessageReceivedThreaded"/> is used (not the non-threaded variant)
+    ///    so logs emitted from background threads are captured too. The buffer is thread-safe.
+    ///
+    /// Capture starts when this type first initializes. Console entries produced before that — or
+    /// before the package's first import — are not retroactively captured; this reads from the public
+    /// log callback, not Unity's internal console store.
+    /// </summary>
+    public static class ConsoleLogCapture
+    {
+        static readonly ConsoleLogBuffer s_Buffer = new ConsoleLogBuffer();
+        static readonly object s_SubscriptionLock = new object();
+        static bool s_Subscribed;
+
+        /// <summary>The shared buffer holding captured console entries.</summary>
+        public static ConsoleLogBuffer Buffer => s_Buffer;
+
+        /// <summary>
+        /// Player entry point. Runs as the application boots so console output is captured from the
+        /// start. In the Editor this also fires when entering Play mode, but <see cref="EnsureCapturing"/>
+        /// is idempotent so it does not double-subscribe.
+        /// </summary>
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        static void RuntimeBootstrap()
+        {
+            EnsureCapturing();
+        }
+
+        /// <summary>
+        /// Subscribe to Unity's log callback if not already subscribed. Safe to call repeatedly and
+        /// from either the runtime bootstrap or the Editor bootstrap.
+        /// </summary>
+        public static void EnsureCapturing()
+        {
+            lock (s_SubscriptionLock)
+            {
+                if (s_Subscribed)
+                    return;
+
+                // Defensive: remove before adding in case a prior subscription leaked across a reload.
+                Application.logMessageReceivedThreaded -= OnLogMessage;
+                Application.logMessageReceivedThreaded += OnLogMessage;
+                s_Subscribed = true;
+            }
+        }
+
+        static void OnLogMessage(string condition, string stackTrace, LogType type)
+        {
+            s_Buffer.Add(type, condition, stackTrace, DateTime.UtcNow);
+        }
+    }
+}