Unity 6000.1.0b1 C# reference source code

Author: Unity Technologies

Editor/Mono/2D/SpriteAtlas/EditorSpriteAtlas.bindings.cs

@@ -7,6 +7,7 @@
 using UnityEngine.U2D;
 using UnityEngine.Bindings;
 using System;
+using UnityEditor.AssetImporters;
 
 namespace UnityEditor.U2D
 {
@@ -100,6 +101,12 @@ public static class SpriteAtlasExtensions
         extern public static void Remove([NotNull] this SpriteAtlas spriteAtlas, UnityEngine.Object[] objects);
         extern internal static void RemoveAt([NotNull] this SpriteAtlas spriteAtlas, int index);
         extern public static UnityEngine.Object[] GetPackables([NotNull] this SpriteAtlas spriteAtlas);
+        extern internal static void SetV2([NotNull] this SpriteAtlas spriteAtlas);
+        internal static void RegisterAndPackAtlas(this SpriteAtlas spriteAtlas, AssetImportContext context, AssetImporter importer, U2D.ScriptablePacker scriptablePacker)
+        {
+            RegisterAndPackAtlasInternal(spriteAtlas, context, importer, scriptablePacker);
+        }
+        extern private static void RegisterAndPackAtlasInternal([NotNull] this SpriteAtlas spriteAtlas, [NotNull] AssetImportContext context, [NotNull] AssetImporter importer, UnityEngine.Object scriptablePacker);
         extern public static SpriteAtlasTextureSettings GetTextureSettings([NotNull] this SpriteAtlas spriteAtlas);
         extern public static void SetTextureSettings([NotNull] this SpriteAtlas spriteAtlas, SpriteAtlasTextureSettings src);
         extern public static SpriteAtlasPackingSettings GetPackingSettings([NotNull] this SpriteAtlas spriteAtlas);

Editor/Mono/2D/SpriteAtlas/SpriteAtlasInspector.cs

@@ -132,6 +132,7 @@ private enum AtlasType { Undefined = -1, Master = 0, Variant = 1 }
         private string m_Hash;
         private int m_PreviewPage = 0;
         private int m_TotalPages = 0;
+        const float kPrefixLabelWidth = 290f;
         private int[] m_OptionValues = null;
         private string[] m_OptionDisplays = null;
         private Texture2D[] m_PreviewTextures = null;
@@ -194,6 +195,17 @@ bool AllTargetsAreMaster()
 
         void OnEnable()
         {
+            if (targets == null)
+                return;
+            var validCount = 0;
+            foreach (var so in targets)
+            {
+                if (so != null)
+                    validCount++;
+            }
+            if (validCount == 0)
+                return;
+
             m_FilterMode = serializedObject.FindProperty("m_EditorData.textureSettings.filterMode");
             m_AnisoLevel = serializedObject.FindProperty("m_EditorData.textureSettings.anisoLevel");
             m_GenerateMipMaps = serializedObject.FindProperty("m_EditorData.textureSettings.generateMipMaps");
@@ -353,6 +365,9 @@ public override void OnInspectorGUI()
 
             serializedObject.Update();
 
+            var oldWidth = EditorGUIUtility.labelWidth;
+            EditorGUIUtility.labelWidth = kPrefixLabelWidth;
+
             HandleCommonSettingUI();
 
             GUILayout.Space(EditorGUI.kSpacing);
@@ -374,22 +389,25 @@ public override void OnInspectorGUI()
             if (targets.Length == 1 && AllTargetsAreMaster())
                 HandlePackableListUI();
 
-            bool spriteAtlasPackignEnabled = (EditorSettings.spritePackerMode == SpritePackerMode.BuildTimeOnlyAtlas
+            bool spriteAtlasPackingEnabled = (EditorSettings.spritePackerMode == SpritePackerMode.BuildTimeOnlyAtlas
                 || EditorSettings.spritePackerMode == SpritePackerMode.AlwaysOnAtlas || EditorSettings.spritePackerMode == SpritePackerMode.SpriteAtlasV2);
-            if (spriteAtlasPackignEnabled && !Application.isPlaying)
+            if (spriteAtlasPackingEnabled && !Application.isPlaying)
             {
-                if (GUILayout.Button(styles.packButton, GUILayout.ExpandWidth(false)))
+                using (new EditorGUI.DisabledScope(!Editor.IsPersistent(spriteAtlas)))
                 {
-                    SpriteAtlas[] spriteAtlases = new SpriteAtlas[targets.Length];
-                    for (int i = 0; i < spriteAtlases.Length; ++i)
-                        spriteAtlases[i] = (SpriteAtlas)targets[i];
+                    if (GUILayout.Button(styles.packButton, GUILayout.ExpandWidth(false)))
+                    {
+                        SpriteAtlas[] spriteAtlases = new SpriteAtlas[targets.Length];
+                        for (int i = 0; i < spriteAtlases.Length; ++i)
+                            spriteAtlases[i] = (SpriteAtlas)targets[i];
 
-                    SpriteAtlasUtility.PackAtlases(spriteAtlases, EditorUserBuildSettings.activeBuildTarget);
+                        SpriteAtlasUtility.PackAtlases(spriteAtlases, EditorUserBuildSettings.activeBuildTarget);
 
-                    // Packing an atlas might change platform settings in the process, reinitialize
-                    SyncPlatformSettings();
+                        // Packing an atlas might change platform settings in the process, reinitialize
+                        SyncPlatformSettings();
 
-                    GUIUtility.ExitGUI();
+                        GUIUtility.ExitGUI();
+                    }
                 }
             }
             else
@@ -400,6 +418,7 @@ public override void OnInspectorGUI()
                 }
             }
 
+            EditorGUIUtility.labelWidth = oldWidth;
             serializedObject.ApplyModifiedProperties();
         }
 
@@ -413,7 +432,10 @@ private void HandleCommonSettingUI()
 
             EditorGUI.BeginChangeCheck();
             EditorGUI.showMixedValue = atlasType == AtlasType.Undefined;
-            atlasType = (AtlasType)EditorGUILayout.IntPopup(styles.atlasTypeLabel, (int)atlasType, styles.atlasTypeOptions, styles.atlasTypeValues);
+            using (new EditorGUI.DisabledScope(!Editor.IsPersistent(spriteAtlas)))
+            {
+                atlasType = (AtlasType)EditorGUILayout.IntPopup(styles.atlasTypeLabel, (int)atlasType, styles.atlasTypeOptions, styles.atlasTypeValues);
+            }
             EditorGUI.showMixedValue = false;
             if (EditorGUI.EndChangeCheck())
             {

Editor/Mono/Animation/MaterialAnimationUtility.cs

@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using UnityEditor;
 using UnityEngine;
+using ShaderPropertyType = UnityEngine.Rendering.ShaderPropertyType;
 using Object = UnityEngine.Object;
 
 namespace UnityEditorInternal
@@ -81,21 +82,21 @@ static public bool OverridePropertyColor(MaterialProperty materialProp, Renderer
             var propertyPaths = new List<string>();
             string basePropertyPath = kMaterialPrefix + materialProp.name;
 
-            if (materialProp.type == MaterialProperty.PropType.Texture)
+            if (materialProp.propertyType == ShaderPropertyType.Texture)
             {
                 propertyPaths.Add(basePropertyPath + "_ST.x");
                 propertyPaths.Add(basePropertyPath + "_ST.y");
                 propertyPaths.Add(basePropertyPath + "_ST.z");
                 propertyPaths.Add(basePropertyPath + "_ST.w");
             }
-            else if (materialProp.type == MaterialProperty.PropType.Color)
+            else if (materialProp.propertyType == ShaderPropertyType.Color)
             {
                 propertyPaths.Add(basePropertyPath + ".r");
                 propertyPaths.Add(basePropertyPath + ".g");
                 propertyPaths.Add(basePropertyPath + ".b");
                 propertyPaths.Add(basePropertyPath + ".a");
             }
-            else if (materialProp.type == MaterialProperty.PropType.Vector)
+            else if (materialProp.propertyType == ShaderPropertyType.Vector)
             {
                 propertyPaths.Add(basePropertyPath + ".x");
                 propertyPaths.Add(basePropertyPath + ".y");
@@ -138,31 +139,31 @@ static public void TearDownMaterialPropertyBlock(Renderer target)
         static public bool ApplyMaterialModificationToAnimationRecording(MaterialProperty materialProp, int changedMask, Renderer target, object oldValue)
         {
             bool applied = false;
-            switch (materialProp.type)
+            switch (materialProp.propertyType)
             {
-                case MaterialProperty.PropType.Color:
+                case ShaderPropertyType.Color:
                     SetupMaterialPropertyBlock(materialProp, changedMask, target);
                     applied = ApplyMaterialModificationToAnimationRecording(MaterialPropertyToPropertyModifications(materialProp, target, (Color)oldValue), MaterialPropertyToPropertyModifications(materialProp, target, materialProp.colorValue));
                     if (!applied)
                         TearDownMaterialPropertyBlock(target);
                     return applied;
 
-                case MaterialProperty.PropType.Vector:
+                case ShaderPropertyType.Vector:
                     SetupMaterialPropertyBlock(materialProp, changedMask, target);
                     applied = ApplyMaterialModificationToAnimationRecording(MaterialPropertyToPropertyModifications(materialProp, target, (Vector4)oldValue), MaterialPropertyToPropertyModifications(materialProp, target, materialProp.vectorValue));
                     if (!applied)
                         TearDownMaterialPropertyBlock(target);
                     return applied;
 
-                case MaterialProperty.PropType.Float:
-                case MaterialProperty.PropType.Range:
+                case ShaderPropertyType.Float:
+                case ShaderPropertyType.Range:
                     SetupMaterialPropertyBlock(materialProp, changedMask, target);
                     applied = ApplyMaterialModificationToAnimationRecording(MaterialPropertyToPropertyModifications(materialProp, target, (float)oldValue), MaterialPropertyToPropertyModifications(materialProp, target, materialProp.floatValue));
                     if (!applied)
                         TearDownMaterialPropertyBlock(target);
                     return applied;
 
-                case MaterialProperty.PropType.Texture:
+                case ShaderPropertyType.Texture:
                 {
                     if (MaterialProperty.IsTextureOffsetAndScaleChangedMask(changedMask))
                     {
@@ -183,17 +184,17 @@ static public bool ApplyMaterialModificationToAnimationRecording(MaterialPropert
 
         static public PropertyModification[] MaterialPropertyToPropertyModifications(MaterialProperty materialProp, Renderer target)
         {
-            switch (materialProp.type)
+            switch (materialProp.propertyType)
             {
-                case MaterialProperty.PropType.Color:
+                case ShaderPropertyType.Color:
                     return MaterialPropertyToPropertyModifications(materialProp, target, materialProp.colorValue);
-                case MaterialProperty.PropType.Vector:
+                case ShaderPropertyType.Vector:
                     return MaterialPropertyToPropertyModifications(materialProp, target, materialProp.vectorValue);
-                case MaterialProperty.PropType.Float:
-                case MaterialProperty.PropType.Range:
+                case ShaderPropertyType.Float:
+                case ShaderPropertyType.Range:
                     return MaterialPropertyToPropertyModifications(materialProp, target, materialProp.floatValue);
 
-                case MaterialProperty.PropType.Texture:
+                case ShaderPropertyType.Texture:
                 {
                     string name = materialProp.name + "_ST";
                     return MaterialPropertyToPropertyModifications(name, target, materialProp.vectorValue);

Editor/Mono/AssemblyInfo/AssemblyInfo.cs

@@ -61,6 +61,7 @@
 [assembly: InternalsVisibleTo("UnityEditor.CloudRendering.Extensions")]
 [assembly: InternalsVisibleTo("UnityEditor.EmbeddedLinux.Extensions")]
 [assembly: InternalsVisibleTo("UnityEditor.QNX.Extensions")]
+[assembly: InternalsVisibleTo("UnityEditor.Kepler.Extensions")]
 [assembly: InternalsVisibleTo("UnityEditor.WindowsStandalone.Extensions")]
 [assembly: InternalsVisibleTo("UnityEditor.OSXStandalone.Extensions")]
 [assembly: InternalsVisibleTo("UnityEditor.Lumin.Extensions")]
@@ -176,3 +177,5 @@
 [assembly: InternalsVisibleTo("Unity.Automation.Players.EmbeddedLinux")]
 [assembly: InternalsVisibleTo("Unity.Automation.Players.QNX")]
 
+[assembly: InternalsVisibleTo("Unity.GraphToolsAuthoringFramework.InternalEditorBridge")]
+

Editor/Mono/AssetPipeline/TextureImporterEnums.cs

@@ -3,6 +3,7 @@
 // https://unity3d.com/legal/licenses/Unity_Reference_Only_License
 
 using System;
+using System.ComponentModel;
 using UnityEngine.Scripting;
 
 namespace UnityEditor
@@ -119,13 +120,22 @@ public enum TextureImporterFormat
         DXT5Crunched = 29,
 
         // PowerVR (iPhone) 2 bits/pixel compressed color texture format.
+        [System.Obsolete("Texture compression format PVRTC has been deprecated and will be removed in a future release")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
         PVRTC_RGB2 = 30,
         // PowerVR (iPhone) 2 bits/pixel compressed with alpha channel texture format.
+        [System.Obsolete("Texture compression format PVRTC has been deprecated and will be removed in a future release")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
         PVRTC_RGBA2 = 31,
         // PowerVR (iPhone) 4 bits/pixel compressed color texture format.
+        [System.Obsolete("Texture compression format PVRTC has been deprecated and will be removed in a future release")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
         PVRTC_RGB4 = 32,
         // PowerVR (iPhone) 4 bits/pixel compressed with alpha channel texture format.
+        [System.Obsolete("Texture compression format PVRTC has been deprecated and will be removed in a future release")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
         PVRTC_RGBA4 = 33,
+
         // ETC (GLES2.0) 4 bits/pixel compressed RGB texture format.
         ETC_RGB4 = 34,
 

Editor/Mono/BuildPipeline/BuildPipelineInterfaces.cs

@@ -13,6 +13,7 @@
 using UnityEngine.Scripting;
 using UnityEditor.AssetImporters;
 using UnityEngine.SceneManagement;
+using UnityEditor.Build.Profile;
 
 namespace UnityEditor.Build
 {
@@ -161,6 +162,7 @@ internal class Processors
 
             public List<IPreprocessBuildWithReport> buildPreprocessorsWithReport;
             public List<IPostprocessBuildWithReport> buildPostprocessorsWithReport;
+            public List<IPostprocessLaunch> launchPostprocessors;
             public List<IProcessSceneWithReport> sceneProcessorsWithReport;
 
             public List<IFilterBuildAssemblies> filterBuildAssembliesProcessor;
@@ -506,6 +508,14 @@ internal static void OnBuildPreProcess(BuildReport report)
                 processors.buildPreprocessorsWithReport, bpp => bpp.OnPreprocessBuild(report),
                 (report.summary.options & BuildOptions.StrictMode) != 0 || (report.summary.assetBundleOptions & BuildAssetBundleOptions.StrictMode) != 0);
 #pragma warning restore 618
+
+            // NOTE: This is a workaround for PLAT-11795.
+            // Sometimes, when a player settings override is modified in one of the callbacks, its internal
+            // serialized version is not updated prior to the build. As a result it will be restored to the
+            // serialized values. To avoid that situation we force the update here.
+            var profile = BuildProfile.GetActiveBuildProfile();
+            if (profile != null)
+                profile.SerializePlayerSettings();
         }
 
         [RequiredByNativeCode]
@@ -572,6 +582,50 @@ internal static void OnBuildPostProcess(BuildReport report)
 #pragma warning restore 618
         }
 
+
+        // Some platforms like Desktop, instead of launching the app via C#, perform their launch in C++
+        // See BuildPlayer.cpp LaunchPlayerIfSupported, which calls native LaunchApplication
+        // Internal_OnPostprocessLaunch is used by this code path
+        [RequiredByNativeCode]
+        internal static void Internal_OnPostprocessLaunch(BuildTarget buildTarget, bool success)
+        {
+            OnPostprocessLaunch(new DefaultLaunchReport(NamedBuildTarget.FromActiveSettings(buildTarget), success ? LaunchResult.Succeeded : LaunchResult.Failed));
+        }
+
+        internal static void OnPostprocessLaunch(ILaunchReport launchReport)
+        {
+            // Domain reload happens after player build, so anything collected in InitializeBuildCallbacks gets invalidated
+            // Thus collect callbacks here as necessary
+            if (processors.launchPostprocessors == null)
+            {
+                foreach (var t in TypeCache.GetTypesDerivedFrom<IPostprocessLaunch>())
+                {
+                    if (t.IsAbstract || t.IsInterface)
+                        continue;
+
+                    object instance = null;
+                    AddToListIfTypeImplementsInterface(t, ref instance, ref processors.launchPostprocessors);
+                }
+
+                processors?.launchPostprocessors?.Sort(CompareICallbackOrder);
+            }
+
+            if (processors.launchPostprocessors == null)
+                return;
+
+            foreach (var run in processors.launchPostprocessors)
+            {
+                try
+                {
+                    run.OnPostprocessLaunch(launchReport);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e);
+                }
+            }
+        }
+
         [RequiredByNativeCode]
         internal static void OnActiveBuildTargetChanged(BuildTarget previousPlatform, BuildTarget newPlatform)
         {

Editor/Mono/BuildPipeline/DesktopStandalonePostProcessor.cs

@@ -48,9 +48,10 @@ public override void UpdateBootConfig(BuildTarget target, BootConfigData config,
             config.Set("capture-startup-logs", "1");
     }
 
-    public override void LaunchPlayer(BuildLaunchPlayerArgs args)
+    public override ILaunchReport LaunchPlayer(BuildLaunchPlayerArgs args)
     {
         // This happens directly from BuildPlayer.cpp
+        return null;
     }
 
     readonly bool m_HasMonoPlayers;

Editor/Mono/BuildPipeline/IPostprocessLaunch.cs

@@ -0,0 +1,41 @@
+// Unity C# reference source
+// Copyright (c) Unity Technologies. For terms of use, see
+// https://unity3d.com/legal/licenses/Unity_Reference_Only_License
+
+namespace UnityEditor.Build
+{
+    public enum LaunchResult
+    {
+        Unknown = 0,
+        Succeeded = 1,
+        // For ex., when running on multiple Android devices, some succeeded, some didn't
+        PartiallySucceeded = 2,
+        Failed = 3
+    }
+
+    public interface ILaunchReport
+    {
+        public NamedBuildTarget buildTarget { get; }
+
+        public LaunchResult result { get; }
+    }
+
+    // Unity will provide DefaultLaunchReport for OnPostprocessLaunch callback if platform doesn't provide its own launch report
+    public class DefaultLaunchReport : ILaunchReport
+    {
+        public NamedBuildTarget buildTarget { get; }
+
+        public LaunchResult result { get; }
+
+        internal DefaultLaunchReport(NamedBuildTarget buildTarget, LaunchResult result)
+        {
+            this.buildTarget = buildTarget;
+            this.result = result;
+        }
+    }
+
+    public interface IPostprocessLaunch : IOrderedCallback
+    {
+        void OnPostprocessLaunch(ILaunchReport launchReport);
+    }
+}