com.wallstop-studios.dxmessaging 2.1.1 → 2.1.3

package/Editor/DxMessagingSceneBuildProcessor.cs

@@ -0,0 +1,81 @@
+namespace DxMessaging.Editor
+{
+#if UNITY_EDITOR && UNITY_2021_3_OR_NEWER
+    using System.Collections.Generic;
+    using DxMessaging.Unity;
+    using UnityEditor.Build;
+    using UnityEditor.Build.Reporting;
+    using UnityEngine;
+    using UnityEngine.SceneManagement;
+
+    /// <summary>
+    /// Ensures MessagingComponent instances do not carry runtime registrations into player builds.
+    /// </summary>
+    internal sealed class DxMessagingSceneBuildProcessor : IProcessSceneWithReport
+    {
+        public int callbackOrder => int.MaxValue;
+
+        /// <summary>
+        /// Strips runtime-only messaging state from the scene before it is serialized into the build.
+        /// </summary>
+        /// <param name="scene">Scene currently being processed.</param>
+        /// <param name="report">Build report associated with the scene export.</param>
+        public void OnProcessScene(Scene scene, BuildReport report)
+        {
+            if (!scene.IsValid() || !scene.isLoaded)
+            {
+                return;
+            }
+
+            MessagingComponent[] components = FindMessagingComponents(scene);
+            if (components == null || components.Length == 0)
+            {
+                return;
+            }
+
+            int cleared = 0;
+            for (int i = 0; i < components.Length; ++i)
+            {
+                MessagingComponent component = components[i];
+                if (component != null && component.EditorResetRuntimeState())
+                {
+                    cleared++;
+                }
+            }
+
+            if (cleared > 0 && report != null)
+            {
+                Debug.Log(
+                    $"[DxMessaging] Cleared {cleared} MessagingComponent instance(s) in scene '{scene.path}' prior to build."
+                );
+            }
+        }
+
+        private static MessagingComponent[] FindMessagingComponents(Scene scene)
+        {
+            List<MessagingComponent> buffer = new List<MessagingComponent>();
+            GameObject[] roots = scene.GetRootGameObjects();
+            for (int i = 0; i < roots.Length; ++i)
+            {
+                GameObject root = roots[i];
+                if (root == null)
+                {
+                    continue;
+                }
+
+                MessagingComponent[] components = root.GetComponentsInChildren<MessagingComponent>(
+                    includeInactive: true
+                );
+                if (components == null || components.Length == 0)
+                {
+                    continue;
+                }
+
+                buffer.AddRange(components);
+            }
+
+            return buffer.ToArray();
+        }
+    }
+#endif
+}

package/Editor/DxMessagingSceneBuildProcessor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ec8789213f7f4c30a9353e90fb4345c8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/Settings/DxMessagingSettings.cs

@@ -2,8 +2,10 @@ namespace DxMessaging.Editor.Settings
 {
 #if UNITY_EDITOR
     using System.Linq;
+    using Core.MessageBus;
     using UnityEditor;
     using UnityEngine;
+    using UnityEngine.Serialization;
 
     /// <summary>
     /// Project-wide DxMessaging settings asset (Editor-only).
@@ -18,18 +20,26 @@ namespace DxMessaging.Editor.Settings
         private const string SettingsPath = "Assets/Editor/DxMessagingSettings.asset";
 
         [SerializeField]
-        internal bool _enableDiagnosticsInEditor;
+        internal DiagnosticsTarget _diagnosticsTargets = DiagnosticsTarget.Off;
+
+        [SerializeField]
+        [HideInInspector]
+        [FormerlySerializedAs("_enableDiagnosticsInEditor")]
+        private bool _legacyEnableDiagnosticsInEditor;
 
         [SerializeField]
         internal int _messageBufferSize = DefaultBufferSize;
 
+        [SerializeField]
+        internal bool _suppressDomainReloadWarning = true;
+
         /// <summary>
-        /// Enables <see cref="Core.MessageBus.IMessageBus.GlobalDiagnosticsMode"/> in the Editor.
+        /// Controls <see cref="DiagnosticsTarget"/> values applied to <see cref="IMessageBus.GlobalDiagnosticsTargets"/>.
         /// </summary>
-        public bool EnableDiagnosticsInEditor
+        public DiagnosticsTarget DiagnosticsTargets
         {
-            get => _enableDiagnosticsInEditor;
-            set => _enableDiagnosticsInEditor = value;
+            get => _diagnosticsTargets;
+            set => _diagnosticsTargets = value;
         }
 
         /// <summary>
@@ -41,6 +51,15 @@ namespace DxMessaging.Editor.Settings
             set => _messageBufferSize = value;
         }
 
+        /// <summary>
+        /// When true, suppresses the Enter Play Mode Options domain reload warning in the Editor.
+        /// </summary>
+        public bool SuppressDomainReloadWarning
+        {
+            get => _suppressDomainReloadWarning;
+            set => _suppressDomainReloadWarning = value;
+        }
+
         /// <summary>
         /// Loads the settings asset if present, otherwise creates it with sensible defaults.
         /// </summary>
@@ -62,8 +81,9 @@ namespace DxMessaging.Editor.Settings
             if (settings == null)
             {
                 settings = CreateInstance<DxMessagingSettings>();
-                settings._enableDiagnosticsInEditor = false;
+                settings._diagnosticsTargets = DiagnosticsTarget.Off;
                 settings._messageBufferSize = DefaultBufferSize;
+                settings._suppressDomainReloadWarning = true;
                 if (!AssetDatabase.IsValidFolder("Assets/Editor"))
                 {
                     AssetDatabase.CreateFolder("Assets", "Editor");
@@ -72,6 +92,17 @@ namespace DxMessaging.Editor.Settings
                 AssetDatabase.SaveAssets();
             }
 
+            if (
+                settings._diagnosticsTargets == DiagnosticsTarget.Off
+                && settings._legacyEnableDiagnosticsInEditor
+            )
+            {
+                settings._diagnosticsTargets = DiagnosticsTarget.Editor;
+                settings._legacyEnableDiagnosticsInEditor = false;
+                EditorUtility.SetDirty(settings);
+                AssetDatabase.SaveAssets();
+            }
+
             return settings;
         }
 

package/Editor/Settings/DxMessagingSettingsProvider.cs

@@ -2,6 +2,7 @@ namespace DxMessaging.Editor.Settings
 {
 #if UNITY_EDITOR
     using System.Collections.Generic;
+    using Core.MessageBus;
     using UnityEditor;
     using UnityEngine;
 
@@ -21,6 +22,11 @@ namespace DxMessaging.Editor.Settings
         )
             : base(path, scope) { }
 
+        /// <summary>
+        /// Initializes the serialized settings backing store when the settings page is opened.
+        /// </summary>
+        /// <param name="searchContext">Search text provided by the Project Settings window.</param>
+        /// <param name="rootElement">Root visual element for UI Toolkit-based providers.</param>
         public override void OnActivate(
             string searchContext,
             UnityEngine.UIElements.VisualElement rootElement
@@ -29,28 +35,60 @@ namespace DxMessaging.Editor.Settings
             _messagingSettings = DxMessagingSettings.GetSerializedSettings();
         }
 
+        /// <summary>
+        /// Renders the DxMessaging settings UI and persists any modifications.
+        /// </summary>
+        /// <param name="searchContext">Search text provided by the Project Settings window.</param>
         public override void OnGUI(string searchContext)
         {
-            EditorGUILayout.PropertyField(
-                _messagingSettings.FindProperty(
-                    nameof(DxMessagingSettings._enableDiagnosticsInEditor)
-                ),
-                new GUIContent("Global Diagnostics Mode")
+            SerializedProperty targetsProp = _messagingSettings.FindProperty(
+                nameof(DxMessagingSettings._diagnosticsTargets)
             );
+            DiagnosticsTarget currentTargets = (DiagnosticsTarget)targetsProp.enumValueFlag;
+            DiagnosticsTarget updatedTargets = (DiagnosticsTarget)
+                EditorGUILayout.EnumFlagsField(
+                    new GUIContent(
+                        "Diagnostics Targets",
+                        "Select where global diagnostics should be enabled by default. Combine flags for multiple targets."
+                    ),
+                    currentTargets
+                );
+            if (updatedTargets != currentTargets)
+            {
+                targetsProp.enumValueFlag = (int)updatedTargets;
+            }
             EditorGUILayout.PropertyField(
                 _messagingSettings.FindProperty(nameof(DxMessagingSettings._messageBufferSize)),
-                new GUIContent("Message Buffer Size")
+                new GUIContent(
+                    "Message Buffer Size",
+                    "Number of emissions kept per bus/token when diagnostics mode is active."
+                )
+            );
+            EditorGUILayout.PropertyField(
+                _messagingSettings.FindProperty(
+                    nameof(DxMessagingSettings._suppressDomainReloadWarning)
+                ),
+                new GUIContent(
+                    "Suppress Domain Reload Warning",
+                    "Disable the warning shown when Enter Play Mode Options skips domain reload; DxMessaging still resets its statics."
+                )
             );
 
             _messagingSettings.ApplyModifiedProperties();
         }
 
         [SettingsProvider]
+        /// <summary>
+        /// Factory used by Unity to register the DxMessaging project settings page.
+        /// </summary>
+        /// <returns>Configured settings provider instance.</returns>
         public static SettingsProvider CreateDxMessagingSettingsProvider()
         {
             DxMessagingSettingsProvider provider = new("Project/DxMessaging")
             {
-                keywords = new HashSet<string>(new[] { "DxMessaging", "Diagnostics" }),
+                keywords = new HashSet<string>(
+                    new[] { "DxMessaging", "Diagnostics", "MessageBus", "Targets" }
+                ),
             };
 
             return provider;

package/Editor/SetupCscRsp.cs

@@ -6,6 +6,7 @@ namespace DxMessaging.Editor
     using System.Collections.Generic;
     using System.IO;
     using System.Linq;
+    using System.Security.Cryptography;
     using UnityEditor;
     using UnityEngine;
     using Object = UnityEngine.Object;
@@ -20,11 +21,11 @@ namespace DxMessaging.Editor
             )
             .Replace("\\", "/");
 
-        private static readonly string AnalyzerPathRelative =
-            "Packages/com.wallstop-studios.dxmessaging/Editor/Analyzers/";
-
-        private static readonly string LibraryPathRelative =
-            "Library/PackageCache/com.wallstop-studios.dxmessaging/Editor/Analyzers/";
+        private static readonly string[] AnalyzerDirectories =
+        {
+            "Packages/com.wallstop-studios.dxmessaging/Editor/Analyzers/",
+            "Library/PackageCache/com.wallstop-studios.dxmessaging/Editor/Analyzers/",
+        };
 
         private static readonly string SourceGeneratorDllName =
             "WallstopStudios.DxMessaging.SourceGenerators.dll";
@@ -34,13 +35,18 @@ namespace DxMessaging.Editor
             SourceGeneratorDllName,
             "Microsoft.CodeAnalysis.dll",
             "Microsoft.CodeAnalysis.CSharp.dll",
+            "System.Text.Encodings.Web.dll",
             "System.Reflection.Metadata.dll",
             "System.Runtime.CompilerServices.Unsafe.dll",
             "System.Collections.Immutable.dll",
+            "System.Memory.dll",
+            "System.Buffers.dll",
+            "System.Threading.Tasks.Extensions.dll",
+            "System.Numerics.Vectors.dll",
+            "System.Text.Encoding.CodePages.dll",
+            "Microsoft.Bcl.AsyncInterfaces.dll",
         };
 
-        private static readonly string LibraryArgument = $"-a:\"{LibraryPathRelative}\"";
-
         private static readonly HashSet<string> DllNames = new(StringComparer.OrdinalIgnoreCase);
 
         static SetupCscRsp()
@@ -69,17 +75,14 @@ namespace DxMessaging.Editor
                 }
             }
 
-            string[] dllRelativeDirectories = { LibraryPathRelative, AnalyzerPathRelative };
-
-            bool anyFound = false;
-            foreach (
-                string requiredDllName in RequiredDllNames.Where(dllName =>
-                    !DllNames.Contains(dllName)
-                )
-            )
+            foreach (string requiredDllName in RequiredDllNames)
             {
-                bool found = false;
-                foreach (string relativeDirectory in dllRelativeDirectories)
+                if (DllNames.Contains(requiredDllName))
+                {
+                    continue;
+                }
+
+                foreach (string relativeDirectory in AnalyzerDirectories)
                 {
                     try
                     {
@@ -92,52 +95,62 @@ namespace DxMessaging.Editor
                         const string pluginsDirectory =
                             "Assets/Plugins/Editor/WallstopStudios.DxMessaging/";
                         string outputAsset = $"{pluginsDirectory}{requiredDllName}";
-                        string sourceAsset = $"{relativeDirectory}{requiredDllName}";
                         if (!Directory.Exists(pluginsDirectory))
                         {
                             Directory.CreateDirectory(pluginsDirectory);
                             AssetDatabase.Refresh();
                         }
-                        if (!File.Exists(outputAsset))
+                        bool needsCopy = FilesDiffer(sourceFile, outputAsset);
+                        if (needsCopy)
                         {
-                            File.Copy(sourceAsset, outputAsset);
+                            File.Copy(sourceFile, outputAsset, true);
                             AssetDatabase.ImportAsset(outputAsset);
-                            found = true;
                         }
-                        else
+
+                        if (requiredDllName == SourceGeneratorDllName)
+                        {
+                            Object loadedDll = AssetDatabase.LoadMainAssetAtPath(outputAsset);
+                            if (loadedDll != null)
+                            {
+                                string[] existingLabels = AssetDatabase.GetLabels(loadedDll);
+                                if (!existingLabels.Contains("RoslynAnalyzer"))
+                                {
+                                    List<string> newLabels = existingLabels.ToList();
+                                    newLabels.Add("RoslynAnalyzer");
+                                    AssetDatabase.SetLabels(loadedDll, newLabels.ToArray());
+                                }
+                            }
+                        }
+
+                        if (AssetImporter.GetAtPath(outputAsset) is PluginImporter importer)
                         {
-                            FileInfo sourceInfo = new(sourceAsset);
-                            FileInfo destInfo = new(outputAsset);
+                            bool importerDirty = false;
 
-                            if (destInfo.LastWriteTime < sourceInfo.LastWriteTime)
+                            if (importer.GetCompatibleWithAnyPlatform())
                             {
-                                // Source file is newer, so copy the file (overwrite destination)
-                                File.Copy(sourceAsset, outputAsset, true);
-                                AssetDatabase.ImportAsset(outputAsset);
-                                found = true;
+                                importer.SetCompatibleWithAnyPlatform(false);
+                                importerDirty = true;
                             }
-                            else
+
+                            if (importer.GetExcludeFromAnyPlatform("Editor"))
                             {
-                                continue;
+                                importer.SetExcludeFromAnyPlatform("Editor", false);
+                                importerDirty = true;
                             }
-                        }
 
-                        if (requiredDllName == SourceGeneratorDllName)
-                        {
-                            Object loadedDll = AssetDatabase.LoadMainAssetAtPath(outputAsset);
-                            AssetDatabase.SetLabels(loadedDll, new[] { "RoslynAnalyzer" });
-                        }
+                            if (!importer.GetExcludeFromAnyPlatform("Standalone"))
+                            {
+                                importer.SetExcludeFromAnyPlatform("Standalone", true);
+                                importerDirty = true;
+                            }
 
-                        PluginImporter importer =
-                            AssetImporter.GetAtPath(outputAsset) as PluginImporter;
-                        if (importer != null)
-                        {
-                            importer.SetCompatibleWithAnyPlatform(false);
-                            importer.SetExcludeFromAnyPlatform("Editor", false);
-                            importer.SetExcludeFromAnyPlatform("Standalone", false);
-                            importer.SaveAndReimport();
+                            if (importerDirty || needsCopy)
+                            {
+                                importer.SaveAndReimport();
+                            }
                         }
 
+                        DllNames.Add(requiredDllName);
                         break;
                     }
                     catch (Exception e)
@@ -147,16 +160,36 @@ namespace DxMessaging.Editor
                         );
                     }
                 }
-
-                anyFound |= found;
             }
 
-            if (anyFound)
+            if (DllNames.Count > 0)
             {
                 AssetDatabase.Refresh();
             }
         }
 
+        private static bool FilesDiffer(string sourcePath, string destinationPath)
+        {
+            if (!File.Exists(destinationPath))
+            {
+                return true;
+            }
+
+            FileInfo sourceInfo = new(sourcePath);
+            FileInfo destinationInfo = new(destinationPath);
+            if (sourceInfo.Length != destinationInfo.Length)
+            {
+                return true;
+            }
+
+            using FileStream sourceStream = File.OpenRead(sourcePath);
+            using FileStream destinationStream = File.OpenRead(destinationPath);
+            using SHA256 sha256 = SHA256.Create();
+            byte[] sourceHash = sha256.ComputeHash(sourceStream);
+            byte[] destinationHash = sha256.ComputeHash(destinationStream);
+            return !sourceHash.AsSpan().SequenceEqual(destinationHash);
+        }
+
         private static void EnsureCscRsp()
         {
             try
@@ -168,20 +201,67 @@ namespace DxMessaging.Editor
                 }
 
                 string rspContent = File.ReadAllText(RspFilePath);
-                if (rspContent.Contains(LibraryArgument, StringComparison.OrdinalIgnoreCase))
+                bool modified = false;
+                foreach (string analyzerArgument in GetAnalyzerArguments())
                 {
-                    return;
+                    if (rspContent.Contains(analyzerArgument, StringComparison.OrdinalIgnoreCase))
+                    {
+                        continue;
+                    }
+
+                    File.AppendAllText(RspFilePath, analyzerArgument + Environment.NewLine);
+                    modified = true;
                 }
 
-                File.AppendAllText(RspFilePath, $"{LibraryArgument}{Environment.NewLine}");
-                AssetDatabase.ImportAsset("csc.rsp");
-                Debug.Log("Updated csc.rsp.");
+                if (modified)
+                {
+                    AssetDatabase.ImportAsset("csc.rsp");
+                    Debug.Log("Updated csc.rsp.");
+                }
             }
             catch (IOException ex)
             {
                 Debug.LogError($"Failed to modify csc.rsp: {ex}");
             }
         }
+
+        private static IEnumerable<string> GetAnalyzerArguments()
+        {
+            HashSet<string> yielded = new(StringComparer.OrdinalIgnoreCase);
+            string projectRoot = Path.GetFullPath(Path.Combine(Application.dataPath, ".."));
+
+            foreach (string directory in AnalyzerDirectories)
+            {
+                foreach (string dllName in RequiredDllNames)
+                {
+                    string absoluteDirectory = Path.IsPathRooted(directory)
+                        ? directory
+                        : Path.GetFullPath(Path.Combine(projectRoot, directory));
+
+                    string absoluteAnalyzerPath = Path.Combine(absoluteDirectory, dllName);
+                    if (!File.Exists(absoluteAnalyzerPath))
+                    {
+                        continue;
+                    }
+
+                    string projectRelativePath = FileUtil.GetProjectRelativePath(
+                        absoluteAnalyzerPath
+                    );
+                    if (string.IsNullOrEmpty(projectRelativePath))
+                    {
+                        continue;
+                    }
+
+                    string normalizedRelativePath = projectRelativePath.Replace("\\", "/");
+                    if (!yielded.Add(normalizedRelativePath))
+                    {
+                        continue;
+                    }
+
+                    yield return $"-a:\"{normalizedRelativePath}\"";
+                }
+            }
+        }
     }
 }
 #endif