Unity 2020.1.0a12 C# reference source code

Author: Unity Technologies

Editor/Mono/Animation/AnimationUtility.bindings.cs

@@ -209,6 +209,7 @@ internal static void SetObjectReferenceCurveNoSync(AnimationClip clip, EditorCur
             Internal_InvokeOnCurveWasModified(clip, binding, keyframes != null ? CurveModifiedType.CurveModified : CurveModifiedType.CurveDeleted);
         }
 
+        [NativeThrows]
         extern private static void Internal_SetObjectReferenceCurve([NotNull] AnimationClip clip, EditorCurveBinding binding, ObjectReferenceKeyframe[] keyframes, bool updateMuscleClip);
 
         extern public static AnimationCurve GetEditorCurve([NotNull] AnimationClip clip, EditorCurveBinding binding);
@@ -225,6 +226,7 @@ internal static void SetEditorCurveNoSync(AnimationClip clip, EditorCurveBinding
             Internal_InvokeOnCurveWasModified(clip, binding, curve != null ? CurveModifiedType.CurveModified : CurveModifiedType.CurveDeleted);
         }
 
+        [NativeThrows]
         extern private static void Internal_SetEditorCurve([NotNull] AnimationClip clip, EditorCurveBinding binding, AnimationCurve curve, bool syncEditorCurves);
 
         extern internal static void SyncEditorCurves([NotNull] AnimationClip clip);

Editor/Mono/Animation/AnimationWindow/AnimationWindowUtility.cs

@@ -826,24 +826,27 @@ public static string GetPropertyGroupName(string propertyName)
 
         public static float GetNextKeyframeTime(AnimationWindowCurve[] curves, float currentTime, float frameRate)
         {
-            float candidate = float.MaxValue;
+            AnimationKeyTime candidateKeyTime = AnimationKeyTime.Frame(int.MaxValue, frameRate);
             AnimationKeyTime time = AnimationKeyTime.Time(currentTime, frameRate);
             AnimationKeyTime nextTime = AnimationKeyTime.Frame(time.frame + 1, frameRate);
-
             bool found = false;
 
             foreach (AnimationWindowCurve curve in curves)
             {
                 foreach (AnimationWindowKeyframe keyframe in curve.m_Keyframes)
                 {
-                    if (keyframe.time < candidate && keyframe.time >= nextTime.time)
+                    AnimationKeyTime keyTime = AnimationKeyTime.Time(keyframe.time, frameRate);
+                    if (keyTime.frame <= candidateKeyTime.frame && keyTime.frame >= nextTime.frame)
                     {
-                        candidate = keyframe.time;
-                        found = true;
+                        if (keyframe.time <= candidateKeyTime.time)
+                        {
+                            candidateKeyTime = keyTime;
+                            found = true;
+                        }
                     }
                 }
             }
-            return found ? candidate : time.time;
+            return found ? candidateKeyTime.time : time.time;
         }
 
         public static float GetPreviousKeyframeTime(AnimationWindowCurve[] curves, float currentTime, float frameRate)

Editor/Mono/Animation/AnimationWindow/CurveEditor.cs

@@ -240,7 +240,16 @@ public CurveWrapper[] animationCurves
                 for (int i = 0; i < m_AnimationCurves.Length; ++i)
                 {
                     m_AnimationCurves[i].listIndex = i;
-                    curveIDToIndexMap.Add(m_AnimationCurves[i].id, i);
+
+                    if (!curveIDToIndexMap.ContainsKey(m_AnimationCurves[i].id))
+                    {
+                        curveIDToIndexMap.Add(m_AnimationCurves[i].id, i);
+                    }
+                    else
+                    {
+                        var binding = m_AnimationCurves[i].binding;
+                        Debug.LogWarning("Mismatching curve: '" + (string.IsNullOrEmpty(binding.path) ? "" : binding.path + " : ") + binding.propertyName + "'");
+                    }
                     m_EnableCurveGroups = m_EnableCurveGroups || (m_AnimationCurves[i].groupId != -1);
                 }
                 SyncDrawOrder();

Editor/Mono/Animation/GameObjectRecorder.bindings.cs

@@ -18,6 +18,7 @@ public struct CurveFilterOptions
         public float scaleError;
         public float floatError;
         public bool keyframeReduction;
+        public bool unrollRotation;
     }
 
     [NativeHeader("Editor/Src/Animation/EditorCurveBinding.bindings.h")]
@@ -28,6 +29,7 @@ public class GameObjectRecorder : Object
     {
         readonly static CurveFilterOptions k_DefaultCurveFilterOptions = new CurveFilterOptions()
         {
+            unrollRotation = true,
             keyframeReduction = true,
             positionError = 0.5f,
             rotationError = 0.5f,

Editor/Mono/Animation/ZoomableArea.cs

@@ -518,6 +518,20 @@ private Rect shownAreaInsideMarginsInternal
             }
         }
 
+        float GetWidthInsideMargins(float widthWithMargins, bool substractSliderWidth = false)
+        {
+            float width = (widthWithMargins < kMinWidth) ? kMinWidth : widthWithMargins;
+            float widthInsideMargins = width - leftmargin - rightmargin - (substractSliderWidth ? (m_VSlider ? styles.visualSliderWidth : 0) : 0);
+            return Mathf.Max(widthInsideMargins, kMinWidth);
+        }
+
+        float GetHeightInsideMargins(float heightWithMargins, bool substractSliderHeight = false)
+        {
+            float height = (heightWithMargins < kMinHeight) ? kMinHeight : heightWithMargins;
+            float heightInsideMargins = height - topmargin - bottommargin - (substractSliderHeight ? (m_HSlider ? styles.visualSliderWidth : 0) : 0);
+            return Mathf.Max(heightInsideMargins, kMinHeight);
+        }
+
         public virtual Bounds drawingBounds
         {
             get
@@ -920,45 +934,38 @@ public void EnforceScaleAndRange()
                 return;
 
             float epsilon = 0.00001f;
+            float minChange = 0.01f;
 
-            if (newArea.width < oldArea.width - epsilon)
-            {
-                float xLerp = Mathf.InverseLerp(oldArea.width, newArea.width, rect.width / m_HScaleMax);
-                newArea = new Rect(
-                    Mathf.Lerp(oldArea.x, newArea.x, xLerp),
-                    newArea.y,
-                    Mathf.Lerp(oldArea.width, newArea.width, xLerp),
-                    newArea.height
-                );
-            }
-            if (newArea.height < oldArea.height - epsilon)
-            {
-                float yLerp = Mathf.InverseLerp(oldArea.height, newArea.height, rect.height / m_VScaleMax);
-                newArea = new Rect(
-                    newArea.x,
-                    Mathf.Lerp(oldArea.y, newArea.y, yLerp),
-                    newArea.width,
-                    Mathf.Lerp(oldArea.height, newArea.height, yLerp)
-                );
-            }
-            if (newArea.width > oldArea.width + epsilon)
+            if (!Mathf.Approximately(newArea.width, oldArea.width))
             {
-                float xLerp = Mathf.InverseLerp(oldArea.width, newArea.width, constrainedHScaleMin);
+                float constrainedValue = newArea.width < oldArea.width - epsilon ? rect.width / m_HScaleMax : constrainedHScaleMin;
+                constrainedValue = GetWidthInsideMargins(constrainedValue, true);
+                float xLerp = Mathf.InverseLerp(oldArea.width, newArea.width, constrainedValue);
+                float newWidth = Mathf.Lerp(oldArea.width, newArea.width, xLerp);
+                float widthChange = Mathf.Abs(newWidth - newArea.width);
                 newArea = new Rect(
-                    Mathf.Lerp(oldArea.x, newArea.x, xLerp),
+                    // only affect the position if there was any significant change in width (the unit is in pixels so technically anything under 0.05f would already be impossible to see)
+                    // this fixes an issue where if width was only different due to rounding issues, position changes are ignored as xLerp comes back 0 (or very nearly 0)
+                    widthChange > minChange ? Mathf.Lerp(oldArea.x, newArea.x, xLerp) : newArea.x,
                     newArea.y,
-                    Mathf.Lerp(oldArea.width, newArea.width, xLerp),
+                    newWidth,
                     newArea.height
                 );
             }
-            if (newArea.height > oldArea.height + epsilon)
+            if (!Mathf.Approximately(newArea.height, oldArea.height))
             {
-                float yLerp = Mathf.InverseLerp(oldArea.height, newArea.height, constrainedVScaleMin);
+                float constrainedValue = newArea.height < oldArea.height - epsilon ? rect.height / m_VScaleMax : constrainedVScaleMin;
+                constrainedValue = GetHeightInsideMargins(constrainedValue, true);
+                float yLerp = Mathf.InverseLerp(oldArea.height, newArea.height, constrainedValue);
+                float newHeight = Mathf.Lerp(oldArea.height, newArea.height, yLerp);
+                float heightChange = Mathf.Abs(newHeight - newArea.height);
                 newArea = new Rect(
                     newArea.x,
-                    Mathf.Lerp(oldArea.y, newArea.y, yLerp),
+                    // only affect the position if there was any significant change in height (the unit is in pixels so technically anything under 0.05f would already be impossible to see)
+                    // this fixes an issue where if height was only different due to rounding issues, position changes are ignored as yLerp comes back 0 (or very nearly 0)
+                    heightChange > minChange ? Mathf.Lerp(oldArea.y, newArea.y, yLerp) : newArea.y,
                     newArea.width,
-                    Mathf.Lerp(oldArea.height, newArea.height, yLerp)
+                    newHeight
                 );
             }
 

Editor/Mono/AssemblyInfo/AssemblyInfo.cs

@@ -109,5 +109,6 @@
 [assembly: InternalsVisibleTo("Unity.2D.Tilemap.Editor")]
 [assembly: InternalsVisibleTo("Unity.2D.Tilemap.EditorTests")]
 [assembly: InternalsVisibleTo("Unity.PackageCleanConsoleTest.Editor")]
+[assembly: InternalsVisibleTo("Unity.SceneTemplate.Editor")]
 
 [assembly: AssemblyIsEditorAssembly]

Editor/Mono/AssetDatabase/AssetMoveInfo.cs

@@ -6,7 +6,7 @@
 
 namespace UnityEditor.Experimental
 {
-    internal struct AssetMoveInfo : IEquatable<AssetMoveInfo>
+    public struct AssetMoveInfo : IEquatable<AssetMoveInfo>
     {
         public AssetMoveInfo(string sourceAssetPath, string destinationAssetPath)
         {

Editor/Mono/AssetDatabase/AssetsModifiedProcessor.cs

@@ -7,9 +7,9 @@
 
 namespace UnityEditor.Experimental
 {
-    internal abstract class AssetsModifiedProcessor
+    public abstract class AssetsModifiedProcessor
     {
-        internal HashSet<string> assetsReportedChanged { get; set; }
+        public HashSet<string> assetsReportedChanged { get; set; }
 
         protected void ReportAssetChanged(string assetChanged)
         {

Editor/Mono/BuildPipeline/DesktopStandalonePostProcessor.cs

@@ -386,8 +386,8 @@ private static void CreateApplicationData(BuildPostProcessArgs args)
 
     protected bool CopyPlayerFilter(string path, BuildPostProcessArgs args)
     {
-        // Don't copy UnityEngine mdb files
-        return Path.GetExtension(path) != ".mdb" || !Path.GetFileName(path).StartsWith("UnityEngine.");
+        // Don't copy UnityEngine mdb/pdb files
+        return (Path.GetExtension(path) != ".mdb"  && Path.GetExtension(path)  != ".pdb") || !Path.GetFileName(path).StartsWith("UnityEngine.");
     }
 
     private static uint StringToFourCC(string literal)
@@ -409,21 +409,6 @@ protected string GetVariationFolder(BuildPostProcessArgs args) =>
 
     protected static void RecordCommonFiles(BuildPostProcessArgs args, string variationSourceFolder, string monoFolderRoot)
     {
-        // Mark all the managed DLLs in Data/Managed as engine API assemblies
-        // Data/Managed may already contain managed DLLs in the UnityEngine.*.dll naming scheme from the extensions
-        // So we find the files in the source Variations directory and mark the corresponding files in the output
-        var path = Path.Combine(variationSourceFolder, "Data/Managed");
-        foreach (var file in Directory.GetFiles(path, "*.dll")
-                 .Concat(Directory.GetFiles(path, "*.pdb")))
-        {
-            var filename = Path.GetFileName(file);
-            if (!filename.StartsWith("UnityEngine"))
-                continue;
-
-            var targetFilePath = Path.Combine(args.stagingArea, "Data/Managed/" + filename);
-            args.report.RecordFileAdded(targetFilePath, CommonRoles.managedEngineApi);
-        }
-
         // Mark the default resources file
         args.report.RecordFileAdded(Path.Combine(args.stagingArea, "Data/Resources/unity default resources"),
             CommonRoles.builtInResources);

Editor/Mono/BuildPipeline/Il2Cpp/IL2CPPUtils.cs

@@ -368,6 +368,10 @@ public void RunCompileAndLink()
                 var compilerConfiguration = PlayerSettings.GetIl2CppCompilerConfiguration(buildTargetGroup);
                 var arguments = Il2CppNativeCodeBuilderUtils.AddBuilderArguments(il2CppNativeCodeBuilder, OutputFileRelativePath(), m_PlatformProvider.includePaths, m_PlatformProvider.libraryPaths, compilerConfiguration).ToList();
 
+                var additionalArgs = IL2CPPUtils.GetAdditionalArguments();
+                if (!string.IsNullOrEmpty(additionalArgs))
+                    arguments.Add(additionalArgs);
+
                 arguments.Add($"--map-file-parser={CommandLineFormatter.PrepareFileName(GetMapFileParserPath())}");
                 arguments.Add($"--generatedcppdir={CommandLineFormatter.PrepareFileName(Path.GetFullPath(GetCppOutputDirectoryInStagingArea()))}");
                 arguments.Add(string.Format("--dotnetprofile=\"{0}\"", IL2CPPUtils.ApiCompatibilityLevelToDotNetProfileArgument(PlayerSettings.GetApiCompatibilityLevel(buildTargetGroup))));