695 lines
35 KiB
C#
695 lines
35 KiB
C#
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using Unity.Pipeline.Editor.Commands;
|
|
using Unity.Pipeline.CodeReload;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
|
|
namespace Unity.Pipeline.Editor
|
|
{
|
|
/// <summary>
|
|
/// Watches a file or folder for <c>.cs</c> saves and re-applies the affected <c>[CodeReload]</c>
|
|
/// methods. The target is resolved automatically at each save: any connected development player
|
|
/// wins (broadcast push via <see cref="Commands.PushReloadCommand"/>),
|
|
/// otherwise the reload applies in this editor process via <see cref="InPlaceReloadProcessor"/>.
|
|
/// Both paths run on the interpreter backend. Folder mode watches recursively,
|
|
/// only touching files that opt into code reload; the settings UI always watches the project's
|
|
/// Assets folder (StartWatch itself accepts any file or folder).
|
|
///
|
|
/// Change detection is event-driven (<see cref="FileSystemWatcher"/>) — polling a whole tree every
|
|
/// editor tick would be prohibitive. The watcher can silently miss saves (macOS kqueue fd
|
|
/// exhaustion, atomic rename-based saves), so a low-rate poll of the <c>.cs</c> files' last-write
|
|
/// times backstops it; both paths feed the same debounce map, so a change seen by both applies once.
|
|
///
|
|
/// Watches also re-push the watched state to any player that connects mid-watch:
|
|
/// pushed overrides live only in the player's memory, so a restarted player boots the original AOT
|
|
/// code. Standalone <see cref="InitializeOnLoadAttribute"/> owner so the watch survives domain
|
|
/// reloads (state persisted in <see cref="EditorPrefs"/>); the Pipeline Settings inspector only
|
|
/// drives Start/Stop.
|
|
/// </summary>
|
|
[InitializeOnLoad]
|
|
static class EditorCodeReloadWatcher
|
|
{
|
|
private const double DebounceSeconds = 0.3;
|
|
// Reconciliation poll period; each poll only stats the watched .cs files, so it stays cheap.
|
|
private const double ReconcileIntervalSeconds = 2.0;
|
|
// PlayerConnection attaches early in player boot but the reload receiver only registers in
|
|
// RuntimePipelineDriver.Start(); an immediate push would go unheard.
|
|
private const double ReconnectPushDelaySeconds = 2.0;
|
|
|
|
// Persisted so an active watch survives editor domain reloads.
|
|
private const string PkPath = "Pipeline.CodeReloadWatch.Path";
|
|
private const string PkIsFolder = "Pipeline.CodeReloadWatch.IsFolder";
|
|
// Prior values of the two auto-refresh prefs, persisted while a watch holds them at 0; -1 = we didn't change that key.
|
|
private const string PkPrevAutoRefresh = "Pipeline.CodeReloadWatch.PrevAutoRefresh";
|
|
private const string PkPrevAutoRefreshMode = "Pipeline.CodeReloadWatch.PrevAutoRefreshMode";
|
|
// Unity reads kAutoRefreshMode (0=disabled, 1=enabled, 2=enabled outside play mode) since 2021.2;
|
|
// kAutoRefresh is the pre-2021.2 bool. Set both — writing only the legacy key is a no-op on Unity 6.
|
|
private const string AutoRefreshPref = "kAutoRefresh";
|
|
private const string AutoRefreshModePref = "kAutoRefreshMode";
|
|
|
|
private static bool s_Watching;
|
|
private static string s_WatchPath;
|
|
private static bool s_IsFolder;
|
|
private static int s_PrevAutoRefresh = -1;
|
|
private static int s_PrevAutoRefreshMode = -1;
|
|
|
|
private static FileSystemWatcher s_Fsw;
|
|
// Set from the watcher's background thread when it faults (buffer overflow, backend failure);
|
|
// OnEditorUpdate recreates the watcher on the main thread — otherwise it dies silently while
|
|
// IsWatching keeps reporting true.
|
|
private static volatile bool s_WatcherFaulted;
|
|
private static string s_WatcherFaultMessage;
|
|
// FileSystemWatcher fires on background threads → enqueue here, drain on the main thread.
|
|
private static readonly ConcurrentQueue<string> s_Changed = new ConcurrentQueue<string>();
|
|
// Main-thread-only: path → last-seen editor time, for per-file debounce.
|
|
private static readonly Dictionary<string, double> s_Pending = new Dictionary<string, double>();
|
|
// Main-thread-only: path → last-write ticks the watch has accounted for. The reconciliation
|
|
// poll enqueues any .cs whose mtime differs (a save the FileSystemWatcher missed). Entries for
|
|
// deleted files linger until the next Start; bounded by .cs count, harmless.
|
|
private static readonly Dictionary<string, long> s_KnownWriteTimes = new Dictionary<string, long>(StringComparer.OrdinalIgnoreCase);
|
|
private static double s_NextReconcile;
|
|
|
|
// Re-pushes due to players that connected mid-watch. Main-thread only; entries are
|
|
// (due time, player id).
|
|
private static readonly List<(double due, int playerId)> s_PendingReconnectPushes = new List<(double, int)>();
|
|
private static bool s_ConnectHooked;
|
|
private static bool s_SuppressConnectCallbacks;
|
|
|
|
/// <summary>Whether an in-editor watch is currently active.</summary>
|
|
public static bool IsWatching => s_Watching;
|
|
/// <summary>The file or folder being watched, or null when not watching.</summary>
|
|
public static string WatchPath => s_Watching ? s_WatchPath : null;
|
|
/// <summary>Whether the active watch is a folder (recursive) rather than a single file.</summary>
|
|
public static bool IsFolder => s_IsFolder;
|
|
/// <summary>Development players currently connected via PlayerConnection. This decides where a
|
|
/// save applies: any connected player wins (broadcast push), otherwise the reload runs in this
|
|
/// editor process. Initializes the connection so the count is accurate even before a watch
|
|
/// starts (Initialize is idempotent).</summary>
|
|
public static int ConnectedPlayerCount
|
|
{
|
|
get
|
|
{
|
|
try
|
|
{
|
|
var conn = UnityEditor.Networking.PlayerConnection.EditorConnection.instance;
|
|
conn.Initialize();
|
|
return conn.ConnectedPlayers.Count;
|
|
}
|
|
catch { return 0; }
|
|
}
|
|
}
|
|
|
|
// Liveness telemetry for the settings inspector: saves applying while the event count stays
|
|
// flat means the FileSystemWatcher is dead and the reconcile poll is carrying the watch.
|
|
// Session-only (reset by domain reloads and Start).
|
|
private static int s_FsEventCount;
|
|
private static long s_LastFsEventTicks; // DateTime.UtcNow ticks; written on the watcher thread
|
|
private static string s_LastApplyFile; // main thread only
|
|
private static long s_LastApplyTicks;
|
|
|
|
/// <summary>Raw FileSystemWatcher events seen since the watch (re)started this session.</summary>
|
|
public static int FsEventCount => s_FsEventCount;
|
|
/// <summary>UTC time of the last raw watcher event, or null if none yet.</summary>
|
|
public static DateTime? LastFsEventUtc => TicksToUtc(System.Threading.Interlocked.Read(ref s_LastFsEventTicks));
|
|
/// <summary>File name of the last reload attempt (either detection path), or null.</summary>
|
|
public static string LastApplyFile => s_LastApplyFile;
|
|
/// <summary>UTC time of the last reload attempt, or null if none yet.</summary>
|
|
public static DateTime? LastApplyUtc => TicksToUtc(s_LastApplyTicks);
|
|
|
|
private static DateTime? TicksToUtc(long ticks) =>
|
|
ticks == 0 ? (DateTime?)null : new DateTime(ticks, DateTimeKind.Utc);
|
|
|
|
static EditorCodeReloadWatcher()
|
|
{
|
|
// Editor may not be fully ready at [InitializeOnLoad] time; resume on the next tick.
|
|
EditorApplication.delayCall += ResumeWatchIfPersisted;
|
|
// The FileSystemWatcher is unmanaged-backed; drop it before a domain reload and recreate on resume.
|
|
AssemblyReloadEvents.beforeAssemblyReload += DisposeWatcher;
|
|
}
|
|
|
|
/// <summary>Start watching <paramref name="path"/> (a file, or a folder when <paramref name="isFolder"/>).
|
|
/// File mode applies once up front; folder mode only reacts to subsequent saves. No-op-with-error if the
|
|
/// path doesn't exist.</summary>
|
|
public static void StartWatch(string path, bool isFolder)
|
|
{
|
|
if (string.IsNullOrEmpty(path) || (isFolder ? !Directory.Exists(path) : !File.Exists(path)))
|
|
{
|
|
Debug.LogError($"[CodeReloadWatch] Cannot watch — {(isFolder ? "folder" : "file")} not found: {path}");
|
|
return;
|
|
}
|
|
|
|
s_WatchPath = Path.GetFullPath(path);
|
|
s_IsFolder = isFolder;
|
|
s_Watching = true;
|
|
s_Pending.Clear();
|
|
while (s_Changed.TryDequeue(out _)) { }
|
|
BaselineWriteTimes();
|
|
var baselines = CaptureMethodBaselines();
|
|
ClearAppliedFilesJournal();
|
|
s_FsEventCount = 0;
|
|
s_LastFsEventTicks = 0;
|
|
s_LastApplyFile = null;
|
|
s_LastApplyTicks = 0;
|
|
|
|
// Turn auto-refresh off so saving a watched .cs doesn't domain-reload the editor (which would wipe
|
|
// the registered overrides and interrupt the watch). Restore only what we changed.
|
|
DisableAutoRefresh();
|
|
|
|
CreateWatcher();
|
|
EditorApplication.update -= OnEditorUpdate;
|
|
EditorApplication.update += OnEditorUpdate;
|
|
HookPlayerConnect();
|
|
|
|
EditorPrefs.SetString(PkPath, s_WatchPath);
|
|
EditorPrefs.SetBool(PkIsFolder, isFolder);
|
|
EditorPrefs.SetInt(PkPrevAutoRefresh, s_PrevAutoRefresh);
|
|
EditorPrefs.SetInt(PkPrevAutoRefreshMode, s_PrevAutoRefreshMode);
|
|
|
|
// Single file: apply once up front so its current state is live. Folder: don't bulk-compile the
|
|
// tree — only react to saves.
|
|
if (!isFolder)
|
|
Apply(s_WatchPath);
|
|
|
|
Debug.Log($"[CodeReloadWatch] Watching {(isFolder ? "folder " : "")}{s_WatchPath} " +
|
|
$"[{DescribeTarget()}]; auto-refresh off" + (baselines != null ? $"; {baselines}" : "") +
|
|
". Stop from Pipeline Settings.");
|
|
}
|
|
|
|
/// <summary>Stop the active watch and restore auto-refresh.</summary>
|
|
public static void StopWatch()
|
|
{
|
|
if (!s_Watching) return;
|
|
s_Watching = false;
|
|
DisposeWatcher();
|
|
UnhookPlayerConnect();
|
|
EditorApplication.update -= OnEditorUpdate;
|
|
s_Pending.Clear();
|
|
s_KnownWriteTimes.Clear();
|
|
while (s_Changed.TryDequeue(out _)) { }
|
|
ClearAppliedFilesJournal();
|
|
CodeReloadBaseline.Clear();
|
|
SessionState.EraseString(SkMethodBaselines);
|
|
|
|
RestoreAutoRefresh();
|
|
|
|
EditorPrefs.DeleteKey(PkPath);
|
|
EditorPrefs.DeleteKey(PkIsFolder);
|
|
EditorPrefs.DeleteKey(PkPrevAutoRefresh);
|
|
EditorPrefs.DeleteKey(PkPrevAutoRefreshMode);
|
|
Debug.Log("[CodeReloadWatch] Watch stopped; auto-refresh restored.");
|
|
}
|
|
|
|
private static void ResumeWatchIfPersisted()
|
|
{
|
|
if (s_Watching) return;
|
|
var path = EditorPrefs.GetString(PkPath, null);
|
|
if (string.IsNullOrEmpty(path)) return;
|
|
|
|
bool isFolder = EditorPrefs.GetBool(PkIsFolder, false);
|
|
bool exists = isFolder ? Directory.Exists(path) : File.Exists(path);
|
|
if (!exists)
|
|
{
|
|
EditorPrefs.DeleteKey(PkPath);
|
|
return;
|
|
}
|
|
|
|
s_WatchPath = path;
|
|
s_IsFolder = isFolder;
|
|
s_PrevAutoRefresh = EditorPrefs.GetInt(PkPrevAutoRefresh, -1);
|
|
s_PrevAutoRefreshMode = EditorPrefs.GetInt(PkPrevAutoRefreshMode, -1);
|
|
s_Watching = true;
|
|
s_Pending.Clear();
|
|
BaselineWriteTimes();
|
|
|
|
CreateWatcher();
|
|
EditorApplication.update -= OnEditorUpdate;
|
|
EditorApplication.update += OnEditorUpdate;
|
|
HookPlayerConnect();
|
|
|
|
// Method baselines mirror the re-apply split below: an edit-mode reload means a real
|
|
// recompile ran, so disk is the compiled state again — recapture. A play-mode reload
|
|
// recompiled nothing (auto-refresh is off) and disk may already carry edits, so
|
|
// recapturing would bless those edits as "compiled"; restore the watch-start snapshot.
|
|
string baselines = null;
|
|
if (EditorApplication.isPlaying)
|
|
CodeReloadBaseline.Restore(SessionState.GetString(SkMethodBaselines, ""));
|
|
else
|
|
baselines = CaptureMethodBaselines();
|
|
|
|
// Edit-mode resume: don't re-apply — the reload came from a real recompile, so the
|
|
// compiled code already matches disk. Play-mode resume (entering play, or a mid-play
|
|
// reload) is different: the reload wiped CodeReloadRegistry's overrides but recompiled
|
|
// nothing (auto-refresh is off), so re-enqueue every file this watch had applied.
|
|
// Routing through s_Pending reuses the debounce, by which time the
|
|
// RuntimePipelineDriver has re-registered the reload targets (it runs in Awake).
|
|
var reapply = ComputeResumeReapplies(EditorApplication.isPlaying, GetJournaledAppliedFiles());
|
|
if (reapply.Count > 0)
|
|
{
|
|
double now = EditorApplication.timeSinceStartup;
|
|
foreach (var f in reapply)
|
|
s_Pending[f] = now;
|
|
}
|
|
// One line per domain reload: what is watched, plus what this resume does about it.
|
|
Debug.Log($"[CodeReloadWatch] Resumed watching {path} after domain reload" +
|
|
(reapply.Count > 0 ? $"; re-applying {reapply.Count} code-reload override(s) the play-mode reload wiped" : "") +
|
|
(baselines != null ? $"; {baselines}" : "") + ".");
|
|
}
|
|
|
|
/// <summary>Set both auto-refresh prefs to 0, remembering each prior value so Stop restores
|
|
/// exactly what the user had (the mode key is an enum — it may have been 2, not 1).</summary>
|
|
private static void DisableAutoRefresh()
|
|
{
|
|
int prev = EditorPrefs.GetInt(AutoRefreshPref, 1);
|
|
s_PrevAutoRefresh = prev == 0 ? -1 : prev;
|
|
if (s_PrevAutoRefresh >= 0)
|
|
EditorPrefs.SetInt(AutoRefreshPref, 0);
|
|
|
|
int prevMode = EditorPrefs.GetInt(AutoRefreshModePref, 1);
|
|
s_PrevAutoRefreshMode = prevMode == 0 ? -1 : prevMode;
|
|
if (s_PrevAutoRefreshMode >= 0)
|
|
EditorPrefs.SetInt(AutoRefreshModePref, 0);
|
|
}
|
|
|
|
private static void RestoreAutoRefresh()
|
|
{
|
|
if (s_PrevAutoRefresh >= 0)
|
|
EditorPrefs.SetInt(AutoRefreshPref, s_PrevAutoRefresh);
|
|
if (s_PrevAutoRefreshMode >= 0)
|
|
EditorPrefs.SetInt(AutoRefreshModePref, s_PrevAutoRefreshMode);
|
|
s_PrevAutoRefresh = -1;
|
|
s_PrevAutoRefreshMode = -1;
|
|
}
|
|
|
|
private static void CreateWatcher()
|
|
{
|
|
DisposeWatcher();
|
|
s_WatcherFaulted = false; // before enabling: a fault firing mid-create must not be wiped
|
|
try
|
|
{
|
|
var dir = s_IsFolder ? s_WatchPath : Path.GetDirectoryName(s_WatchPath);
|
|
s_Fsw = new FileSystemWatcher(dir)
|
|
{
|
|
Filter = s_IsFolder ? "*.cs" : Path.GetFileName(s_WatchPath),
|
|
IncludeSubdirectories = s_IsFolder,
|
|
NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName,
|
|
InternalBufferSize = 64 * 1024,
|
|
};
|
|
s_Fsw.Changed += OnFsEvent;
|
|
s_Fsw.Created += OnFsEvent;
|
|
s_Fsw.Renamed += OnFsEvent;
|
|
s_Fsw.Error += OnFsError;
|
|
s_Fsw.EnableRaisingEvents = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogError($"[CodeReloadWatch] Failed to start file watcher on {s_WatchPath}: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
private static void HookPlayerConnect()
|
|
{
|
|
if (s_ConnectHooked) return;
|
|
try
|
|
{
|
|
// RegisterConnection replays the callback synchronously for players that are already
|
|
// connected; suppress those — folder watches deliberately don't bulk-push on start,
|
|
// and an already-running player still has whatever was pushed to it. Only players
|
|
// that connect *after* this (i.e. fresh boots with no overrides) need catching up.
|
|
s_SuppressConnectCallbacks = true;
|
|
UnityEditor.Networking.PlayerConnection.EditorConnection.instance.Initialize();
|
|
UnityEditor.Networking.PlayerConnection.EditorConnection.instance.RegisterConnection(OnPlayerConnected);
|
|
s_ConnectHooked = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogWarning($"[CodeReloadWatch] Could not hook player connections (reconnect re-push disabled): {ex.Message}");
|
|
}
|
|
finally
|
|
{
|
|
s_SuppressConnectCallbacks = false;
|
|
}
|
|
}
|
|
|
|
private static void UnhookPlayerConnect()
|
|
{
|
|
s_PendingReconnectPushes.Clear();
|
|
if (!s_ConnectHooked) return;
|
|
try { UnityEditor.Networking.PlayerConnection.EditorConnection.instance.UnregisterConnection(OnPlayerConnected); }
|
|
catch { /* connection may be gone during teardown */ }
|
|
s_ConnectHooked = false;
|
|
}
|
|
|
|
// Main thread (EditorConnection dispatches connection events there).
|
|
private static void OnPlayerConnected(int playerId)
|
|
{
|
|
if (s_SuppressConnectCallbacks || !s_Watching) return;
|
|
|
|
// Read the setting at event time so an inspector toggle applies to the next connection
|
|
// without restarting the watch. No settings asset (CLI-driven watch) = enabled.
|
|
if (!(EditorPipelineManager.Load()?.CodeReloadRepushOnConnect ?? true))
|
|
{
|
|
// Nothing happens until the next save, so this is first-reload-summary material,
|
|
// not a console entry of its own on every connect.
|
|
CodeReloadRegistry.NoteForFirstReload($"player {playerId} connected, not re-pushed " +
|
|
"(Re-push On Connect is off in Pipeline Settings; it catches up on the next save)");
|
|
return;
|
|
}
|
|
|
|
s_PendingReconnectPushes.Add((EditorApplication.timeSinceStartup + ReconnectPushDelaySeconds, playerId));
|
|
Debug.Log($"[CodeReloadWatch] Player {playerId} connected — re-pushing watched code-reload state " +
|
|
$"in {ReconnectPushDelaySeconds:0}s (a restarted player has none of the previously pushed overrides).");
|
|
}
|
|
|
|
private static void OnFsEvent(object sender, FileSystemEventArgs e)
|
|
{
|
|
System.Threading.Interlocked.Increment(ref s_FsEventCount);
|
|
System.Threading.Interlocked.Exchange(ref s_LastFsEventTicks, DateTime.UtcNow.Ticks);
|
|
s_Changed.Enqueue(e.FullPath);
|
|
}
|
|
|
|
// Background thread: only record the fault; the recreate must happen on the main thread.
|
|
private static void OnFsError(object sender, ErrorEventArgs e)
|
|
{
|
|
s_WatcherFaultMessage = e.GetException()?.Message ?? "unknown error";
|
|
s_WatcherFaulted = true;
|
|
}
|
|
|
|
private static void DisposeWatcher()
|
|
{
|
|
if (s_Fsw == null) return;
|
|
try { s_Fsw.EnableRaisingEvents = false; s_Fsw.Dispose(); } catch { /* best effort */ }
|
|
s_Fsw = null;
|
|
}
|
|
|
|
private static void OnEditorUpdate()
|
|
{
|
|
if (!s_Watching) return;
|
|
|
|
if (s_WatcherFaulted)
|
|
{
|
|
s_WatcherFaulted = false;
|
|
Debug.LogWarning($"[CodeReloadWatch] File watcher faulted ({s_WatcherFaultMessage}); " +
|
|
"recreating it. Changes saved in the meantime may have been missed — save again to re-apply.");
|
|
CreateWatcher();
|
|
}
|
|
|
|
double now = EditorApplication.timeSinceStartup;
|
|
|
|
for (int i = s_PendingReconnectPushes.Count - 1; i >= 0; i--)
|
|
{
|
|
if (now < s_PendingReconnectPushes[i].due) continue;
|
|
int playerId = s_PendingReconnectPushes[i].playerId;
|
|
s_PendingReconnectPushes.RemoveAt(i);
|
|
PushReloadCommand.RepushAll(s_WatchPath, s_IsFolder, playerId);
|
|
}
|
|
|
|
while (s_Changed.TryDequeue(out var p))
|
|
if (!string.IsNullOrEmpty(p) && p.EndsWith(".cs", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
s_Pending[p] = now; // (re)start this file's debounce window
|
|
// Stamp the accounted-for mtime so the reconcile poll doesn't re-enqueue a
|
|
// change the watcher already delivered.
|
|
try { s_KnownWriteTimes[p] = File.GetLastWriteTimeUtc(p).Ticks; } catch { /* transient */ }
|
|
}
|
|
|
|
ReconcilePoll(now);
|
|
|
|
if (s_Pending.Count == 0) return;
|
|
|
|
List<string> ready = null;
|
|
foreach (var kv in s_Pending)
|
|
if (now - kv.Value >= DebounceSeconds)
|
|
(ready ??= new List<string>()).Add(kv.Key);
|
|
if (ready == null) return;
|
|
|
|
foreach (var p in ready)
|
|
{
|
|
s_Pending.Remove(p);
|
|
if (File.Exists(p))
|
|
Apply(p);
|
|
}
|
|
}
|
|
|
|
/// <summary>Record the current last-write time of every watched .cs so the reconcile poll only
|
|
/// reacts to saves made after the watch (re)started — mirrors "don't re-apply on resume".</summary>
|
|
private static void BaselineWriteTimes()
|
|
{
|
|
s_KnownWriteTimes.Clear();
|
|
try
|
|
{
|
|
if (s_IsFolder)
|
|
foreach (var f in Directory.EnumerateFiles(s_WatchPath, "*.cs", SearchOption.AllDirectories))
|
|
s_KnownWriteTimes[f] = File.GetLastWriteTimeUtc(f).Ticks;
|
|
else
|
|
s_KnownWriteTimes[s_WatchPath] = File.GetLastWriteTimeUtc(s_WatchPath).Ticks;
|
|
}
|
|
catch { /* best effort — the poll fills in files it couldn't stat here */ }
|
|
s_NextReconcile = EditorApplication.timeSinceStartup + ReconcileIntervalSeconds;
|
|
}
|
|
|
|
/// <summary>Low-rate safety net for saves the <see cref="FileSystemWatcher"/> missed: stat the
|
|
/// watched .cs files and route any mtime change into the same debounce map the watcher feeds.</summary>
|
|
private static void ReconcilePoll(double now)
|
|
{
|
|
if (now < s_NextReconcile) return;
|
|
s_NextReconcile = now + ReconcileIntervalSeconds;
|
|
try
|
|
{
|
|
if (s_IsFolder)
|
|
{
|
|
foreach (var f in Directory.EnumerateFiles(s_WatchPath, "*.cs", SearchOption.AllDirectories))
|
|
CheckWriteTime(f, now);
|
|
}
|
|
else if (File.Exists(s_WatchPath))
|
|
{
|
|
CheckWriteTime(s_WatchPath, now);
|
|
}
|
|
}
|
|
catch { /* transient IO (file mid-write, folder shuffle) — next poll retries */ }
|
|
}
|
|
|
|
private static void CheckWriteTime(string path, double now)
|
|
{
|
|
long ticks = File.GetLastWriteTimeUtc(path).Ticks;
|
|
if (s_KnownWriteTimes.TryGetValue(path, out var known) && known == ticks)
|
|
return;
|
|
s_KnownWriteTimes[path] = ticks;
|
|
s_Pending[path] = now;
|
|
}
|
|
|
|
/// <summary>Apply one changed file to the active target. Never throws.</summary>
|
|
private static void Apply(string path)
|
|
{
|
|
// Folder mode: only compile files that actually opt into code reload — an unrelated .cs save in the
|
|
// tree shouldn't recompile or log. (Single-file mode was chosen explicitly, so always apply.)
|
|
if (s_IsFolder && !PushReloadCommand.FileMentionsCodeReload(path))
|
|
return;
|
|
|
|
s_LastApplyFile = Path.GetFileName(path);
|
|
s_LastApplyTicks = DateTime.UtcNow.Ticks;
|
|
|
|
try
|
|
{
|
|
// Resolve the target per save, not per watch: a connected development player wins
|
|
// (connecting one is a deliberate act, and the in-editor path is a no-op outside
|
|
// play mode anyway), otherwise apply in this editor process. Plugging in or
|
|
// disconnecting a device mid-watch reroutes the next save with no restart.
|
|
if (ConnectedPlayerCount > 0)
|
|
{
|
|
// PushChanged logs its own summary; -1 broadcasts to every connected player.
|
|
// Baseline-filtered: methods untouched since the watch started stay compiled
|
|
// on the device instead of being re-registered as interpreter overrides.
|
|
PushReloadCommand.PushChanged(path, player: -1);
|
|
return;
|
|
}
|
|
|
|
var result = InPlaceReloadProcessor.ProcessSourceFileOnMainThread(
|
|
path, assemblyDir: null, pdb: false, useInterpreter: true);
|
|
if (result.Success)
|
|
{
|
|
// ProcessSourceFileOnMainThread only binds the overrides; firing [OnCodeReload]
|
|
// callbacks on live instances is the caller's job (mirrors CodeReloadCommands.reload_file).
|
|
// Reverted methods changed behavior too (their override was removed), so they
|
|
// count as reloaded for the callbacks.
|
|
CodeReloadRegistry.InvokeReloadCallbacks(
|
|
result.RevertedMethods.Count == 0
|
|
? result.RegisteredMethods
|
|
: result.RegisteredMethods.Concat(result.RevertedMethods));
|
|
|
|
if (result.AllUpToDate)
|
|
{
|
|
Debug.Log($"[CodeReloadWatch] {Path.GetFileName(path)} is up to date — " +
|
|
$"{result.UpToDateMethods.Count} method(s) already match compiled code" +
|
|
(result.RevertedMethods.Count > 0
|
|
? $"; removed {result.RevertedMethods.Count} stale override(s)" : "") + ".");
|
|
}
|
|
// "Compiled but 0 methods bound" looks like success yet applies nothing — surface
|
|
// the per-method skip reasons (e.g. the runtime Pipeline isn't running, or the
|
|
// interpreter backend rejecting an unsupported construct) instead of a bare count.
|
|
else if (result.RegisteredMethods.Count == 0)
|
|
{
|
|
var reasons = result.CompilationDiagnostics != null && result.CompilationDiagnostics.Count > 0
|
|
? ":\n- " + string.Join("\n- ", result.CompilationDiagnostics)
|
|
: ". Is the runtime Pipeline driver active (in play mode)?";
|
|
Debug.LogWarning($"[CodeReloadWatch] Compiled {Path.GetFileName(path)} " +
|
|
$"but bound 0 method(s){reasons}");
|
|
}
|
|
else
|
|
{
|
|
// Journal it so the next play-mode domain reload (which wipes the registry
|
|
// while auto-refresh keeps the compiled code stale) re-applies this file.
|
|
JournalAppliedFile(path);
|
|
Debug.Log($"[CodeReloadWatch] Applied {Path.GetFileName(path)}: " +
|
|
$"{result.RegisteredMethods.Count} method(s)" +
|
|
(result.UpToDateMethods.Count > 0
|
|
? $" ({result.UpToDateMethods.Count} up to date, left compiled)" : "") + ".");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Surface the actual compiler diagnostics, not just the generic ErrorMessage —
|
|
// otherwise the watcher path swallows the reason the reload_file command already reports.
|
|
var details = result.CompilationDiagnostics != null && result.CompilationDiagnostics.Count > 0
|
|
? ":\n- " + string.Join("\n- ", result.CompilationDiagnostics)
|
|
: "";
|
|
Debug.LogError($"[CodeReloadWatch] Reload failed for {Path.GetFileName(path)}: {result.ErrorMessage}{details}");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogError($"[CodeReloadWatch] Reload error for {Path.GetFileName(path)}: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
// Per-method baselines (CodeReloadBaseline) captured when the watch starts, i.e. when disk
|
|
// still matches the compiled code. Reloads diff each save against them and leave untouched
|
|
// methods running compiled instead of re-registering an interpreter override for the whole
|
|
// file. SessionState-backed for the same reason as the applied-files journal: the play-mode
|
|
// domain reload wipes the store while disk keeps the user's edits.
|
|
private const string SkMethodBaselines = "Pipeline.CodeReloadWatch.MethodBaselines";
|
|
|
|
/// <summary>Snapshot the compiled method bodies of the watched files. Returns a short clause
|
|
/// for the caller's log line (null when nothing was captured), so a watch start or resume
|
|
/// stays a single console entry.</summary>
|
|
private static string CaptureMethodBaselines()
|
|
{
|
|
CodeReloadBaseline.Clear();
|
|
int captured = 0, stale = 0;
|
|
try
|
|
{
|
|
var files = s_IsFolder
|
|
? Directory.EnumerateFiles(s_WatchPath, "*.cs", SearchOption.AllDirectories)
|
|
.Where(PushReloadCommand.FileMentionsCodeReload)
|
|
: (IEnumerable<string>)new[] { s_WatchPath };
|
|
|
|
foreach (var f in files)
|
|
{
|
|
// A source newer than its compiled assembly was edited without a recompile —
|
|
// snapshotting it would bless those edits as "compiled" and silently skip them
|
|
// on the next save. Leave it baseline-less: every method reloads, like before.
|
|
if (!CompiledStateMatchesDisk(f))
|
|
{
|
|
stale++;
|
|
continue;
|
|
}
|
|
|
|
if (CodeReloadBaseline.Capture(f))
|
|
captured++;
|
|
// Pushes diff under the player's defines; capture that variant too so a device
|
|
// save doesn't fall back to reloading everything when #if regions differ.
|
|
var playerDefines = PushReloadCommand.PlayerDefinesFor(f);
|
|
if (playerDefines != null)
|
|
CodeReloadBaseline.Capture(f, playerDefines);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogWarning($"[CodeReloadWatch] Baseline capture failed ({ex.Message}); " +
|
|
"saves will reload every [CodeReload] method in a file.");
|
|
}
|
|
|
|
SessionState.SetString(SkMethodBaselines, CodeReloadBaseline.Serialize());
|
|
if (captured == 0 && stale == 0)
|
|
return null;
|
|
return $"method baselines captured for {captured} file(s)" +
|
|
(stale > 0 ? $" ({stale} newer than their compiled assembly, unfiltered)" : "") +
|
|
", so saves only reload methods that differ";
|
|
}
|
|
|
|
/// <summary>Whether the compiled assembly owning <paramref name="path"/> is at least as new
|
|
/// as the file — i.e. the source on disk is what the editor is running. Unknown = false.</summary>
|
|
private static bool CompiledStateMatchesDisk(string path)
|
|
{
|
|
try
|
|
{
|
|
var projectRoot = Path.GetFullPath(Path.GetDirectoryName(Application.dataPath));
|
|
var full = Path.GetFullPath(path);
|
|
if (!full.StartsWith(projectRoot, StringComparison.OrdinalIgnoreCase))
|
|
return false;
|
|
var relative = full.Substring(projectRoot.Length).TrimStart('/', '\\').Replace('\\', '/');
|
|
var asmName = UnityEditor.Compilation.CompilationPipeline.GetAssemblyNameFromScriptPath(relative);
|
|
if (string.IsNullOrEmpty(asmName))
|
|
return false;
|
|
if (!asmName.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
|
|
asmName += ".dll";
|
|
var dll = Path.Combine(projectRoot, "Library", "ScriptAssemblies", asmName);
|
|
return File.Exists(dll) && File.GetLastWriteTimeUtc(dll) >= File.GetLastWriteTimeUtc(full);
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Applied-files journal: full paths of files whose overrides this watch applied in-editor.
|
|
// SessionState-backed because the overrides it mirrors live only in CodeReloadRegistry's
|
|
// statics — the domain reload triggered by entering play mode wipes them while the watched
|
|
// sources stay un-recompiled (auto-refresh is off), so without this record the next play
|
|
// session silently runs the stale compiled bodies. Session-scoped, like the overrides.
|
|
private const string SkAppliedFiles = "Pipeline.CodeReloadWatch.AppliedFiles";
|
|
|
|
/// <summary>Record a file whose overrides were successfully applied in this editor process.</summary>
|
|
internal static void JournalAppliedFile(string path)
|
|
{
|
|
if (string.IsNullOrEmpty(path)) return;
|
|
var files = GetJournaledAppliedFiles();
|
|
foreach (var f in files)
|
|
if (string.Equals(f, path, StringComparison.OrdinalIgnoreCase))
|
|
return;
|
|
var joined = files.Length == 0 ? path : string.Join("\n", files) + "\n" + path;
|
|
SessionState.SetString(SkAppliedFiles, joined);
|
|
}
|
|
|
|
/// <summary>All journaled applied files (empty when none).</summary>
|
|
internal static string[] GetJournaledAppliedFiles()
|
|
{
|
|
var raw = SessionState.GetString(SkAppliedFiles, "");
|
|
return string.IsNullOrEmpty(raw) ? Array.Empty<string>() : raw.Split('\n');
|
|
}
|
|
|
|
/// <summary>Forget all journaled applies (watch started/stopped: overrides no longer ours to restore).</summary>
|
|
internal static void ClearAppliedFilesJournal() => SessionState.EraseString(SkAppliedFiles);
|
|
|
|
/// <summary>Files to re-apply when a watch resumes after a domain reload. Only in play mode:
|
|
/// there the reload wiped the registry without recompiling the watched sources, so disk and
|
|
/// compiled code have diverged. An edit-mode resume follows a real recompile — current
|
|
/// compiled state already matches disk, so nothing needs re-applying.</summary>
|
|
internal static List<string> ComputeResumeReapplies(bool isPlaying, string[] journaledFiles)
|
|
{
|
|
var result = new List<string>();
|
|
if (!isPlaying || journaledFiles == null) return result;
|
|
foreach (var f in journaledFiles)
|
|
if (!string.IsNullOrEmpty(f) && File.Exists(f))
|
|
result.Add(f);
|
|
return result;
|
|
}
|
|
|
|
private static string DescribeTarget() =>
|
|
"target: connected players when present, else in-editor (always interpreter)";
|
|
}
|
|
}
|