[ShaderGraph] [Backport 10.3] Fix texture associated state (samplerstate, TexelSize) for subgraphs, CFNs (#2577)

* Add ST to texture params

* Working with Universal / Texture2D (but not CFN yet)

* CustomFunctionNode Texture2D working, allows full bare/non-bare selection of types, warns when using bare output types

* Started on Cubemap/Array/3D

* Partial fixes fore 3d/array/cubemap

* Fix for texelSize node

* Texture2D nodes all working

* Fixes for cubemap nodes, Texture2DArray nodes, Texture3d nodes

* Fix for HDRP

* Fixes for GLES2

* Fixes for NormalFromTextureNode, Texture2dAssetNode

* Added SamplerState handling, cleaned up code to remove macro usage

* Fix for ParallaxOcclusionMappingNode

* Fix for NormalFromTextureNode, cleanup, adding changelog

* Fix for old Texture2DArray and Texture3D inputs to CustomFunctionNodes

* Fix for ParallaxMapping and Triplanar nodes handling of SamplerState types

* Cleanup, removing unused code and _ST values (for now)

* Fix samplerstates on SampleRawCubemap and SampleTexture2DLOD nodes

* Fix for VFX support, additional cleanup

* Fix for decals

* Fix for tests

* Fix VFX path generation issues with textures

* Improved backwards compatibility, added graphics tests, addressing feedback

* Fix for GLES2 compilation

* Fix for OpenGL Core

* Adding GLCore support for LOAD_TEXTURE3D and LOAD_TEXTURE3D_LOD

* Fix for consoles

* Disallow creating v0 of custom function node (which will upgrade incorrectly when saved/loaded)

Author: Chris Tchou

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

@@ -1,6 +1,7 @@
 using NUnit.Framework;
 using System.Collections;
 using System.IO;
+using System.Linq;
 using UnityEditor.Graphing.Util;
 using UnityEditor.ShaderGraph.Serialization;
 using UnityEngine;
@@ -10,63 +11,116 @@ namespace UnityEditor.ShaderGraph.UnitTests
     [TestFixture]
     class ImportUpdateTests
     {
-        public class ImportCases : IEnumerable
+        public class SingleImportCases : IEnumerable
         {
             private const string kGraphsLocation = "PreviousGraphVersions/";
             public IEnumerator GetEnumerator()
             {
-                return Directory.GetFiles(Application.dataPath + "/../" + kGraphsLocation, "*", SearchOption.AllDirectories).GetEnumerator();
+                var versionDirs =  Directory.GetDirectories(Application.dataPath + "/../" + kGraphsLocation, "*", SearchOption.TopDirectoryOnly);
+                foreach (var dir in versionDirs)
+                    foreach (var assetPath in Directory.GetFiles(dir, "*", SearchOption.TopDirectoryOnly))
+                        yield return assetPath;
+            }
+        }
+
+        public class MultiImportDirectories : IEnumerable
+        {
+            private const string kGraphsLocation = "PreviousGraphVersions/";
+            public IEnumerator GetEnumerator()
+            {
+                var versionDirs = Directory.GetDirectories(Application.dataPath + "/../" + kGraphsLocation, "*", SearchOption.TopDirectoryOnly);
+                foreach (var dir in versionDirs)
+                    foreach (var multiDir in Directory.GetDirectories(dir, "*", SearchOption.TopDirectoryOnly))
+                        yield return multiDir;
             }
         }
 
         [OneTimeSetUp]
         public void Setup()
         {
-            if(!AssetDatabase.IsValidFolder("Assets/Testing/ImportTests"))
+            if (!Directory.Exists(Application.dataPath + "Testing/ImportTests"))
+                Directory.CreateDirectory(Application.dataPath + "Testing/ImportTests");
+            AssetDatabase.Refresh();
+
+            if (!AssetDatabase.IsValidFolder("Assets/Testing/ImportTests"))
             {
                 AssetDatabase.CreateFolder("Assets/Testing", "ImportTests");
             }
         }
 
-        [TestCaseSource(typeof(ImportCases))]
-        public void CopyOverAndImport(string assetPath)
+        [TestCaseSource(typeof(SingleImportCases))]
+        public void ImportSingle(string assetPath)
         {
             string fileName = Path.GetFileName(assetPath);
-            string fileNameNoExtension = Path.GetFileNameWithoutExtension(assetPath);
             string fileContents = File.ReadAllText(assetPath);
-            string fileExtension = Path.GetExtension(assetPath).ToLower();
-            bool isSubgraph = (fileExtension == "shadersubgraph");
 
-            string localFilePath = "Assets/Testing/ImportTests/" + fileName;
-            string localFilePathNoExtension = "Assets/Testing/ImportTests/" + fileNameNoExtension;
+            string targetPath = Application.dataPath + "/Testing/ImportTests/" + fileName;
+            File.WriteAllText(targetPath, fileContents);
 
-            File.WriteAllText(Application.dataPath + "/Testing/ImportTests/" + fileName, fileContents);
-            AssetDatabase.ImportAsset(localFilePath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate | ImportAssetOptions.DontDownloadFromCacheServer);
-            var graphGuid = AssetDatabase.AssetPathToGUID(localFilePath);
+            string unityLocalPath = "Assets/Testing/ImportTests/" + fileName;
+            TestImportAsset(unityLocalPath, targetPath);
+        }
+
+        [TestCaseSource(typeof(MultiImportDirectories))]
+        public void ImportMulti(string directory)
+        {
+            string sourceDir = Path.GetFullPath(directory).TrimEnd(Path.DirectorySeparatorChar);
+            string dirName = Path.GetFileName(sourceDir);
+
+            string targetDir = Application.dataPath + "/Testing/ImportTests/" + dirName;
+            DirectoryCopy(sourceDir, targetDir, true, true);
+
+            foreach (var assetFullPath in Directory.GetFiles(targetDir, "*.shader*", SearchOption.TopDirectoryOnly))
+            {
+                if (!assetFullPath.EndsWith(".meta"))
+                {
+                    string relativeFilePath = assetFullPath.Substring(targetDir.Length);
+                    string unityLocalPath = "Assets/Testing/ImportTests/" + dirName + relativeFilePath;
+                    TestImportAsset(unityLocalPath, assetFullPath);
+                }
+            }
+        }
+
+        public void TestImportAsset(string unityLocalPath, string fullPath)
+        {
+            unityLocalPath = unityLocalPath.Replace("\\", "/");
+            Debug.Log("Testing file: " + unityLocalPath);
+
+            // invoke an import
+            AssetDatabase.ImportAsset(unityLocalPath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate | ImportAssetOptions.DontDownloadFromCacheServer);
+
+            // double check we can load it up and validate it
+            string fileContents = File.ReadAllText(fullPath);
+            Assert.Greater(fileContents.Length, 0);
+
+            var graphGuid = AssetDatabase.AssetPathToGUID(unityLocalPath);
             var messageManager = new MessageManager();
             GraphData graphData = new GraphData() { assetGuid = graphGuid, messageManager = messageManager };
             MultiJson.Deserialize(graphData, fileContents);
             graphData.OnEnable();
             graphData.ValidateGraph();
 
+            string fileExtension = Path.GetExtension(fullPath).ToLower();
+            bool isSubgraph = (fileExtension == "shadersubgraph");
             if (isSubgraph)
             {
                 // check that the SubGraphAsset is the same after versioning twice
                 // this is important to ensure we're not importing subgraphs non-deterministically when they are out-of-date on disk
-                AssetDatabase.ImportAsset(localFilePath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate | ImportAssetOptions.DontDownloadFromCacheServer);
-                var subGraph = AssetDatabase.LoadAssetAtPath<SubGraphAsset>(localFilePath);
+                AssetDatabase.ImportAsset(unityLocalPath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate | ImportAssetOptions.DontDownloadFromCacheServer);
+                var subGraph = AssetDatabase.LoadAssetAtPath<SubGraphAsset>(unityLocalPath);
                 var serialized = EditorJsonUtility.ToJson(subGraph);
 
-                AssetDatabase.ImportAsset(localFilePath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate | ImportAssetOptions.DontDownloadFromCacheServer);
-                var subGraph2 = AssetDatabase.LoadAssetAtPath<SubGraphAsset>(localFilePath);
+                AssetDatabase.ImportAsset(unityLocalPath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate | ImportAssetOptions.DontDownloadFromCacheServer);
+                var subGraph2 = AssetDatabase.LoadAssetAtPath<SubGraphAsset>(unityLocalPath);
                 var serialized2 = EditorJsonUtility.ToJson(subGraph2);
 
-                Assert.AreEqual(serialized, serialized2, $"Importing the subgraph {localFilePath} twice resulted in different subgraph assets.");
+                Assert.AreEqual(serialized, serialized2, $"Importing the subgraph {unityLocalPath} twice resulted in different subgraph assets.");
             }
             else
             {
                 // check that the generated shader is the same after versioning twice
                 // this is important to ensure we're not importing shaders non-deterministically when they are out-of-date on disk
+                string fileNameNoExtension = Path.GetFileNameWithoutExtension(fullPath);
                 var generator = new Generator(graphData, graphData.outputNode, GenerationMode.ForReals, fileNameNoExtension, null);
                 string shader = generator.generatedShader;
 
@@ -78,18 +132,55 @@ public void CopyOverAndImport(string assetPath)
                 var generator2 = new Generator(graphData2, graphData2.outputNode, GenerationMode.ForReals, fileNameNoExtension, null);
                 string shader2 = generator2.generatedShader;
 
-                Assert.AreEqual(shader, shader2, $"Importing the graph {localFilePath} twice resulted in different generated shaders.");
+                Assert.AreEqual(shader, shader2, $"Importing the graph {unityLocalPath} twice resulted in different generated shaders.");
             }
         }
 
         [OneTimeTearDown]
         public void Cleanup()
         {
+            AssetDatabase.Refresh();
             foreach (string assetGuid in AssetDatabase.FindAssets("*", new string[] { "Assets/Testing/ImportTests" }))
             {
                 Debug.Log(AssetDatabase.GUIDToAssetPath(assetGuid));
                 AssetDatabase.DeleteAsset(AssetDatabase.GUIDToAssetPath(assetGuid));
             }
         }
+
+        private static void DirectoryCopy(string sourceDirName, string destDirName, bool copySubDirs, bool overwriteFiles)
+        {
+            // Get the subdirectories for the specified directory.
+            DirectoryInfo dir = new DirectoryInfo(sourceDirName);
+
+            if (!dir.Exists)
+            {
+                throw new DirectoryNotFoundException(
+                    "Source directory does not exist or could not be found: "
+                    + sourceDirName);
+            }
+
+            DirectoryInfo[] dirs = dir.GetDirectories();
+
+            // If the destination directory doesn't exist, create it.       
+            Directory.CreateDirectory(destDirName);
+
+            // Get the files in the directory and copy them to the new location.
+            FileInfo[] files = dir.GetFiles();
+            foreach (FileInfo file in files)
+            {
+                string tempPath = Path.Combine(destDirName, file.Name);
+                file.CopyTo(tempPath, overwriteFiles);
+            }
+
+            // If copying subdirectories, copy them and their contents to new location.
+            if (copySubDirs)
+            {
+                foreach (DirectoryInfo subdir in dirs)
+                {
+                    string tempPath = Path.Combine(destDirName, subdir.Name);
+                    DirectoryCopy(subdir.FullName, tempPath, copySubDirs, overwriteFiles);
+                }
+            }
+        }
     }
 }

TestProjects/ShaderGraph/Assets/TestbedAssets/Textures/Textures/Numbers.psd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c2f3a88b52643dcdd288ab5d616577b8d9fbe686a4d2a09dc9f325bbb135cf9
+size 189915