Unity 2023.1.0a23 C# reference source code

Author: Unity Technologies

Editor/Mono/AssetStore/AssetStoreWindow.cs

@@ -13,9 +13,6 @@ namespace UnityEditor
     [EditorWindowTitle(title = "Asset Store", icon = "Asset Store")]
     internal class AssetStoreWindow : EditorWindow
     {
-        // Use this for initialization
-        // Index at 1499 because "Package Manager" is 1500, pairing tools for user to get external content
-        [MenuItem("Window/Asset Store", false, 1499)]
         public static AssetStoreWindow Init()
         {
             if (EditorPrefs.GetBool("AlwaysOpenAssetStoreInBrowser", false))
@@ -32,14 +29,21 @@ public static AssetStoreWindow Init()
             }
         }
 
-        private static void OpenAssetStoreInBrowser()
+        [MenuItem("Window/Asset Store", false, 1497)]
+        public static void OpenAssetStoreInBrowser()
         {
             string assetStoreUrl = UnityConnect.instance.GetConfigurationURL(CloudConfigUrl.CloudAssetStoreUrl);
-            if (UnityEditor.Connect.UnityConnect.instance.loggedIn)
-                UnityEditor.Connect.UnityConnect.instance.OpenAuthorizedURLInWebBrowser(assetStoreUrl);
+            if (UnityConnect.instance.loggedIn)
+                UnityConnect.instance.OpenAuthorizedURLInWebBrowser(assetStoreUrl);
             else Application.OpenURL(assetStoreUrl);
         }
 
+        [MenuItem("Window/My Assets", false, 1498)]
+        public static void OpenMyAssetsInPackageManager()
+        {
+            PackageManagerWindow.SelectPackageAndFilterStatic(string.Empty, PackageManager.UI.Internal.PackageFilterTab.AssetStore);
+        }
+
         public void OnEnable()
         {
             this.antiAliasing = 4;

Editor/Mono/BuildPipeline/NamedBuildTarget.cs

@@ -41,6 +41,7 @@ namespace UnityEditor.Build
         public static readonly NamedBuildTarget WebGL = new NamedBuildTarget("WebGL");
         public static readonly NamedBuildTarget WindowsStoreApps = new NamedBuildTarget("Windows Store Apps");
         public static readonly NamedBuildTarget PS4 = new NamedBuildTarget("PS4");
+        public static readonly NamedBuildTarget PS5 = new NamedBuildTarget("PS5");
         public static readonly NamedBuildTarget XboxOne = new NamedBuildTarget("XboxOne");
         public static readonly NamedBuildTarget tvOS = new NamedBuildTarget("tvOS");
         public static readonly NamedBuildTarget NintendoSwitch = new NamedBuildTarget("Nintendo Switch");

Editor/Mono/CustomEditorAttributes.cs

@@ -212,11 +212,13 @@ static bool TryGatherRenderPipelineTypes([DisallowNull] Type type, [DisallowNull
                 }
             }
 
+#pragma warning disable CS0618
             if (inspectAttr is CustomEditorForRenderPipelineAttribute attr)
             {
                 results = new[] { attr.renderPipelineType };
                 return true;
             }
+#pragma warning restore CS0618
 
             results = null;
             return true;

Editor/Mono/Inspector/AssemblyDefinitionImporterInspector.cs

@@ -306,6 +306,7 @@ internal interface IToolModeOwner
         bool ModeSurvivesSelectionChange(int toolMode);
     }
 
+    [Obsolete(@"CustomEditorForRenderPipelineAttribute is deprecated. Use CustomEditor with SupportedOnCurrentPipeline instead. #from(2023.1)", false)]
     [AttributeUsage(AttributeTargets.Class)]
     public class CustomEditorForRenderPipelineAttribute : CustomEditor
     {

Editor/Mono/Inspector/Editor.cs

@@ -195,6 +195,7 @@ class SettingsContent
             public static readonly GUIContent requireAEP = EditorGUIUtility.TrTextContent("Require ES3.1+AEP");
             public static readonly GUIContent require32 = EditorGUIUtility.TrTextContent("Require ES3.2");
             public static readonly GUIContent skinOnGPU = EditorGUIUtility.TrTextContent("GPU Skinning*", "Calculate mesh skinning and blend shapes on the GPU via shaders");
+            public static readonly GUIContent[] meshDeformations = { EditorGUIUtility.TrTextContent("CPU"), EditorGUIUtility.TrTextContent("GPU"), EditorGUIUtility.TrTextContent("GPU (Batched)") };
             public static readonly GUIContent scriptingDefineSymbols = EditorGUIUtility.TrTextContent("Scripting Define Symbols", "Preprocessor defines passed to the C# script compiler.");
             public static readonly GUIContent additionalCompilerArguments = EditorGUIUtility.TrTextContent("Additional Compiler Arguments", "Additional arguments passed to the C# script compiler.");
             public static readonly GUIContent scriptingDefineSymbolsApply = EditorGUIUtility.TrTextContent("Apply");
@@ -258,28 +259,30 @@ class SettingsContent
             public static readonly GUIContent allowHDRDisplay = EditorGUIUtility.TrTextContent("Allow HDR Display Output*", "Checks if the display supports HDR and if it does, switches to HDR output at the start of the application.");
             public static readonly GUIContent hdrOutputRequireHDRRenderingWarning = EditorGUIUtility.TrTextContent("The active Render Pipeline does not have HDR enabled. Enable HDR in the Render Pipeline Asset to see the changes.");
 
-            public static string undoChangedBatchingString { get { return LocalizationDatabase.GetLocalizedString("Changed Batching Settings"); } }
-            public static string undoChangedGraphicsAPIString { get { return LocalizationDatabase.GetLocalizedString("Changed Graphics API Settings"); } }
-            public static string undoChangedScriptingDefineString { get { return LocalizationDatabase.GetLocalizedString("Changed Scripting Define Settings"); } }
-            public static string undoChangedGraphicsJobsString { get { return LocalizationDatabase.GetLocalizedString("Changed Graphics Jobs Setting"); } }
-            public static string undoChangedGraphicsJobModeString { get { return LocalizationDatabase.GetLocalizedString("Changed Graphics Job Mode Setting"); } }
-            public static string changeColorSpaceString { get { return LocalizationDatabase.GetLocalizedString("Changing the color space may take a significant amount of time."); } }
-            public static string undoChangedPlatformShaderChunkSizeString { get { return LocalizationDatabase.GetLocalizedString("Changed Shader Chunk Size Platform Setting"); } }
-            public static string undoChangedPlatformShaderChunkCountString { get { return LocalizationDatabase.GetLocalizedString("Changed Shader Chunk Count Platform Setting"); } }
-            public static string undoChangedDefaultShaderChunkSizeString { get { return LocalizationDatabase.GetLocalizedString("Changed Shader Chunk Size Default Setting"); } }
-            public static string undoChangedDefaultShaderChunkCountString { get { return LocalizationDatabase.GetLocalizedString("Changed Shader Chunk Count Default Setting"); } }
+            public static readonly string undoChangedBatchingString                 = L10n.Tr("Changed Batching Settings");
+            public static readonly string undoChangedGraphicsAPIString              = L10n.Tr("Changed Graphics API Settings");
+            public static readonly string undoChangedScriptingDefineString          = L10n.Tr("Changed Scripting Define Settings");
+            public static readonly string undoChangedGraphicsJobsString             = L10n.Tr("Changed Graphics Jobs Setting");
+            public static readonly string undoChangedGraphicsJobModeString          = L10n.Tr("Changed Graphics Job Mode Setting");
+            public static readonly string changeColorSpaceString                    = L10n.Tr("Changing the color space may take a significant amount of time.");
+            public static readonly string undoChangedPlatformShaderChunkSizeString  = L10n.Tr("Changed Shader Chunk Size Platform Setting");
+            public static readonly string undoChangedPlatformShaderChunkCountString = L10n.Tr("Changed Shader Chunk Count Platform Setting");
+            public static readonly string undoChangedDefaultShaderChunkSizeString   = L10n.Tr("Changed Shader Chunk Size Default Setting");
+            public static readonly string undoChangedDefaultShaderChunkCountString  = L10n.Tr("Changed Shader Chunk Count Default Setting");
         }
 
         class RecompileReason
         {
-            public static readonly string scriptingDefineSymbolsModified = "Scripting define symbols setting modified";
-            public static readonly string suppressCommonWarningsModified = "Suppress common warnings setting modified";
-            public static readonly string allowUnsafeCodeModified = "Allow 'unsafe' code setting modified";
-            public static readonly string apiCompatibilityLevelModified = "API Compatibility level modified";
-            public static readonly string editorAssembliesCompatibilityLevelModified = "Editor Assemblies Compatibility level modified";
-            public static readonly string useDeterministicCompilationModified = "Use deterministic compilation modified";
-            public static readonly string additionalCompilerArgumentsModified = "Additional compiler arguments modified";
-            public static readonly string activeBuildTargetGroupModified = "Active build target group modified";
+            public static readonly string scriptingDefineSymbolsModified             = L10n.Tr("Scripting define symbols setting modified");
+            public static readonly string suppressCommonWarningsModified             = L10n.Tr("Suppress common warnings setting modified");
+            public static readonly string allowUnsafeCodeModified                    = L10n.Tr("Allow 'unsafe' code setting modified");
+            public static readonly string apiCompatibilityLevelModified              = L10n.Tr("API Compatibility level modified");
+            public static readonly string editorAssembliesCompatibilityLevelModified = L10n.Tr("Editor Assemblies Compatibility level modified");
+            public static readonly string useDeterministicCompilationModified        = L10n.Tr("Use deterministic compilation modified");
+            public static readonly string additionalCompilerArgumentsModified        = L10n.Tr("Additional compiler arguments modified");
+            public static readonly string activeBuildTargetGroupModified             = L10n.Tr("Active build target group modified");
+
+            public static readonly string presetChanged = L10n.Tr("Preset changed");
         }
 
         PlayerSettingsSplashScreenEditor m_SplashScreenEditor;
@@ -306,6 +309,7 @@ PlayerSettingsIconsEditor iconsEditor
 
         private static GraphicsJobMode[] m_GfxJobModeValues = new GraphicsJobMode[] { GraphicsJobMode.Native, GraphicsJobMode.Legacy };
         private static GUIContent[] m_GfxJobModeNames = new GUIContent[] { EditorGUIUtility.TrTextContent("Native"), EditorGUIUtility.TrTextContent("Legacy") };
+        private static MeshDeformation[] m_MeshDeformations = { MeshDeformation.CPU, MeshDeformation.GPU, MeshDeformation.GPUBatched };
 
         // Section and tab selection state
 
@@ -423,6 +427,7 @@ PlayerSettingsIconsEditor iconsEditor
         SerializedProperty m_CaptureSingleScreen;
 
         SerializedProperty m_SkinOnGPU;
+        SerializedProperty m_MeshDeformation;
 
         SerializedProperty m_EnableLoadStoreDebugMode;
 
@@ -640,6 +645,7 @@ void OnEnable()
             m_VisibleInBackground              = FindPropertyAssert("visibleInBackground");
             m_AllowFullscreenSwitch            = FindPropertyAssert("allowFullscreenSwitch");
             m_SkinOnGPU                        = FindPropertyAssert("gpuSkinning");
+            m_MeshDeformation                  = FindPropertyAssert("meshDeformation");
             m_ForceSingleInstance              = FindPropertyAssert("forceSingleInstance");
             m_UseFlipModelSwapchain            = FindPropertyAssert("useFlipModelSwapchain");
 
@@ -927,6 +933,11 @@ public override void OnInspectorGUI()
 
             if (hasPresetWindowClosed)
             {
+                // We recompile after the window is closed just to make sure all the values are set/shown correctly.
+                // There might be a smarter idea where you detect the values that have changed and only do it if it's required,
+                // but the way the Preset window applies those changes as well as the way IMGUI works makes it difficult to track.
+                SetReason(RecompileReason.presetChanged);
+
                 OnPresetSelectorClosed();
             }
             else if (HasReasonToCompile())
@@ -1997,11 +2008,43 @@ private void OtherSectionRenderingGUI(BuildPlatform platform, ISettingEditorExte
             // GPU Skinning toggle (only show on relevant platforms)
             if (!BuildTargetDiscovery.PlatformHasFlag(platform.defaultTarget, TargetAttributes.GPUSkinningNotSupported))
             {
-                EditorGUI.BeginChangeCheck();
-                EditorGUILayout.PropertyField(m_SkinOnGPU, SettingsContent.skinOnGPU);
-                if (EditorGUI.EndChangeCheck())
+                /// Adding support to other platforms in progress...
+                bool platformSupportsBatching =
+                    platform.namedBuildTarget == NamedBuildTarget.NintendoSwitch ||
+                    platform.namedBuildTarget == NamedBuildTarget.PS5;
+
+                if (platformSupportsBatching)
+                {
+                    MeshDeformation currentDeformation = (MeshDeformation)m_MeshDeformation.intValue;
+
+                    EditorGUI.BeginChangeCheck();
+                    MeshDeformation newDeformation = BuildEnumPopup(SettingsContent.skinOnGPU, currentDeformation, m_MeshDeformations, SettingsContent.meshDeformations);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        m_SkinOnGPU.boolValue = newDeformation != MeshDeformation.CPU;
+                        m_MeshDeformation.intValue = (int)newDeformation;
+                        serializedObject.ApplyModifiedProperties();
+                        ShaderUtil.RecreateSkinnedMeshResources();
+                    }
+                }
+                else
                 {
-                    ShaderUtil.RecreateSkinnedMeshResources();
+                    // Use the original checkbox UI but preserve underlying batching mode whenever possible.
+                    // We need to do this because gpuSkinning/meshDeformation are properties which are shared between all platforms
+                    // and if the user sets gpuSkinning mode to "enabled", we actually want to preserve "batchEnabled" if it was set for other platforms.
+                    // Platforms that do not support batching but have meshDeformation == GPUBatched just silently use original non-batched code.
+                    EditorGUI.BeginChangeCheck();
+                    EditorGUILayout.PropertyField(m_SkinOnGPU, SettingsContent.skinOnGPU);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        // Preserve the value of m_MeshDeformation when possible.
+                        if (!m_SkinOnGPU.boolValue)
+                            m_MeshDeformation.intValue = (int)MeshDeformation.CPU;
+                        else
+                            m_MeshDeformation.intValue = m_MeshDeformation.intValue != (int)MeshDeformation.CPU ? m_MeshDeformation.intValue : (int)MeshDeformation.GPUBatched;
+                        serializedObject.ApplyModifiedProperties();
+                        ShaderUtil.RecreateSkinnedMeshResources();
+                    }
                 }
             }
 
@@ -2031,7 +2074,7 @@ private void OtherSectionRenderingGUI(BuildPlatform platform, ISettingEditorExte
                 PlayerSettings.SetGraphicsJobModeForPlatform(platform.defaultTarget, newGfxJobMode);
                 graphicsJobsModeOptionEnabled = false;
             }
-            else if (platform.namedBuildTarget == new NamedBuildTarget("PS5"))
+            else if (platform.namedBuildTarget == NamedBuildTarget.PS5)
             {
                 // On PS5NGGC, we only have kGfxJobModeNative so we disable the options in that case
                 GraphicsDeviceType[] gfxAPIs = PlayerSettings.GetGraphicsAPIs(platform.defaultTarget);

Editor/Mono/Inspector/PlayerSettingsEditor/PlayerSettingsEditor.cs

@@ -2,6 +2,8 @@
 // Copyright (c) Unity Technologies. For terms of use, see
 // https://unity3d.com/legal/licenses/Unity_Reference_Only_License
 
+using System;
+using Unity.IntegerTime;
 using UnityEngine;
 
 namespace UnityEditor
@@ -17,31 +19,60 @@ class Content
             public static readonly GUIContent maxParticleTimestepLabel = EditorGUIUtility.TrTextContent("Maximum Particle Timestep", "The maximum frame delta time Unity permits for a single iteration of the Particle System update. If the delta time is larger than this value, Unity will run the Particle System update multiple times during the frame with smaller timesteps. This preserves the quality of the simulation.");
         }
 
-        SerializedProperty m_FixedTimestepProperty;
+        SerializedProperty m_FixedTimestepCountProperty;
         SerializedProperty m_MaxAllowedTimestepProperty;
         SerializedProperty m_TimeScaleProperty;
         SerializedProperty m_MaxParticleTimestepProperty;
 
+        static RationalTime.TicksPerSecond m_FixedTimeTicksPerSecond;
+        const float MinFixedTimeStep = 0.0001f;
+
         public void OnEnable()
         {
-            m_FixedTimestepProperty = serializedObject.FindProperty("Fixed Timestep");
+            var fixedTimestepProperty = serializedObject.FindProperty("Fixed Timestep");
+            m_FixedTimestepCountProperty = fixedTimestepProperty.FindPropertyRelative("m_Count");
             m_MaxAllowedTimestepProperty = serializedObject.FindProperty("Maximum Allowed Timestep");
             m_TimeScaleProperty = serializedObject.FindProperty("m_TimeScale");
             m_MaxParticleTimestepProperty = serializedObject.FindProperty("Maximum Particle Timestep");
+
+            if (!m_FixedTimeTicksPerSecond.Valid) // FixedTime has a constant ticks per second value
+            {
+                var numerator = fixedTimestepProperty.FindPropertyRelative("m_Rate.m_Numerator");
+                var denominator = fixedTimestepProperty.FindPropertyRelative("m_Rate.m_Denominator");
+                m_FixedTimeTicksPerSecond =
+                    new RationalTime.TicksPerSecond(numerator.uintValue, denominator.uintValue);
+            }
         }
 
         public override void OnInspectorGUI()
         {
             serializedObject.Update();
 
-            EditorGUILayout.PropertyField(m_FixedTimestepProperty, Content.fixedTimestepLabel);
+            DrawFixedTimeAsFloat(m_FixedTimestepCountProperty);
             EditorGUILayout.PropertyField(m_MaxAllowedTimestepProperty, Content.maxAllowedTimestepLabel);
             EditorGUILayout.PropertyField(m_TimeScaleProperty, Content.timeScaleLabel);
             EditorGUILayout.PropertyField(m_MaxParticleTimestepProperty, Content.maxParticleTimestepLabel);
 
             serializedObject.ApplyModifiedProperties();
         }
 
+        static void DrawFixedTimeAsFloat(SerializedProperty prop)
+        {
+            var fixedTime = (float)new RationalTime(prop.longValue, m_FixedTimeTicksPerSecond).ToDouble(); // Convert a tick count to a float
+            using (var c = new EditorGUI.ChangeCheckScope())
+            {
+                fixedTime = EditorGUILayout.FloatField(Content.fixedTimestepLabel, fixedTime);
+                if (c.changed)
+                {
+                    var newCount = RationalTime
+                        .FromDouble(MathF.Max(fixedTime, MinFixedTimeStep), m_FixedTimeTicksPerSecond)
+                        .Count; // convert it back to a count to store in the property
+                    prop.longValue = newCount;
+                }
+            }
+        }
+
+
         [SettingsProvider]
         internal static SettingsProvider CreateProjectSettingsProvider()
         {