dirty first pass pass architecture.

7 年前 · da15e457
--- a/MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Implementation/NodeUtils.cs
+++ b/MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Implementation/NodeUtils.cs
            if (node == null)
                return;

-            using (var stackDisposable = StackPool<INode>.GetDisposable())
-            using (var queueDisposable = QueuePool<INode>.GetDisposable())
-            {
-                var stack = stackDisposable.value;
-                var queue = queueDisposable.value;
-                queue.Enqueue(node);
+            // already added this node
+            if (nodeList.Contains(node))
+                return;
-                while (queue.Any())
-                {
-                    var fromNode = queue.Dequeue();
-
-                    // already added this node
-                    if (nodeList.Contains(fromNode))
-                        continue;
-
-                    foreach (var slot in fromNode.GetInputSlots<ISlot>())
-                    {
-                        if (slotIds != null && !slotIds.Contains(slot.id))
-                            continue;
+            var ids = node.GetInputSlots<ISlot>().Select(x => x.id);
+            if (slotIds != null)
+                ids = node.GetInputSlots<ISlot>().Where(x => slotIds.Contains(x.id)).Select(x => x.id);
-                        foreach (var edge in fromNode.owner.GetEdges(fromNode.GetSlotReference(slot.id)))
-                        {
-                            var outputNode = fromNode.owner.GetNodeFromGuid(edge.outputSlot.nodeGuid);
-                            queue.Enqueue(outputNode);
-                            stack.Push(outputNode);
-                        }
-                    }
+            foreach (var slot in ids)
+            {
+                foreach (var edge in node.owner.GetEdges(node.GetSlotReference(slot)))
+                {
+                    var outputNode = node.owner.GetNodeFromGuid(edge.outputSlot.nodeGuid);
+                    DepthFirstCollectNodesFromNode(nodeList, outputNode);
+            }
-                while (stack.Any())
-                    nodeList.Add(stack.Pop());
-
-                if (includeSelf == IncludeSelf.Include)
-                    nodeList.Add(node);
-            }
+            if (includeSelf == IncludeSelf.Include)
+                nodeList.Add(node);
        }

        public static void CollectNodesNodeFeedsInto(List<INode> nodeList, INode node, IncludeSelf includeSelf = IncludeSelf.Include)
--- a/MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/AbstractMaterialGraph.cs
+++ b/MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/AbstractMaterialGraph.cs
            base.OnAfterDeserialize();
        }

-        protected static ShaderGraphRequirements GetRequirements(List<INode> nodes)
+        internal static ShaderGraphRequirements GetRequirements(List<INode> nodes)
        {
            NeededCoordinateSpace requiresNormal = nodes.OfType<IMayRequireNormal>().Aggregate(NeededCoordinateSpace.None, (mask, node) => mask | node.RequiresNormal());
            NeededCoordinateSpace requiresBitangent = nodes.OfType<IMayRequireBitangent>().Aggregate(NeededCoordinateSpace.None, (mask, node) => mask | node.RequiresBitangent());
            return GetShader(null, GenerationMode.Preview, "hidden/preview", out configuredTextures, out previewMode, out outputIdProperty, ids);
        }

-        protected static void GenerateSurfaceDescriptionStruct(ShaderGenerator surfaceDescriptionStruct, List<MaterialSlot> slots, bool isMaster)
+        internal static void GenerateSurfaceDescriptionStruct(ShaderGenerator surfaceDescriptionStruct, List<MaterialSlot> slots, bool isMaster)
        {
            surfaceDescriptionStruct.AddShaderChunk("struct SurfaceDescription{", false);
            surfaceDescriptionStruct.Indent();
                    surfaceDescriptionStruct.AddShaderChunk(string.Format("{0} {1};", AbstractMaterialNode.ConvertConcreteSlotValueTypeToString(AbstractMaterialNode.OutputPrecision.@float, slot.concreteValueType), AbstractMaterialNode.GetHLSLSafeName(slot.shaderOutputName)), false);
                surfaceDescriptionStruct.Deindent();
-                surfaceDescriptionStruct.AddShaderChunk("};", false);
-                surfaceDescriptionStruct.AddShaderChunk("void ScaleSurfaceDescription(inout SurfaceDescription surface, float scale){", false);
+               /* surfaceDescriptionStruct.AddShaderChunk("void ScaleSurfaceDescription(inout SurfaceDescription surface, float scale){", false);
                surfaceDescriptionStruct.Indent();
                foreach (var slot in slots)
                    surfaceDescriptionStruct.AddShaderChunk(string.Format("surface.{0} = scale * surface.{0};", AbstractMaterialNode.GetHLSLSafeName(slot.shaderOutputName)), false);
                surfaceDescriptionStruct.AddShaderChunk("void AddSurfaceDescription(inout SurfaceDescription base, in SurfaceDescription add){", false);
                surfaceDescriptionStruct.Indent();
                foreach (var slot in slots)
-                    surfaceDescriptionStruct.AddShaderChunk(string.Format("base.{0} = base.{0} + add.{0};", AbstractMaterialNode.GetHLSLSafeName(slot.shaderOutputName)), false);
+                    surfaceDescriptionStruct.AddShaderChunk(string.Format("base.{0} = base.{0} + add.{0};", AbstractMaterialNode.GetHLSLSafeName(slot.shaderOutputName)), false);*/
            }
            else
            {
            surfaceDescriptionStruct.AddShaderChunk("};", false);
        }

-        protected static void GenerateSurfaceDescription(
-            List<INode> activeNodeList,
+        internal static void GenerateSurfaceDescription(
+            List<int> slots,
            AbstractMaterialGraph graph,
            ShaderGenerator surfaceDescriptionFunction,
            ShaderGenerator shaderFunctionVisitor,
            if (graph == null)
                return;

+            var activeNodeList = ListPool<INode>.Get();
+            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, masterNode, NodeUtils.IncludeSelf.Include, slots);
+
+            var usedSlots = new List<MaterialSlot>();
+            foreach (var id in slots)
+                usedSlots.Add(masterNode.FindSlot<MaterialSlot>(id));
+
            surfaceDescriptionFunction.AddShaderChunk(string.Format("{0} {1}(SurfaceInputs IN) {{", surfaceDescriptionName, functionName), false);
            surfaceDescriptionFunction.Indent();
            surfaceDescriptionFunction.AddShaderChunk(string.Format("{0} surface = ({0})0;", surfaceDescriptionName), false);
            {
                if (masterNode is IMasterNode)
                {
-                    foreach (var input in masterNode.GetInputSlots<MaterialSlot>())
+                    foreach (var input in usedSlots)
                    {
                        var foundEdges = graph.GetEdges(input.slotReference).ToArray();
                        if (foundEdges.Any())
            surfaceDescriptionFunction.AddShaderChunk("return surface;", false);
            surfaceDescriptionFunction.Deindent();
            surfaceDescriptionFunction.AddShaderChunk("}", false);
+
+             ListPool<INode>.Release(activeNodeList);
        }

        static void Visit(List<INode> outputList, Dictionary<Guid, INode> unmarkedNodes, INode node)
            };
            if (isUber)
                shaderProperties.AddShaderProperty(outputIdProperty);
-            GenerateSurfaceDescription(
-                activeNodeList,
+            /*GenerateSurfaceDescription(
                node,
                this,
                surfaceDescriptionFunction,
                mode,
                outputIdProperty: outputIdProperty,
-                ids: ids);
+                ids: ids);*/

            var finalShader = new ShaderGenerator();
            finalShader.AddShaderChunk(string.Format(@"Shader ""{0}""", name), false);
--- a/MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/LightweightPipeline/AbstractLightweightMasterNode.cs
+++ b/MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/LightweightPipeline/AbstractLightweightMasterNode.cs
            }
        }

+        struct Pass
+        {
+            public string Name;
+            public List<int> VertexShaderSlots;
+            public List<int> PixelShaderSlots;
+        }
+
+        public string GetShader(GenerationMode mode, out List<PropertyCollector.TextureInfo> configuredTextures)
+        {
+            var activeNodeList = ListPool<INode>.Get();
+            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, this);
+
+            var shaderProperties = new PropertyCollector();
+
+            var abstractMaterialGraph = owner as AbstractMaterialGraph;
+            if (abstractMaterialGraph != null)
+                abstractMaterialGraph.CollectShaderProperties(shaderProperties, mode);
+
+            foreach (var activeNode in activeNodeList.OfType<AbstractMaterialNode>())
+                activeNode.CollectShaderProperties(shaderProperties, mode);
+
+            var finalShader = new ShaderGenerator();
+            finalShader.AddShaderChunk(string.Format(@"Shader ""{0}""", name), false);
+            finalShader.AddShaderChunk("{", false);
+            finalShader.Indent();
+
+            finalShader.AddShaderChunk("Properties", false);
+            finalShader.AddShaderChunk("{", false);
+            finalShader.Indent();
+            finalShader.AddShaderChunk(shaderProperties.GetPropertiesBlock(2), false);
+            finalShader.Deindent();
+            finalShader.AddShaderChunk("}", false);
+
+            var lwSub = new LightWeightSubShader();
+            foreach (var subshader in lwSub.GetSubshader(this, GenerationMode.ForReals))
+                finalShader.AddShaderChunk(subshader, true);
+
+            finalShader.Deindent();
+            finalShader.AddShaderChunk("}", false);
+
+            configuredTextures = shaderProperties.GetConfiguredTexutres();
+            return finalShader.GetShaderString(0);
+        }
+
+        public class LightWeightSubShader
+        {
+            Pass m_ForwardPass = new Pass()
+            {
+                Name = "LightweightForward",
+                PixelShaderSlots = new List<int>()
+                {
+                    AbstractLightweightPBRMasterNode.AlbedoSlotId,
+                    AbstractLightweightPBRMasterNode.EmissionSlotId,
+                    AbstractLightweightPBRMasterNode.NormalSlotId,
+                    AbstractLightweightPBRMasterNode.OcclusionSlotId,
+                    AbstractLightweightPBRMasterNode.SmoothnessSlotId,
+                    AbstractLightweightPBRMasterNode.AlphaSlotId
+                }
+            };
+
+            public IEnumerable<string> GetSubshader(AbstractLightweightMasterNode masterNode, GenerationMode mode)
+            {
+                var surfaceVertexShader = new ShaderGenerator();
+                var surfaceDescriptionFunction = new ShaderGenerator();
+                var surfaceDescriptionStruct = new ShaderGenerator();
+                var shaderFunctionVisitor = new ShaderGenerator();
+                var surfaceInputs = new ShaderGenerator();
+
+                var shaderProperties = new PropertyCollector();
+
+                var graphVertexInput = @"
+struct GraphVertexInput
+{
+     float4 vertex : POSITION;
+     float3 normal : NORMAL;
+     float4 tangent : TANGENT;
+     float4 color : COLOR;
+     float4 texcoord0 : TEXCOORD0;
+     float4 lightmapUV : TEXCOORD1;
+     UNITY_VERTEX_INPUT_INSTANCE_ID
+};";
+
+                surfaceInputs.AddShaderChunk("struct SurfaceInputs{", false);
+                surfaceInputs.Indent();
+
+                var activeNodeList = ListPool<INode>.Get();
+                NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, masterNode, NodeUtils.IncludeSelf.Include, m_ForwardPass.PixelShaderSlots);
+
+                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);
+
+                if (requirements.requiresVertexColor)
+                    surfaceInputs.AddShaderChunk(string.Format("float4 {0};", ShaderGeneratorNames.VertexColor), 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);
+
+                surfaceInputs.Deindent();
+                surfaceInputs.AddShaderChunk("};", false);
+
+                surfaceVertexShader.AddShaderChunk("GraphVertexInput PopulateVertexData(GraphVertexInput v){", false);
+                surfaceVertexShader.Indent();
+                surfaceVertexShader.AddShaderChunk("return v;", false);
+                surfaceVertexShader.Deindent();
+                surfaceVertexShader.AddShaderChunk("}", false);
+
+                var slots = new List<MaterialSlot>();
+                foreach (var id in m_ForwardPass.PixelShaderSlots)
+                    slots.Add(masterNode.FindSlot<MaterialSlot>(id));
+                AbstractMaterialGraph.GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, true);
+
+                AbstractMaterialGraph.GenerateSurfaceDescription(
+                    masterNode,
+                    m_ForwardPass.PixelShaderSlots,
+                    masterNode.owner as AbstractMaterialGraph,
+                    surfaceDescriptionFunction,
+                    shaderFunctionVisitor,
+                    shaderProperties,
+                    requirements,
+                    mode);
+
+                var graph = new ShaderGenerator();
+                graph.AddShaderChunk(shaderFunctionVisitor.GetShaderString(2), false);
+                graph.AddShaderChunk(graphVertexInput, false);
+                graph.AddShaderChunk(surfaceInputs.GetShaderString(2), false);
+                graph.AddShaderChunk(surfaceDescriptionStruct.GetShaderString(2), false);
+                graph.AddShaderChunk(shaderProperties.GetPropertiesDeclaration(2), false);
+                graph.AddShaderChunk(surfaceVertexShader.GetShaderString(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 materialOptions = new SurfaceMaterialOptions();
+                materialOptions.GetTags(tagsVisitor);
+                materialOptions.GetBlend(blendingVisitor);
+                materialOptions.GetCull(cullingVisitor);
+                materialOptions.GetDepthTest(zTestVisitor);
+                materialOptions.GetDepthWrite(zWriteVisitor);
+
+                var interpolators = new ShaderGenerator();
+                var localVertexShader = 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;
+
+                ShaderGenerator.GenerateStandardTransforms(
+                    3,
+                    10,
+                    interpolators,
+                    localVertexShader,
+                    localPixelShader,
+                    localSurfaceInputs,
+                    requirements,
+                    reqs,
+                    CoordinateSpace.World);
+
+                ShaderGenerator defines = new ShaderGenerator();
+                var templateLocation = ShaderGenerator.GetTemplatePath("lightweightSubshaderPBR.template");
+
+                var usedSlots = new List<MaterialSlot>();
+                foreach (var id in m_ForwardPass.PixelShaderSlots)
+                    usedSlots.Add(masterNode.FindSlot<MaterialSlot>(id));
+
+                foreach (var slot in usedSlots)
+                {
+                    surfaceOutputRemap.AddShaderChunk(slot.shaderOutputName
+                        + " = surf."
+                        + slot.shaderOutputName + ";", true);
+                }
+
+                if (!File.Exists(templateLocation))
+                    return new string[] { };
+
+                var subShaderTemplate = File.ReadAllText(templateLocation);
+                var resultShader = subShaderTemplate.Replace("${Defines}", defines.GetShaderString(3));
+                resultShader = resultShader.Replace("${Graph}", graph.GetShaderString(3));
+                resultShader = resultShader.Replace("${Interpolators}", interpolators.GetShaderString(3));
+                resultShader = resultShader.Replace("${VertexShader}", localVertexShader.GetShaderString(3));
+                resultShader = resultShader.Replace("${LocalPixelShader}", localPixelShader.GetShaderString(3));
+                resultShader = resultShader.Replace("${SurfaceInputs}", localSurfaceInputs.GetShaderString(3));
+                resultShader = resultShader.Replace("${SurfaceOutputRemap}", surfaceOutputRemap.GetShaderString(3));
+
+
+                resultShader = resultShader.Replace("${Tags}", tagsVisitor.GetShaderString(2));
+                resultShader = resultShader.Replace("${Blending}", blendingVisitor.GetShaderString(2));
+                resultShader = resultShader.Replace("${Culling}", cullingVisitor.GetShaderString(2));
+                resultShader = resultShader.Replace("${ZTest}", zTestVisitor.GetShaderString(2));
+                resultShader = resultShader.Replace("${ZWrite}", zWriteVisitor.GetShaderString(2));
+                resultShader = resultShader.Replace("${LOD}", "" + materialOptions.lod);
+                return new[] { resultShader };
+            }
+        }
+        
        public override IEnumerable<string> GetSubshader(ShaderGraphRequirements graphRequirements, MasterRemapGraph remapper)
        {
            var tagsVisitor = new ShaderGenerator();
--- a/MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/SubGraph/LayeredShaderGraph.cs
+++ b/MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/SubGraph/LayeredShaderGraph.cs
                var masterNode = baseGraph.masterNode;
                GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, ((AbstractMaterialNode) masterNode).GetInputSlots<MaterialSlot>().ToList(), true);

-                foreach (var layer in layerMap)
+              /*  foreach (var layer in layerMap)
                {
                    activeNodes.Clear();
                    NodeUtils.DepthFirstCollectNodesFromNode(activeNodes, layer.Value.masterNode as AbstractMaterialNode);
                        requirements,
                        mode,
                        LayerToFunctionName(layer.Key));
-                }
+                }*/

                surfaceDescriptionStruct.AddShaderChunk("struct WeightsSurfaceDescription{", false);
                surfaceDescriptionStruct.Indent();

                activeNodes.Clear();
                NodeUtils.DepthFirstCollectNodesFromNode(activeNodes, outputNode);
-                GenerateSurfaceDescription(
+                /*GenerateSurfaceDescription(
                    activeNodes,
                    outputNode,
                    this,
                    mode,
                    "PopulateWeightsGraph",
                    "WeightsSurfaceDescription");
+                    */

                string functionName = "PopulateSurfaceData";
                string surfaceDescriptionName = "SurfaceDescription";
--- a/MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Inspector/StandardNodeEditorView.cs
+++ b/MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Inspector/StandardNodeEditorView.cs
-using System.Linq;
-using UnityEditor.Graphing.Util;
-using UnityEngine;
-using UnityEngine.Experimental.UIElements;
-using UnityEditor.Graphing;
-using UnityEditor.ShaderGraph;
+using UnityEditor.Graphing;

 namespace UnityEditor.ShaderGraph.Drawing.Inspector
 {
--- a/MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/GraphEditorView.cs
+++ b/MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/GraphEditorView.cs
                        var textureInfo = new List<PropertyCollector.TextureInfo>();
                        PreviewMode previewMode;
                        FloatShaderProperty outputIdProperty;
-                        string shader = graph.GetShader(copyFromNode, GenerationMode.ForReals, assetName, out textureInfo, out previewMode, out outputIdProperty);
-                        GUIUtility.systemCopyBuffer = shader;
+                        if (copyFromNode is AbstractLightweightMasterNode)
+                        {
+                            var shader = ((AbstractLightweightMasterNode)copyFromNode).GetShader(GenerationMode.ForReals, out textureInfo);
+                            GUIUtility.systemCopyBuffer = shader;
+                        }
+                        else
+                        {
+                            string shader = graph.GetShader(copyFromNode, GenerationMode.ForReals, assetName, out textureInfo, out previewMode, out outputIdProperty);
+                            GUIUtility.systemCopyBuffer = shader;
+                        }
                    }
                ));

--- a/MaterialGraphProject/Assets/UnityShaderEditor/Editor/Templates/lightweightSubshaderPBR.template
+++ b/MaterialGraphProject/Assets/UnityShaderEditor/Editor/Templates/lightweightSubshaderPBR.template
 		${Defines}

 		#include "LightweightLighting.cginc"
+
+		${Graph}
 		
 		struct GraphVertexOutput
        {