UPM release 4.1.0

Author: git-upm-publisher

.assets/event_adapter.png

@@ -19,6 +19,14 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 
 
+## [4.1.0] - 2024-06-16
+
+### Added
+- `SceneReferenceUnityEventAdapter` class: A utility `MonoBehaviour` that allows using statically provided `SceneReference`s as parameters to a `UnityEvent`.
+- Utility Ignores: A set of settings that allow ignoring certain scenes from having the inline utilities.
+
+
+
 ## [4.0.0] - 2024-01-23
 There are fundamental changes to the editor-time behaviour in this release. Please examine carefully before upgrading.
 

CHANGELOG.md

@@ -0,0 +1,34 @@
+using System;
+
+namespace Eflatun.SceneReference.Editor
+{
+    internal static class IgnoreCheckers
+    {
+        public static IgnoreChecker Coloring = new IgnoreChecker(SettingsManager.UtilityIgnores.ColoringIgnoresPatterns.value);
+        public static IgnoreChecker Toolbox = new IgnoreChecker(SettingsManager.UtilityIgnores.ToolboxIgnoresPatterns.value);
+
+        internal class IgnoreChecker
+        {
+            private static readonly string[] LineSeperators = new string[] { "\r\n", "\r", "\n" };
+
+            private Ignore.Ignore Checker;
+
+            public IgnoreChecker(string patterns)
+            {
+                SetPatterns(patterns);
+            }
+
+            public void SetPatterns(string patterns)
+            {
+                Checker = new Ignore.Ignore();
+                var split = patterns.Split(LineSeperators, StringSplitOptions.RemoveEmptyEntries);
+                Checker.Add(split);
+            }
+
+            public bool IsIgnored(string path)
+            {
+                return Checker.IsIgnored(path);
+            }
+        }
+    }
+}

Editor/IgnoreCheckers.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -46,23 +46,26 @@ private enum SceneBundlingState
         private AddressableAssetEntry _addressableEntry;
 #endif // ESR_ADDRESSABLES
 
-        private bool ShouldColorSceneInBuild => _optionsAttribute.SceneInBuildColoring switch
+        private bool IsColoringIgnored => SettingsManager.UtilityIgnores.IsIgnoredForColoring(_path, _guid);
+        private bool IsToolboxIgnored => SettingsManager.UtilityIgnores.IsIgnoredForToolbox(_path, _guid);
+
+        private bool ShouldColorSceneInBuild => !IsColoringIgnored && _optionsAttribute.SceneInBuildColoring switch
         {
             ColoringBehaviour.Enabled => true,
             ColoringBehaviour.Disabled => false,
             ColoringBehaviour.DoNotOverride => SettingsManager.PropertyDrawer.ColorBasedOnSceneInBuildState.value,
             _ => throw new ArgumentOutOfRangeException(nameof(_optionsAttribute.SceneInBuildColoring), _optionsAttribute.SceneInBuildColoring, null)
         };
 
-        private bool ShouldColorAddressable => _optionsAttribute.AddressableColoring switch
+        private bool ShouldColorAddressable => !IsColoringIgnored && _optionsAttribute.AddressableColoring switch
         {
             ColoringBehaviour.Enabled => true,
             ColoringBehaviour.Disabled => false,
             ColoringBehaviour.DoNotOverride => SettingsManager.AddressablesSupport.ColorAddressableScenes.value,
             _ => throw new ArgumentOutOfRangeException(nameof(_optionsAttribute.AddressableColoring), _optionsAttribute.AddressableColoring, null)
         };
 
-        private bool ShouldShowToolbox => _optionsAttribute.Toolbox switch
+        private bool ShouldShowToolbox => !IsToolboxIgnored && _optionsAttribute.Toolbox switch
         {
             ToolboxBehaviour.Enabled => true,
             ToolboxBehaviour.Disabled => false,
@@ -212,7 +215,7 @@ private ToolboxPopupWindow CreateToolboxPopupWindow()
             }
 
 #if ESR_ADDRESSABLES
-            if(_bundlingState == SceneBundlingState.Nowhere || _bundlingState == SceneBundlingState.InBuildDisabled)
+            if (_bundlingState == SceneBundlingState.Nowhere || _bundlingState == SceneBundlingState.InBuildDisabled)
             {
                 tools.Add(new MakeAddressableTool(_path, _guid, _asset));
             }

Editor/IgnoreCheckers.cs.meta

@@ -2,6 +2,9 @@
 using Eflatun.SceneReference.Utility;
 using JetBrains.Annotations;
 using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
 using UnityEditor;
 using UnityEditor.SettingsManagement;
@@ -13,7 +16,7 @@ namespace Eflatun.SceneReference.Editor
     /// Manages and contains settings for Scene Reference.
     /// </summary>
     /// <remarks>
-    /// Changing the settings from code may have unintended consequences. Make sure you now what you are doing.
+    /// Changing the settings from code may have unintended consequences. Make sure you know what you are doing.
     /// </remarks>
     [PublicAPI]
     public static class SettingsManager
@@ -206,5 +209,264 @@ public static class Logging
             public static ProjectSetting<LogLevel> EditorLogLevel { get; }
                 = new ProjectSetting<LogLevel>("Logging.EditorLogLevel", LogLevel.Warning);
         }
+
+        /// <summary>
+        /// Settings for preventing certain scenes from having inline utilities.
+        /// </summary>
+        /// <remarks>
+        /// <inheritdoc cref="SettingsManager"/>
+        /// </remarks>
+        [PublicAPI]
+        public static class UtilityIgnores
+        {
+            private const string CategoryName = "Utility Ignores";
+
+            /// <summary>
+            /// The mode of operation for preventing certain scenes from having the inline coloring utility.
+            /// <list type="bullet">
+            /// <item>
+            /// <term><see cref="UtilityIgnoreMode.Disabled"/></term>
+            /// <description>Nothing will be ignored.</description>
+            /// </item>
+            /// <item>
+            /// <term><see cref="UtilityIgnoreMode.List"/></term>
+            /// <description>The scenes with GUIDs in <see cref="ColoringIgnoresList"/> will not be colored.</description>
+            /// </item>
+            /// <item>
+            /// <term><see cref="UtilityIgnoreMode.Patterns"/></term>
+            /// <description>The scenes with paths matching the patterns in <see cref="ColoringIgnoresPatterns"/> will not be colored.</description>
+            /// </item>
+            /// </list>
+            /// </summary>
+            /// <remarks>
+            /// <inheritdoc cref="SettingsManager"/>
+            /// </remarks>
+            [field: UserSetting]
+            public static ProjectSetting<UtilityIgnoreMode> ColoringIgnoreMode { get; }
+                = new ProjectSetting<UtilityIgnoreMode>("UtilityIgnores.ColoringIgnoreMode", UtilityIgnoreMode.Disabled);
+
+            /// <summary>
+            /// The mode of operation for preventing certain scenes from having the inline toolbox utility.
+            /// <list type="bullet">
+            /// <item>
+            /// <term><see cref="UtilityIgnoreMode.Disabled"/></term>
+            /// <description>Nothing will be ignored.</description>
+            /// </item>
+            /// <item>
+            /// <term><see cref="UtilityIgnoreMode.List"/></term>
+            /// <description>The scenes with GUIDs in <see cref="ToolboxIgnoresList"/> will not have toolboxes.</description>
+            /// </item>
+            /// <item>
+            /// <term><see cref="UtilityIgnoreMode.Patterns"/></term>
+            /// <description>The scenes with paths matching the patterns in <see cref="ToolboxIgnoresPatterns"/> will not have toolboxes.</description>
+            /// </item>
+            /// </list>
+            /// </summary>
+            /// <remarks>
+            /// <inheritdoc cref="SettingsManager"/>
+            /// </remarks>
+            [field: UserSetting]
+            public static ProjectSetting<UtilityIgnoreMode> ToolboxIgnoreMode { get; }
+                = new ProjectSetting<UtilityIgnoreMode>("UtilityIgnores.ToolboxIgnoreMode", UtilityIgnoreMode.Disabled);
+
+            /// <summary>
+            /// If the <see cref="ColoringIgnoreMode"/> is set to <see cref="UtilityIgnoreMode.List"/>, the scenes with GUIDs in this list will not be colored.
+            /// </summary>
+            /// <remarks>
+            /// <inheritdoc cref="SettingsManager"/>
+            /// </remarks>
+            [field: UserSetting]
+            public static ProjectSetting<List<string>> ColoringIgnoresList { get; }
+                = new ProjectSetting<List<string>>("UtilityIgnores.ColoringIgnoresList", new List<string>());
+
+            /// <summary>
+            /// If the <see cref="ToolboxIgnoreMode"/> is set to <see cref="UtilityIgnoreMode.List"/>, the scenes with GUIDs in this list will not have toolboxes.
+            /// </summary>
+            /// <remarks>
+            /// <inheritdoc cref="SettingsManager"/>
+            /// </remarks>
+            [field: UserSetting]
+            public static ProjectSetting<List<string>> ToolboxIgnoresList { get; }
+                = new ProjectSetting<List<string>>("UtilityIgnores.ToolboxIgnoresList", new List<string>());
+
+            /// <summary>
+            /// If the <see cref="ColoringIgnoreMode"/> is set to <see cref="UtilityIgnoreMode.Patterns"/>, the scenes with paths matching the patterns in this setting will not be colored.<p/>
+            /// Make sure to call <see cref="ApplyColoringIgnoresPatterns"/> after modifying this setting via code.
+            /// </summary>
+            /// <remarks>
+            /// The patterns are evaluated together, just like <c>.gitignore</c> files. Each line corresponds to one pattern. The following library is used for matching patterns: <see href="https://github.com/goelhardik/ignore"/><p/>
+            /// <inheritdoc cref="SettingsManager"/>
+            /// </remarks>
+            [field: UserSetting]
+            public static ProjectSetting<string> ColoringIgnoresPatterns { get; }
+                = new ProjectSetting<string>("UtilityIgnores.ColoringIgnoresPatterns", string.Empty);
+
+            /// <summary>
+            /// If the <see cref="ToolboxIgnoreMode"/> is set to <see cref="UtilityIgnoreMode.Patterns"/>, the scenes with paths matching the patterns in this setting will not have toolboxes.
+            /// Make sure to call <see cref="ApplyToolboxIgnoresPatterns"/> after modifying this setting via code.
+            /// </summary>
+            /// <remarks>
+            /// <inheritdoc cref="ColoringIgnoresPatterns"/>
+            /// </remarks>
+            [field: UserSetting]
+            public static ProjectSetting<string> ToolboxIgnoresPatterns { get; }
+                = new ProjectSetting<string>("UtilityIgnores.ToolboxIgnoresPatterns", string.Empty);
+
+            /// <summary>
+            /// Call this after modifying <see cref="ColoringIgnoresPatterns"/> via code.
+            /// </summary>
+            /// <remarks>
+            /// <inheritdoc cref="ColoringIgnoresPatterns"/>
+            /// </remarks>
+            public static void ApplyColoringIgnoresPatterns()
+            {
+                IgnoreCheckers.Coloring.SetPatterns(ColoringIgnoresPatterns.value);
+            }
+
+            /// <summary>
+            /// Call this after modifying <see cref="ToolboxIgnoresPatterns"/> via code.
+            /// </summary>
+            /// <remarks>
+            /// <inheritdoc cref="ColoringIgnoresPatterns"/>
+            /// </remarks>
+            public static void ApplyToolboxIgnoresPatterns()
+            {
+                IgnoreCheckers.Toolbox.SetPatterns(ToolboxIgnoresPatterns.value);
+            }
+
+            internal static bool IsIgnoredForToolbox(string path, string guid) => ToolboxIgnoreMode.value switch
+            {
+                UtilityIgnoreMode.Disabled => false,
+                UtilityIgnoreMode.List => ToolboxIgnoresList.value.Contains(guid),
+                UtilityIgnoreMode.Patterns => IgnoreCheckers.Toolbox.IsIgnored(path),
+                _ => throw new ArgumentOutOfRangeException()
+            };
+
+            internal static bool IsIgnoredForColoring(string path, string guid) => ColoringIgnoreMode.value switch
+            {
+                UtilityIgnoreMode.Disabled => false,
+                UtilityIgnoreMode.List => ColoringIgnoresList.value.Contains(guid),
+                UtilityIgnoreMode.Patterns => IgnoreCheckers.Coloring.IsIgnored(path),
+                _ => throw new ArgumentOutOfRangeException()
+            };
+
+            [UserSettingBlock(CategoryName)]
+            private static void Draw(string searchContext)
+            {
+                var shouldSave = false;
+
+                EditorGUI.BeginChangeCheck();
+
+                const string patternsSharedTooltip = "The patterns are evaluated together, just like .gitignore files. Each line corresponds to one pattern.\n\nThe following library is used for matching patterns: https://github.com/goelhardik/ignore";
+
+                DrawUtilityIgnores(ColoringIgnoreMode, ColoringIgnoresList, ColoringIgnoresPatterns,
+                    title: "Coloring",
+                    modeTooltip: "The mode of operation for preventing certain scenes from having the inline coloring utility.\n\n• Disabled: Nothing will be ignored.\n\n• List: The scenes with GUIDs in the list will not be colored.\n\n• Patterns: The scenes with paths matching the patterns will not be colored.",
+                    listTooltip: "The scenes in this list will not be colored.",
+                    patternsTooltip: $"The scenes with paths matching the patterns in this setting will not be colored.\n\n{patternsSharedTooltip}"
+                );
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    ApplyColoringIgnoresPatterns();
+                    shouldSave = true;
+                }
+
+                EditorGUI.BeginChangeCheck();
+
+                DrawUtilityIgnores(ToolboxIgnoreMode, ToolboxIgnoresList, ToolboxIgnoresPatterns,
+                    title: "Toolbox",
+                    modeTooltip: "The mode of operation for preventing certain scenes from having the inline toolbox utility.\n\n• Disabled: Nothing will be ignored.\n\n• List: The scenes with GUIDs in the list will not have toolboxes.\n\n• Patterns: The scenes with paths matching the patterns will not have toolboxes.",
+                    listTooltip: "The scenes in this list will not have toolboxes.",
+                    patternsTooltip: $"The scenes with paths matching the patterns in this setting will not have toolboxes.\n\n{patternsSharedTooltip}"
+                );
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    ApplyToolboxIgnoresPatterns();
+                    shouldSave = true;
+                }
+
+                if (shouldSave)
+                {
+                    Settings.Save();
+                }
+            }
+
+            private static void DrawUtilityIgnores(ProjectSetting<UtilityIgnoreMode> ignoreMode,
+                ProjectSetting<List<string>> ignoresList,
+                ProjectSetting<string> ignoresPatterns,
+                string title,
+                string modeTooltip,
+                string listTooltip,
+                string patternsTooltip)
+            {
+                ignoreMode.value = (UtilityIgnoreMode)EditorGUILayout.EnumPopup(new GUIContent($"{title} Ignore Mode", modeTooltip), ignoreMode.value);
+
+                switch (ignoreMode.value)
+                {
+                    case UtilityIgnoreMode.Disabled:
+                        break;
+
+                    case UtilityIgnoreMode.List:
+                        EditorGUI.BeginChangeCheck();
+
+                        EditorGUILayout.BeginHorizontal();
+
+                        EditorGUILayout.LabelField(new GUIContent($"{title} Ignored Scenes", listTooltip));
+
+                        if (GUILayout.Button("Clear"))
+                        {
+                            ignoresList.value.Clear();
+                        }
+
+                        if (GUILayout.Button("+"))
+                        {
+                            ignoresList.value.Add(string.Empty);
+                        }
+
+                        EditorGUILayout.EndHorizontal();
+
+                        for (var i = 0; i < ignoresList.value.Count; i++)
+                        {
+                            EditorGUILayout.BeginHorizontal();
+
+                            EditorGUILayout.LabelField(i.ToString(), GUILayout.Width(20));
+
+                            var guid = ignoresList.value[i];
+                            var obj = AssetDatabase.LoadAssetAtPath<SceneAsset>(AssetDatabase.GUIDToAssetPath(guid));
+                            var sceneAsset = EditorGUILayout.ObjectField(obj, typeof(SceneAsset), false) as SceneAsset;
+
+                            ignoresList.value[i] = sceneAsset == null
+                                ? string.Empty
+                                : AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(sceneAsset));
+
+                            if (GUILayout.Button("-", GUILayout.Width(20)))
+                            {
+                                ignoresList.value.RemoveAt(i);
+                            }
+
+                            EditorGUILayout.EndHorizontal();
+                        }
+
+                        if (EditorGUI.EndChangeCheck())
+                        {
+                            ignoresList.value = ignoresList.value.ToList();
+                        }
+
+                        EditorGUILayout.Separator();
+                        break;
+
+                    case UtilityIgnoreMode.Patterns:
+                        EditorGUILayout.LabelField(new GUIContent($"{title} Ignore Patterns", patternsTooltip));
+                        ignoresPatterns.value = EditorGUILayout.TextArea(ignoresPatterns.value);
+                        EditorGUILayout.Separator();
+                        break;
+
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+        }
     }
 }