Unity 6000.0.0b13 C# reference source code

Author: Unity Technologies

Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9Importer.cs

@@ -30,23 +30,16 @@ public class SpeedTree9Importer : ScriptedImporter
         internal static class ImporterSettings
         {
             internal const string kGameObjectName = "SpeedTree";
-            internal const string kHDRPShaderName = "HDRP/Nature/SpeedTree9_HDRP";
-            internal const string kURPShaderName = "Universal Render Pipeline/Nature/SpeedTree9_URP";
             internal const string kLegacyShaderName = "Nature/SpeedTree9";
             internal const string kWindAssetName = "SpeedTreeWind";
-            internal const string kSRPDependencyName = "srp/default-pipeline";
+            internal const string kSRPDependencyName = "SpeedTree9Importer_DefaultShader";
             internal const string kMaterialSettingsDependencyname = "SpeedTree9Importer_MaterialSettings";
-
-            // In some very specific scenarios, the Shader cannot be found using "Shader.Find" (e.g project upgrade).
-            // Adding an extra-security is necessary to avoid that, by manually forcing the load of the Shader using
-            // "AssetDatabase.LoadAssetAtPath". It only happens for SRPs during project upgrades.
-            internal const string kHDRPShaderPath = "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Nature/SpeedTree9_HDRP.shadergraph";
-            internal const string kURPShaderPath = "Packages/com.unity.render-pipelines.universal/Shaders/Nature/SpeedTree9_URP.shadergraph";
+            internal const string kIconName = "UnityEditor/SpeedTree9Importer Icon";
         }
 
         private static class Styles
         {
-            internal static readonly Texture2D kIcon = EditorGUIUtility.FindTexture("UnityEditor/SpeedTree9Importer Icon");
+            internal static readonly Texture2D kIcon = EditorGUIUtility.FindTexture(ImporterSettings.kIconName);
         }
 
         private struct STMeshGeometry
@@ -118,12 +111,15 @@ public STMeshGeometry(int vertexCount, int UVCount, int indexLod)
         [SerializeField]
         internal SpeedTreeImporterOutputData m_OutputImporterData;
 
+        private static ulong s_DefaultShaderHash;
+        private static readonly TimeSpan k_CheckDependencyFrequency = TimeSpan.FromSeconds(5);
+        private static DateTime s_LastCheck;
+
         // Cache main objects, created during import process.
         private AssetImportContext m_Context;
         private SpeedTree9Reader m_Tree;
         private Shader m_Shader;
         private SpeedTreeWindAsset m_WindAsset;
-        private STRenderPipeline m_RenderPipeline;
 
         // Values cached at the begining of the import process.
         private bool m_HasFacingData;
@@ -157,11 +153,9 @@ public override void OnImportAsset(AssetImportContext ctx)
 
             CacheTreeImporterValues(ctx.assetPath);
 
-            m_RenderPipeline = GetCurrentRenderPipelineType();
-
             ctx.DependsOnCustomDependency(ImporterSettings.kSRPDependencyName);
 
-            if (!TryGetShaderForCurrentRenderPipeline(m_RenderPipeline, out m_Shader))
+            if (!TryGetShaderForCurrentRenderPipeline(out m_Shader))
             {
                 ctx.LogImportError("SpeedTree9 shader is invalid, cannot create Materials for this SpeedTree asset.");
                 return;
@@ -273,6 +267,61 @@ internal void RegenerateMaterials()
             }
         }
 
+        [InitializeOnLoadMethod]
+        static void InitializeEditorCallback()
+        {
+            EditorApplication.update += DirtyCustomDependencies;
+            s_DefaultShaderHash = ComputeDefaultShaderHash();
+            AssetDatabase.RegisterCustomDependency(ImporterSettings.kSRPDependencyName, new Hash128(s_DefaultShaderHash, 0));
+        }
+
+
+        static ulong CombineHash(ulong h1, ulong h2)
+        {
+            unchecked
+            {
+                return h1 ^ h2 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2); // Similar to c++ boost::hash_combine
+            }
+        }
+
+        static ulong ComputeDefaultShaderHash()
+        {
+            ulong newDefaultShaderHash = 0UL;
+            if (GraphicsSettings.currentRenderPipeline == null || GraphicsSettings.currentRenderPipeline.defaultSpeedTree9Shader == null)
+            {
+                newDefaultShaderHash = 0;
+            }
+            else
+            {
+                if (AssetDatabase.TryGetGUIDAndLocalFileIdentifier(GraphicsSettings.currentRenderPipeline.defaultSpeedTree9Shader, out var guid,
+                        out long fileId))
+                {
+                    newDefaultShaderHash = CombineHash((ulong)guid.GetHashCode(), (ulong)fileId);
+                }
+            }
+
+            return newDefaultShaderHash;
+        }
+
+        static void DirtyCustomDependencies()
+        {
+            DateTime now = DateTime.Now;
+            if (Application.isPlaying || now - s_LastCheck < k_CheckDependencyFrequency)
+            {
+                return;
+            }
+
+            s_LastCheck = now;
+
+            ulong newDefaultShaderHash = ComputeDefaultShaderHash();
+            if (s_DefaultShaderHash != newDefaultShaderHash)
+            {
+                s_DefaultShaderHash = newDefaultShaderHash;
+                AssetDatabase.RegisterCustomDependency(ImporterSettings.kSRPDependencyName, new Hash128(s_DefaultShaderHash, 0));
+                AssetDatabase.Refresh();
+            }
+        }
+
         #region Mesh Geometry & Renderers
         private Mesh CreateMeshAndGeometry(Lod lod, int lodIndex)
         {
@@ -717,9 +766,7 @@ private void RegenerateAndPopulateExternalMaterials(string assetPath)
 
             CacheTreeImporterValues(assetPath);
 
-            m_RenderPipeline = GetCurrentRenderPipelineType();
-
-            if (!TryGetShaderForCurrentRenderPipeline(m_RenderPipeline, out m_Shader))
+            if (!TryGetShaderForCurrentRenderPipeline(out m_Shader))
             {
                 Debug.LogError("SpeedTree9 shader is invalid, cannot create Materials for this SpeedTree asset.");
                 return;
@@ -999,22 +1046,24 @@ private void SetMaterialOtherProperties(STMaterial stMaterial, Material mat)
             }
             mat.SetFloat(MaterialProperties.LeafFacingKwToggleID, m_HasFacingData ? 1.0f : 0.0f);
 
-            if (m_RenderPipeline == STRenderPipeline.HDRP)
-            {
+            if (mat.HasFloat(MaterialProperties.DoubleSidedToggleID))
                 mat.SetFloat(MaterialProperties.DoubleSidedToggleID, stMaterial.TwoSided ? 1.0f : 0.0f);
+
+            if (mat.HasFloat(MaterialProperties.DoubleSidedNormalModeID))
                 mat.SetFloat(MaterialProperties.DoubleSidedNormalModeID, stMaterial.FlipNormalsOnBackside ? 0.0f : 2.0f);
 
+            if (mat.HasVector(MaterialProperties.DiffusionProfileAssetID))
                 mat.SetVector(MaterialProperties.DiffusionProfileAssetID, m_MaterialSettings.diffusionProfileAssetID);
+
+            if (mat.HasFloat(MaterialProperties.DiffusionProfileID))
                 mat.SetFloat(MaterialProperties.DiffusionProfileID, m_MaterialSettings.diffusionProfileID);
-            }
-            else if (m_RenderPipeline == STRenderPipeline.URP)
-            {
+
+            if (mat.HasFloat(MaterialProperties.BackfaceNormalModeID))
                 mat.SetFloat(MaterialProperties.BackfaceNormalModeID, stMaterial.FlipNormalsOnBackside ? 0.0f : 2.0f);
-            }
-            else // legacy rendering pipeline
-            {
+
+            if (mat.HasFloat(MaterialProperties.TwoSidedID))
                 mat.SetFloat(MaterialProperties.TwoSidedID, stMaterial.TwoSided ? 0.0f : 2.0f); // matches cull mode. 0: no cull
-            }
+
             mat.enableInstancing = true;
             mat.doubleSidedGI = stMaterial.TwoSided;
         }
@@ -1108,20 +1157,6 @@ internal string GetMaterialFolderPath()
             return FileUtil.DeleteLastPathNameComponent(assetPath) + "/";
         }
 
-        internal string GetShaderNameFromPipeline(STRenderPipeline renderPipeline)
-        {
-            switch (renderPipeline)
-            {
-                case STRenderPipeline.HDRP:
-                    return ImporterSettings.kHDRPShaderName;
-                case STRenderPipeline.URP:
-                    return ImporterSettings.kURPShaderName;
-                case STRenderPipeline.Legacy:
-                default:
-                    return ImporterSettings.kLegacyShaderName;
-            }
-        }
-
         internal void SetMaterialsVersionToCurrent()
         {
             m_MaterialVersion = SPEEDTREE_9_MATERIAL_VERSION;
@@ -1353,27 +1388,17 @@ private bool TreeHasFacingData()
             return false;
         }
 
-        private bool TryGetShaderForCurrentRenderPipeline(STRenderPipeline renderPipeline, out Shader shader)
+        internal static bool TryGetShaderForCurrentRenderPipeline(out Shader shader)
         {
-            switch (renderPipeline)
+            shader = null;
+            if (GraphicsSettings.currentRenderPipeline != null)
             {
-                case STRenderPipeline.URP:
-                    shader = Shader.Find(ImporterSettings.kURPShaderName);
-                    if (shader == null)
-                    {
-                        shader = m_Context.GetReferenceToAssetMainObject(ImporterSettings.kURPShaderPath) as Shader;
-                    }
-                    break;
-                case STRenderPipeline.HDRP:
-                    shader = Shader.Find(ImporterSettings.kHDRPShaderName);
-                    if (shader == null)
-                    {
-                        shader = m_Context.GetReferenceToAssetMainObject(ImporterSettings.kHDRPShaderPath) as Shader;
-                    }
-                    break;
-                default:
-                    shader = Shader.Find(ImporterSettings.kLegacyShaderName);
-                    break;
+                shader = GraphicsSettings.currentRenderPipeline.defaultSpeedTree9Shader;
+            }
+
+            if (shader == null)
+            {
+                shader = Shader.Find(ImporterSettings.kLegacyShaderName);
             }
 
             return shader != null;

Editor/Mono/AssetPipeline/SpeedTree/SpeedTree9ImporterModelEditor.cs

@@ -280,14 +280,19 @@ internal bool DoMaterialsHaveDifferentShader()
                 importerArray.Add(importer);
             }
 
-            var renderPipeline = SpeedTreeImporterCommon.GetCurrentRenderPipelineType();
+            string defaultShaderName = String.Empty;
+            if (TryGetShaderForCurrentRenderPipeline(out var shader))
+            {
+                defaultShaderName = shader.name;
+            }
+            else
+            {
+                Debug.LogWarning("SpeedTree9 shader is invalid, cannot create Materials for this SpeedTree asset.");
+            }
 
             // In tests assetTargets can become null
             for (int i = 0; i < Math.Min(importerArray.Count, prefabs?.Length ?? 0); ++i)
             {
-                var im = importerArray[i];
-                var defaultShaderName = im.GetShaderNameFromPipeline(renderPipeline);
-
                 foreach (var mr in prefabs[i].transform.GetComponentsInChildren<MeshRenderer>())
                 {
                     foreach (var mat in mr.sharedMaterials)

Editor/Mono/AssetPipeline/SpeedTree/SpeedTreeImporterCommon.cs

@@ -20,13 +20,6 @@ class SpeedTreeConstants
 
     static class SpeedTreeImporterCommon
     {
-        internal enum STRenderPipeline
-        {
-            Legacy,
-            URP,
-            HDRP
-        }
-
         internal enum STUnitConversion
         {
             kLeaveAsIs = 0,
@@ -84,41 +77,6 @@ internal static class MaterialKeywords
             internal static readonly string VBSetupID = "VB_SETUP";
             internal static readonly string BillboardID = "_BILLBOARD";
         }
-
-        internal static STRenderPipeline GetCurrentRenderPipelineType()
-        {
-            var renderPipelineAsset = GraphicsSettings.renderPipelineAsset;
-            if (renderPipelineAsset != null)
-            {
-                if (renderPipelineAsset.name.Contains("UniversalRP") ||
-                    renderPipelineAsset.name.Contains("URP"))
-                {
-                    return STRenderPipeline.URP;
-                }
-                else if (renderPipelineAsset.name.Contains("HDRenderPipeline") ||
-                         renderPipelineAsset.name.Contains("HDRP"))
-                {
-                    return STRenderPipeline.HDRP;
-                }
-            }
-
-            renderPipelineAsset = QualitySettings.renderPipeline;
-            if (renderPipelineAsset != null)
-            {
-                if (renderPipelineAsset.name.Contains("UniversalRP") ||
-                    renderPipelineAsset.name.Contains("URP"))
-                {
-                    return STRenderPipeline.URP;
-                }
-                else if (renderPipelineAsset.name.Contains("HDRenderPipeline") ||
-                         renderPipelineAsset.name.Contains("HDRP"))
-                {
-                    return STRenderPipeline.HDRP;
-                }
-            }
-
-            return STRenderPipeline.Legacy;
-        }
     }
 
     static class SpeedTreeImporterCommonEditor

Editor/Mono/GUI/Toolbars/EditorToolbar.cs

@@ -18,11 +18,6 @@ sealed class EditorToolbar
         public const string elementLabelClassName = elementClassName + "__label";
         public const string elementTextIconClassName = elementClassName + "__text-icon";
 
-        static readonly string[] k_DeprecatedElements = new[]
-        {
-            "SceneView/Snap Increment"
-        };
-
         string[] m_ToolbarElements;
         readonly EditorWindow m_Context;
         VisualElement m_RootVisualElement;
@@ -81,10 +76,6 @@ static bool TryCreateElement(string id, EditorWindow ctx, out VisualElement ve)
                 return true;
             }
 
-            if(Array.IndexOf(k_DeprecatedElements, id) < 0)
-                Debug.LogError($"Failed to load EditorToolbar ID '{id}' for window '{ctx}'. "
-                    + "No element with that ID and target toolbar was registered using the EditorToolbarElement attribute.");
-
             return false;
         }
     }

Editor/Mono/ImportSettings/IHVImageFormatImporterInspector.cs

@@ -31,8 +31,8 @@ internal class Styles
             public static readonly GUIContent sRGBTexture   = EditorGUIUtility.TrTextContent("sRGB (Color Texture)", "Texture content is stored in gamma space. Non-HDR color textures should enable this flag (except if used for IMGUI).");
             public static readonly GUIContent wrapMode      = EditorGUIUtility.TrTextContent("Wrap Mode");
             public static readonly GUIContent filterMode    = EditorGUIUtility.TrTextContent("Filter Mode");
-            public static readonly GUIContent streamingMipmaps = EditorGUIUtility.TrTextContent("Streaming Mipmaps", "Only load larger mipmaps as needed to render the current game cameras.");
-            public static readonly GUIContent streamingMipmapsPriority = EditorGUIUtility.TrTextContent("Mip Map Priority", "Mip map streaming priority when there's contention for resources. Positive numbers represent higher priority. Valid range is -128 to 127.");
+            public static readonly GUIContent streamingMipmaps = EditorGUIUtility.TrTextContent("Stream Mipmap Levels", "Only load larger mipmap levels as needed to render the current game cameras.");
+            public static readonly GUIContent streamingMipmapsPriority = EditorGUIUtility.TrTextContent("Priority", "Mipmap streaming priority when there's contention for resources. Positive numbers represent higher priority. Valid range is -128 to 127.");
 
             public static readonly int[] filterModeValues           =
             { (int)FilterMode.Point, (int)FilterMode.Bilinear, (int)FilterMode.Trilinear };