Advanced master updates

- Add subsurface master node
- Add custom data support to abstract advanced master
- Removed pragma target 5.0 (for GL)

MaterialGraphProject/Assets/Matt/AbstractAdvancedMasterNode.cs

         public abstract string GetSurfaceOutputName();
         public abstract string GetLightFunction();
         public abstract string GetMaterialID();
+        public abstract int[] GetCustomDataSlots();
+        public abstract string[] GetCustomData();
 
         public override string GetSubShader(GenerationMode mode, PropertyGenerator shaderPropertiesVisitor)
         {
                     (node as IGeneratesBodyCode).GenerateNodeCode(shaderBody, generationMode);
             }
             ListPool<INode>.Release(nodes);
+            
+            foreach (var slot in GetInputSlots<MaterialSlot>())
+            {
+                if (!CheckForCustomData(slot.id)) // Check to ignore writing surface data for items getting packed into custom data
+                {
+                    foreach (var edge in owner.GetEdges(slot.slotReference))
+                    {
+                        var outputRef = edge.outputSlot;
+                        var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(outputRef.nodeGuid);
+                        if (fromNode == null)
+                            continue;
+                        var remapper = fromNode as INodeGroupRemapper;
+                        if (remapper != null && !remapper.IsValidSlotConnection(outputRef.slotId))
+                            continue;
+
+                        shaderBody.AddShaderChunk("o." + slot.shaderOutputName + " = " + fromNode.GetVariableNameForSlot(outputRef.slotId) + ";", true);
+
+                        if (slot.id == NormalSlotId)
+                            shaderBody.AddShaderChunk("o." + slot.shaderOutputName + " += 1e-6;", true);
+                    }
+
+                    // Write tangent data to WorldVectors input on SurfaceOutput
+                    if (slot.id == TangentSlotId)
+                    {
+                        var edges = owner.GetEdges(slot.slotReference);
+                        if (edges.Any())
+                        {
+                            shaderBody.AddShaderChunk("float3x3 worldToTangent;", false);
+                            shaderBody.AddShaderChunk("worldToTangent[0] = float3(1, 0, 0);", false);
+                            shaderBody.AddShaderChunk("worldToTangent[1] = float3(0, 1, 0);", false);
+                            shaderBody.AddShaderChunk("worldToTangent[2] = float3(0, 0, 1);", false);
+                            shaderBody.AddShaderChunk("float3 tangentTWS = mul(o." + slot.shaderOutputName + ", worldToTangent);", false);
+                            shaderBody.AddShaderChunk("o.WorldVectors = float3x3(tangentTWS, " + ShaderGeneratorNames.WorldSpaceBitangent + ", " + ShaderGeneratorNames.WorldSpaceNormal + ");", false);
+                        }
+                        else
+                        {
+                            shaderBody.AddShaderChunk("o.WorldVectors = float3x3(" + ShaderGeneratorNames.WorldSpaceTangent + ", " + ShaderGeneratorNames.WorldSpaceBitangent + ", " + ShaderGeneratorNames.WorldSpaceNormal + ");", false);
+                        }
+                    }
+                }
+            }
+
+            string[] customData = GetCustomData();
+            foreach(string data in customData)
+            {
+                shaderBody.AddShaderChunk(data, false);
+            }
+        }
+
+        public MaterialSlot GetMaterialSlot(int id)
+        {
+                if (slot.id == id)
+                    return slot;
+            }
+            return null;
+        }
+
+        public string GetVariableNameForSlotAtId(int id)
+        {
+            MaterialSlot slot = GetMaterialSlot(id);
+            if (slot != null)
+            {
                 foreach (var edge in owner.GetEdges(slot.slotReference))
                 {
                     var outputRef = edge.outputSlot;
                     if (remapper != null && !remapper.IsValidSlotConnection(outputRef.slotId))
                         continue;
 
-                    shaderBody.AddShaderChunk("o." + slot.shaderOutputName + " = " + fromNode.GetVariableNameForSlot(outputRef.slotId) + ";", true);
-
-                    if (slot.id == NormalSlotId)
-                        shaderBody.AddShaderChunk("o." + slot.shaderOutputName + " += 1e-6;", true);
+                    return fromNode.GetVariableNameForSlot(outputRef.slotId);
+                    //shaderBody.AddShaderChunk("o." + slot.shaderOutputName + " = " + fromNode.GetVariableNameForSlot(outputRef.slotId) + ";", true);
+            }
+            return "";
+        }
-                // Write tangent data to WorldVectors input on SurfaceOutput
-                if (slot.id == TangentSlotId)
-                {
-                    var edges = owner.GetEdges(slot.slotReference);
-                    if (edges.Any())
-                    {
-                        shaderBody.AddShaderChunk("float3x3 worldToTangent;", false);
-                        shaderBody.AddShaderChunk("worldToTangent[0] = float3(1, 0, 0);", false);
-                        shaderBody.AddShaderChunk("worldToTangent[1] = float3(0, 1, 0);", false);
-                        shaderBody.AddShaderChunk("worldToTangent[2] = float3(0, 0, 1);", false);
-                        shaderBody.AddShaderChunk("float3 tangentTWS = mul(o." + slot.shaderOutputName + ", worldToTangent);", false);
-                        shaderBody.AddShaderChunk("o.WorldVectors = float3x3(tangentTWS, "+ ShaderGeneratorNames.WorldSpaceBitangent + ", "+ ShaderGeneratorNames.WorldSpaceNormal+ ");", false);
-                    }
-                    else
-                    {
-                        shaderBody.AddShaderChunk("o.WorldVectors = float3x3(" + ShaderGeneratorNames.WorldSpaceTangent + ", " + ShaderGeneratorNames.WorldSpaceBitangent + ", " + ShaderGeneratorNames.WorldSpaceNormal + ");", false);
-                    }
-                }
+        bool CheckForCustomData(int id)
+        {
+            foreach (var custom in GetCustomDataSlots())
+            {
+                if (custom == id)
+                    return true;
+            return false;
         }
     }
 }

MaterialGraphProject/Assets/Matt/AnisotropicMetallicMasterNode.cs

 
         public AnisotropicMetallicMasterNode()
         {
-            name = "AnisotropicMetallicMasterNode";
+            name = "AnisotropicMetallicMaster";
             UpdateNodeAfterDeserialization();
         }
 
+        }
+
+        public override int[] GetCustomDataSlots()
+        {
+            return new int[] { };
+        }
+
+        public override string[] GetCustomData()
+        {
+            return new string[] { };
         }
 
         public sealed override void UpdateNodeAfterDeserialization()

MaterialGraphProject/Assets/Matt/New Material.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: New Material
-  m_Shader: {fileID: 4800000, guid: 9ab5e16c2083a4fe689209a8c1ae425e, type: 3}
+  m_Shader: {fileID: 4800000, guid: 4afc3341bed83d34cb1aebb7e98d8751, type: 3}
   m_ShaderKeywords: 
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Templates/advancedSubshader.template

 
 float3 SubsurfaceShadingSimple(float3 diffColor, float3 normal, float3 viewDir, float3 thickness, UnityLight light)
 {
-	half3 vLTLight = light.dir + normal * _TDistortion;
-	half  fLTDot = pow(saturate(dot(viewDir, -vLTLight)), _TPower) * _TScale;
-	half3 fLT = _TAttenuation * (fLTDot + _TAmbient) * (thickness);
-	return diffColor * ((light.color * fLT) * _TransmissionOverallStrength);
+	half3 vLTLight = light.dir + normal * 1;
+	half  fLTDot = pow(saturate(dot(viewDir, -vLTLight)), 3.5) * 1.5;
+	half3 fLT = 1 * (fLTDot + 1.2) * (thickness);
+	return diffColor * ((light.color * fLT) * 0.4);
 }
 
 // ------------------------------------------------------------------
 	///END
 	
 	
-	#pragma target 5.0
+	//#pragma target 5.0
 	#pragma surface surf ${LightingFunctionName} ${VertexShaderDecl}
 	#pragma glsl
 	#pragma debug

MaterialGraphProject/Assets/Matt/SubsurfaceMaster.ShaderGraph.meta

+fileFormatVersion: 2
+guid: 25497a67e7ee41d4c8f2039c1df994a1
+timeCreated: 1495614205
+licenseType: Pro
+ScriptedImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3}

MaterialGraphProject/Assets/Matt/SubsurfaceMetallicMasterNode.cs

+using System;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    [Title("Master/SubsurfaceMetallic")]
+    public class SubsurfaceMetallicMasterNode : AbstractAdvancedMasterNode
+    {
+        public const string MetallicSlotName = "Metallic";
+        public const int MetallicSlotId = 2;
+
+        public const string TranslucencySlotName = "Translucency";
+        public const int TranslucencySlotId = 9;
+
+        public const string LightFunctionName = "Advanced";
+        public const string SurfaceOutputStructureName = "SurfaceOutputAdvanced";
+
+        public SubsurfaceMetallicMasterNode()
+        {
+            name = "SubsurfaceMetallic";
+            UpdateNodeAfterDeserialization();
+        }
+
+        public override string GetMaterialID()
+        {
+            return "SHADINGMODELID_SUBSURFACE";
+        }
+
+        public override int[] GetCustomDataSlots()
+        {
+            return new int[] { 9 };
+        }
+
+        public override string[] GetCustomData()
+        {
+            string translucencyInput = GetVariableNameForSlotAtId(9);
+            if (translucencyInput == "")
+                translucencyInput = "float3(0,0,0)";
+            else
+                translucencyInput = translucencyInput + ".rgb";
+            return new string[] { "o.CustomData = float4(" + translucencyInput + ", 0);" };
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new MaterialSlot(AlbedoSlotId, AlbedoSlotName, AlbedoSlotName, SlotType.Input, SlotValueType.Vector3, Vector4.zero));
+            AddSlot(new MaterialSlot(NormalSlotId, NormalSlotName, NormalSlotName, SlotType.Input, SlotValueType.Vector3, Vector4.zero));
+            AddSlot(new MaterialSlot(EmissionSlotId, EmissionSlotName, EmissionSlotName, SlotType.Input, SlotValueType.Vector3, Vector4.zero));
+            AddSlot(new MaterialSlot(MetallicSlotId, MetallicSlotName, MetallicSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero));
+            AddSlot(new MaterialSlot(SmoothnessSlotId, SmoothnessSlotName, SmoothnessSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero));
+            AddSlot(new MaterialSlot(OcclusionSlotId, OcclusionSlotName, OcclusionSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero));
+            AddSlot(new MaterialSlot(AnisotropySlotId, AnisotropySlotName, AnisotropySlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero));
+            AddSlot(new MaterialSlot(TangentSlotId, TangentSlotName, TangentSlotName, SlotType.Input, SlotValueType.Vector3, Vector4.zero));
+            AddSlot(new MaterialSlot(AnisotropySlotId, AnisotropySlotName, AnisotropySlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero));
+            AddSlot(new MaterialSlot(TranslucencySlotId, TranslucencySlotName, TranslucencySlotName, SlotType.Input, SlotValueType.Vector3, Vector4.zero));
+
+            // clear out slot names that do not match the slots
+            // we support
+            RemoveSlotsNameNotMatching(
+                                       new[]
+                                       {
+                                           AlbedoSlotId,
+                                           NormalSlotId,
+                                           EmissionSlotId,
+                                           MetallicSlotId,
+                                           SmoothnessSlotId,
+                                           OcclusionSlotId,
+                                           AlphaSlotId,
+                                           AnisotropySlotId,
+                                           TangentSlotId,
+                                           TranslucencySlotId
+                                       });
+        }
+        
+        public override string GetSurfaceOutputName()
+        {
+            return SurfaceOutputStructureName;
+        }
+
+        public override string GetLightFunction()
+        {
+            return LightFunctionName;
+        }
+    }
+}

MaterialGraphProject/Assets/Matt/SubsurfaceMetallicMasterNode.cs.meta

+fileFormatVersion: 2
+guid: 7c541e9dc2ccc50469af225259c7cb17
+timeCreated: 1478188276
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: