[2021.2] [ShaderGraph] URP Uber Shader

TestProjects/ShaderGraph/Assets/CommonAssets/Editor/KeywordTests.cs

@@ -195,11 +195,7 @@ public void CanGetKeywordDeclarationForReals()
             var sb =  new ShaderStringBuilder();
             foreach (var keyword in m_Collector.keywords)
             {
-                string declaration = keyword.GetKeywordDeclarationString();
-                if(!string.IsNullOrEmpty(declaration))
-                {
-                    sb.AppendLine(declaration);
-                }
+                keyword.AppendKeywordDeclarationStrings(sb);
             }
 
             Assert.AreEqual(kExpectedForRealsDeclaration.Replace("\r\n", "\n"), sb.ToString(), "Keyword declaration snippet for final shader was invalid");

TestProjects/ShaderGraph/Assets/CommonAssets/Editor/PropertyTests.cs

@@ -154,6 +154,7 @@ public IEnumerator RemoveInputTests()
             var menuItems = m_BlackboardTestController.addBlackboardItemsMenu.GetPrivateProperty<IList>("menuItems");
             Assert.IsNotNull(menuItems, "Could not retrieve reference to the menu items of the Blackboard Add Items menu");
 
+            // invoke all menu items on the "add Blackboard Items Menu" to add all property types
             foreach (var item in menuItems)
             {
                 var menuFunction = item.GetNonPrivateField<GenericMenu.MenuFunction>("func");

TestProjects/ShaderGraph/SaveLoadGraphs/SimpleWithSubGraph.shadergraph

@@ -1124,7 +1124,7 @@
     },
     "m_Name": "A",
     "m_DefaultReferenceName": "Vector1_e29cd19dafd54a1dbd31dcf1d75c21b2",
-    "m_OverrideReferenceName": "a_3_4_d__",
+    "m_OverrideReferenceName": "a_3_4_d_",
     "m_GeneratePropertyBlock": true,
     "m_Precision": 0,
     "m_GPUInstanced": false,

com.unity.render-pipelines.high-definition/Editor/AssetProcessors/MaterialPostProcessor.cs

@@ -342,7 +342,7 @@ static void ShaderGraphStack(Material material, HDShaderUtils.ShaderID id)
         {
             Shader shader = material.shader;
 
-            if (shader.IsShaderGraph())
+            if (shader.IsShaderGraphAsset())
             {
                 if (shader.TryGetMetadataOfType<HDMetadata>(out var obj))
                 {
@@ -375,7 +375,7 @@ static void ShaderGraphStack(Material material, HDShaderUtils.ShaderID id)
 
         static void MoreMaterialSurfaceOptionFromShaderGraph(Material material, HDShaderUtils.ShaderID id)
         {
-            if (material.shader.IsShaderGraph())
+            if (material.IsShaderGraph())
             {
                 // Synchronize properties we exposed from SG to the material
                 ResetFloatProperty(kReceivesSSR);

com.unity.render-pipelines.high-definition/Editor/Material/Lit/LitShaderPreprocessor.cs

@@ -33,7 +33,7 @@ protected override bool DoShadersStripper(HDRenderPipelineAsset hdrpAsset, Shade
             // Cache Shader Graph lookup data so we don't continually keep reloading graphs from disk.
             // TODO: Should really be able to answer the questions "is shader graph" and "uses HDLitMasterNode" without
             //       hitting disk on every invoke.
-            if (shader.IsShaderGraph())
+            if (shader.IsShaderGraphAsset())
             {
                 if (shader.TryGetMetadataOfType<HDMetadata>(out var obj))
                 {

com.unity.render-pipelines.high-definition/Editor/Material/UIBlocks/SurfaceOptionUIBlock.cs

@@ -433,7 +433,7 @@ protected override void OnGUIOpen()
             DrawLitSurfaceOptions();
         }
 
-        bool AreMaterialsShaderGraphs() => materials.All(m => m.shader.IsShaderGraph());
+        bool AreMaterialsShaderGraphs() => materials.All(m => m.IsShaderGraph());
 
         /// <summary>Returns false if there are multiple materials selected and they have different default values for propName</summary>
         float GetShaderDefaultFloatValue(string propName)

com.unity.render-pipelines.high-definition/Editor/Material/UIBlocks/TransparencyUIBlock.cs

@@ -71,9 +71,9 @@ protected override bool showSection
                     return false;
 
                 // If refraction model is not enabled in SG, we don't show the section
-                var shader = materials[0].shader;
-                if (shader.IsShaderGraph())
+                if (materials[0].IsShaderGraph())
                 {
+                    var shader = materials[0].shader;
                     var defaultRefractionModel = shader.GetPropertyDefaultFloatValue(shader.FindPropertyIndex(kRefractionModel));
                     if (defaultRefractionModel == 0)
                         return false;

com.unity.render-pipelines.high-definition/Editor/Material/Unlit/BaseUnlitGUI.cs

@@ -297,7 +297,7 @@ public static void SetupMainTexForAlphaTestGI(this Material material, string col
 
         static public void SetupBaseUnlitPass(this Material material)
         {
-            if (material.shader.IsShaderGraph())
+            if (material.IsShaderGraph())
             {
                 // Shader graph generate distortion pass only if required. So we can safely enable it
                 // all the time here.
@@ -360,7 +360,7 @@ static public void SetupBaseUnlitPass(this Material material)
 
             // Shader graphs materials have their own management of motion vector pass in the material inspector
             // (see DrawMotionVectorToggle())
-            if (!material.shader.IsShaderGraph())
+            if (!material.IsShaderGraph())
             {
                 //In the case of additional velocity data we will enable the motion vector pass.
                 bool addPrecomputedVelocity = false;

com.unity.render-pipelines.high-definition/Editor/RenderPipeline/HDShaderUtils.cs

@@ -124,7 +124,7 @@ internal static bool IsHDRPShader(Shader shader, bool upgradable = false)
             if (shader == null)
                 return false;
 
-            if (shader.IsShaderGraph())
+            if (shader.IsShaderGraphAsset())
             {
                 // All HDRP shader graphs should have HD metadata
                 return shader.TryGetMetadataOfType<HDMetadata>(out _);
@@ -140,7 +140,7 @@ internal static bool IsUnlitHDRPShader(Shader shader)
             if (shader == null)
                 return false;
 
-            if (shader.IsShaderGraph())
+            if (shader.IsShaderGraphAsset())
             {
                 // Throw exception if no metadata is found
                 // This case should be handled by the Target
@@ -168,7 +168,7 @@ internal static string GetShaderPath(ShaderID id)
 
         internal static ShaderID GetShaderEnumFromShader(Shader shader)
         {
-            if (shader.IsShaderGraph())
+            if (shader.IsShaderGraphAsset())
             {
                 // Throw exception if no metadata is found
                 // This case should be handled by the Target

com.unity.render-pipelines.universal/CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ### Changed
 - Moved fog evaluation from vertex shader to pixel shader. This improves rendering of fog for big triangles and fog quality. This can change the look of the fog slightly.
 - UNITY_Z_0_FAR_FROM_CLIPSPACE now remaps to [0, far] range on all platforms consistently. Previously OpenGL platforms did not remap, discarding small amount of range [-near, 0].
+- Added "Allow Material Override" option to Lit and Unlit ShaderGraph targets.  When checked, allows Material to control the surface options (transparent/opaque, blend mode, etc).
 
 ### Added
 - Added View Vector node to mimic old behavior of View Direction node in URP.

com.unity.render-pipelines.universal/Editor/AssetPostProcessors/MaterialPostprocessor.cs

@@ -2,8 +2,10 @@
 using System.Collections.Generic;
 using System.Linq;
 using UnityEditor.Rendering.Universal.ShaderGUI;
+using UnityEditor.ShaderGraph;
 using UnityEngine;
 using UnityEngine.Rendering.Universal;
+using static Unity.Rendering.Universal.ShaderUtils;
 
 namespace UnityEditor.Rendering.Universal
 {
@@ -89,7 +91,7 @@ class MaterialPostprocessor : AssetPostprocessor
         internal static List<string> s_ImportedAssetThatNeedSaving = new List<string>();
         internal static bool s_NeedsSavingAssets = false;
 
-        internal static readonly Action<Material, ShaderPathID>[] k_Upgraders = { UpgradeV1, UpgradeV2, UpgradeV3, UpgradeV4 };
+        internal static readonly Action<Material, ShaderID>[] k_Upgraders = { UpgradeV1, UpgradeV2, UpgradeV3, UpgradeV4 };
 
         static internal void SaveAssetsToDisk()
         {
@@ -119,23 +121,28 @@ static internal void SaveAssetsToDisk()
 
         static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
         {
-            var upgradeLog = "UniversalRP Material log:";
+            string upgradeLog = "";
             var upgradeCount = 0;
 
             foreach (var asset in importedAssets)
             {
+                // we only care about materials
                 if (!asset.EndsWith(".mat", StringComparison.InvariantCultureIgnoreCase))
                     continue;
 
+                // load the material and look for it's Universal ShaderID
+                // we only care about versioning materials using a known Universal ShaderID
+                // this skips any materials that only target other render pipelines, are user shaders,
+                // or are shaders we don't care to version
                 var material = (Material)AssetDatabase.LoadAssetAtPath(asset, typeof(Material));
-                if (!ShaderUtils.IsLWShader(material.shader))
+                var shaderID = GetShaderID(material.shader);
+                if (shaderID == ShaderID.Unknown)
                     continue;
 
-                ShaderPathID id = ShaderUtils.GetEnumFromPath(material.shader.name);
                 var wasUpgraded = false;
+                var debug = "\n" + material.name + "(" + shaderID + ")";
 
-                var debug = "\n" + material.name;
-
+                // look for the Universal AssetVersion
                 AssetVersion assetVersion = null;
                 var allAssets = AssetDatabase.LoadAllAssetsAtPath(asset);
                 foreach (var subAsset in allAssets)
@@ -154,13 +161,23 @@ static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAsse
                     {
                         assetVersion.version = k_Upgraders.Length;
                         s_CreatedAssets.Remove(asset);
-                        InitializeLatest(material, id);
+                        InitializeLatest(material, shaderID);
                         debug += " initialized.";
                     }
                     else
                     {
-                        assetVersion.version = UniversalProjectSettings.materialVersionForUpgrade;
-                        debug += $" assumed to be version {UniversalProjectSettings.materialVersionForUpgrade} due to missing version.";
+                        if (shaderID.IsShaderGraph())
+                        {
+                            // ShaderGraph materials NEVER had asset versioning applied prior to version 5.
+                            // so if we see a ShaderGraph material with no assetVersion, set it to 4 to ensure we apply all necessary versions.
+                            assetVersion.version = 4;
+                            debug += $" shadergraph material assumed to be version 4 due to missing version.";
+                        }
+                        else
+                        {
+                            assetVersion.version = UniversalProjectSettings.materialVersionForUpgrade;
+                            debug += $" assumed to be version {UniversalProjectSettings.materialVersionForUpgrade} due to missing version.";
+                        }
                     }
 
                     assetVersion.hideFlags = HideFlags.HideInHierarchy | HideFlags.HideInInspector | HideFlags.NotEditable;
@@ -169,7 +186,7 @@ static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAsse
 
                 while (assetVersion.version < k_Upgraders.Length)
                 {
-                    k_Upgraders[assetVersion.version](material, id);
+                    k_Upgraders[assetVersion.version](material, shaderID);
                     debug += $" upgrading:v{assetVersion.version} to v{assetVersion.version + 1}";
                     assetVersion.version++;
                     wasUpgraded = true;
@@ -184,62 +201,77 @@ static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAsse
                     s_NeedsSavingAssets = true;
                 }
             }
+
+            // Uncomment to show upgrade debug logs
+            //if (!string.IsNullOrEmpty(upgradeLog))
+            //    Debug.Log("UniversalRP Material log: " + upgradeLog);
         }
 
-        static void InitializeLatest(Material material, ShaderPathID id)
+        static void InitializeLatest(Material material, ShaderID id)
         {
+            // newly created materials should reset their keywords immediately (in case inspector doesn't get invoked)
+            Unity.Rendering.Universal.ShaderUtils.ResetMaterialKeywords(material, id);
         }
 
-        static void UpgradeV1(Material material, ShaderPathID shaderID)
+        static void UpgradeV1(Material material, ShaderID shaderID)
         {
-            var shaderPath = ShaderUtils.GetShaderPath(shaderID);
+            if (shaderID.IsShaderGraph())
+                return;
+
+            var shaderPath = ShaderUtils.GetShaderPath((ShaderPathID)shaderID);
             var upgradeFlag = MaterialUpgrader.UpgradeFlags.LogMessageWhenNoUpgraderFound;
 
             switch (shaderID)
             {
-                case ShaderPathID.Unlit:
+                case ShaderID.Unlit:
                     MaterialUpgrader.Upgrade(material, new UnlitUpdaterV1(shaderPath), upgradeFlag);
                     UnlitShader.SetMaterialKeywords(material);
                     break;
-                case ShaderPathID.SimpleLit:
+                case ShaderID.SimpleLit:
                     MaterialUpgrader.Upgrade(material, new SimpleLitUpdaterV1(shaderPath), upgradeFlag);
                     SimpleLitShader.SetMaterialKeywords(material, SimpleLitGUI.SetMaterialKeywords);
                     break;
-                case ShaderPathID.Lit:
+                case ShaderID.Lit:
                     MaterialUpgrader.Upgrade(material, new LitUpdaterV1(shaderPath), upgradeFlag);
                     LitShader.SetMaterialKeywords(material, LitGUI.SetMaterialKeywords);
                     break;
-                case ShaderPathID.ParticlesLit:
+                case ShaderID.ParticlesLit:
                     MaterialUpgrader.Upgrade(material, new ParticleUpdaterV1(shaderPath), upgradeFlag);
                     ParticlesLitShader.SetMaterialKeywords(material, LitGUI.SetMaterialKeywords, ParticleGUI.SetMaterialKeywords);
                     break;
-                case ShaderPathID.ParticlesSimpleLit:
+                case ShaderID.ParticlesSimpleLit:
                     MaterialUpgrader.Upgrade(material, new ParticleUpdaterV1(shaderPath), upgradeFlag);
                     ParticlesSimpleLitShader.SetMaterialKeywords(material, SimpleLitGUI.SetMaterialKeywords, ParticleGUI.SetMaterialKeywords);
                     break;
-                case ShaderPathID.ParticlesUnlit:
+                case ShaderID.ParticlesUnlit:
                     MaterialUpgrader.Upgrade(material, new ParticleUpdaterV1(shaderPath), upgradeFlag);
                     ParticlesUnlitShader.SetMaterialKeywords(material, null, ParticleGUI.SetMaterialKeywords);
                     break;
             }
         }
 
-        static void UpgradeV2(Material material, ShaderPathID shaderID)
+        static void UpgradeV2(Material material, ShaderID shaderID)
         {
+            if (shaderID.IsShaderGraph())
+                return;
+
             // fix 50 offset on shaders
             if (material.HasProperty("_QueueOffset"))
                 BaseShaderGUI.SetupMaterialBlendMode(material);
         }
 
-        static void UpgradeV3(Material material, ShaderPathID shaderID)
+        static void UpgradeV3(Material material, ShaderID shaderID)
         {
+            if (shaderID.IsShaderGraph())
+                return;
+
             switch (shaderID)
             {
-                case ShaderPathID.Lit:
-                case ShaderPathID.SimpleLit:
-                case ShaderPathID.ParticlesLit:
-                case ShaderPathID.ParticlesSimpleLit:
-                case ShaderPathID.ParticlesUnlit:
+                case ShaderID.Lit:
+                case ShaderID.SimpleLit:
+                case ShaderID.ParticlesLit:
+                case ShaderID.ParticlesSimpleLit:
+                case ShaderID.ParticlesUnlit:
                     var propertyID = Shader.PropertyToID("_EmissionColor");
                     if (material.HasProperty(propertyID))
                     {
@@ -254,8 +286,9 @@ static void UpgradeV3(Material material, ShaderPathID shaderID)
             }
         }
 
-        static void UpgradeV4(Material material, ShaderPathID shaderID)
-        {}
+        static void UpgradeV4(Material material, ShaderID shaderID)
+        {
+        }
     }
 
     // Upgraders v1