Unity 2020.1.0a7 C# reference source code

Author: Unity Technologies

Editor/Mono/Annotation/AnnotationWindow.cs

@@ -580,12 +580,8 @@ void DrawListElement(Rect rect, bool even, AInfo ainfo)
 
             // Icon toggle
             Rect iconRect = new Rect(rect.width - iconRightAlign + 2, rect.y + (rect.height - iconSize) * 0.5f, iconSize, iconSize); // +2 because the given rect is shortened by 2px before this method call
-            Texture thumb = null;
             if (ainfo.m_ScriptClass != "")
             {
-                // Icon for scripts
-                thumb = EditorGUIUtility.GetIconForObject(EditorGUIUtility.GetScript(ainfo.m_ScriptClass));
-
                 Rect div = iconRect;
                 div.x += 18;
                 div.y += 1;
@@ -622,22 +618,16 @@ void DrawListElement(Rect rect, bool even, AInfo ainfo)
                     }
                 }
             }
-            else
-            {
-                // Icon for builtin components
-                if (ainfo.HasIcon())
-                    thumb = AssetPreview.GetMiniTypeThumbnailFromClassID(ainfo.m_ClassID);
-            }
 
-            if (thumb != null)
+            if (ainfo.Thumb != null)
             {
                 if (!ainfo.m_IconEnabled)
                 {
                     GUI.color = new Color(GUI.color.r, GUI.color.g, GUI.color.b, disabledAlpha);
                     tooltip = "";
                 }
 
-                iconToggleContent.image = thumb;
+                iconToggleContent.image = ainfo.Thumb;
                 if (GUI.Button(iconRect, iconToggleContent, GUIStyle.none))
                 {
                     ainfo.m_IconEnabled = !ainfo.m_IconEnabled;
@@ -711,6 +701,33 @@ public AInfo(bool gizmoEnabled, bool iconEnabled, int flags, int classID, string
         public string m_ScriptClass;
         public string m_DisplayText;
         public int m_Flags;
+        private Object m_Script;
+        public Object Script
+        {
+            get
+            {
+                if (m_Script == null && m_ScriptClass != "")
+                    m_Script = EditorGUIUtility.GetScript(m_ScriptClass);
+                return m_Script;
+            }
+        }
+        private Texture2D m_Thumb;
+        public Texture2D Thumb
+        {
+            get
+            {
+                if (m_Thumb == null)
+                {
+                    // Icon for scripts
+                    if (Script != null)
+                        m_Thumb = EditorGUIUtility.GetIconForObject(m_Script);
+                    // Icon for builtin components
+                    else if (HasIcon())
+                        m_Thumb = AssetPreview.GetMiniTypeThumbnailFromClassID(m_ClassID);
+                }
+                return m_Thumb;
+            }
+        }
 
         public bool HasGizmo()
         {

Editor/Mono/AssemblyHelper.cs

@@ -263,6 +263,12 @@ public static string[] GetDefaultAssemblySearchPaths()
             foreach (var asm in precompiledAssemblies)
                 searchPaths.Add(Path.GetDirectoryName(asm.Path));
 
+            // Add Unity compiled assembly output directory.
+            // Required for MonoBehaviour derived types like UIBehaviour that
+            // were previous in a precompiled UnityEngine.UI.dll, but are now
+            // compiled in a package.
+            searchPaths.Add("Library/ScriptAssemblies");
+
             return searchPaths.ToArray();
         }
 

Editor/Mono/AssetDatabase/AssetDatabase.cs

@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using UnityEditor.VersionControl;
 using UnityEngine.Scripting;
 using uei = UnityEngine.Internal;
 
@@ -77,5 +78,24 @@ public static void IsOpenForEdit(string[] assetOrMetaFilePaths, List<string> out
             AssetModificationProcessorInternal.IsOpenForEdit(assetOrMetaFilePaths, outNotEditablePaths, statusQueryOptions);
             UnityEngine.Profiling.Profiler.EndSample();
         }
+
+        public static bool MakeEditable(string path)
+        {
+            if (path == null)
+                throw new ArgumentNullException(nameof(path));
+            return MakeEditable(new[] {path});
+        }
+
+        public static bool MakeEditable(string[] paths, string prompt = null, List<string> outNotEditablePaths = null)
+        {
+            if (paths == null)
+                throw new ArgumentNullException(nameof(paths));
+
+            ChangeSet changeSet = null;
+            if (!Provider.HandlePreCheckoutCallback(ref paths, ref changeSet))
+                return false;
+
+            return Provider.MakeEditableImpl(paths, prompt, changeSet, outNotEditablePaths);
+        }
     }
 }

Editor/Mono/AssetModificationProcessor.cs

@@ -121,22 +121,20 @@ static void OnWillCreateAsset(string path)
             }
         }
 
+        // ReSharper disable once UnusedMember.Local - invoked from native code
         static void FileModeChanged(string[] assets, UnityEditor.VersionControl.FileMode mode)
         {
-            // Make sure that all assets are checked out in version control and
-            // that we have the most recent status
-            if (Provider.enabled)
-            {
-                var editableAssets = new string[assets.Length];
-                if (Provider.MakeEditable(assets, editableAssets))
-                {
-                    // TODO: handle partial results from MakeEditable i.e. editableassets
-                    Provider.SetFileMode(assets, mode);
-                }
-            }
+            if (!Provider.enabled)
+                return;
+
+            // we'll want to re-serialize these assets in different (text vs binary) mode;
+            // make sure they are editable first
+            AssetDatabase.MakeEditable(assets);
+            Provider.SetFileMode(assets, mode);
         }
 
         // Postprocess on all assets once an automatic import has completed
+        // ReSharper disable once UnusedMember.Local - invoked from native code
         static void OnWillSaveAssets(string[] assets, out string[] assetsThatShouldBeSaved, out string[] assetsThatShouldBeReverted, bool explicitlySaveAsset)
         {
             assetsThatShouldBeReverted = new string[0];
@@ -179,16 +177,15 @@ static void OnWillSaveAssets(string[] assets, out string[] assetsThatShouldBeSav
             AssetDatabase.IsOpenForEdit(assetsThatShouldBeSaved, assetsNotOpened, StatusQueryOptions.ForceUpdate);
             assets = assetsNotOpened.ToArray();
 
-            // Try to checkout if needed. This may fail but is caught below.
-            var editableAssets = new string[assets.Length];
-            if (assets.Length != 0 && !Provider.MakeEditable(assets, editableAssets))
+            // Try to checkout if needed
+            var notEditableAssets = new List<string>();
+            if (assets.Length != 0 && !AssetDatabase.MakeEditable(assets, null, notEditableAssets))
             {
                 // only save assets that can be made editable (not locked by someone else, etc.),
                 // unless we are in the behavior mode that just overwrites everything anyway
                 if (!EditorUserSettings.overwriteFailedCheckoutAssets)
                 {
-                    editableAssets = editableAssets.Where(a => a != null).ToArray();
-                    assetsThatShouldBeReverted = assets.Except(editableAssets).ToArray();
+                    assetsThatShouldBeReverted = notEditableAssets.ToArray();
                     assetsThatShouldBeSaved = assetsThatShouldBeSaved.Except(assetsThatShouldBeReverted).ToArray();
                 }
             }

Editor/Mono/AssetPipeline/AssetImporter.bindings.cs

@@ -139,7 +139,7 @@ public Dictionary<SourceAssetIdentifier, Object> GetExternalObjectMap()
         }
 
         [FreeFunction("AssetImporterBindings::RegisterImporter")]
-        extern internal static  void RegisterImporter(Type importer, int importerVersion, int queuePos, string fileExt, bool supportsImportDependencyHinting, bool autoSelect);
+        extern internal static  void RegisterImporter(Type importer, int importerVersion, int queuePos, string fileExt, bool supportsImportDependencyHinting, bool autoSelect, bool allowCaching);
 
         [FreeFunction("AssetImporterBindings::SupportsRemappedAssetType", HasExplicitThis = true, IsThreadSafe = true)]
         public extern bool SupportsRemappedAssetType(Type type);

Editor/Mono/BuildPipeline.bindings.cs

@@ -110,7 +110,10 @@ public enum BuildOptions
         //StripUnityVersion = 1 << 27
 
         // Enable C# code instrumentation for the player.
-        EnableDeepProfilingSupport = 1 << 28
+        EnableDeepProfilingSupport = 1 << 28,
+
+        // The BuildReport object returned by BuildPipeline.BuildPlayer will contain more details (about build times and contents), at the cost of a slightly (typically, a few percents) longer build time
+        DetailedBuildReport = 1 << 29
     }
 
     // Asset Bundle building options.

Editor/Mono/CSPreProcess.cs

@@ -35,7 +35,7 @@ private static ProcessStartInfo GetJamStartInfo(bool includeModules)
                     moduleArgs.Append(" ").Append(target);
             }
 
-            return new ProcessStartInfo
+            var psi = new ProcessStartInfo
             {
                 WorkingDirectory = Unsupported.GetBaseUnityDeveloperFolder(),
                 RedirectStandardOutput = true,
@@ -44,6 +44,18 @@ private static ProcessStartInfo GetJamStartInfo(bool includeModules)
                 Arguments = moduleArgs.ToString(),
                 FileName = "perl",
             };
+
+            var path = Environment.GetEnvironmentVariable("PATH") ?? "";
+            // on macOS the typical mercurial path might not be in our environment variable, so add it for executing jam
+            if (Application.platform == RuntimePlatform.OSXEditor)
+            {
+                var localBin = "/usr/local/bin";
+                if (!path.Contains(localBin))
+                    path = $"{path}:{localBin}";
+            }
+            psi.EnvironmentVariables["PATH"] = path;
+
+            return psi;
         }
 
         private static CompilerMessage[] ParseResults(string text)

Editor/Mono/CodeEditor/DefaultExternalCodeEditor.cs

@@ -2,7 +2,6 @@
 // Copyright (c) Unity Technologies. For terms of use, see
 // https://unity3d.com/legal/licenses/Unity_Reference_Only_License
 
-using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
@@ -17,6 +16,7 @@ internal class DefaultExternalCodeEditor : IExternalCodeEditor
         static bool IsOSX => Application.platform == RuntimePlatform.OSXEditor;
 
         string m_ChosenInstallation;
+
         const string k_ArgumentKey = "kScriptEditorArgs";
         const string k_DefaultArgument = "$(File)";
 
@@ -35,25 +35,40 @@ string Arguments
                 // The year 2021: Delete mac hack.
                 if (Application.platform == RuntimePlatform.OSXEditor)
                 {
-                    var oldMac = EditorPrefs.GetString("kScriptEditorArgs_" + m_ChosenInstallation);
+                    var oldMac = EditorPrefs.GetString("kScriptEditorArgs_" + Installation);
                     if (!string.IsNullOrEmpty(oldMac))
                     {
                         EditorPrefs.SetString(k_ArgumentKey, oldMac);
                     }
                 }
 
-                return EditorPrefs.GetString(k_ArgumentKey + m_ChosenInstallation, k_DefaultArgument);
+                return EditorPrefs.GetString(k_ArgumentKey + Installation, k_DefaultArgument);
             }
             set
             {
                 if (Application.platform == RuntimePlatform.OSXEditor)
                 {
-                    EditorPrefs.SetString("kScriptEditorArgs_" + m_ChosenInstallation, value);
+                    EditorPrefs.SetString("kScriptEditorArgs_" + Installation, value);
                 }
 
-                EditorPrefs.SetString(k_ArgumentKey + m_ChosenInstallation, value);
+                EditorPrefs.SetString(k_ArgumentKey + Installation, value);
             }
         }
+
+        string Installation
+        {
+            get
+            {
+                if (m_ChosenInstallation == null)
+                    m_ChosenInstallation = CodeEditor.CurrentEditorInstallation;
+                return m_ChosenInstallation;
+            }
+            set
+            {
+                m_ChosenInstallation = value;
+            }
+        }
+
         public CodeEditor.Installation[] Installations { get; }
         public bool TryGetInstallationForPath(string editorPath, out CodeEditor.Installation installation)
         {
@@ -84,7 +99,6 @@ public void SyncAll()
 
         public void Initialize(string editorInstallationPath)
         {
-            m_ChosenInstallation = editorInstallationPath;
         }
 
         static string[] defaultExtensions

Editor/Mono/ContainerWindow.cs

@@ -198,7 +198,7 @@ internal bool IsNotDocked()
             return ( // hallelujah
 
                 (m_ShowMode == (int)ShowMode.Utility || m_ShowMode == (int)ShowMode.AuxWindow) ||
-                (m_ShowMode == (int)ShowMode.MainWindow && (rootView is HostView || rootView is MainView)) ||
+                (m_ShowMode == (int)ShowMode.MainWindow && rootView is HostView) ||
                 (rootView is SplitView &&
                     rootView.children.Length == 1 &&
                     rootView.children[0] is DockArea &&

Editor/Mono/Delayer.cs

@@ -0,0 +1,81 @@
+// Unity C# reference source
+// Copyright (c) Unity Technologies. For terms of use, see
+// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
+
+using System;
+
+namespace UnityEditor
+{
+    internal class Delayer
+    {
+        private double m_LastExecutionTime;
+        private readonly Action<object> m_Action;
+        private readonly double m_DebounceDelay;
+        private object m_Context;
+        private readonly bool m_IsThrottle;
+
+        public static Delayer Throttle(Action<object> action, double delay = 0.2)
+        {
+            return new Delayer(action, delay, true);
+        }
+
+        public static Delayer Debounce(Action<object> action, double delay = 0.2)
+        {
+            return new Delayer(action, delay, false);
+        }
+
+        public void Execute(object context = null)
+        {
+            m_Context = context;
+            if (m_IsThrottle)
+            {
+                if (m_LastExecutionTime == 0)
+                    Throttle();
+            }
+            else
+            {
+                m_LastExecutionTime = EditorApplication.timeSinceStartup;
+                Debounce();
+            }
+        }
+
+        private Delayer(Action<object> action, double delay, bool isThrottle)
+        {
+            m_Action = action;
+            m_DebounceDelay = delay;
+            m_IsThrottle = isThrottle;
+        }
+
+        private void Debounce()
+        {
+            EditorApplication.delayCall -= Debounce;
+            var currentTime = EditorApplication.timeSinceStartup;
+            if (m_LastExecutionTime != 0 && currentTime - m_LastExecutionTime > m_DebounceDelay)
+            {
+                m_Action(m_Context);
+                m_LastExecutionTime = 0;
+            }
+            else
+            {
+                EditorApplication.delayCall += Debounce;
+            }
+        }
+
+        private void Throttle()
+        {
+            EditorApplication.delayCall -= Throttle;
+            var currentTime = EditorApplication.timeSinceStartup;
+            if (m_LastExecutionTime != 0 && currentTime - m_LastExecutionTime > m_DebounceDelay)
+            {
+                m_Action(m_Context);
+                m_LastExecutionTime = 0;
+            }
+            else
+            {
+                if (m_LastExecutionTime == 0)
+                    m_LastExecutionTime = currentTime;
+                EditorApplication.delayCall += Throttle;
+            }
+        }
+    }
+}