Unity 2023.3.0b3 C# reference source code

Author: Unity Technologies

Editor/Mono/BuildPlayerWindow.cs

@@ -572,11 +572,11 @@ static bool IsVirtualTexturingSettingsValid(BuildPlatform platform)
         static Dictionary<string, string> s_ModuleNames = new Dictionary<string, string>()
         {
             { "tvOS", "AppleTV" },
-            { "OSXStandalone", "Mac" },
+            { "OSXStandalone", "Mac-Mono" },
             { "OSXDedicatedServer", "Mac-Server" },
-            { "WindowsStandalone", "Windows" },
+            { "WindowsStandalone", "Windows-Mono" },
             { "WindowsDedicatedServer", "Windows-Server" },
-            { "LinuxStandalone", "Linux" },
+            { "LinuxStandalone", "Linux-Mono" },
             { "LinuxDedicatedServer", "Linux-Server" },
             { "UWP", "Universal-Windows-Platform"}
         };
@@ -624,7 +624,7 @@ static public string GetPlaybackEngineDownloadURL(string moduleName)
             }
             else if (Application.platform == RuntimePlatform.LinuxEditor)
             {
-                if (moduleName == "Android" || moduleName == "Mac" || moduleName == "Windows")
+                if (moduleName == "Android" || moduleName == "Mac-Mono" || moduleName == "Windows-Mono")
                 {
                     folder = "MacEditorTargetInstaller";
                     extension = ".pkg";

Editor/Mono/ContainerWindow.cs

@@ -125,6 +125,10 @@ internal void ShowPopupWithMode(ShowMode mode, bool giveFocus)
                     m_RootView.SetWindowRecurse(this);
                 Internal_SetTitle(m_Title);
                 Save();
+
+                // System windows that come from the OS (like a context menu from search) need theming
+                SetBackgroundColor(skinBackgroundColor);
+
                 //  only set focus if mode is a popupMenu.
                 Internal_BringLiveAfterCreation(true, giveFocus, false);
 

Editor/Mono/EditorGUI.RenderPipeline.cs

@@ -2,7 +2,9 @@
 // Copyright (c) Unity Technologies. For terms of use, see
 // https://unity3d.com/legal/licenses/Unity_Reference_Only_License
 
-using System.Diagnostics.CodeAnalysis;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using UnityEditor.Rendering;
 using UnityEngine;
 
 namespace UnityEditor
@@ -49,8 +51,7 @@ static uint RenderingLayerMaskFieldInternal(Rect position, GUIContent label, uin
             if (label != null)
                 position = PrefixLabel(position, id, label);
 
-            var names = RenderingLayerMask.GetDefinedRenderingLayerNames();
-            var values = RenderingLayerMask.GetDefinedRenderingLayerValues();
+            var (names, values) = RenderPipelineEditorUtility.GetRenderingLayerNamesAndValuesForMask(layers);
 
             using var scope = new MixedValueScope();
 
@@ -63,6 +64,11 @@ static uint RenderingLayerMaskFieldInternal(Rect position, GUIContent label, uin
                 bits.uintValue = (uint)newValue;
             }
 
+            var currentLimit = RenderPipelineEditorUtility.GetActiveMaxRenderingLayers();
+            var newValueUint = unchecked((uint)newValue);
+            if (currentLimit != 32 && newValueUint != uint.MaxValue && newValueUint >= 1u << currentLimit)
+                EditorGUILayout.HelpBox($"Current mask contains layers outside of a supported range by active Render Pipeline. The active Render Pipeline only supports up to {currentLimit} layers. Rendering Layers above {currentLimit} are ignored.", MessageType.Warning);
+
             return unchecked((uint)newValue);
         }
     }

Editor/Mono/EditorGraphicsSettings.bindings.cs

@@ -148,6 +148,20 @@ internal static void ForEachPipelineSettings(Action<RenderPipelineGlobalSettings
                 action?.Invoke(Internal_GetSettingsForRenderPipelineAt(i) as RenderPipelineGlobalSettings);
         }
 
+        public static TSettingsInterfaceType[] GetRenderPipelineSettingsFromInterface<TSettingsInterfaceType>()
+            where TSettingsInterfaceType : class, IRenderPipelineGraphicsSettings
+        {
+            if (!GraphicsSettings.TryGetCurrentRenderPipelineGlobalSettings(out RenderPipelineGlobalSettings asset))
+                return new TSettingsInterfaceType[] {};
+
+            if (asset.GetSettingsImplementingInterface<TSettingsInterfaceType>(out var baseSettings))
+            {
+                return baseSettings.ToArray();
+            }
+
+            return new TSettingsInterfaceType[] {};
+        }
+
         public static bool TryGetFirstRenderPipelineSettingsFromInterface<TSettingsInterfaceType>(out TSettingsInterfaceType settings)
             where TSettingsInterfaceType : class, IRenderPipelineGraphicsSettings
         {
@@ -165,18 +179,40 @@ public static bool TryGetFirstRenderPipelineSettingsFromInterface<TSettingsInter
             return false;
         }
 
-        public static TSettingsInterfaceType[] GetRenderPipelineSettingsFromInterface<TSettingsInterfaceType>()
+        public static bool TryGetRenderPipelineSettingsFromInterface<TSettingsInterfaceType>(out TSettingsInterfaceType[] settings)
             where TSettingsInterfaceType : class, IRenderPipelineGraphicsSettings
         {
+            settings = null;
+
             if (!GraphicsSettings.TryGetCurrentRenderPipelineGlobalSettings(out RenderPipelineGlobalSettings asset))
-                return new TSettingsInterfaceType[] {};
+                return false;
 
             if (asset.GetSettingsImplementingInterface<TSettingsInterfaceType>(out var baseSettings))
-            {
-                return baseSettings.ToArray();
-            }
+                settings = baseSettings.ToArray();
 
-            return new TSettingsInterfaceType[] {};
+            return settings != null;
+        }
+
+        public static bool TryGetRenderPipelineSettingsFromInterfaceForPipeline<TSettingsInterfaceType, TPipeline>(out TSettingsInterfaceType[] settings)
+            where TSettingsInterfaceType : class, IRenderPipelineGraphicsSettings
+            where TPipeline : RenderPipeline
+        {
+            return TryGetRenderPipelineSettingsFromInterfaceForPipeline(typeof(TPipeline), out settings);
+        }
+
+        public static bool TryGetRenderPipelineSettingsFromInterfaceForPipeline<TSettingsInterfaceType>(Type renderPipelineType, out TSettingsInterfaceType[] settings)
+            where TSettingsInterfaceType : class, IRenderPipelineGraphicsSettings
+        {
+            settings = null;
+
+            var pipelineGlobalSettings = GraphicsSettings.GetSettingsForRenderPipeline(renderPipelineType);
+            if (pipelineGlobalSettings == null)
+                return false;
+
+            if (pipelineGlobalSettings.GetSettingsImplementingInterface<TSettingsInterfaceType>(out var baseSettings))
+                settings = baseSettings.ToArray();
+
+            return settings != null;
         }
     }
 }

Editor/Mono/Graphics/RenderingLayersLimitSettings.cs

@@ -0,0 +1,31 @@
+// Unity C# reference source
+// Copyright (c) Unity Technologies. For terms of use, see
+// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
+
+using System;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityEditor.Rendering
+{
+    public abstract class RenderingLayersLimitSettings : IRenderPipelineGraphicsSettings
+    {
+        #region Version
+
+        internal enum Version
+        {
+            Initial = 0,
+        }
+
+        [SerializeField] [HideInInspector] Version m_Version = Version.Initial;
+
+        /// <summary>Current version.</summary>
+        public int version => (int)m_Version;
+
+        #endregion
+
+        protected abstract int maxRenderingLayersForPipeline { get; }
+
+        public int maxSupportedRenderingLayers => maxRenderingLayersForPipeline is > 1 and <= 32 ? maxRenderingLayersForPipeline : 32;
+    }
+}

Editor/Mono/Inspector/RenderPipelineEditorUtility.cs

@@ -8,6 +8,7 @@
 using System.Reflection;
 using UnityEngine;
 using UnityEngine.Rendering;
+using Object = UnityEngine.Object;
 
 namespace UnityEditor.Rendering
 {
@@ -31,13 +32,12 @@ public static Type FetchFirstCompatibleTypeUsingScriptableRenderPipelineExtensio
                 if (Attribute.GetCustomAttribute(extensionType, typeof(ScriptableRenderPipelineExtensionAttribute)) is ScriptableRenderPipelineExtensionAttribute { inUse: true })
                     return extensionType;
 #pragma warning restore CS0618
-
             }
 
             return null;
         }
 
-        private static Dictionary<Type, Type> s_RenderPipelineAssetToRenderPipelineType = new ();
+        private static Dictionary<Type, Type> s_RenderPipelineAssetToRenderPipelineType = new();
 
         public static Type GetPipelineTypeFromPipelineAssetType(Type pipelineAssetType)
         {
@@ -63,12 +63,95 @@ public static Type GetPipelineTypeFromPipelineAssetType(Type pipelineAssetType)
 
             var pipelineAsset = ScriptableObject.CreateInstance(pipelineAssetType) as RenderPipelineAsset;
             pipelineType = pipelineAsset.pipelineType;
-            UnityEngine.Object.DestroyImmediate(pipelineAsset);
+            Object.DestroyImmediate(pipelineAsset);
             s_RenderPipelineAssetToRenderPipelineType[pipelineAssetType] = pipelineType;
             return pipelineType;
         }
 
         public static bool TrySetRenderingLayerName(int index, string name)
-            => TagManager.TrySetRenderingLayerName(index, name);
+            => TagManager.Internal_TrySetRenderingLayerName(index, name);
+
+        public static bool TryAddRenderingLayerName(string name)
+            => TagManager.Internal_TryAddRenderingLayerName(name);
+
+        internal static int GetActiveMaxRenderingLayers()
+        {
+            if (EditorGraphicsSettings.TryGetRenderPipelineSettingsFromInterface<RenderingLayersLimitSettings>(out var settings)
+                && settings.Length != 0)
+                return settings[0].maxSupportedRenderingLayers;
+            return 32;
+        }
+
+        internal static List<(int, string)> GetMaxRenderingLayersFromSettings()
+        {
+            var result = new List<(int, string)>();
+            var renderPipelineAssets = GraphicsSettings.allConfiguredRenderPipelines;
+            foreach (var renderPipelineAsset in renderPipelineAssets)
+            {
+                var pipelineType = GetPipelineTypeFromPipelineAssetType(renderPipelineAsset.GetType());
+                if (pipelineType == null)
+                    continue;
+
+                if (!EditorGraphicsSettings.TryGetRenderPipelineSettingsFromInterfaceForPipeline<RenderingLayersLimitSettings>(pipelineType, out var settings))
+                    continue;
+
+                if (settings.Length == 0)
+                    continue;
+
+                result.Add((settings[0].maxSupportedRenderingLayers, renderPipelineAsset.pipelineType.Name));
+            }
+
+            return result;
+        }
+
+        internal static (string[], int[]) GetRenderingLayerNamesAndValuesForMask(uint currentMask)
+        {
+            var names = RenderingLayerMask.GetDefinedRenderingLayerNames();
+            var values = RenderingLayerMask.GetDefinedRenderingLayerValues();
+
+            if (currentMask != uint.MaxValue)
+            {
+                //calculate remaining mask value
+                uint remainingMask = currentMask;
+                for (int i = 0; i < values.Length; i++)
+                {
+                    uint valueUint = unchecked((uint)values[i]);
+                    if ((currentMask & valueUint) != 0)
+                        remainingMask &= ~valueUint;
+                }
+
+                //add remaining mask value to the end of the list
+                if (remainingMask != 0)
+                {
+                    var listOfUnnamedBits = new List<(int, uint)>();
+                    for (int i = 0; i < 32; i++)
+                    {
+                        if ((remainingMask & (1u << i)) != 0)
+                            listOfUnnamedBits.Add((i, 1u << i));
+                    }
+
+                    var allNames = new List<string>(names.Length + listOfUnnamedBits.Count);
+                    var allValues = new List<int>(names.Length + listOfUnnamedBits.Count);
+                    allNames.AddRange(names);
+                    allValues.AddRange(values);
+
+                    for (int i = 0; i < listOfUnnamedBits.Count; i++)
+                    {
+                        var bit = listOfUnnamedBits[i];
+                        var indexOfTheNextValue = allValues.FindIndex((currentValue) => unchecked((uint)currentValue) > bit.Item2);
+                        if (indexOfTheNextValue == -1)
+                            indexOfTheNextValue = allValues.Count;
+
+                        //find an index of specific bit value
+                        allNames.Insert(indexOfTheNextValue, $"Undefined Layer {bit.Item1}");
+                        allValues.Insert(indexOfTheNextValue, unchecked((int)bit.Item2));
+                    }
+                    names = allNames.ToArray();
+                    values = allValues.ToArray();
+                }
+            }
+
+            return (names, values);
+        }
     }
 }