Unity 2023.1.0a15 C# reference source code

Author: Unity Technologies

Editor/Mono/ContainerWindow.cs

@@ -26,6 +26,7 @@ internal partial class ContainerWindow : ScriptableObject
 
         internal int m_DisplayIndex;
         internal bool m_IsFullscreenContainer;
+        internal bool m_IsForceTitleBar;
 
         internal bool m_DontSaveToLayout = false;
         private bool m_HasUnsavedChanges = false;
@@ -372,6 +373,11 @@ internal void InternalCloseWindow()
             DestroyImmediate(this, true);
         }
 
+        internal bool InternalIsForceTitleBar()
+        {
+            return m_IsForceTitleBar;
+        }
+
         private static List<EditorWindow> FindUnsavedChanges(View view)
         {
             var unsavedChanges = new List<EditorWindow>();

Editor/Mono/Delayer.cs

@@ -13,50 +13,73 @@ class Delayer
         private readonly double m_DebounceDelay;
         private object m_Context;
         private readonly bool m_IsThrottle;
+        private readonly bool m_FirstExecuteImmediate;
+        private bool m_DelayInProgress;
 
         public static Delayer Throttle(Action<object> action, double delay = 0.2)
         {
-            return new Delayer(action, delay, true);
+            return new Delayer(action, delay, true, false);
+        }
+
+        public static Delayer Throttle(Action<object> action, double delay, bool firstExecuteImmediate)
+        {
+            return new Delayer(action, delay, true, firstExecuteImmediate);
         }
 
         public static Delayer Debounce(Action<object> action, double delay = 0.2)
         {
-            return new Delayer(action, delay, false);
+            return new Delayer(action, delay, false, false);
+        }
+
+        public static Delayer Debounce(Action<object> action, double delay, bool firstExecuteImmediate)
+        {
+            return new Delayer(action, delay, false, firstExecuteImmediate);
         }
 
         public void Execute(object context = null)
         {
             m_Context = context;
+
             if (m_IsThrottle)
             {
-                if (m_LastExecutionTime == 0)
+                if (m_LastExecutionTime == 0 || !m_DelayInProgress)
                     Throttle();
             }
             else
             {
-                m_LastExecutionTime = DateTime.UtcNow.Ticks;
-                Debounce();
+                if (m_FirstExecuteImmediate && m_LastExecutionTime == 0)
+                {
+                    m_Action?.Invoke(m_Context);
+                    m_LastExecutionTime = DateTime.UtcNow.Ticks;
+                }
+                else
+                {
+                    m_LastExecutionTime = DateTime.UtcNow.Ticks;
+                    Debounce();
+                }
             }
         }
 
-        private Delayer(Action<object> action, double delay, bool isThrottle)
+        private Delayer(Action<object> action, double delay, bool isThrottle, bool firstExecuteImmediate)
         {
             m_Action = action;
             m_DebounceDelay = delay;
             m_IsThrottle = isThrottle;
+            m_FirstExecuteImmediate = firstExecuteImmediate;
         }
 
         public void Dispose()
         {
-            EditorApplication.delayCall -= Debounce;
-            EditorApplication.delayCall -= Throttle;
+            EditorApplication.tick -= Debounce;
+            EditorApplication.tick -= Throttle;
             m_Context = null;
             m_Action = null;
         }
 
         private void Debounce()
         {
-            EditorApplication.delayCall -= Debounce;
+            m_DelayInProgress = false;
+            EditorApplication.tick -= Debounce;
             var currentTime = DateTime.UtcNow.Ticks;
             if (m_LastExecutionTime != 0 && DelayHasPassed(currentTime))
             {
@@ -65,31 +88,51 @@ private void Debounce()
             }
             else
             {
-                EditorApplication.delayCall += Debounce;
+                EditorApplication.tick += Debounce;
+                m_DelayInProgress = true;
             }
         }
 
         private void Throttle()
         {
-            EditorApplication.delayCall -= Throttle;
+            m_DelayInProgress = false;
+            EditorApplication.tick -= Throttle;
             var currentTime = DateTime.UtcNow.Ticks;
-            if (m_LastExecutionTime != 0 && DelayHasPassed(currentTime))
+
+            if (m_FirstExecuteImmediate)
             {
-                m_Action?.Invoke(m_Context);
-                m_LastExecutionTime = 0;
+                if (m_LastExecutionTime == 0 || DelayHasPassed(currentTime))
+                {
+                    m_Action?.Invoke(m_Context);
+                    m_LastExecutionTime = currentTime;
+                }
+                else
+                {
+                    EditorApplication.tick += Throttle;
+                    m_DelayInProgress = true;
+                }
             }
             else
             {
-                if (m_LastExecutionTime == 0)
-                    m_LastExecutionTime = currentTime;
-                EditorApplication.delayCall += Throttle;
+                if (m_LastExecutionTime != 0 && DelayHasPassed(currentTime))
+                {
+                    m_Action?.Invoke(m_Context);
+                    m_LastExecutionTime = 0;
+                }
+                else
+                {
+                    if (m_LastExecutionTime == 0)
+                        m_LastExecutionTime = currentTime;
+                    EditorApplication.tick += Throttle;
+                    m_DelayInProgress = true;
+                }
             }
         }
 
         private bool DelayHasPassed(long currentTime)
         {
             var timeSpan = new TimeSpan(currentTime - m_LastExecutionTime);
-            return timeSpan.TotalSeconds > m_DebounceDelay;
+            return timeSpan.TotalSeconds >= m_DebounceDelay;
         }
     }
 }

Editor/Mono/GUI/WindowLayout.cs

@@ -211,6 +211,92 @@ internal static ContainerWindow FindMainWindow()
             return null;
         }
 
+        internal static ContainerWindow ShowWindowWithDynamicLayout(string windowId, string layoutDataPath)
+        {
+            try
+            {
+                ContainerWindow.SetFreezeDisplay(true);
+
+                if (!File.Exists(layoutDataPath))
+                {
+                    Debug.LogError($"Failed to find layout data file at path {layoutDataPath}");
+                    return null;
+                }
+
+                var layoutDataJson = File.ReadAllText(layoutDataPath);
+                var layoutData = SJSON.LoadString(layoutDataJson);
+
+                LayoutViewInfo viewInfo = new LayoutViewInfo("view", 0, true);
+                var availableEditorWindowTypes = TypeCache.GetTypesDerivedFrom<EditorWindow>().ToArray();
+
+                if (!GetLayoutViewInfo(layoutData, availableEditorWindowTypes, ref viewInfo))
+                {
+                    Debug.LogError("Failed to load window layout; no view defined");
+                    return null;
+                }
+
+                var window = Resources.FindObjectsOfTypeAll<ContainerWindow>()
+                    .FirstOrDefault(w => w.windowID == windowId);
+                if (window == null)
+                {
+                    window = ScriptableObject.CreateInstance<ContainerWindow>();
+
+                    var windowMinSize = new Vector2(120, 80);
+                    var windowMaxSize = new Vector2(8192, 8192);
+                    if (layoutData.Contains("min_width"))
+                    {
+                        windowMinSize.x = Convert.ToSingle(layoutData["min_width"]);
+                    }
+                    if (layoutData.Contains("min_height"))
+                    {
+                        windowMinSize.y = Convert.ToSingle(layoutData["min_height"]);
+                    }
+                    if (layoutData.Contains("max_width"))
+                    {
+                        windowMaxSize.x = Convert.ToSingle(layoutData["max_width"]);
+                    }
+                    if (layoutData.Contains("max_height"))
+                    {
+                        windowMaxSize.y = Convert.ToSingle(layoutData["max_height"]);
+                    }
+
+                    window.SetMinMaxSizes(windowMinSize, windowMaxSize);
+                }
+
+                var hasGeometrySettings = EditorPrefs.HasKey(windowId);
+                window.windowID = windowId;
+                if (hasGeometrySettings)
+                    window.LoadGeometry(true);
+
+                var width = window.position.width;
+                var height = window.position.height;
+
+                View view = LoadLayoutView<DockArea>(availableEditorWindowTypes, viewInfo, width, height);
+
+                var main = ScriptableObject.CreateInstance<MainView>();
+                main.useTopView = false;
+                main.useBottomView = false;
+
+                view.position = new Rect(0, 0, width, height);
+                main.AddChild(view);
+
+                if (window.rootView)
+                    ScriptableObject.DestroyImmediate(window.rootView, true);
+
+                window.rootView = main;
+                window.rootView.position = new Rect(0, 0, width, height);
+                window.m_IsForceTitleBar = true;
+                window.Show(ShowMode.Utility, true, true, true);
+                window.DisplayAllViews();
+
+                return window;
+            }
+            finally
+            {
+                ContainerWindow.SetFreezeDisplay(false);
+            }
+        }
+
         private static ContainerWindow GenerateLayout(bool keepMainWindow, Type[] availableEditorWindowTypes, LayoutViewInfo center, LayoutViewInfo top, LayoutViewInfo bottom, JSONObject layoutData)
         {
             ContainerWindow mainContainerWindow = FindMainWindow();

Editor/Mono/Inspector/AddComponent/AddComponentWindow.cs

@@ -68,7 +68,7 @@ private void OnItemSelected(AdvancedDropdownItem item)
             {
                 SendUsabilityAnalyticsEvent(new AnalyticsEventData
                 {
-                    name = name,
+                    name = item.name,
                     filter = searchString,
                     isNewScript = false
                 });

Editor/Mono/Inspector/PlayerSettingsEditor/PlayerSettingsEditor.cs

@@ -200,7 +200,7 @@ class SettingsContent
             public static readonly GUIContent scriptingDefineSymbolsApply = EditorGUIUtility.TrTextContent("Apply");
             public static readonly GUIContent scriptingDefineSymbolsApplyRevert = EditorGUIUtility.TrTextContent("Revert");
             public static readonly GUIContent scriptingDefineSymbolsCopyDefines = EditorGUIUtility.TrTextContent("Copy Defines", "Copy applied defines");
-            public static readonly GUIContent suppressCommonWarnings = EditorGUIUtility.TrTextContent("Suppress Common Warnings", "Suppresses C# warnings CS0169 and CS0649.");
+            public static readonly GUIContent suppressCommonWarnings = EditorGUIUtility.TrTextContent("Suppress Common Warnings", "Suppresses C# warnings CS0169, CS0649, and CS0282.");
             public static readonly GUIContent scriptingBackend = EditorGUIUtility.TrTextContent("Scripting Backend");
             public static readonly GUIContent managedStrippingLevel = EditorGUIUtility.TrTextContent("Managed Stripping Level", "If scripting backend is IL2CPP, managed stripping can't be disabled.");
             public static readonly GUIContent il2cppCompilerConfiguration = EditorGUIUtility.TrTextContent("C++ Compiler Configuration");
@@ -653,8 +653,9 @@ void OnEnable()
 
             m_ForceSRGBBlit                 = FindPropertyAssert("hmiForceSRGBBlit");
 
-            m_SettingsExtensions = new ISettingEditorExtension[validPlatforms.Length];
-            for (int i = 0; i < validPlatforms.Length; i++)
+            var validPlatformsLength = validPlatforms.Length;
+            m_SettingsExtensions = new ISettingEditorExtension[validPlatformsLength];
+            for (int i = 0; i < validPlatformsLength; i++)
             {
                 string module = ModuleManager.GetTargetStringFromBuildTargetGroup(validPlatforms[i].namedBuildTarget.ToBuildTargetGroup());
                 m_SettingsExtensions[i] = ModuleManager.GetEditorSettingsExtension(module);
@@ -673,8 +674,15 @@ void OnEnable()
             // we access this cache both from player settings editor and script side when changing api
             s_GraphicsDeviceLists.Clear();
 
+            var selectedPlatform = m_SelectedPlatform.intValue;
+            if (selectedPlatform < 0)
+                selectedPlatform = 0;
+
+            if (selectedPlatform >= validPlatformsLength)
+                selectedPlatform = validPlatformsLength - 1;
+
             // Setup initial values to prevent immediate script recompile (or editor restart)
-            NamedBuildTarget namedBuildTarget = validPlatforms[m_SelectedPlatform.intValue].namedBuildTarget;
+            NamedBuildTarget namedBuildTarget = validPlatforms[selectedPlatform].namedBuildTarget;
             serializedActiveInputHandler = m_ActiveInputHandler.intValue;
             serializedSuppressCommonWarnings = m_SuppressCommonWarnings.boolValue;
             serializedAllowUnsafeCode = m_AllowUnsafeCode.boolValue;
@@ -1009,7 +1017,7 @@ public void ResolutionSectionGUI(NamedBuildTarget namedBuildTarget, ISettingEdit
                         settingsExtension.ResolutionSectionGUI(h, kLabelFloatMinW, kLabelFloatMaxW);
                     }
 
-                    if (namedBuildTarget == NamedBuildTarget.Standalone || namedBuildTarget == NamedBuildTarget.EmbeddedLinux)
+                    if (namedBuildTarget == NamedBuildTarget.Standalone)
                     {
                         GUILayout.Label(SettingsContent.resolutionTitle, EditorStyles.boldLabel);
 

Editor/Mono/Modules/BeeBuildPostprocessor.cs

@@ -577,19 +577,6 @@ public virtual string PrepareForBuild(BuildOptions options, BuildTarget target)
             if ((options & BuildOptions.CleanBuildCache) == BuildOptions.CleanBuildCache)
                 EditorCompilation.ClearBeeBuildArtifacts();
 
-            if (Unsupported.IsDeveloperBuild())
-            {
-                NPath editorGitRevisionFile = $"{EditorApplication.applicationContentsPath}/Tools/BuildPipeline/gitrevision.txt";
-                NPath playerGitRevisionFile = $"{BuildPipeline.GetPlaybackEngineDirectory(target, options)}/Bee/gitrevision.txt";
-                if (editorGitRevisionFile.Exists() && playerGitRevisionFile.Exists())
-                {
-                    string editorGitRevision = editorGitRevisionFile.ReadAllText();
-                    string playerGitRevision = playerGitRevisionFile.ReadAllText();
-                    if (editorGitRevision != playerGitRevision)
-                        return $"The Bee libraries used in the editor come from a different revision, than the ones used for the player. Please rebuild both editor and player when making changes to Bee player build libraries. (editor: '{editorGitRevision}', player: '{playerGitRevision}')";
-                }
-            }
-
             return null;
         }
 

Editor/Mono/Networking/PlayerConnection/EditorConnection.cs

@@ -80,7 +80,7 @@ private void Cleanup()
         {
             UnregisterAllPersistedListeners(m_PlayerEditorConnectionEvents.connectionEvent);
             UnregisterAllPersistedListeners(m_PlayerEditorConnectionEvents.disconnectionEvent);
-            m_PlayerEditorConnectionEvents.messageTypeSubscribers.Clear();
+            m_PlayerEditorConnectionEvents.Clear();
         }
 
         private void UnregisterAllPersistedListeners(UnityEventBase connectionEvent)

Editor/Mono/Prefabs/PrefabUtility.cs

@@ -505,7 +505,7 @@ static void HandleApplySingleProperties(
             HashSet<SerializedObject> changedObjects,
             bool allowApplyDefaultOverride,
             InteractionMode action
-            )
+        )
         {
             bool isObjectOnRootInAsset = IsObjectOnRootInAsset(prefabInstanceObject, assetPath);
 
@@ -1969,13 +1969,13 @@ internal static void ValidatePath(GameObject instanceRoot, string path)
             }
         }
 
-        private static void SaveAsPrefabAssetArgumentCheck(GameObject instanceRoot, string path)
+        private static void SaveAsPrefabAssetArgumentCheck(GameObject instanceRoot, string path, bool connectToInstance)
         {
             if (instanceRoot == null)
                 throw new ArgumentNullException("Parameter root is null");
 
-            if (EditorUtility.IsPersistent(instanceRoot))
-                throw new ArgumentException("Can't save persistent object as a Prefab asset");
+            if (EditorUtility.IsPersistent(instanceRoot) && connectToInstance)
+                throw new ArgumentException("Can't save persistent Objects and connect them to the saved Prefab");
 
             if (IsPartOfNonAssetPrefabInstance(instanceRoot))
             {
@@ -2007,7 +2007,7 @@ private static void ReplacePrefabArgumentCheck(GameObject root, string path)
 
         public static GameObject SaveAsPrefabAsset(GameObject instanceRoot, string assetPath, out bool success)
         {
-            SaveAsPrefabAssetArgumentCheck(instanceRoot, assetPath);
+            SaveAsPrefabAssetArgumentCheck(instanceRoot, assetPath, false);
 
             return SaveAsPrefabAsset_Internal(instanceRoot, assetPath, out success);
         }
@@ -2026,7 +2026,7 @@ public static GameObject SaveAsPrefabAssetAndConnect(GameObject instanceRoot, st
 
         public static GameObject SaveAsPrefabAssetAndConnect(GameObject instanceRoot, string assetPath, InteractionMode action, out bool success)
         {
-            SaveAsPrefabAssetArgumentCheck(instanceRoot, assetPath);
+            SaveAsPrefabAssetArgumentCheck(instanceRoot, assetPath, true);
 
             if (IsPathInStreamingAssets(assetPath))
                 throw new ArgumentException("Can't connect a Prefab in the StreamingAssets folder to GameObjects in the scene. To save a Prefab to the StreamingAssets folder use SaveAsPrefabAsset instead.");
@@ -2075,7 +2075,7 @@ internal static void ApplyPrefabInstance(GameObject instance)
             var assetObject = GetCorrespondingObjectFromSource(instance);
             string path = AssetDatabase.GetAssetPath(assetObject);
 
-            SaveAsPrefabAssetArgumentCheck(instance, path);
+            SaveAsPrefabAssetArgumentCheck(instance, path, true);
 
             ApplyPrefabInstance_Internal(instance);
         }