fixing merge

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/HDPipeline/HDUnlitSubShader.cs

-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using UnityEditor.Graphing;
+//using System.Collections.Generic;
+//using System.IO;
+//using System.Linq;
+//using UnityEditor.Graphing;
-namespace UnityEditor.ShaderGraph
-{
-    public class HDUnlitSubShader
-    {
-        struct Pass
-        {
-            public string Name;
-            public string ShaderPassName;
-            public string ShaderPassInclude;
-            public List<int> VertexShaderSlots;
-            public List<int> PixelShaderSlots;
-        }
+//namespace UnityEditor.ShaderGraph
+//{
+//    public class HDUnlitSubShader
+//    {
+//        struct Pass
+//        {
+//            public string Name;
+//            public string ShaderPassName;
+//            public string ShaderPassInclude;
+//            public List<int> VertexShaderSlots;
+//            public List<int> PixelShaderSlots;
+//        }
-        Pass m_UnlitPassForwardOnly = new Pass()
-        {
-            Name = "ForwardOnly",
-            ShaderPassName = "SHADERPASS_FORWARD_UNLIT",
-            ShaderPassInclude = "ShaderPassForwardUnlit",
-            PixelShaderSlots = new List<int>()
-            {
-                UnlitMasterNode.ColorSlotId,
-                UnlitMasterNode.AlphaSlotId
-            }
-        };
+//        Pass m_UnlitPassForwardOnly = new Pass()
+//        {
+//            Name = "ForwardOnly",
+//            ShaderPassName = "SHADERPASS_FORWARD_UNLIT",
+//            ShaderPassInclude = "ShaderPassForwardUnlit",
+//            PixelShaderSlots = new List<int>()
+//            {
+//                UnlitMasterNode.ColorSlotId,
+//                UnlitMasterNode.AlphaSlotId
+//            }
+//        };
-        Pass m_UnlitPassForwardDepthOnly = new Pass()
-        {
-            Name = "DepthForwardOnly",
-            ShaderPassName = "SHADERPASS_DEPTH_ONLY",
-            ShaderPassInclude = "ShaderPassDepthOnly",
-            PixelShaderSlots = new List<int>()
-            {
-                UnlitMasterNode.ColorSlotId,
-                UnlitMasterNode.AlphaSlotId
-            }
-        };
+//        Pass m_UnlitPassForwardDepthOnly = new Pass()
+//        {
+//            Name = "DepthForwardOnly",
+//            ShaderPassName = "SHADERPASS_DEPTH_ONLY",
+//            ShaderPassInclude = "ShaderPassDepthOnly",
+//            PixelShaderSlots = new List<int>()
+//            {
+//                UnlitMasterNode.ColorSlotId,
+//                UnlitMasterNode.AlphaSlotId
+//            }
+//        };
-        private static string GetShaderPassFromTemplate(UnlitMasterNode masterNode, Pass pass, GenerationMode mode)
-        {
-            var surfaceDescriptionFunction = new ShaderGenerator();
-            var surfaceDescriptionStruct = new ShaderGenerator();
-            var shaderFunctionVisitor = new ShaderGenerator();
-            var surfaceInputs = new ShaderGenerator();
+//        private static string GetShaderPassFromTemplate(UnlitMasterNode masterNode, Pass pass, GenerationMode mode)
+//        {
+//            var surfaceDescriptionFunction = new ShaderGenerator();
+//            var surfaceDescriptionStruct = new ShaderGenerator();
+//            var shaderFunctionVisitor = new ShaderGenerator();
+//            var surfaceInputs = new ShaderGenerator();
-            var shaderProperties = new PropertyCollector();
+//            var shaderProperties = new PropertyCollector();
-            surfaceInputs.AddShaderChunk("struct SurfaceInputs{", false);
-            surfaceInputs.Indent();
+//            surfaceInputs.AddShaderChunk("struct SurfaceInputs{", false);
+//            surfaceInputs.Indent();
-            var activeNodeList = ListPool<INode>.Get();
-            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, masterNode, NodeUtils.IncludeSelf.Include, pass.PixelShaderSlots);
+//            var activeNodeList = ListPool<INode>.Get();
+//            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, masterNode, NodeUtils.IncludeSelf.Include, pass.PixelShaderSlots);
-            var requirements = AbstractMaterialGraph.GetRequirements(activeNodeList);
+//            var requirements = AbstractMaterialGraph.GetRequirements(activeNodeList);
-            /*
-            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresNormal, InterpolatorType.Normal, surfaceInputs);
-            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresTangent, InterpolatorType.Tangent, surfaceInputs);
-            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresBitangent, InterpolatorType.BiTangent, surfaceInputs);
-            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresViewDir, InterpolatorType.ViewDirection, surfaceInputs);
-            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresPosition, InterpolatorType.Position, surfaceInputs);*/
+//            /*
+//            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresNormal, InterpolatorType.Normal, surfaceInputs);
+//            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresTangent, InterpolatorType.Tangent, surfaceInputs);
+//            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresBitangent, InterpolatorType.BiTangent, surfaceInputs);
+//            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresViewDir, InterpolatorType.ViewDirection, surfaceInputs);
+//            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresPosition, InterpolatorType.Position, surfaceInputs);*/
-            ShaderGenerator defines = new ShaderGenerator();
-            defines.AddShaderChunk(string.Format("#define SHADERPASS {0}", pass.ShaderPassName), true);
+//            ShaderGenerator defines = new ShaderGenerator();
+//            defines.AddShaderChunk(string.Format("#define SHADERPASS {0}", pass.ShaderPassName), true);
-            if (requirements.requiresVertexColor)
-                surfaceInputs.AddShaderChunk(string.Format("float4 {0};", ShaderGeneratorNames.VertexColor), false);
+//            if (requirements.requiresVertexColor)
+//                surfaceInputs.AddShaderChunk(string.Format("float4 {0};", ShaderGeneratorNames.VertexColor), false);
-            /*if (requirements.requiresScreenPosition)
-                surfaceInputs.AddShaderChunk(string.Format("float4 {0};", ShaderGeneratorNames.ScreenPosition), false);*/
+//            /*if (requirements.requiresScreenPosition)
+//                surfaceInputs.AddShaderChunk(string.Format("float4 {0};", ShaderGeneratorNames.ScreenPosition), false);*/
-            foreach (var channel in requirements.requiresMeshUVs.Distinct())
-            {
-                surfaceInputs.AddShaderChunk(string.Format("half4 {0};", channel.GetUVName()), false);
-                defines.AddShaderChunk("#define ATTRIBUTES_NEED_TEXCOORD" + (int)channel, true);
-                defines.AddShaderChunk("#define VARYINGS_NEED_TEXCOORD" + (int)channel, true);
-            }
+//            foreach (var channel in requirements.requiresMeshUVs.Distinct())
+//            {
+//                surfaceInputs.AddShaderChunk(string.Format("half4 {0};", channel.GetUVName()), false);
+//                defines.AddShaderChunk("#define ATTRIBUTES_NEED_TEXCOORD" + (int)channel, true);
+//                defines.AddShaderChunk("#define VARYINGS_NEED_TEXCOORD" + (int)channel, true);
+//            }
-            surfaceInputs.Deindent();
-            surfaceInputs.AddShaderChunk("};", false);
+//            surfaceInputs.Deindent();
+//            surfaceInputs.AddShaderChunk("};", false);
-            var slots = new List<MaterialSlot>();
-            foreach (var id in pass.PixelShaderSlots)
-            {
-                var slot = masterNode.FindSlot<MaterialSlot>(id);
-                if (slot != null)
-                    slots.Add(slot);
-            }
-            AbstractMaterialGraph.GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, true);
+//            var slots = new List<MaterialSlot>();
+//            foreach (var id in pass.PixelShaderSlots)
+//            {
+//                var slot = masterNode.FindSlot<MaterialSlot>(id);
+//                if (slot != null)
+//                    slots.Add(slot);
+//            }
+//            AbstractMaterialGraph.GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, true);
-            var usedSlots = new List<MaterialSlot>();
-            foreach (var id in pass.PixelShaderSlots)
-                usedSlots.Add(masterNode.FindSlot<MaterialSlot>(id));
+//            var usedSlots = new List<MaterialSlot>();
+//            foreach (var id in pass.PixelShaderSlots)
+//                usedSlots.Add(masterNode.FindSlot<MaterialSlot>(id));
-            AbstractMaterialGraph.GenerateSurfaceDescription(
-                activeNodeList,
-                masterNode,
-                masterNode.owner as AbstractMaterialGraph,
-                surfaceDescriptionFunction,
-                shaderFunctionVisitor,
-                shaderProperties,
-                requirements,
-                mode,
-                "PopulateSurfaceData",
-                "SurfaceDescription",
-                null,
-                null,
-                usedSlots);
+//            AbstractMaterialGraph.GenerateSurfaceDescription(
+//                activeNodeList,
+//                masterNode,
+//                masterNode.owner as AbstractMaterialGraph,
+//                surfaceDescriptionFunction,
+//                shaderFunctionVisitor,
+//                shaderProperties,
+//                requirements,
+//                mode,
+//                "PopulateSurfaceData",
+//                "SurfaceDescription",
+//                null,
+//                null,
+//                usedSlots);
-            var graph = new ShaderGenerator();
-            graph.AddShaderChunk(shaderFunctionVisitor.GetShaderString(2), false);
-            graph.AddShaderChunk(surfaceInputs.GetShaderString(2), false);
-            graph.AddShaderChunk(surfaceDescriptionStruct.GetShaderString(2), false);
-            graph.AddShaderChunk(shaderProperties.GetPropertiesDeclaration(2), false);
-            graph.AddShaderChunk(surfaceDescriptionFunction.GetShaderString(2), false);
+//            var graph = new ShaderGenerator();
+//            graph.AddShaderChunk(shaderFunctionVisitor.GetShaderString(2), false);
+//            graph.AddShaderChunk(surfaceInputs.GetShaderString(2), false);
+//            graph.AddShaderChunk(surfaceDescriptionStruct.GetShaderString(2), false);
+//            graph.AddShaderChunk(shaderProperties.GetPropertiesDeclaration(2), false);
+//            graph.AddShaderChunk(surfaceDescriptionFunction.GetShaderString(2), false);
-            var tagsVisitor = new ShaderGenerator();
-            var blendingVisitor = new ShaderGenerator();
-            var cullingVisitor = new ShaderGenerator();
-            var zTestVisitor = new ShaderGenerator();
-            var zWriteVisitor = new ShaderGenerator();
+//            var tagsVisitor = new ShaderGenerator();
+//            var blendingVisitor = new ShaderGenerator();
+//            var cullingVisitor = new ShaderGenerator();
+//            var zTestVisitor = new ShaderGenerator();
+//            var zWriteVisitor = new ShaderGenerator();
-            var materialOptions = new SurfaceMaterialOptions();
-            materialOptions.GetTags(tagsVisitor);
-            materialOptions.GetBlend(blendingVisitor);
-            materialOptions.GetCull(cullingVisitor);
-            materialOptions.GetDepthTest(zTestVisitor);
-            materialOptions.GetDepthWrite(zWriteVisitor);
+//            var materialOptions = new SurfaceMaterialOptions();
+//            materialOptions.GetTags(tagsVisitor);
+//            materialOptions.GetBlend(blendingVisitor);
+//            materialOptions.GetCull(cullingVisitor);
+//            materialOptions.GetDepthTest(zTestVisitor);
+//            materialOptions.GetDepthWrite(zWriteVisitor);
-            var localPixelShader = new ShaderGenerator();
-            var localSurfaceInputs = new ShaderGenerator();
-            var surfaceOutputRemap = new ShaderGenerator();
+//            var localPixelShader = new ShaderGenerator();
+//            var localSurfaceInputs = new ShaderGenerator();
+//            var surfaceOutputRemap = new ShaderGenerator();
-            var reqs = ShaderGraphRequirements.none;
-            reqs.requiresNormal |= NeededCoordinateSpace.World;
-            reqs.requiresTangent |= NeededCoordinateSpace.World;
-            reqs.requiresBitangent |= NeededCoordinateSpace.World;
-            reqs.requiresPosition |= NeededCoordinateSpace.World;
-            reqs.requiresViewDir |= NeededCoordinateSpace.World;
+//            var reqs = ShaderGraphRequirements.none;
+//            reqs.requiresNormal |= NeededCoordinateSpace.World;
+//            reqs.requiresTangent |= NeededCoordinateSpace.World;
+//            reqs.requiresBitangent |= NeededCoordinateSpace.World;
+//            reqs.requiresPosition |= NeededCoordinateSpace.World;
+//            reqs.requiresViewDir |= NeededCoordinateSpace.World;
-            foreach (var channel in requirements.requiresMeshUVs.Distinct())
-                localSurfaceInputs.AddShaderChunk(string.Format("surfaceInput.{0} = {1};", channel.GetUVName(), string.Format("half4(input.texCoord{0}, 0, 0)", (int)channel)), false);
+//            foreach (var channel in requirements.requiresMeshUVs.Distinct())
+//                localSurfaceInputs.AddShaderChunk(string.Format("surfaceInput.{0} = {1};", channel.GetUVName(), string.Format("half4(input.texCoord{0}, 0, 0)", (int)channel)), false);
-            /*ShaderGenerator.GenerateStandardTransforms(
-                3,
-                10,
-                interpolators,
-                localVertexShader,
-                localPixelShader,
-                localSurfaceInputs,
-                requirements,
-                reqs,
-                CoordinateSpace.World);*/
+//            /*ShaderGenerator.GenerateStandardTransforms(
+//                3,
+//                10,
+//                interpolators,
+//                localVertexShader,
+//                localPixelShader,
+//                localSurfaceInputs,
+//                requirements,
+//                reqs,
+//                CoordinateSpace.World);*/
-            var templateLocation = ShaderGenerator.GetTemplatePath("HDUnlitPassForward.template");
+//            var templateLocation = ShaderGenerator.GetTemplatePath("HDUnlitPassForward.template");
-            foreach (var slot in usedSlots)
-            {
-                surfaceOutputRemap.AddShaderChunk(slot.shaderOutputName
-                                                  + " = surf."
-                                                  + slot.shaderOutputName + ";", true);
-            }
+//            foreach (var slot in usedSlots)
+//            {
+//                surfaceOutputRemap.AddShaderChunk(slot.shaderOutputName
+//                                                  + " = surf."
+//                                                  + slot.shaderOutputName + ";", true);
+//            }
-            if (!File.Exists(templateLocation))
-                return string.Empty;
+//            if (!File.Exists(templateLocation))
+//                return string.Empty;
-            var subShaderTemplate = File.ReadAllText(templateLocation);
-            var resultPass = subShaderTemplate.Replace("${Defines}", defines.GetShaderString(3));
-            resultPass = resultPass.Replace("${Graph}", graph.GetShaderString(3));
-            resultPass = resultPass.Replace("${LocalPixelShader}", localPixelShader.GetShaderString(3));
-            resultPass = resultPass.Replace("${SurfaceInputs}", localSurfaceInputs.GetShaderString(3));
-            resultPass = resultPass.Replace("${SurfaceOutputRemap}", surfaceOutputRemap.GetShaderString(3));
-            resultPass = resultPass.Replace("${LightMode}", pass.Name);
-            resultPass = resultPass.Replace("${ShaderPassInclude}", pass.ShaderPassInclude);
+//            var subShaderTemplate = File.ReadAllText(templateLocation);
+//            var resultPass = subShaderTemplate.Replace("${Defines}", defines.GetShaderString(3));
+//            resultPass = resultPass.Replace("${Graph}", graph.GetShaderString(3));
+//            resultPass = resultPass.Replace("${LocalPixelShader}", localPixelShader.GetShaderString(3));
+//            resultPass = resultPass.Replace("${SurfaceInputs}", localSurfaceInputs.GetShaderString(3));
+//            resultPass = resultPass.Replace("${SurfaceOutputRemap}", surfaceOutputRemap.GetShaderString(3));
+//            resultPass = resultPass.Replace("${LightMode}", pass.Name);
+//            resultPass = resultPass.Replace("${ShaderPassInclude}", pass.ShaderPassInclude);
-            resultPass = resultPass.Replace("${Tags}", tagsVisitor.GetShaderString(2));
-            resultPass = resultPass.Replace("${Blending}", blendingVisitor.GetShaderString(2));
-            resultPass = resultPass.Replace("${Culling}", cullingVisitor.GetShaderString(2));
-            resultPass = resultPass.Replace("${ZTest}", zTestVisitor.GetShaderString(2));
-            resultPass = resultPass.Replace("${ZWrite}", zWriteVisitor.GetShaderString(2));
-            resultPass = resultPass.Replace("${LOD}", "" + materialOptions.lod);
-            return resultPass;
-        }
+//            resultPass = resultPass.Replace("${Tags}", tagsVisitor.GetShaderString(2));
+//            resultPass = resultPass.Replace("${Blending}", blendingVisitor.GetShaderString(2));
+//            resultPass = resultPass.Replace("${Culling}", cullingVisitor.GetShaderString(2));
+//            resultPass = resultPass.Replace("${ZTest}", zTestVisitor.GetShaderString(2));
+//            resultPass = resultPass.Replace("${ZWrite}", zWriteVisitor.GetShaderString(2));
+//            resultPass = resultPass.Replace("${LOD}", "" + materialOptions.lod);
+//            return resultPass;
+//        }
-        public IEnumerable<string> GetSubshader(UnlitMasterNode masterNode, GenerationMode mode)
-        {
-            var subShader = new ShaderGenerator();
-            subShader.AddShaderChunk("SubShader", true);
-            subShader.AddShaderChunk("{", true);
-            subShader.Indent();
-            subShader.AddShaderChunk("Tags{ \"RenderType\" = \"Opaque\" }", true);
+//        public IEnumerable<string> GetSubshader(UnlitMasterNode masterNode, GenerationMode mode)
+//        {
+//            var subShader = new ShaderGenerator();
+//            subShader.AddShaderChunk("SubShader", true);
+//            subShader.AddShaderChunk("{", true);
+//            subShader.Indent();
+//            subShader.AddShaderChunk("Tags{ \"RenderType\" = \"Opaque\" }", true);
-            subShader.AddShaderChunk(
-                GetShaderPassFromTemplate(
-                    masterNode,
-                    m_UnlitPassForwardDepthOnly,
-                    mode),
-                true);
+//            subShader.AddShaderChunk(
+//                GetShaderPassFromTemplate(
+//                    masterNode,
+//                    m_UnlitPassForwardDepthOnly,
+//                    mode),
+//                true);
-            subShader.AddShaderChunk(
-                GetShaderPassFromTemplate(
-                    masterNode,
-                    m_UnlitPassForwardOnly,
-                    mode),
-                true);
+//            subShader.AddShaderChunk(
+//                GetShaderPassFromTemplate(
+//                    masterNode,
+//                    m_UnlitPassForwardOnly,
+//                    mode),
+//                true);
-            subShader.Deindent();
-            subShader.AddShaderChunk("}", true);
+//            subShader.Deindent();
+//            subShader.AddShaderChunk("}", true);
-            return new[] { subShader.GetShaderString(0) };
-        }
-    }
-}
+//            return new[] { subShader.GetShaderString(0) };
+//        }
+//    }
+//}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/LightweightPipeline/LightWeightPBRSubShader.cs

 
             foreach (var channel in graphRequiements.requiresMeshUVs.Distinct())
                 vertexInputs.AddShaderChunk(string.Format("float4 texcoord{0} : TEXCOORD{0};", (int)channel), false);
-
-            vertexInputs.AddShaderChunk("UNITY_VERTEX_INPUT_INSTANCE_ID", false);
+            
             vertexInputs.Deindent();
             vertexInputs.AddShaderChunk("};", false);
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/MasterNodes/UnlitMasterNode.cs

             finalShader.Deindent();
             finalShader.AddShaderChunk("}", false);
 
-            var lwSub = new HDUnlitSubShader();
+            var lwSub = new LightWeightUnlitSubShader();
             foreach (var subshader in lwSub.GetSubshader(this, mode))
                 finalShader.AddShaderChunk(subshader, true);
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Util/GraphUtil.cs

                 vertexInputs.AddShaderChunk(String.Format("float4 texcoord{0} : TEXCOORD{1};", ((int)channel).ToString(), vertexInputIndex.ToString()), false);
                 vertexInputIndex++;
             }
-
-            vertexInputs.AddShaderChunk("UNITY_VERTEX_INPUT_INSTANCE_ID", false);
+            
             vertexInputs.Deindent();
             vertexInputs.AddShaderChunk("};", false);
         }
                     finalBuilder.AppendLines(shaderProperties.GetPropertiesBlock(0));
                 }
 
-                finalBuilder.AppendLine(@"CGINCLUDE");
-                finalBuilder.AppendLine(@"#include ""UnityCG.cginc""");
+                finalBuilder.AppendLine(@"HLSLINCLUDE");
+                finalBuilder.AppendLine("#define USE_LEGACY_UNITY_MATRIX_VARIABLES");
+                finalBuilder.AppendLine(@"#include ""Common.hlsl""");
+                finalBuilder.AppendLine(@"#include ""Packing.hlsl""");
+                finalBuilder.AppendLine(@"#include ""ShaderVariables.hlsl""");
+                finalBuilder.AppendLine(@"#include ""ShaderVariablesFunctions.hlsl""");
                 finalBuilder.Concat(functionBuilder);
                 finalBuilder.AppendLines(vertexInputs.GetShaderString(0));
                 finalBuilder.AppendLines(surfaceInputs.GetShaderString(0));
                 finalBuilder.AppendLines(surfaceDescriptionFunction.GetShaderString(0));
-                finalBuilder.AppendLine(@"ENDCG");
+                finalBuilder.AppendLine(@"ENDHLSL");
 
                 finalBuilder.AppendLines(ShaderGenerator.GetPreviewSubShader(node, requirements));
                 ListPool<INode>.Release(activeNodeList);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Util/ShaderGenerator.cs

 using System.IO;
 using System.Linq;
 using System.Text;
+using System.Text.RegularExpressions;
 using UnityEngine;
 using UnityEditor.Graphing;
 

MaterialGraphProject/Assets/ASDF.shader.meta

+fileFormatVersion: 2
+guid: 13688daeb472a81479c26aeef30f92e8
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/MaterialGraphAsset.cs.meta

+fileFormatVersion: 2
+guid: 562bd27a5e73fc64d80a1d9d936ffbd5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/SerializableGraph.meta

+fileFormatVersion: 2
+guid: e47723110397ff04388ed94332cd6208
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/SerializableGraph/Testing.meta

+fileFormatVersion: 2
+guid: ad1c022ae8278c34ba435f1ef3928952
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/SerializableGraph/Testing/IntegrationTests.meta

+fileFormatVersion: 2
+guid: 9f4fb832eb82d9b4996748c4ea70e0eb
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/SerializableGraph/Testing/UnitTests.meta

+fileFormatVersion: 2
+guid: 89f9b9afe66134b4b98db24006adefd5
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: