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,267 @@
+using UnityEditor;
+using UnityEngine;
+using Unity.Pipeline.Models;
+using Unity.Pipeline.Commands;
+using Unity.Pipeline.Threading;
+using UnityEditor.MPE;
+
+namespace Unity.Pipeline.Editor
+{
+    /// <summary>
+    /// Automatically starts Pipeline HTTP server when Unity Editor loads.
+    /// Handles startup, domain reload persistence, and cleanup.
+    ///
+    /// Static owner of the live editor server: a static owner survives domain reloads cleanly
+    /// (re-created by [InitializeOnLoad]), whereas a ScriptableObject's lifetime does not track the
+    /// server across editor events. <see cref="EditorPipelineManager"/> is an optional, inspectable
+    /// settings asset whose config is read here at start.
+    /// </summary>
+    [InitializeOnLoad]
+    public static class PipelineServerStartup
+    {
+        private static EditorPipelineServer m_Server;
+
+        /// <summary>
+        /// The live editor pipeline server instance (null when stopped). Exposed so the test guard
+        /// can disable its watchdog for a test run and the EditorPipelineManager inspector can read
+        /// live status.
+        /// </summary>
+        public static EditorPipelineServer Server => m_Server;
+
+        static PipelineServerStartup()
+        {
+            // Don't start server in AssetImportWorker processes
+            if (!IsMainProcess())
+                return;
+            // Setup command discovery using TypeCache for fast Editor performance
+            CommandRegistry.SetDiscovery(new TypeCacheCommandDiscovery());
+
+            // Clean up any stale instance descriptor files from previous sessions
+            CleanupStaleDescriptors();
+
+            // Start the pipeline server (respecting the settings asset's autoStart if one exists)
+            if (EditorPipelineManager.Load()?.AutoStart ?? true)
+                StartServer();
+
+            // Handle domain reloads and editor shutdown
+            EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
+            EditorApplication.quitting += OnEditorQuitting;
+
+            // Handle domain reload detection
+            AssemblyReloadEvents.beforeAssemblyReload += OnBeforeAssemblyReload;
+            AssemblyReloadEvents.afterAssemblyReload += OnAfterAssemblyReload;
+        }
+
+        public static void EnsureServerStarted()
+        {
+            StartServer();
+        }
+
+        /// <summary>
+        /// Force a clean restart of the editor pipeline server. Unlike EnsureServerStarted, this
+        /// works even when the current server's listener has died but still reports IsRunning
+        /// (e.g. after a test disrupted it). Used by tests to revive the live server they disrupted.
+        /// </summary>
+        public static void RestartServer()
+        {
+            StopServer();
+            StartServer();
+        }
+
+        [MenuItem("Pipeline/Start Server")]
+        private static void MenuStartServer()
+        {
+            StartServer();
+            if (m_Server != null && m_Server.IsRunning)
+                Debug.Log($"Pipeline Server started on port {m_Server.Port}");
+            else
+                Debug.LogWarning("Pipeline Server failed to start");
+        }
+
+        [MenuItem("Pipeline/Start Server", true)]
+        private static bool MenuStartServerValidate() => m_Server == null || !m_Server.IsRunning;
+
+        [MenuItem("Pipeline/Stop Server")]
+        private static void MenuStopServer()
+        {
+            StopServer();
+        }
+
+        [MenuItem("Pipeline/Stop Server", true)]
+        private static bool MenuStopServerValidate() => m_Server != null && m_Server.IsRunning;
+
+        /// <summary>
+        /// Select the EditorPipelineManager settings asset, creating it under Assets/Settings/Pipeline
+        /// on first use (the live server otherwise runs from built-in defaults).
+        /// </summary>
+        [MenuItem("Pipeline/Settings...")]
+        private static void OpenSettings()
+        {
+            var mgr = EditorPipelineManager.Load();
+            if (mgr == null)
+            {
+                const string folder = "Assets/Settings/Pipeline";
+                if (!AssetDatabase.IsValidFolder(folder))
+                {
+                    if (!AssetDatabase.IsValidFolder("Assets/Settings"))
+                        AssetDatabase.CreateFolder("Assets", "Settings");
+                    AssetDatabase.CreateFolder("Assets/Settings", "Pipeline");
+                }
+
+                mgr = ScriptableObject.CreateInstance<EditorPipelineManager>();
+                AssetDatabase.CreateAsset(mgr, folder + "/EditorPipelineManager.asset");
+                AssetDatabase.SaveAssets();
+            }
+            Selection.activeObject = mgr;
+            EditorGUIUtility.PingObject(mgr);
+        }
+
+        internal static bool IsMainProcess()
+        {
+            // Check command line arguments for asset import worker indicators
+            var args = System.Environment.GetCommandLineArgs();
+            for (int i = 0; i < args.Length; i++)
+            {
+                if (args[i] == "-readonly" || args[i] == "--virtual-project-clone")
+                    return true;
+            }
+
+            if (AssetDatabase.IsAssetImportWorkerProcess())
+                return false;
+
+            if (ProcessService.level != ProcessLevel.Main)
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Start the Pipeline HTTP server, reading configuration from the EditorPipelineManager
+        /// settings asset if one exists (otherwise using defaults).
+        /// </summary>
+        private static void StartServer()
+        {
+            if (m_Server != null && m_Server.IsRunning)
+                return;
+
+            try
+            {
+                var cfg = EditorPipelineManager.Load();
+                m_Server = new EditorPipelineServer
+                {
+                    // Self-healing watchdog: if the listener dies without a Stop() (an unexpected fault
+                    // outside a domain reload), the watchdog re-opens it so the dogfood loop doesn't
+                    // wedge. Set before Start() (Start arms the watchdog).
+                    WatchdogEnabled = cfg?.WatchdogEnabled ?? true,
+                    WatchdogIntervalSeconds = cfg?.WatchdogIntervalSeconds ?? 5,
+                    LogRequestsResponses = cfg?.LogRequestsResponses ?? false
+                };
+
+                // Rotate the transaction log once per Unity session (main thread; SessionState-gated).
+                // The append path runs off-thread and can't touch SessionState.
+                PipelineTransactionLog.RotateForNewSession();
+
+                m_Server.Start(cfg?.Port ?? 0); // 0 auto-assigns from the 7800-7849 range.
+
+                if (m_Server.WatchdogEnabled)
+                {
+                    // The watchdog rides EditorApplication.update, but a backgrounded/idle editor stops
+                    // ticking once the listener dies (no requests left to wake it) — the exact moment the
+                    // watchdog must run. Keep auto-tick on so the update loop keeps spinning regardless of
+                    // focus, which keeps both the watchdog AND the dispatcher message pump alive.
+                    Commands.AutoTickCommand.SetAutoTick(true);
+                }
+            }
+            catch (System.Exception ex)
+            {
+                Debug.LogError($"Failed to start Pipeline Server: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Stop the Pipeline HTTP server.
+        /// </summary>
+        public static void StopServer()
+        {
+            if (m_Server != null)
+            {
+                try
+                {
+                    m_Server.Stop();
+                }
+                catch (System.Exception ex)
+                {
+                    Debug.LogWarning($"Error stopping Pipeline Server: {ex.Message}");
+                }
+                finally
+                {
+                    m_Server = null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Clean up stale instance descriptor files from previous Editor sessions.
+        /// </summary>
+        private static void CleanupStaleDescriptors()
+        {
+            var projectPath = System.IO.Path.GetDirectoryName(Application.dataPath);
+
+            // Try to read existing descriptor
+            var existing = InstanceDescriptor.ReadFromProjectRoot(projectPath);
+            if (existing != null)
+            {
+                // Check if process is still running
+                try
+                {
+                    var process = System.Diagnostics.Process.GetProcessById(existing.Pid);
+                    if (process.HasExited)
+                    {
+                        // Process is dead, remove stale file
+                        InstanceDescriptor.RemoveFromProjectRoot(projectPath);
+                    }
+                }
+                catch
+                {
+                    // Process doesn't exist or access denied, remove stale file
+                    InstanceDescriptor.RemoveFromProjectRoot(projectPath);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Handle play mode state changes.
+        /// </summary>
+        private static void OnPlayModeStateChanged(PlayModeStateChange state)
+        {
+            // Server continues running through play mode changes
+            // Status endpoint will reflect current play mode via EditorApplication.isPlaying
+        }
+
+        /// <summary>
+        /// Handle Editor shutdown.
+        /// </summary>
+        private static void OnEditorQuitting()
+        {
+            StopServer(); // Stop() shuts down the server's own dispatcher.
+        }
+
+        /// <summary>
+        /// Handle before assembly reload (domain reload).
+        /// </summary>
+        private static void OnBeforeAssemblyReload()
+        {
+            // Server will be automatically recreated after reload due to [InitializeOnLoad]
+            // Instance descriptor file will be cleaned up and recreated
+        }
+
+        /// <summary>
+        /// Handle after assembly reload (domain reload).
+        /// </summary>
+        private static void OnAfterAssemblyReload()
+        {
+            // Server should already be restarted via [InitializeOnLoad]
+            // This is mainly for logging/verification
+        }
+    }
+}