Add Face Sign functionality to LWRP, HDRP and preview subshaders

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDPBRPass.template

             
             $SurfaceDescriptionInputs.vertexColor:               output.vertexColor =    input.color;
 
+            $SurfaceDescriptionInputs.FaceSign:                  output.FaceSign =    input.isFrontFace;
+
             return output;
         }
 

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDSubShaderUtilities.cs

             [Optional] Vector4 uv2;
             [Optional] Vector4 uv3;
             [Optional] Vector4 vertexColor;
+            [Optional] float FaceSign;
 
             public static Dependency[] dependencies = new Dependency[]
             {
                 new Dependency("SurfaceDescriptionInputs.uv2",                       "FragInputs.texCoord2"),
                 new Dependency("SurfaceDescriptionInputs.uv3",                       "FragInputs.texCoord3"),
                 new Dependency("SurfaceDescriptionInputs.vertexColor",               "FragInputs.color"),
+                new Dependency("SurfaceDescriptionInputs.FaceSign",                 "FragInputs.isFrontFace"),
             };
         };
 
             if (requirements.requiresVertexColor)
             {
                 activeFields.Add("SurfaceDescriptionInputs.vertexColor");
+            }
+
+            if (requirements.requiresFaceSign)
+            {
+                activeFields.Add("SurfaceDescriptionInputs.FaceSign");
             }
 
             if (requirements.requiresNormal != 0)

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDUnlitPassForward.template

             
             $SurfaceDescriptionInputs.vertexColor:               output.vertexColor =    input.color;
 
+            $SurfaceDescriptionInputs.FaceSign:                  output.FaceSign =    input.isFrontFace;
+
             return output;
         }
 

com.unity.render-pipelines.lightweight/LWRP/Editor/ShaderGraph/LightWeightPBRSubShader.cs

                 if (surfaceRequirements.requiresScreenPosition)
                     surfaceDescriptionInputStruct.AppendLine("float4 {0};", ShaderGeneratorNames.ScreenPosition);
 
+                if (surfaceRequirements.requiresFaceSign)
+                    surfaceDescriptionInputStruct.AppendLine("float {0};", ShaderGeneratorNames.FaceSign);
+
                 foreach (var channel in surfaceRequirements.requiresMeshUVs.Distinct())
                     surfaceDescriptionInputStruct.AppendLine("half4 {0};", channel.GetUVName());
             }
                 pixelShaderSurfaceRemap.AppendLine("{0} = surf.{0};", slot.shaderOutputName);
             }
 
+            // -------------------------------------
+            // Extra pixel shader work
+
+            var faceSign = new ShaderStringBuilder();
+
+            if (pixelRequirements.requiresFaceSign)
+                faceSign.AppendLine(", half FaceSign : VFACE");
+
             // ----------------------------------------------------- //
             //                      FINALIZE                         //
             // ----------------------------------------------------- //
             resultPass = resultPass.Replace("${VertexShaderDescriptionInputs}", vertexShaderDescriptionInputs.ToString());
             resultPass = resultPass.Replace("${VertexShaderOutputs}", vertexShaderOutputs.ToString());
 
+            resultPass = resultPass.Replace("${FaceSign}", faceSign.ToString());
             resultPass = resultPass.Replace("${PixelShader}", pixelShader.ToString());
             resultPass = resultPass.Replace("${PixelShaderSurfaceInputs}", pixelShaderSurfaceInputs.ToString());
             resultPass = resultPass.Replace("${PixelShaderSurfaceRemap}", pixelShaderSurfaceRemap.ToString());

com.unity.render-pipelines.lightweight/LWRP/Editor/ShaderGraph/LightWeightUnlitSubShader.cs

                 if (surfaceRequirements.requiresScreenPosition)
                     surfaceDescriptionInputStruct.AppendLine("float4 {0};", ShaderGeneratorNames.ScreenPosition);
 
+                if (surfaceRequirements.requiresFaceSign)
+                    surfaceDescriptionInputStruct.AppendLine("float {0};", ShaderGeneratorNames.FaceSign);
+
                 foreach (var channel in surfaceRequirements.requiresMeshUVs.Distinct())
                     surfaceDescriptionInputStruct.AppendLine("half4 {0};", channel.GetUVName());
             }
                 pixelShaderSurfaceRemap.AppendLine("{0} = surf.{0};", slot.shaderOutputName);
             }
 
+            // -------------------------------------
+            // Extra pixel shader work
+
+            var faceSign = new ShaderStringBuilder();
+
+            if (pixelRequirements.requiresFaceSign)
+                faceSign.AppendLine(", half FaceSign : VFACE");
+
             // ----------------------------------------------------- //
             //                      FINALIZE                         //
             // ----------------------------------------------------- //
             resultPass = resultPass.Replace("${VertexShaderDescriptionInputs}", vertexShaderDescriptionInputs.ToString());
             resultPass = resultPass.Replace("${VertexShaderOutputs}", vertexShaderOutputs.ToString());
 
+            resultPass = resultPass.Replace("${FaceSign}", faceSign.ToString());
             resultPass = resultPass.Replace("${PixelShader}", pixelShader.ToString());
             resultPass = resultPass.Replace("${PixelShaderSurfaceInputs}", pixelShaderSurfaceInputs.ToString());
             resultPass = resultPass.Replace("${PixelShaderSurfaceRemap}", pixelShaderSurfaceRemap.ToString());

com.unity.render-pipelines.lightweight/LWRP/Editor/ShaderGraph/lightweightPBRForwardPass.template

 		return o;
 	}
 
-	half4 frag (GraphVertexOutput IN) : SV_Target
+	half4 frag (GraphVertexOutput IN ${FaceSign}) : SV_Target
     {
     	UNITY_SETUP_INSTANCE_ID(IN);
 

com.unity.render-pipelines.lightweight/LWRP/Editor/ShaderGraph/lightweightUnlitPass.template

         return o;
     }
 
-    half4 frag (GraphVertexOutput IN) : SV_Target
+    half4 frag (GraphVertexOutput IN ${FaceSign}) : SV_Target
     {
         UNITY_SETUP_INSTANCE_ID(IN);
 

com.unity.shadergraph/Editor/Data/Graphs/ShaderGraphRequirements.cs

         public NeededCoordinateSpace requiresPosition;
         public bool requiresScreenPosition;
         public bool requiresVertexColor;
+        public bool requiresFaceSign;
         public List<UVChannel> requiresMeshUVs;
 
         public static ShaderGraphRequirements none
             newReqs.requiresPosition = other.requiresPosition | requiresPosition;
             newReqs.requiresScreenPosition = other.requiresScreenPosition | requiresScreenPosition;
             newReqs.requiresVertexColor = other.requiresVertexColor | requiresVertexColor;
+            newReqs.requiresFaceSign = other.requiresFaceSign | requiresFaceSign;
 
             newReqs.requiresMeshUVs = new List<UVChannel>();
             if (requiresMeshUVs != null)
             NeededCoordinateSpace requiresPosition = nodes.OfType<IMayRequirePosition>().Aggregate(NeededCoordinateSpace.None, (mask, node) => mask | node.RequiresPosition(stageCapability));
             bool requiresScreenPosition = nodes.OfType<IMayRequireScreenPosition>().Any(x => x.RequiresScreenPosition());
             bool requiresVertexColor = nodes.OfType<IMayRequireVertexColor>().Any(x => x.RequiresVertexColor());
+            bool requiresFaceSign = nodes.OfType<IMayRequireFaceSign>().Any(x => x.RequiresFaceSign());
 
             var meshUV = new List<UVChannel>();
             for (int uvIndex = 0; uvIndex < ShaderGeneratorNames.UVCount; ++uvIndex)
                 requiresPosition = requiresPosition,
                 requiresScreenPosition = requiresScreenPosition,
                 requiresVertexColor = requiresVertexColor,
+                requiresFaceSign = requiresFaceSign,
                 requiresMeshUVs = meshUV
             };
 

com.unity.shadergraph/Editor/Data/Util/GraphUtil.cs

             {
                 return 2;
             }
-            else if (typeName.Equals("float"))
+            else if (typeName.Equals("Single"))
             {
                 return 1;
             }
 
                 if (requirements.requiresScreenPosition)
                     surfaceDescriptionInputStruct.AppendLine("float4 {0};", ShaderGeneratorNames.ScreenPosition);
+
+                if (requirements.requiresFaceSign)
+                    surfaceDescriptionInputStruct.AppendLine("float {0};", ShaderGeneratorNames.FaceSign);
 
                 results.previewMode = PreviewMode.Preview3D;
                 if (!isUber)

com.unity.shadergraph/Editor/Data/Util/ShaderGenerator.cs

             if (pixelRequirements.requiresScreenPosition)
                 pixelShaderSurfaceInputs.AppendLine("surfaceInput.{0} = {0};", ShaderGeneratorNames.ScreenPosition);
 
+            if (pixelRequirements.requiresFaceSign)
+                pixelShaderSurfaceInputs.AppendLine("surfaceInput.{0} = {0};", ShaderGeneratorNames.FaceSign);
+
             foreach (var channel in pixelRequirements.requiresMeshUVs.Distinct())
                 pixelShaderSurfaceInputs.AppendLine("surfaceInput.{0} = {0};", ShaderGeneratorNames.GetUVName(channel));
 
                 pixelShaderSurfaceRemap.AppendLine("return surf.PreviewOutput;");
             }
 
+            // -------------------------------------
+            // Extra pixel shader work
+
+            var faceSign = new ShaderStringBuilder();
+
+            if (shaderGraphRequirements.requiresFaceSign)
+                faceSign.AppendLine(", half FaceSign : VFACE");
+
+            res = res.Replace("${FaceSign}", faceSign.ToString());
             res = res.Replace("${LocalPixelShader}", pixelShader.ToString());
             res = res.Replace("${SurfaceInputs}", pixelShaderSurfaceInputs.ToString());
             res = res.Replace("${SurfaceOutputRemap}", pixelShaderSurfaceRemap.ToString());
             return o;
         }
 
-        float4 frag (GraphVertexOutput IN) : SV_Target
+        float4 frag (GraphVertexOutput IN ${FaceSign}) : SV_Target
         {
     ${LocalPixelShader}
             SurfaceDescriptionInputs surfaceInput = (SurfaceDescriptionInputs)0;;

com.unity.shadergraph/Editor/Data/Util/ShaderGeneratorNames.cs

 
         public const string ScreenPosition = "ScreenPosition";
         public const string VertexColor = "VertexColor";
+        public const string FaceSign = "FaceSign";
 
 
         public static string GetUVName(this UVChannel channel)

com.unity.shadergraph/Editor/Data/Interfaces/IMayRequireFaceSign.cs

+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph
+{
+    public interface IMayRequireFaceSign
+    {
+        bool RequiresFaceSign(ShaderStageCapability stageCapability = ShaderStageCapability.Fragment);
+    }
+
+    public static class IMayRequireFaceSignExtensions
+    {
+        public static bool RequiresFaceSign(this ISlot slot)
+        {
+            var mayRequireFaceSign = slot as IMayRequireFaceSign;
+            return mayRequireFaceSign != null && mayRequireFaceSign.RequiresFaceSign();
+        }
+    }
+}

com.unity.shadergraph/Editor/Data/Interfaces/IMayRequireFaceSign.cs.meta

+fileFormatVersion: 2
+guid: 23f5d9c2f1ec442a7b8c59e893a6724d
+timeCreated: 1512469767

com.unity.shadergraph/Editor/Data/Nodes/Input/Geometry/FaceSignNode.cs

+using UnityEngine;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph
+{
+	[Title("Input", "Geometry", "Face Sign")]
+	public class FaceSignNode : AbstractMaterialNode, IGeneratesBodyCode, IMayRequireFaceSign
+	{
+		public FaceSignNode()
+		{
+			name = "Face Sign";
+			UpdateNodeAfterDeserialization();
+		}
+
+		public override string documentationURL
+		{
+			get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Face-Sign-Node"; }
+		}
+
+		public override bool hasPreview { get { return false; } }
+
+		public const int OutputSlotId = 0;
+        private const string kOutputSlotName = "Out";
+
+		public override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new BooleanMaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, true, ShaderStageCapability.Fragment));
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
+        }
+
+        public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+        {
+            visitor.AddShaderChunk(string.Format("{0} {1} = IN.{2};", precision, GetVariableNameForSlot(OutputSlotId), ShaderGeneratorNames.FaceSign), true);
+        }
+
+		public bool RequiresFaceSign(ShaderStageCapability stageCapability = ShaderStageCapability.Fragment)
+		{
+			return true;
+		}
+	}
+}

com.unity.shadergraph/Editor/Data/Nodes/Input/Geometry/FaceSignNode.cs.meta

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