Merge branch 'master' into node-input

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/ColorShaderProperty.cs

             displayName = "Color";
         }
 
+        public ColorShaderProperty(bool hdr)
+        {
+            displayName = "HDR Color";
+            HDR = hdr;
+        }
+
         public override PropertyType propertyType
         {
             get { return PropertyType.Color; }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/DynamicVectorMaterialSlot.cs

         protected override string ConcreteSlotValueAsVariable(AbstractMaterialNode.OutputPrecision precision)
         {
             var channelCount = SlotValueHelper.GetChannelCount(concreteValueType);
-            var values = value.x.ToString();
+            string values = NodeUtils.FloatToShaderValue(value.x);
             if (channelCount == 1)
                 return values;
             for (var i = 1; i < channelCount; i++)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/MaterialSlot.cs

                     return "(3)";
                 case ConcreteSlotValueType.Vector4:
                     return "(4)";
+                case ConcreteSlotValueType.Boolean:
+                    return "(B)";
                 case ConcreteSlotValueType.Matrix2:
                     return "(2x2)";
                 case ConcreteSlotValueType.Matrix3:
                     return new Vector2MaterialSlot(slotId, displayName, shaderOutputName, slotType, defaultValue, shaderStage, hidden);
                 case SlotValueType.Vector1:
                     return new Vector1MaterialSlot(slotId, displayName, shaderOutputName, slotType, defaultValue.x, shaderStage, hidden);
+                case SlotValueType.Boolean:
+                    return new BooleanMaterialSlot(slotId, displayName, shaderOutputName, slotType, false, shaderStage, hidden);
             }
 
             throw new ArgumentOutOfRangeException("type", type, null);
                         || inputType == SlotValueType.Vector2
                         || inputType == SlotValueType.Vector1
                         || inputType == SlotValueType.Dynamic;
+                case SlotValueType.Boolean:
+                    return inputType == SlotValueType.Boolean;
             }
             return false;
         }
                     return PropertyType.Texture;
                 case ConcreteSlotValueType.Cubemap:
                     return PropertyType.Cubemap;
+                case ConcreteSlotValueType.Boolean:
+                    return PropertyType.Boolean;
                 case ConcreteSlotValueType.Vector1:
                     return PropertyType.Float;
                 case ConcreteSlotValueType.Vector2:

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/PreviewProperty.cs

             public Vector4 vector4Value;
             [FieldOffset(0)]
             public float floatValue;
+            [FieldOffset(0)]
+            public bool booleanValue;
         }
 
         Data m_Data;
             }
         }
 
+        public bool booleanValue
+        {
+            get
+            {
+                if (propType != PropertyType.Boolean)
+                    throw new ArgumentException(string.Format(k_GetErrorMessage, PropertyType.Boolean, propType));
+                return m_Data.booleanValue;
+            }
+            set
+            {
+                if (propType != PropertyType.Boolean)
+                    throw new ArgumentException(string.Format(k_SetErrorMessage, PropertyType.Boolean, propType));
+                m_Data.booleanValue = value;
+            }
+        }
+
         const string k_SetErrorMessage = "Cannot set a {0} property on a PreviewProperty with type {1}.";
         const string k_GetErrorMessage = "Cannot get a {0} property on a PreviewProperty with type {1}.";
 
                 block.SetVector(name, m_Data.vector4Value);
             else if (propType == PropertyType.Float)
                 block.SetFloat(name, m_Data.floatValue);
+            else if (propType == PropertyType.Boolean)
+                block.SetFloat(name, m_Data.booleanValue ? 1 : 0);
         }
     }
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/SerializableCubemap.cs

 namespace UnityEditor.ShaderGraph
 {
     [Serializable]
-    public class SerializableCubemap : ISerializationCallbackReceiver
+    public class SerializableCubemap
     {
         [SerializeField]
         private string m_SerializedCubemap;
             public Cubemap cubemap;
         }
 
-        Cubemap m_Cubemap;
-
-                if (m_Cubemap == null && !string.IsNullOrEmpty(m_SerializedCubemap))
-                {
-                    var cube = new CubemapHelper();
-                    EditorJsonUtility.FromJsonOverwrite(m_SerializedCubemap, cube);
-                    m_Cubemap = cube.cubemap;
-                    m_SerializedCubemap = null;
-                }
-                return m_Cubemap;
-            }
-            set { m_Cubemap = value; }
-        }
+                if (string.IsNullOrEmpty(m_SerializedCubemap))
+                    return null;
-        public void OnBeforeSerialize()
-        {
-            var cube = new CubemapHelper { cubemap = cubemap };
-            m_SerializedCubemap = EditorJsonUtility.ToJson(cube, true);
-        }
+                var cube = new CubemapHelper();
+                EditorJsonUtility.FromJsonOverwrite(m_SerializedCubemap, cube);
+                return cube.cubemap;
+            }
+            set
+            {
+                if(cubemap == value)
+                    return;
-        public void OnAfterDeserialize()
-        {
+                var cubemapHelper = new CubemapHelper();
+                cubemapHelper.cubemap = value;
+                m_SerializedCubemap = EditorJsonUtility.ToJson(cubemapHelper, true);
+            }
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/SerializableTexture.cs

 namespace UnityEditor.ShaderGraph
 {
     [Serializable]
-    public class SerializableTexture : ISerializationCallbackReceiver
+    public class SerializableTexture
     {
         [SerializeField]
         private string m_SerializedTexture;
             public Texture texture;
         }
 
-        Texture m_Texture;
-
-                if (m_Texture == null && !string.IsNullOrEmpty(m_SerializedTexture))
-                {
-                    var tex = new TextureHelper();
-                    EditorJsonUtility.FromJsonOverwrite(m_SerializedTexture, tex);
-                    m_Texture = tex.texture;
-                    m_SerializedTexture = null;
-                }
-                return m_Texture;
+                if (string.IsNullOrEmpty(m_SerializedTexture))
+                    return null;
+                var tex = new TextureHelper();
+                EditorJsonUtility.FromJsonOverwrite(m_SerializedTexture, tex);
+                return tex.texture;
-            set { m_Texture = value; }
-        }
+            set
+            {
+                if (texture == value)
+                    return;
-        public void OnBeforeSerialize()
-        {
-            var tex = new TextureHelper { texture = texture };
-            m_SerializedTexture = EditorJsonUtility.ToJson(tex, true);
-        }
-
-        public void OnAfterDeserialize()
-        {
+                var textureHelper = new TextureHelper();
+                textureHelper.texture = value;
+                m_SerializedTexture = EditorJsonUtility.ToJson(textureHelper, true);
+            }
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/Vector1MaterialSlot.cs

 
         protected override string ConcreteSlotValueAsVariable(AbstractMaterialNode.OutputPrecision precision)
         {
-            return value.ToString();
+            return NodeUtils.FloatToShaderValue(value);
         }
 
         public override void AddDefaultProperty(PropertyCollector properties, GenerationMode generationMode)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/Vector2MaterialSlot.cs

 
         protected override string ConcreteSlotValueAsVariable(AbstractMaterialNode.OutputPrecision precision)
         {
-            return precision + "2 (" + value.x + "," + value.y + ")";
+            return precision + "2 (" + NodeUtils.FloatToShaderValue(value.x) + "," + NodeUtils.FloatToShaderValue(value.y) + ")";
         }
 
         public override void AddDefaultProperty(PropertyCollector properties, GenerationMode generationMode)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/Vector3MaterialSlot.cs

 
         protected override string ConcreteSlotValueAsVariable(AbstractMaterialNode.OutputPrecision precision)
         {
-            return precision + "3 (" + value.x + "," + value.y + "," + value.z + ")";
+            return precision + "3 (" + NodeUtils.FloatToShaderValue(value.x) + "," + NodeUtils.FloatToShaderValue(value.y) + "," + NodeUtils.FloatToShaderValue(value.z) + ")";
         }
 
         public override void AddDefaultProperty(PropertyCollector properties, GenerationMode generationMode)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/Vector4MaterialSlot.cs

 
         protected override string ConcreteSlotValueAsVariable(AbstractMaterialNode.OutputPrecision precision)
         {
-            return precision + "4 (" + value.x + "," + value.y + "," + value.z + "," + value.w + ")";
+            return precision + "4 (" + NodeUtils.FloatToShaderValue(value.x) + "," + NodeUtils.FloatToShaderValue(value.y) + "," + NodeUtils.FloatToShaderValue(value.z) + "," + NodeUtils.FloatToShaderValue(value.w) + ")";
         }
 
         public override void AddDefaultProperty(PropertyCollector properties, GenerationMode generationMode)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Implementation/NodeUtils.cs

 using System;
 using System.Collections.Generic;
+using System.Globalization;
+using UnityEngine;
 
 namespace UnityEditor.Graphing
 {
         {
             switch (slotValue)
             {
+                case ConcreteSlotValueType.Boolean:
+                    return p.ToString();
                 case ConcreteSlotValueType.Vector1:
                     return p.ToString();
                 case ConcreteSlotValueType.Vector2:
             char[] arr = input.ToCharArray();
             arr = Array.FindAll<char>(arr, (c => (Char.IsLetterOrDigit(c))));
             return new string(arr);
+        }
+
+        public static string FloatToShaderValue(float value)
+        {
+            if (Single.IsPositiveInfinity(value))
+                return "1.#INF";
+            else if (Single.IsNegativeInfinity(value))
+                return "-1.#INF";
+            else if (Single.IsNaN(value))
+                return "NAN";
+            else
+            {
+                decimal amount;
+                if( decimal.TryParse(value.ToString(), NumberStyles.Any, CultureInfo.InvariantCulture, out amount) )
+                    return amount.ToString();
+                else
+                    return value.ToString();
+            }
         }
     }
 }

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

             }
         };
 
-        private static void GenerateApplicationVertexInputs(ShaderGraphRequirements graphRequiements, ShaderGenerator vertexInputs)
-        {
-            vertexInputs.AddShaderChunk("struct GraphVertexInput", false);
-            vertexInputs.AddShaderChunk("{", false);
-            vertexInputs.Indent();
-            vertexInputs.AddShaderChunk("float4 vertex : POSITION;", false);
-            vertexInputs.AddShaderChunk("float3 normal : NORMAL;", false);
-            vertexInputs.AddShaderChunk("float4 tangent : TANGENT;", false);
-
-            if (graphRequiements.requiresVertexColor)
-            {
-                vertexInputs.AddShaderChunk("float4 color : COLOR;", false);
-            }
-
-            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", true);
-            vertexInputs.Deindent();
-            vertexInputs.AddShaderChunk("};", false);
-        }
-
         private static string GetShaderPassFromTemplate(string template, PBRMasterNode masterNode, Pass pass, GenerationMode mode, SurfaceMaterialOptions materialOptions)
         {
             var builder = new ShaderStringBuilder();
             modelRequiements.requiresViewDir |= NeededCoordinateSpace.World;
             modelRequiements.requiresMeshUVs.Add(UVChannel.UV1);
 
-            GenerateApplicationVertexInputs(requirements.Union(modelRequiements), vertexInputs);
+            GraphUtil.GenerateApplicationVertexInputs(requirements.Union(modelRequiements), vertexInputs);
             ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresNormal, InterpolatorType.Normal, surfaceInputs);
             ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresTangent, InterpolatorType.Tangent, surfaceInputs);
             ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresBitangent, InterpolatorType.BiTangent, surfaceInputs);
             if (masterNode.model == PBRMasterNode.Model.Specular)
                 defines.AddShaderChunk("#define _SPECULAR_SETUP 1", true);
 
-            switch (masterNode.alphaMode)
-            {
-                case PBRMasterNode.AlphaMode.AlphaBlend:
-                case PBRMasterNode.AlphaMode.AdditiveBlend:
-                    defines.AddShaderChunk("#define _AlphaOut 1", true);
-                    break;
-            }
-
-                    defines.AddShaderChunk("#define _AlphaClip 1", true);
+                defines.AddShaderChunk("#define _AlphaClip 1", true);
 
             var templateLocation = ShaderGenerator.GetTemplatePath(template);
 
             resultPass = resultPass.Replace("${SurfaceInputs}", localSurfaceInputs.GetShaderString(3));
             resultPass = resultPass.Replace("${SurfaceOutputRemap}", surfaceOutputRemap.GetShaderString(3));
 
-
             resultPass = resultPass.Replace("${Tags}", string.Empty);
             resultPass = resultPass.Replace("${Blending}", blendingVisitor.GetShaderString(2));
             resultPass = resultPass.Replace("${Culling}", cullingVisitor.GetShaderString(2));
             subShader.Indent();
             subShader.AddShaderChunk("Tags{ \"RenderPipeline\" = \"LightweightPipeline\"}", true);
 
-            var materialOptions = new SurfaceMaterialOptions();
-            switch (masterNode.alphaMode)
-            {
-                case PBRMasterNode.AlphaMode.Opaque:
-                    materialOptions.srcBlend = SurfaceMaterialOptions.BlendMode.One;
-                    materialOptions.dstBlend = SurfaceMaterialOptions.BlendMode.Zero;
-                    materialOptions.cullMode = SurfaceMaterialOptions.CullMode.Back;
-                    materialOptions.zTest = SurfaceMaterialOptions.ZTest.LEqual;
-                    materialOptions.zWrite = SurfaceMaterialOptions.ZWrite.On;
-                    materialOptions.renderQueue = SurfaceMaterialOptions.RenderQueue.Geometry;
-                    materialOptions.renderType = SurfaceMaterialOptions.RenderType.Opaque;
-                    break;
-                case PBRMasterNode.AlphaMode.AlphaBlend:
-                    materialOptions.srcBlend = SurfaceMaterialOptions.BlendMode.SrcAlpha;
-                    materialOptions.dstBlend = SurfaceMaterialOptions.BlendMode.OneMinusSrcAlpha;
-                    materialOptions.cullMode = SurfaceMaterialOptions.CullMode.Back;
-                    materialOptions.zTest = SurfaceMaterialOptions.ZTest.LEqual;
-                    materialOptions.zWrite = SurfaceMaterialOptions.ZWrite.Off;
-                    materialOptions.renderQueue = SurfaceMaterialOptions.RenderQueue.Transparent;
-                    materialOptions.renderType = SurfaceMaterialOptions.RenderType.Transparent;
-                    break;
-                case PBRMasterNode.AlphaMode.AdditiveBlend:
-                    materialOptions.srcBlend = SurfaceMaterialOptions.BlendMode.One;
-                    materialOptions.dstBlend = SurfaceMaterialOptions.BlendMode.One;
-                    materialOptions.cullMode = SurfaceMaterialOptions.CullMode.Back;
-                    materialOptions.zTest = SurfaceMaterialOptions.ZTest.LEqual;
-                    materialOptions.zWrite = SurfaceMaterialOptions.ZWrite.Off;
-                    materialOptions.renderQueue = SurfaceMaterialOptions.RenderQueue.Transparent;
-                    materialOptions.renderType = SurfaceMaterialOptions.RenderType.Transparent;
-                    break;
-            }
-
+            var materialOptions = MasterNode.GetMaterialOptionsFromAlphaMode(masterNode.alphaMode);
             var tagsVisitor = new ShaderGenerator();
             materialOptions.GetTags(tagsVisitor);
             subShader.AddShaderChunk(tagsVisitor.GetShaderString(0), true);

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

             PixelShaderSlots = new List<int>()
             {
                 UnlitMasterNode.ColorSlotId,
-                UnlitMasterNode.AlphaSlotId
+                UnlitMasterNode.AlphaSlotId,
+                UnlitMasterNode.AlphaThresholdSlotId
             }
         };
 
             public List<int> PixelShaderSlots;
         }
 
-        private static string GetShaderPassFromTemplate(string template, UnlitMasterNode masterNode, Pass pass, GenerationMode mode)
+        private static string GetShaderPassFromTemplate(
+            string template, 
+            UnlitMasterNode masterNode, 
+            Pass pass, 
+            GenerationMode mode,
+            SurfaceMaterialOptions materialOptions)
         {
             var builder = new ShaderStringBuilder();
             builder.IncreaseIndent();
             graph.AddShaderChunk(surfaceVertexShader.GetShaderString(2), false);
             graph.AddShaderChunk(surfaceDescriptionFunction.GetShaderString(2), false);
 
-            var tagsVisitor = new ShaderGenerator();
-
-            var materialOptions = new SurfaceMaterialOptions();
-            materialOptions.GetTags(tagsVisitor);
+            
             materialOptions.GetBlend(blendingVisitor);
             materialOptions.GetCull(cullingVisitor);
             materialOptions.GetDepthTest(zTestVisitor);
             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,
                 CoordinateSpace.World);
 
             ShaderGenerator defines = new ShaderGenerator();
+
+            if (masterNode.IsSlotConnected(UnlitMasterNode.AlphaThresholdSlotId))
+                defines.AddShaderChunk("#define _AlphaClip 1", true);
+
             var templateLocation = ShaderGenerator.GetTemplatePath(template);
 
             foreach (var slot in usedSlots)
             resultPass = resultPass.Replace("${SurfaceInputs}", localSurfaceInputs.GetShaderString(3));
             resultPass = resultPass.Replace("${SurfaceOutputRemap}", surfaceOutputRemap.GetShaderString(3));
 
-
-            resultPass = resultPass.Replace("${Tags}", tagsVisitor.GetShaderString(2));
+            resultPass = resultPass.Replace("${Tags}", string.Empty);
-            resultPass = resultPass.Replace("${LOD}", "" + materialOptions.lod);
             return resultPass;
         }
 
             subShader.Indent();
             subShader.AddShaderChunk("Tags{ \"RenderType\" = \"Opaque\" \"RenderPipeline\" = \"LightweightPipeline\"}", true);
 
+            var materialOptions = MasterNode.GetMaterialOptionsFromAlphaMode(masterNode.alphaMode);
+            var tagsVisitor = new ShaderGenerator();
+            materialOptions.GetTags(tagsVisitor);
+            subShader.AddShaderChunk(tagsVisitor.GetShaderString(0), true);
+
-                    mode),
+                    mode,
+                    materialOptions),
                 true);
 
             subShader.Deindent();

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

 
 namespace UnityEditor.ShaderGraph
 {
+    public enum AlphaMode
+    {
+        Opaque,
+        AlphaBlend,
+        AdditiveBlend
+    }
+
     [Serializable]
     [Title("Master", "PBR")]
     public class PBRMasterNode : MasterNode
             Metallic
         }
 
-        public enum AlphaMode
-        {
-            Opaque,
-            AlphaBlend,
-            AdditiveBlend
-        }
-
         [SerializeField]
         private Model m_Model = Model.Metallic;
 
         public PBRMasterNode()
         {
             UpdateNodeAfterDeserialization();
-        }
-
-        public bool IsSlotConnected(int slotId)
-        {
-            var slot = FindSlot<MaterialSlot>(slotId);
-            return slot != null && owner.GetEdges(slot.slotReference).Any();
         }
 
         public sealed override void UpdateNodeAfterDeserialization()

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

 using System.Collections.Generic;
 using System.Linq;
 using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph
     {
         public const string ColorSlotName = "Color";
         public const string AlphaSlotName = "Alpha";
+        public const string AlphaClipThresholdSlotName = "AlphaClipThreshold";
+        public const int AlphaThresholdSlotId = 8;
+
+        [SerializeField]
+        private AlphaMode m_AlphaMode;
+
+        [EnumControl("")]
+        public AlphaMode alphaMode
+        {
+            get { return m_AlphaMode; }
+            set
+            {
+                if (m_AlphaMode == value)
+                    return;
+
+                m_AlphaMode = value;
+                Dirty(ModificationScope.Graph);
+            }
+        }
 
         public UnlitMasterNode()
         {
             name = "Unlit Master";
             AddSlot(new ColorRGBMaterialSlot(ColorSlotId, ColorSlotName, ColorSlotName, SlotType.Input, Color.grey, ShaderStage.Fragment));
             AddSlot(new Vector1MaterialSlot(AlphaSlotId, AlphaSlotName, AlphaSlotName, SlotType.Input, 1, ShaderStage.Fragment));
+            AddSlot(new Vector1MaterialSlot(AlphaThresholdSlotId, AlphaClipThresholdSlotName, AlphaClipThresholdSlotName, SlotType.Input, 0f, ShaderStage.Fragment));
 
             // clear out slot names that do not match the slots
             // we support
                 ColorSlotId,
-                AlphaSlotId
+                AlphaSlotId,
+                AlphaThresholdSlotId
             });
         }
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/AbstractMaterialNode.cs

 
         public virtual void UpdateNodeAfterDeserialization()
         {}
+
+        public bool IsSlotConnected(int slotId)
+        {
+            var slot = FindSlot<MaterialSlot>(slotId);
+            return slot != null && owner.GetEdges(slot.slotReference).Any();
+        }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/CodeFunctionNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        protected struct Boolean
+        {}
+
         protected struct Vector1
         {}
 
             if (p.ParameterType.IsByRef)
                 t = p.ParameterType.GetElementType();
 
+            if (t == typeof(Boolean))
+            {
+                return SlotValueType.Boolean;
+            }
             if (t == typeof(Vector1))
             {
                 return SlotValueType.Vector1;

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/Vector1Node.cs

             if (generationMode.IsPreview())
                 return;
 
-            visitor.AddShaderChunk(precision + " " + GetVariableNameForNode() + " = " + m_Value + ";", true);
+            visitor.AddShaderChunk(precision + " " + GetVariableNameForNode() + " = " + NodeUtils.FloatToShaderValue(m_Value) + ";", true);
         }
 
         public override string GetVariableNameForSlot(int slotId)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/Vector2Node.cs

             if (generationMode.IsPreview())
                 return;
 
-            visitor.AddShaderChunk(precision + "2 " + GetVariableNameForNode() + " = " + precision + "2" + m_Value + ";", true);
+            visitor.AddShaderChunk(string.Format("{0}2 {1} = {0}2({2},{3});", precision, GetVariableNameForNode(), NodeUtils.FloatToShaderValue(m_Value.x), NodeUtils.FloatToShaderValue(m_Value.y)), true);
         }
 
         public override string GetVariableNameForSlot(int slotId)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/Vector3Node.cs

             if (generationMode.IsPreview())
                 return;
 
-            visitor.AddShaderChunk(precision + "3 " + GetVariableNameForNode() + " = " + precision + "3" + m_Value + ";", true);
+            var s = string.Format("{0}3 {1} = {0}3({2},{3},{4});",
+                precision,
+                GetVariableNameForNode(),
+                NodeUtils.FloatToShaderValue(m_Value.x),
+                NodeUtils.FloatToShaderValue(m_Value.y),
+                NodeUtils.FloatToShaderValue(m_Value.z));
+            visitor.AddShaderChunk(s, true);
         }
 
         public override string GetVariableNameForSlot(int slotId)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/Vector4Node.cs

             if (generationMode.IsPreview())
                 return;
 
-            visitor.AddShaderChunk(precision + "4 " + GetVariableNameForNode() + " = " + precision + "4" + m_Value + ";", true);
+            var s = string.Format("{0}4 {1} = {0}4({2},{3},{4},{5});",
+                precision,
+                GetVariableNameForNode(),
+                NodeUtils.FloatToShaderValue(m_Value.x),
+                NodeUtils.FloatToShaderValue(m_Value.y),
+                NodeUtils.FloatToShaderValue(m_Value.z),
+                NodeUtils.FloatToShaderValue(m_Value.w));
+            visitor.AddShaderChunk(s, true);
         }
 
         public override string GetVariableNameForSlot(int slotId)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/PropertyNode.cs

                 AddSlot(new CubemapMaterialSlot(OutputSlotId, "Out", "Out", SlotType.Output));
                 RemoveSlotsNameNotMatching(new[] { OutputSlotId });
             }
+            else if (property is IntegerShaderProperty)
+            {
+                AddSlot(new Vector1MaterialSlot(OutputSlotId, "Out", "Out", SlotType.Output, 0));
+                RemoveSlotsNameNotMatching(new[] { OutputSlotId });
+            }
+            else if (property is SliderShaderProperty)
+            {
+                AddSlot(new Vector1MaterialSlot(OutputSlotId, "Out", "Out", SlotType.Output, 0));
+                RemoveSlotsNameNotMatching(new[] { OutputSlotId });
+            }
+            else if (property is BooleanShaderProperty)
+            {
+                AddSlot(new BooleanMaterialSlot(OutputSlotId, "Out", "Out", SlotType.Output, false));
+                RemoveSlotsNameNotMatching(new[] { OutputSlotId });
+            }
         }
 
         public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
             else if (property is ColorShaderProperty)
             {
                 var result = string.Format("{0}4 {1} = {2};"
+                        , precision
+                        , GetVariableNameForSlot(OutputSlotId)
+                        , property.referenceName);
+                visitor.AddShaderChunk(result, true);
+            }
+            else if (property is IntegerShaderProperty)
+            {
+                var result = string.Format("{0} {1} = {2};"
+                        , precision
+                        , GetVariableNameForSlot(OutputSlotId)
+                        , property.referenceName);
+                visitor.AddShaderChunk(result, true);
+            }
+            else if (property is SliderShaderProperty)
+            {
+                var result = string.Format("{0} {1} = {2};"
+                        , precision
+                        , GetVariableNameForSlot(OutputSlotId)
+                        , property.referenceName);
+                visitor.AddShaderChunk(result, true);
+            }
+            else if (property is BooleanShaderProperty)
+            {
+                var result = string.Format("{0} {1} = {2};"
                         , precision
                         , GetVariableNameForSlot(OutputSlotId)
                         , property.referenceName);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/MasterNode.cs

         }
 
         public abstract string GetShader(GenerationMode mode, string name, out List<PropertyCollector.TextureInfo> configuredTextures);
+        
+        public static SurfaceMaterialOptions GetMaterialOptionsFromAlphaMode(AlphaMode alphaMode)
+        {
+            var materialOptions = new SurfaceMaterialOptions();
+            switch (alphaMode)
+            {
+                case AlphaMode.Opaque:
+                    materialOptions.srcBlend = SurfaceMaterialOptions.BlendMode.One;
+                    materialOptions.dstBlend = SurfaceMaterialOptions.BlendMode.Zero;
+                    materialOptions.cullMode = SurfaceMaterialOptions.CullMode.Back;
+                    materialOptions.zTest = SurfaceMaterialOptions.ZTest.LEqual;
+                    materialOptions.zWrite = SurfaceMaterialOptions.ZWrite.On;
+                    materialOptions.renderQueue = SurfaceMaterialOptions.RenderQueue.Geometry;
+                    materialOptions.renderType = SurfaceMaterialOptions.RenderType.Opaque;
+                    break;
+                case AlphaMode.AlphaBlend:
+                    materialOptions.srcBlend = SurfaceMaterialOptions.BlendMode.SrcAlpha;
+                    materialOptions.dstBlend = SurfaceMaterialOptions.BlendMode.OneMinusSrcAlpha;
+                    materialOptions.cullMode = SurfaceMaterialOptions.CullMode.Back;
+                    materialOptions.zTest = SurfaceMaterialOptions.ZTest.LEqual;
+                    materialOptions.zWrite = SurfaceMaterialOptions.ZWrite.Off;
+                    materialOptions.renderQueue = SurfaceMaterialOptions.RenderQueue.Transparent;
+                    materialOptions.renderType = SurfaceMaterialOptions.RenderType.Transparent;
+                    break;
+                case AlphaMode.AdditiveBlend:
+                    materialOptions.srcBlend = SurfaceMaterialOptions.BlendMode.One;
+                    materialOptions.dstBlend = SurfaceMaterialOptions.BlendMode.One;
+                    materialOptions.cullMode = SurfaceMaterialOptions.CullMode.Back;
+                    materialOptions.zTest = SurfaceMaterialOptions.ZTest.LEqual;
+                    materialOptions.zWrite = SurfaceMaterialOptions.ZWrite.Off;
+                    materialOptions.renderQueue = SurfaceMaterialOptions.RenderQueue.Transparent;
+                    materialOptions.renderType = SurfaceMaterialOptions.RenderType.Transparent;
+                    break;
+            }
+            return materialOptions;
+        }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/PropertyType.cs

         Color,
         Texture,
         Cubemap,
+        Boolean,
         Float,
         Vector2,
         Vector3,

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/SlotValue.cs

         Vector4,
         Vector3,
         Vector2,
-        Vector1
+        Vector1,
+        Boolean
     }
 
     public enum ConcreteSlotValueType
         Vector4,
         Vector3,
         Vector2,
-        Vector1
+        Vector1,
+        Boolean
     }
 
     public static class SlotValueHelper
             "typeFloat4",
             "typeFloat3",
             "typeFloat2",
-            "typeFloat1"
+            "typeFloat1",
+            "typeBoolean"
         };
 
         public static string ToClassName(this ConcreteSlotValueType type)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Util/GraphUtil.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", true);
             vertexInputs.Deindent();
             vertexInputs.AddShaderChunk("};", false);
         }
                 finalBuilder.AppendLine(@"#include ""CoreRP/ShaderLibrary/Common.hlsl""");
                 finalBuilder.AppendLine(@"#include ""CoreRP/ShaderLibrary/Packing.hlsl""");
                 finalBuilder.AppendLine(@"#include ""CoreRP/ShaderLibrary/Color.hlsl""");
+                finalBuilder.AppendLine(@"#include ""CoreRP/ShaderLibrary/UnityInstancing.hlsl""");
                 finalBuilder.AppendLine(@"#include ""CoreRP/ShaderLibrary/EntityLighting.hlsl""");
                 finalBuilder.AppendLine(@"#include ""ShaderGraphLibrary/ShaderVariables.hlsl""");
                 finalBuilder.AppendLine(@"#include ""ShaderGraphLibrary/ShaderVariablesFunctions.hlsl""");
                         var foundEdges = graph.GetEdges(input.slotReference).ToArray();
                         if (foundEdges.Any())
                         {
-                            var outputRef = foundEdges[0].outputSlot;
-                            var fromNode = graph.GetNodeFromGuid<AbstractMaterialNode>(outputRef.nodeGuid);
-                            surfaceDescriptionFunction.AddShaderChunk(string.Format("surface.{0} = {1};", NodeUtils.GetHLSLSafeName(input.shaderOutputName), fromNode.GetVariableNameForSlot(outputRef.slotId)), true);
+                            surfaceDescriptionFunction.AddShaderChunk(string.Format("surface.{0} = {1};", NodeUtils.GetHLSLSafeName(input.shaderOutputName), masterNode.GetSlotValue(input.id, mode)), true);
                         }
                         else
                         {
                 else if (masterNode.hasPreview)
                 {
                     foreach (var slot in masterNode.GetOutputSlots<MaterialSlot>())
-                        surfaceDescriptionFunction.AddShaderChunk(string.Format("surface.{0} = {1};", NodeUtils.GetHLSLSafeName(slot.shaderOutputName), masterNode.GetVariableNameForSlot(slot.id)), true);
+                        surfaceDescriptionFunction.AddShaderChunk(string.Format("surface.{0} = {1};", NodeUtils.GetHLSLSafeName(slot.shaderOutputName), masterNode.GetSlotValue(slot.id, mode)), true);
                 }
             }
 

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

 
         private const string kErrorString = @"ERROR!";
 
-        public static string AdaptNodeOutput(AbstractMaterialNode node, int outputSlotId, ConcreteSlotValueType convertToType, bool textureSampleUVHack = false)
+        public static string AdaptNodeOutput(AbstractMaterialNode node, int outputSlotId, ConcreteSlotValueType convertToType)
         {
             var outputSlot = node.FindOutputSlot<MaterialSlot>(outputSlotId);
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Controls/ColorControl.cs

 
 namespace UnityEditor.ShaderGraph.Drawing.Controls
 {
+    public enum ColorMode
+    {
+        Default,
+        HDR
+    }
+
+        ColorMode m_ColorMode;
-        public ColorControlAttribute(string label = null)
+        public ColorControlAttribute(string label = null, ColorMode colorMode = ColorMode.Default)
+            m_ColorMode = colorMode;
-            return new ColorControlView(m_Label, node, propertyInfo);
+            return new ColorControlView(m_Label, m_ColorMode, node, propertyInfo);
         }
     }
 
         PropertyInfo m_PropertyInfo;
 
-        public ColorControlView(string label, AbstractMaterialNode node, PropertyInfo propertyInfo)
+        public ColorControlView(string label, ColorMode colorMode, AbstractMaterialNode node, PropertyInfo propertyInfo)
         {
             m_Node = node;
             m_PropertyInfo = propertyInfo;
             if (!string.IsNullOrEmpty(label))
                 Add(new Label(label));
 
-            var colorField = new ColorField { value = (Color)m_PropertyInfo.GetValue(m_Node, null), 
-                showEyeDropper = false };
+            ColorField colorField;
+            switch(colorMode)
+            {
+                case ColorMode.HDR:
+                    colorField = new ColorField { value = (Color)m_PropertyInfo.GetValue(m_Node, null), hdr = true, showEyeDropper = false };
+                    break;
+                default:
+                    colorField = new ColorField { value = (Color)m_PropertyInfo.GetValue(m_Node, null), showEyeDropper = false };
+                    break;
+            }
             colorField.OnValueChanged(OnChange);
             Add(colorField);
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Controls/DefaultControl.cs

         public VisualElement InstantiateControl(AbstractMaterialNode node, PropertyInfo propertyInfo)
         {
             if (propertyInfo.PropertyType == typeof(Color))
-                return new ColorControlView(null, node, propertyInfo);
+                return new ColorControlView(null, ColorMode.Default, node, propertyInfo);
             if (typeof(Enum).IsAssignableFrom(propertyInfo.PropertyType))
                 return new EnumControlView(null, node, propertyInfo);
             if (propertyInfo.PropertyType == typeof(Texture2D))

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/EdgeConnectorListener.cs

 
 namespace UnityEditor.ShaderGraph.Drawing
 {
-    public class EdgeConnectorListener : IEdgeConnectorListener
+    class EdgeConnectorListener : IEdgeConnectorListener
     {
         readonly AbstractMaterialGraph m_Graph;
         readonly SearchWindowProvider m_SearchWindowProvider;
         public void OnDropOutsidePort(Edge edge, Vector2 position)
         {
             var draggedPort = (edge.output != null ? edge.output.edgeConnector.edgeDragHelper.draggedPort : null) ?? (edge.input != null ? edge.input.edgeConnector.edgeDragHelper.draggedPort : null);
-            m_SearchWindowProvider.connectedPort = draggedPort;
+            m_SearchWindowProvider.connectedPort = (ShaderPort) draggedPort;
-            var leftSlot = edge.output.userData as ISlot;
-            var rightSlot = edge.input.userData as ISlot;
+            var leftSlot = edge.output.GetSlot();
+            var rightSlot = edge.input.GetSlot();
             if (leftSlot != null && rightSlot != null)
             {
                 m_Graph.owner.RegisterCompleteObjectUndo("Connect Edge");

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Inspector/GraphInspectorView.cs

 using System;
 using System.Linq;
 using UnityEditor.Experimental.UIElements;
-using UnityEditor.Graphing;
-using Object = UnityEngine.Object;
+using UnityEditor.Experimental.UIElements.GraphView;
 
 namespace UnityEditor.ShaderGraph.Drawing.Inspector
 {
             }
             Add(topContainer);
 
-            var bottomContainer = new VisualElement {name = "bottom"};
-            {
-                m_PreviewTextureView = new PreviewTextureView { name = "preview", image = Texture2D.blackTexture };
-                m_PreviewTextureView.AddManipulator(new Draggable(OnMouseDrag, true));
-                bottomContainer.Add(m_PreviewTextureView);
-
-                m_PreviewScrollPosition = new Vector2(0f, 0f);
-
-                m_PreviewMeshPicker = new ObjectField { objectType = typeof(Mesh) };
-                m_PreviewMeshPicker.OnValueChanged(OnPreviewMeshChanged);
-
-                bottomContainer.Add(m_PreviewMeshPicker);
-            }
-            Add(bottomContainer);
-
-            m_PreviewRenderHandle = previewManager.masterRenderData;
-            m_PreviewRenderHandle.onPreviewChanged += OnPreviewChanged;
-
-            m_PreviewMeshPicker.SetValueAndNotify(m_Graph.previewData.serializedMesh.mesh);
-
-            Add(new ResizeSideHandle(this, ResizeHandleAnchor.TopLeft, new string[] {"resize", "diagonal", "top-left"}));
-            Add(new ResizeSideHandle(this, ResizeHandleAnchor.Top, new string[] {"resize", "vertical", "top"}));
-            Add(new ResizeSideHandle(this, ResizeHandleAnchor.TopRight, new string[] {"resize", "diagonal", "top-right"}));
-            Add(new ResizeSideHandle(this, ResizeHandleAnchor.Right, new string[] {"resize", "horizontal", "right"}));
-            Add(new ResizeSideHandle(this, ResizeHandleAnchor.BottomRight, new string[] {"resize", "diagonal", "bottom-right"}));
-            Add(new ResizeSideHandle(this, ResizeHandleAnchor.Bottom, new string[] {"resize", "vertical", "bottom"}));
-            Add(new ResizeSideHandle(this, ResizeHandleAnchor.BottomLeft, new string[] {"resize", "diagonal", "bottom-left"}));
-            Add(new ResizeSideHandle(this, ResizeHandleAnchor.Left, new string[] {"resize", "horizontal", "left"}));
-        }
+            Add(new ResizeBorderFrame(this) { name = "resizeBorderFrame" });
-        MasterNode masterNode
-        {
-            get { return m_PreviewRenderHandle.shaderData.node as MasterNode; }
-        }
-
-        void OnMouseDrag(Vector2 deltaMouse)
-        {
-            Vector2 previewSize = m_PreviewTextureView.contentRect.size;
-
-            m_PreviewScrollPosition -= deltaMouse * (Event.current.shift ? 3f : 1f) / Mathf.Min(previewSize.x, previewSize.y) * 140f;
-            m_PreviewScrollPosition.y = Mathf.Clamp(m_PreviewScrollPosition.y, -90f, 90f);
-            Quaternion previewRotation = Quaternion.Euler(m_PreviewScrollPosition.y, 0, 0) * Quaternion.Euler(0, m_PreviewScrollPosition.x, 0);
-            m_Graph.previewData.rotation = previewRotation;
-
-            masterNode.Dirty(ModificationScope.Node);
+            this.AddManipulator(new WindowDraggable());
         }
 
         void OnAddProperty()
             gm.AddItem(new GUIContent("Vector3"), false, () => AddProperty(new Vector3ShaderProperty()));
             gm.AddItem(new GUIContent("Vector4"), false, () => AddProperty(new Vector4ShaderProperty()));
             gm.AddItem(new GUIContent("Color"), false, () => AddProperty(new ColorShaderProperty()));
+            gm.AddItem(new GUIContent("HDR Color"), false, () => AddProperty(new ColorShaderProperty(true)));
+            gm.AddItem(new GUIContent("Integer"), false, () => AddProperty(new IntegerShaderProperty()));
+            gm.AddItem(new GUIContent("Slider"), false, () => AddProperty(new SliderShaderProperty()));
+            gm.AddItem(new GUIContent("Boolean"), false, () => AddProperty(new BooleanShaderProperty()));
             gm.AddItem(new GUIContent("Texture"), false, () => AddProperty(new TextureShaderProperty()));
             gm.AddItem(new GUIContent("Cubemap"), false, () => AddProperty(new CubemapShaderProperty()));
             gm.ShowAsContext();
         {
             m_PreviewTextureView.image = m_PreviewRenderHandle.texture ?? Texture2D.blackTexture;
             m_PreviewTextureView.Dirty(ChangeType.Repaint);
-        }
-
-        void OnPreviewMeshChanged(ChangeEvent<Object> changeEvent)
-        {
-            Mesh changedMesh = changeEvent.newValue as Mesh;
-
-            masterNode.Dirty(ModificationScope.Node);
-
-            if (m_Graph.previewData.serializedMesh.mesh != changedMesh)
-            {
-                m_Graph.previewData.rotation = Quaternion.identity;
-            }
-
-            m_Graph.previewData.serializedMesh.mesh = changedMesh;
         }
 
         public void HandleGraphChanges()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Inspector/ShaderPropertyView.cs

                 m_ValueAction = Vector3Field;
             else if (property is Vector4ShaderProperty)
                 m_ValueAction = Vector4Field;
+            else if (property is IntegerShaderProperty)
+                m_ValueAction = IntegerField;
+            else if (property is SliderShaderProperty)
+                m_ValueAction = SliderField;
+            else if (property is BooleanShaderProperty)
+                m_ValueAction = BooleanField;
 
             if (m_ValueAction != null)
             {
             {
                 var fProp = (ColorShaderProperty)property;
-                var colorField = new ColorField { name = "value", value = fProp.value };
+                ColorField colorField;
+                if(fProp.HDR)
+                    colorField = new ColorField { name = "value", value = fProp.value, hdr = true };
+                else
+                    colorField = new ColorField { name = "value", value = fProp.value };
                 colorField.OnValueChanged(OnColorChanged);
                 Add(colorField);
             }
         {
             var fProp = (Vector4ShaderProperty)property;
             fProp.value = EditorGUILayout.Vector4Field("", fProp.value);
+        }
+
+        void IntegerField()
+        {
+            var fProp = (IntegerShaderProperty)property;
+            fProp.value = EditorGUILayout.IntField(fProp.value);
+        }
+
+        void SliderField()
+        {
+            var fProp = (SliderShaderProperty)property;
+            var value = fProp.value;
+            
+            GUILayoutOption[] sliderOptions = { GUILayout.ExpandWidth(true) };
+            GUILayoutOption[] options = { GUILayout.MaxWidth(30.0f) };
+            value.x = EditorGUILayout.Slider(fProp.value.x, fProp.value.y, fProp.value.z, sliderOptions);
+            EditorGUILayout.BeginHorizontal();
+            float previousLabelWidth = EditorGUIUtility.labelWidth;
+            EditorGUIUtility.labelWidth = 30f;
+            Rect minMaxRect = EditorGUILayout.GetControlRect(new GUILayoutOption[]{ GUILayout.ExpandWidth(true) } );
+            Rect minRect = new Rect(minMaxRect.x, minMaxRect.y, minMaxRect.width / 2, minMaxRect.height);
+            Rect maxRect = new Rect(minMaxRect.x + minMaxRect.width / 2, minMaxRect.y, minMaxRect.width / 2, minMaxRect.height);
+            value.y = EditorGUI.FloatField(minRect, "Min", fProp.value.y);
+            value.z = EditorGUI.FloatField(maxRect, "Max", fProp.value.z);
+            EditorGUIUtility.labelWidth = previousLabelWidth;
+            EditorGUILayout.EndHorizontal();
+            fProp.value = value;
+        }
+
+        void BooleanField()
+        {
+            var fProp = (BooleanShaderProperty)property;
+            fProp.value = EditorGUILayout.Toggle(fProp.value);
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Manipulators/ResizeSideHandle.cs

 using System;
+using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.Experimental.UIElements;
 
     {
         VisualElement m_ResizeTarget;
 
-        ResizeHandleAnchor m_HandleAnchor;
+        public Action OnResizeFinished;
-        public ResizeSideHandle(VisualElement resizeTarget, ResizeHandleAnchor anchor, string[] styleClasses)
+        public ResizeSideHandle(VisualElement resizeTarget, ResizeHandleAnchor anchor)
-            foreach (string styleClass in styleClasses)
+            AddToClassList("resize");
+
+            switch (anchor)
-                AddToClassList(styleClass);
+                case ResizeHandleAnchor.Top:
+                {
+                    AddToClassList("vertical");
+                    AddToClassList("top");
+                    break;
+                }
+                case ResizeHandleAnchor.TopRight:
+                {
+                    AddToClassList("diagonal");
+                    AddToClassList("top-right");
+                    break;
+                }
+                case ResizeHandleAnchor.Right:
+                {
+                    AddToClassList("horizontal");
+                    AddToClassList("right");
+                    break;
+                }
+                case ResizeHandleAnchor.BottomRight:
+                {
+                    AddToClassList("diagonal");
+                    AddToClassList("bottom-right");
+                    break;
+                }
+                case ResizeHandleAnchor.Bottom:
+                {
+                    AddToClassList("vertical");
+                    AddToClassList("bottom");
+                    break;
+                }
+                case ResizeHandleAnchor.BottomLeft:
+                {
+                    AddToClassList("diagonal");
+                    AddToClassList("bottom-left");
+                    break;
+                }
+                case ResizeHandleAnchor.Left:
+                {
+                    AddToClassList("horizontal");
+                    AddToClassList("left");
+                    break;
+                }
+                case ResizeHandleAnchor.TopLeft:
+                {
+                    AddToClassList("diagonal");
+                    AddToClassList("top-left");
+                    break;
+                }
-
-            m_HandleAnchor = anchor;
-
-            bool moveWhileResizeHorizontal = anchor == ResizeHandleAnchor.TopLeft || anchor == ResizeHandleAnchor.BottomLeft || anchor == ResizeHandleAnchor.Left;
-            bool moveWhileResizeVertical = anchor == ResizeHandleAnchor.TopLeft || anchor == ResizeHandleAnchor.TopRight || anchor == ResizeHandleAnchor.Top;
 
             if (anchor == ResizeHandleAnchor.Left || anchor == ResizeHandleAnchor.Right)
             {
                 resizeDirection = ResizeDirection.Any;
             }
 
+            bool moveWhileResizeHorizontal = anchor == ResizeHandleAnchor.TopLeft || anchor == ResizeHandleAnchor.BottomLeft || anchor == ResizeHandleAnchor.Left;
+            bool moveWhileResizeVertical = anchor == ResizeHandleAnchor.TopLeft || anchor == ResizeHandleAnchor.TopRight || anchor == ResizeHandleAnchor.Top;
+
+            RegisterCallback<MouseUpEvent>(HandleDraggableMouseUp);
         }
 
         void OnResize(Vector2 resizeDelta, ResizeDirection direction, bool moveWhileResizeHorizontal, bool moveWhileresizerVertical)
+            Vector2 minSize = new Vector2(60f, 60f);
+
+            if (!Mathf.Approximately(m_ResizeTarget.style.minWidth.value, 0f))
+            {
+                minSize.x = m_ResizeTarget.style.minWidth;
+            }
+
+            if (!Mathf.Approximately(m_ResizeTarget.style.minHeight.value, 0f))
+            {
+                minSize.y = m_ResizeTarget.style.minHeight.value;
+            }
+
             if (direction == ResizeDirection.Vertical)
             {
                 normalizedResizeDelta.x = 0f;
             // Resize form bottom/right
             if (!moveWhileResizeHorizontal)
             {
-                newLayout.width = Mathf.Max(newLayout.width + normalizedResizeDelta.x, 60f);
+                newLayout.width = Mathf.Max(newLayout.width + normalizedResizeDelta.x, minSize.x);
-                newLayout.height = Mathf.Max(newLayout.height + normalizedResizeDelta.y, 60f);
+                newLayout.height = Mathf.Max(newLayout.height + normalizedResizeDelta.y, minSize.y);
                 normalizedResizeDelta.y = 0f;
             }
 
-            newLayout.width = Mathf.Max(newLayout.width - normalizedResizeDelta.x, 60f);
-            newLayout.height = Mathf.Max(newLayout.height - normalizedResizeDelta.y, 60f);
+            newLayout.width = Mathf.Max(newLayout.width - normalizedResizeDelta.x, minSize.x);
+            newLayout.height = Mathf.Max(newLayout.height - normalizedResizeDelta.y, minSize.y);
-            newLayout.x = Mathf.Min(newLayout.x + normalizedResizeDelta.x, previousFarX - 60f);
-            newLayout.y = Mathf.Min(newLayout.y + normalizedResizeDelta.y, previousFarY - 60f);
+            newLayout.x = Mathf.Min(newLayout.x + normalizedResizeDelta.x, previousFarX - minSize.x);
+            newLayout.y = Mathf.Min(newLayout.y + normalizedResizeDelta.y, previousFarY - minSize.y);
+        }
+
+        void HandleDraggableMouseUp(MouseUpEvent evt)
+        {
+            if (OnResizeFinished != null)
+            {
+                OnResizeFinished();
+            }
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/MaterialGraphEditWindow.cs

         [NonSerialized]
         bool m_HasError;
 
+        [NonSerialized]
+        public bool forceRedrawPreviews = false;
+
+        ColorSpace m_ColorSpace;
+
         GraphEditorView m_GraphEditorView;
 
         GraphEditorView graphEditorView
                     m_GraphEditorView.RemoveFromHierarchy();
                     m_GraphEditorView.Dispose();
                 }
+
                 m_GraphEditorView = value;
                 if (m_GraphEditorView != null)
                 {
             if (m_HasError)
                 return;
 
+            if (PlayerSettings.colorSpace != m_ColorSpace)
+            {
+                graphEditorView = null;
+                m_ColorSpace = PlayerSettings.colorSpace;
+            }
+
             try
             {
                 if (graphObject == null && selectedGuid != null)
                 {
                     var asset = AssetDatabase.LoadAssetAtPath<Object>(AssetDatabase.GUIDToAssetPath(selectedGuid));
                     graphEditorView = new GraphEditorView(this, materialGraph, asset.name) { persistenceKey = selectedGuid };
+                    m_ColorSpace = PlayerSettings.colorSpace;
+                if (forceRedrawPreviews)
+                {
+                    // Redraw all previews
+                    foreach (INode node in m_GraphObject.graph.GetNodes<INode>())
+                        node.Dirty(ModificationScope.Node);
+                    forceRedrawPreviews = false;
+                }
+                    
                 graphEditorView.HandleGraphChanges();
                 graphObject.graph.ClearChanges();
             }
                 Undo.ClearUndo(graphObject);
                 DestroyImmediate(graphObject);
             }
+
             graphEditorView = null;
         }
 
                     var inputSlotRef = new SlotReference(remappedInputNodeGuid, inputSlot.slotId);
                     subGraph.Connect(outputSlotRef, inputSlotRef);
                 }
+
                 // one edge needs to go to outside world
                 else if (outputSlotExistsInSubgraph)
                 {
                         break;
                     case ConcreteSlotValueType.Vector1:
                         prop = new FloatShaderProperty();
+                        break;
+                    case ConcreteSlotValueType.Boolean:
+                        prop = new BooleanShaderProperty();
                         break;
                     default:
                         throw new ArgumentOutOfRangeException();
             var graph = graphObject.graph as IShaderGraph;
             if (graph == null)
                 return;
-
-            List<PropertyCollector.TextureInfo> configuredTextures;
-            graph.GetShader(Path.GetFileNameWithoutExtension(path), GenerationMode.ForReals, out configuredTextures);
 
             var shaderImporter = AssetImporter.GetAtPath(path) as ShaderGraphImporter;
             if (shaderImporter == null)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/PreviewManager.cs

             // Render 2D previews
             m_SceneResources.camera.transform.position = -Vector3.forward * 2;
             m_SceneResources.camera.transform.rotation = Quaternion.identity;
-            m_SceneResources.camera.orthographicSize = 1;
+            m_SceneResources.camera.orthographicSize = 0.5f;
             m_SceneResources.camera.orthographic = true;
 
             foreach (var renderData in m_RenderList2D)
             m_PreviewPropertyBlock.SetFloat(m_OutputIdName, renderData.shaderData.node.tempId.index);
             if (m_PreviewMaterial.shader != renderData.shaderData.shader)
                 m_PreviewMaterial.shader = renderData.shaderData.shader;
-            m_SceneResources.camera.targetTexture = renderData.renderTexture;
-            RenderTexture.active = renderData.renderTexture;
+
+
+            //Temp workaround for alpha previews...
+            var temp = RenderTexture.GetTemporary(renderData.renderTexture.descriptor);
+            RenderTexture.active = temp;
-            Graphics.Blit(Texture2D.whiteTexture, renderData.renderTexture, m_SceneResources.checkerboardMaterial);
+            Graphics.Blit(Texture2D.whiteTexture, temp, m_SceneResources.checkerboardMaterial);
+            m_SceneResources.camera.targetTexture = temp;
             Graphics.DrawMesh(mesh, transform, m_PreviewMaterial, 1, m_SceneResources.camera, 0, m_PreviewPropertyBlock, ShadowCastingMode.Off, false, null, false);
 
             var previousUseSRP = Unsupported.useScriptableRenderPipeline;
+
+            Graphics.Blit(temp, renderData.renderTexture, m_SceneResources.blitNoAlphaMaterial);
+            RenderTexture.ReleaseTemporary(temp);
+
             RenderTexture.active = previousRenderTexure;
             renderData.texture = renderData.renderTexture;
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/SearchWindowProvider.cs

 
 namespace UnityEditor.ShaderGraph.Drawing
 {
-    public class SearchWindowProvider : ScriptableObject, ISearchWindowProvider
+    class SearchWindowProvider : ScriptableObject, ISearchWindowProvider
-        public Port connectedPort { get; set; }
+        public ShaderPort connectedPort { get; set; }
         public bool nodeNeedsRepositioning { get; set; }
         public SlotReference targetSlotReference { get; private set; }
         public Vector2 targetPosition { get; private set; }
 
         int GetFirstCompatibleSlotId(AbstractMaterialNode node)
         {
-            var connectedSlot = (MaterialSlot)connectedPort.userData;
+            var connectedSlot = connectedPort.slot;
             m_Slots.Clear();
             node.GetSlots(m_Slots);
             foreach (var slot in m_Slots)
 
             if (connectedPort != null)
             {
-                var connectedSlot = (MaterialSlot)connectedPort.userData;
+                var connectedSlot = connectedPort.slot;
                 var connectedSlotReference = connectedSlot.owner.GetSlotReference(connectedSlot.id);
                 var compatibleSlotReference = node.GetSlotReference(nodeEntry.compatibleSlotId);
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/GraphEditorView.cs

 
 namespace UnityEditor.ShaderGraph.Drawing
 {
+    [Serializable]
+    class FloatingWindowsLayout
+    {
+        public Rect inspectorLayout;
+        public Rect previewLayout;
+    }
+
+
+        MasterPreviewView m_MasterPreviewView;
+
         private EditorWindow m_EditorWindow;
 
         AbstractMaterialGraph m_Graph;
+
+        string m_FloatingWindowsLayoutKey;
+        FloatingWindowsLayout m_FLoatingWindowsLayout;
 
         public Action onUpdateAssetClick
         {
                 content.Add(m_GraphView);
 
                 m_GraphInspectorView = new GraphInspectorView(assetName, previewManager, graph) { name = "inspector" };
-                m_GraphInspectorView.AddManipulator(new Draggable(OnMouseDrag, true));
-                m_GraphView.RegisterCallback<PostLayoutEvent>(OnPostLayout);
-                m_GraphInspectorView.RegisterCallback<PostLayoutEvent>(OnPostLayout);
+                m_MasterPreviewView = new MasterPreviewView(assetName, previewManager, graph) { name = "masterPreview" };
+
+                WindowDraggable masterPreviewViewDraggable = new WindowDraggable();
+                masterPreviewViewDraggable.OnDragFinished += UpdateSerializedWindowLayout;
+                m_MasterPreviewView.AddManipulator(masterPreviewViewDraggable);
+                m_GraphView.Add(m_MasterPreviewView);
+
+                ResizeBorderFrame masterPreviewResizeBorderFrame = new ResizeBorderFrame(m_MasterPreviewView) { name = "resizeBorderFrame" };
+                masterPreviewResizeBorderFrame.OnResizeFinished += UpdateSerializedWindowLayout;
+                m_MasterPreviewView.Add(masterPreviewResizeBorderFrame);
+
+
+                m_FloatingWindowsLayoutKey = "UnityEditor.ShaderGraph.FloatingWindowsLayout";
+                string serializedWindowLayout = EditorUserSettings.GetConfigValue(m_FloatingWindowsLayoutKey);
+
+                if (!String.IsNullOrEmpty(serializedWindowLayout))
+                {
+                    m_FLoatingWindowsLayout = JsonUtility.FromJson<FloatingWindowsLayout>(serializedWindowLayout);
+
+                    m_GraphInspectorView.layout = m_FLoatingWindowsLayout.inspectorLayout;
+                    m_MasterPreviewView.layout = m_FLoatingWindowsLayout.previewLayout;
+                }
+                else
+                {
+                    m_FLoatingWindowsLayout = new FloatingWindowsLayout();
+                }
             }
 
             m_SearchWindowProvider = ScriptableObject.CreateInstance<SearchWindowProvider>();
             Add(content);
         }
 
-        void OnPostLayout(PostLayoutEvent evt)
-        {
-            const float minimumVisibility = 60f;
-
-            Rect inspectorViewRect = m_GraphInspectorView.layout;
-
-            float minimumXPosition = minimumVisibility - inspectorViewRect.width;
-            float maximumXPosition = m_GraphView.layout.width - minimumVisibility;
-
-            float minimumYPosition = minimumVisibility - inspectorViewRect.height;
-            float maximumYPosition = m_GraphView.layout.height - minimumVisibility;
-
-            inspectorViewRect.x = Mathf.Clamp(inspectorViewRect.x, minimumXPosition, maximumXPosition);
-            inspectorViewRect.y = Mathf.Clamp(inspectorViewRect.y, minimumYPosition, maximumYPosition);
-
-            inspectorViewRect.width = Mathf.Min(inspectorViewRect.width, layout.width);
-            inspectorViewRect.height = Mathf.Min(inspectorViewRect.height, layout.height);
-
-            m_GraphInspectorView.layout = inspectorViewRect;
-        }
-
         void OnSpaceDown(KeyDownEvent evt)
         {
             if( evt.keyCode == KeyCode.Space)
 
                 graphView.nodeCreationRequest(new NodeCreationContext() { screenMousePosition = screenPoint });
             }
-        }
-
-        void OnMouseDrag(Vector2 mouseDelta)
-        {
-            Vector2 normalizedDelta = mouseDelta / 2f;
-
-            Rect inspectorWindowRect = m_GraphInspectorView.layout;
-
-            inspectorWindowRect.x += normalizedDelta.x;
-            inspectorWindowRect.y += normalizedDelta.y;
-
-            m_GraphInspectorView.layout = inspectorWindowRect;
         }
 
         GraphViewChange GraphViewChanged(GraphViewChange graphViewChange)
                 foreach (var edge in graphViewChange.edgesToCreate)
                 {
-                    var leftSlot = edge.output.userData as ISlot;
-                    var rightSlot = edge.input.userData as ISlot;
+                    var leftSlot = edge.output.GetSlot();
+                    var rightSlot = edge.input.GetSlot();
                     if (leftSlot != null && rightSlot != null)
                     {
                         m_Graph.owner.RegisterCompleteObjectUndo("Connect Edge");
                     var port = element as ShaderPort;
                     if (port == null)
                         continue;
-                    var slot = (MaterialSlot)port.userData;
-                    if (slot.slotReference.Equals(m_SearchWindowProvider.targetSlotReference))
+                    if (port.slot.slotReference.Equals(m_SearchWindowProvider.targetSlotReference))
                     {
                         port.RegisterCallback<PostLayoutEvent>(RepositionNode);
                         return;
             var sourceNodeView = m_GraphView.nodes.ToList().OfType<MaterialNodeView>().FirstOrDefault(x => x.node == sourceNode);
             if (sourceNodeView != null)
             {
-                var sourceAnchor = sourceNodeView.outputContainer.Children().OfType<Port>().FirstOrDefault(x => x.userData is ISlot && (x.userData as ISlot).Equals(sourceSlot));
+                var sourceAnchor = sourceNodeView.outputContainer.Children().OfType<ShaderPort>().FirstOrDefault(x => x.slot.Equals(sourceSlot));
-                var targetAnchor = targetNodeView.inputContainer.Children().OfType<Port>().FirstOrDefault(x => x.userData is ISlot && (x.userData as ISlot).Equals(targetSlot));
+                var targetAnchor = targetNodeView.inputContainer.Children().OfType<ShaderPort>().FirstOrDefault(x => x.slot.Equals(targetSlot));
 
                 var edgeView = new Edge
                 {
                 {
                     foreach (var edgeView in anchorView.connections.OfType<Edge>())
                     {
-                        var targetSlot = (MaterialSlot)edgeView.input.userData;
+                        var targetSlot = edgeView.input.GetSlot();
                         if (targetSlot.valueType == SlotValueType.Dynamic)
                         {
                             var connectedNodeView = edgeView.input.node as MaterialNodeView;
                 }
                 foreach (var anchorView in nodeView.inputContainer.Children().OfType<Port>())
                 {
-                    var targetSlot = (MaterialSlot)anchorView.userData;
+                    var targetSlot = anchorView.GetSlot();
                     if (targetSlot.valueType != SlotValueType.Dynamic)
                         continue;
                     foreach (var edgeView in anchorView.connections.OfType<Edge>())
                     }
                 }
             }
+        }
+
+        void UpdateSerializedWindowLayout()
+        {
+            m_FLoatingWindowsLayout.inspectorLayout = m_GraphInspectorView.layout;
+            m_FLoatingWindowsLayout.previewLayout = m_MasterPreviewView.layout;
+
+            string serializedWindowLayout = JsonUtility.ToJson(m_FLoatingWindowsLayout);
+            EditorUserSettings.SetConfigValue(m_FloatingWindowsLayoutKey, serializedWindowLayout);
         }
 
         public void Dispose()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/MaterialGraphView.cs

         public override List<Port> GetCompatiblePorts(Port startAnchor, NodeAdapter nodeAdapter)
         {
             var compatibleAnchors = new List<Port>();
-            var startSlot = startAnchor.userData as MaterialSlot;
+            var startSlot = startAnchor.GetSlot();
             if (startSlot == null)
                 return compatibleAnchors;
 
 
             foreach (var candidateAnchor in ports.ToList())
             {
-                var candidateSlot = candidateAnchor.userData as MaterialSlot;
+                var candidateSlot = candidateAnchor.GetSlot();
                 if (!startSlot.IsCompatibleWith(candidateSlot))
                     continue;
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/MaterialNodeView.cs

                 name = "controls"
             };
             extensionContainer.Add(m_ControlsContainer);
-            m_ControlsDivider = new VisualElement {name = "divider"};
+            m_ControlsDivider = new VisualElement { name = "divider" };
             m_ControlsDivider.AddToClassList("horizontal");
 
             if (node.hasPreview)
                     m_PreviewRenderData.onPreviewChanged += UpdatePreviewTexture;
                     UpdatePreviewTexture();
 
-                    var collapsePreviewButton = new VisualElement { name = "collapse"};
+                    var collapsePreviewButton = new VisualElement { name = "collapse" };
-                        {
-                            node.owner.owner.RegisterCompleteObjectUndo("Collapse Preview");
-                            UpdatePreviewExpandedState(false);
-                        }));
+                    {
+                        node.owner.owner.RegisterCompleteObjectUndo("Collapse Preview");
+                        UpdatePreviewExpandedState(false);
+                    }));
-                    var expandPreviewButton = new VisualElement { name = "expand"};
-                    expandPreviewButton.Add(new VisualElement { name = "icon"});
+                    var expandPreviewButton = new VisualElement { name = "expand" };
+                    expandPreviewButton.Add(new VisualElement { name = "icon" });
-                        {
-                            node.owner.owner.RegisterCompleteObjectUndo("Expand Preview");
-                            UpdatePreviewExpandedState(true);
-                        }));
+                    {
+                        node.owner.owner.RegisterCompleteObjectUndo("Expand Preview");
+                        UpdatePreviewExpandedState(true);
+                    }));
                     m_PreviewContainer.Add(expandPreviewButton);
                 }
 
             m_ControlViews = new List<VisualElement>();
             foreach (var propertyInfo in node.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
-                foreach (IControlAttribute attribute in propertyInfo.GetCustomAttributes(typeof(IControlAttribute), false))
-                    m_ControlViews.Add(attribute.InstantiateControl(node, propertyInfo));
+            foreach (IControlAttribute attribute in propertyInfo.GetCustomAttributes(typeof(IControlAttribute), false))
+                m_ControlViews.Add(attribute.InstantiateControl(node, propertyInfo));
             m_Attachers = new List<Attacher>(node.GetInputSlots<MaterialSlot>().Count());
 
             AddSlots(node.GetSlots<MaterialSlot>());
                 UpdatePreviewExpandedState(node.previewExpanded);
 
             base.expanded = node.drawState.expanded;
+
-                var anchorsToRemove = inputContainer.Children().ToList();
-                foreach (var anchorElement in anchorsToRemove)
+                var inputPorts = inputContainer.Children().OfType<ShaderPort>().ToList();
+                foreach (var port in inputPorts)
-                    inputContainer.Remove(anchorElement);
-                    var attacher = m_Attachers.FirstOrDefault(a => a.target == anchorElement);
-                    if (attacher != null)
+                    var currentSlot = port.slot;
+                    var newSlot = slots.FirstOrDefault(s => s.id == currentSlot.id);
+                    if (newSlot == null)
+                    {
+                        // Slot doesn't exist anymore, remove it
+                        inputContainer.Remove(port);
+
+                        // We also need to remove the attacher along with the element it's attaching
+                        var attacher = m_Attachers.FirstOrDefault(a => a.target == port);
+                        if (attacher != null)
+                        {
+                            attacher.Detach();
+                            attacher.element.parent.Remove(attacher.element);
+                            m_Attachers.Remove(attacher);
+                        }
+                    }
+                    else
-                        attacher.Detach();
-                        attacher.element.parent.Remove(attacher.element);
-                        m_Attachers.Remove(attacher);
+                        port.slot = newSlot;
+                        slots.Remove(newSlot);
-                anchorsToRemove = outputContainer.Children().ToList();
-                foreach (var ve in anchorsToRemove)
-                    outputContainer.Remove(ve);
-
-                foreach (var port in inputContainer.Union(outputContainer).OfType<Port>())
+                var outputPorts = outputContainer.Children().OfType<ShaderPort>().ToList();
+                foreach (var port in outputPorts)
-                    var slot = (MaterialSlot)port.userData;
-                    port.portName = slot.displayName;
+                    var currentSlot = port.slot;
+                    var newSlot = slots.FirstOrDefault(s => s.id == currentSlot.id);
+                    if (newSlot == null)
+                    {
+                        outputContainer.Remove(port);
+                    }
+                    else
+                    {
+                        port.slot = newSlot;
+                        slots.Remove(newSlot);
+                    }
+
+                slots.Clear();
+                slots.AddRange(node.GetSlots<MaterialSlot>());
-                    inputContainer.Sort((x, y) => slots.IndexOf(x.userData as MaterialSlot) - slots.IndexOf(y.userData as MaterialSlot));
+                    inputContainer.Sort((x, y) => slots.IndexOf(((ShaderPort)x).slot) - slots.IndexOf(((ShaderPort)y).slot));
-                    outputContainer.Sort((x, y) => slots.IndexOf(x.userData as MaterialSlot) - slots.IndexOf(y.userData as MaterialSlot));
+                    outputContainer.Sort((x, y) => slots.IndexOf(((ShaderPort)x).slot) - slots.IndexOf(((ShaderPort)y).slot));
             }
 
             UpdateControls();
                 if (slot.hidden)
                     continue;
 
-                var port = ShaderPort.Create(Orientation.Horizontal, slot.isInputSlot ? Direction.Input : Direction.Output, null, m_ConnectorListener);
-                port.portName = slot.displayName;
-                port.userData = slot;
-                port.visualClass = slot.concreteValueType.ToClassName();
-
+                var port = ShaderPort.Create(slot, m_ConnectorListener);
                 if (slot.isOutputSlot)
                     outputContainer.Add(port);
                 else
 
         void UpdateSlotAttachers()
         {
-            foreach (var port in inputContainer.OfType<Port>())
+            foreach (var port in inputContainer.OfType<ShaderPort>())
-                    var portInputView = new PortInputView((MaterialSlot)port.userData);
+                    var portInputView = new PortInputView(port.slot);
                     Add(portInputView);
                     mainContainer.BringToFront();
                     m_Attachers.Add(new Attacher(portInputView, port, SpriteAlignment.LeftCenter) { distance = -8f });
         {
             foreach (var attacher in m_Attachers)
             {
-                var slot = (MaterialSlot)attacher.target.userData;
+                var slot = ((ShaderPort)attacher.target).slot;
                 attacher.element.visible = expanded && !node.owner.GetEdges(node.GetSlotReference(slot.id)).Any();
             }
         }
-            foreach (var anchor in inputContainer.Concat(outputContainer).OfType<Port>())
+            foreach (var anchor in inputContainer.Concat(outputContainer).OfType<ShaderPort>())
-                var slot = (MaterialSlot)anchor.userData;
+                var slot = anchor.slot;
                 anchor.portName = slot.displayName;
                 anchor.visualClass = slot.concreteValueType.ToClassName();
             }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/PreviewSceneResources.cs

     public class PreviewSceneResources : IDisposable
     {
         readonly Scene m_Scene;
-        static Mesh s_Quad;
+        Material m_BlitNoAlphaMaterial;
 
         static readonly Mesh[] s_Meshes = { null, null, null, null, null };
         static readonly GUIContent[] s_MeshIcons = { null, null, null, null, null };
             light1.color = new Color(.4f, .4f, .45f, 0f) * .7f;
 
             m_CheckerboardMaterial = new Material(Shader.Find("Hidden/Checkerboard"));
+            m_BlitNoAlphaMaterial = new Material(Shader.Find("Hidden/BlitNoAlpha"));
+            blitNoAlphaMaterial.hideFlags = HideFlags.HideAndDontSave;
 
             if (s_Meshes[0] == null)
             {
                 Mesh quadMesh = Resources.GetBuiltinResource(typeof(Mesh), "Quad.fbx") as Mesh;
                 s_Meshes[4] = quadMesh;
             }
-
-            if (s_Quad == null)
-            {
-                var vertices = new[]
-                {
-                    new Vector3(-1f, -1f, 0f),
-                    new Vector3(1f, 1f, 0f),
-                    new Vector3(1f, -1f, 0f),
-                    new Vector3(-1f, 1f, 0f)
-                };
-
-                var uvs = new[]
-                {
-                    new Vector2(0f, 0f),
-                    new Vector2(1f, 1f),
-                    new Vector2(1f, 0f),
-                    new Vector2(0f, 1f)
-                };
-
-                var indices = new[] { 0, 1, 2, 1, 0, 3 };
-
-                s_Quad = new Mesh
-                {
-                    vertices = vertices,
-                    uv = uvs,
-                    triangles = indices
-                };
-                s_Quad.RecalculateNormals();
-                s_Quad.RecalculateBounds();
-            }
         }
 
         public Mesh sphere
 
         public Mesh quad
         {
-            get { return s_Quad; }
+            get { return s_Meshes[4]; }
+        }
+
+        public Material blitNoAlphaMaterial
+        {
+            get { return m_BlitNoAlphaMaterial; }
         }
 
         public Camera camera
             {
                 UnityEngine.Object.DestroyImmediate(checkerboardMaterial, true);
                 m_CheckerboardMaterial = null;
+            }
+            if (blitNoAlphaMaterial != null)
+            {
+                UnityEngine.Object.DestroyImmediate(blitNoAlphaMaterial, true);
+                m_BlitNoAlphaMaterial = null;
             }
 
             EditorSceneManager.ClosePreviewScene(m_Scene);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/ShaderPort.cs

         ShaderPort(Orientation portOrientation, Direction portDirection, Type type)
             : base(portOrientation, portDirection, type) { }
 
-        public static Port Create(Orientation orientation, Direction direction, Type type, IEdgeConnectorListener connectorListener)
+        MaterialSlot m_Slot;
+
+        public static Port Create(MaterialSlot slot, IEdgeConnectorListener connectorListener)
-            var port = new ShaderPort(orientation, direction, type)
+            var port = new ShaderPort(Orientation.Horizontal, slot.isInputSlot ? Direction.Input : Direction.Output, null)
+            port.slot = slot;
+            port.portName = slot.displayName;
+            port.visualClass = slot.concreteValueType.ToClassName();
-        public VisualElement connectorBox
+        public MaterialSlot slot
-            get { return m_ConnectorBox; }
+            get { return m_Slot; }
+            set
+            {
+                if (ReferenceEquals(value, m_Slot))
+                    return;
+                if (value == null)
+                    throw new NullReferenceException();
+                if (m_Slot != null && value.isInputSlot != m_Slot.isInputSlot)
+                    throw new ArgumentException("Cannot change direction of already created port");
+                m_Slot = value;
+                portName = slot.displayName;
+                visualClass = slot.concreteValueType.ToClassName();
+            }
+        }
+    }
+
+    static class ShaderPortExtensions
+    {
+        public static MaterialSlot GetSlot(this Port port)
+        {
+            var shaderPort = port as ShaderPort;
+            return shaderPort != null ? shaderPort.slot : null;
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Importers/ShaderGraphImporter.cs

 using System.Text;
 using UnityEditor;
 using UnityEditor.Experimental.AssetImporters;
+using UnityEditor.Experimental.UIElements;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing;
-[ScriptedImporter(3, ShaderGraphImporter.ShaderGraphExtension)]
+[ScriptedImporter(4, ShaderGraphImporter.ShaderGraphExtension)]
 public class ShaderGraphImporter : ScriptedImporter
 {
     public const string ShaderGraphExtension = "shadergraph";
         var text = GetShaderText<MaterialGraph>(ctx.assetPath, out configuredTextures);
         if (text == null)
             text = errorShader;
+        
+        var name = Path.GetFileNameWithoutExtension(ctx.assetPath);
+        string shaderName = string.Format("graphs/{0}", name);
+        text = text.Replace("Hidden/GraphErrorShader2", shaderName);
 
         var shader = ShaderUtil.CreateShaderAsset(text);
 
 
     static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
     {
+        MaterialGraphEditWindow[] windows = Resources.FindObjectsOfTypeAll<MaterialGraphEditWindow>();
+        foreach (var matGraphEditWindow in windows)
+        {
+            matGraphEditWindow.forceRedrawPreviews = true;
+        }
-}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Resources/Styles/MaterialGraph.uss

 }
 
 MaterialGraphView {
-    background-color: rgb(20, 21, 21);
+    background-color: #202020;
 }
 
 MaterialNodeView.graphElement.node.MaterialNode {
     margin-right: 0;
 }
 
+BooleanSlotControlView {
+    flex-direction: row;
+    align-items: center;
+}
+
+BooleanSlotControlView > Toggle {
+    width: 20;
+}
+
 .edge.fromMatrix4, .edge.fromMatrix3, .edge.fromMatrix2 {
     edge-output-color: #8FC1DF;
 }
     position-type: absolute;
     position-right: 0;
     position-top: 0;
-    width: 600;
-    height: 800;
+    width: 400;
+    min-width: 300;
 }
 
 GraphInspectorView * {
     padding-bottom: 4;
 }
 
-GraphInspectorView > .resize {
+MasterPreviewView {
+    flex-direction: column;
+    position-type: absolute;
+    position-right: 0;
+    position-bottom: 0;
+    background-color: rgb(79, 79, 79);
+    justify-content: flex-start;
+    min-width: 200;
+    min-height: 200;
+}
+
+MasterPreviewView > #top {
+    background-color: rgb(64, 64, 64);
+}
+
+MasterPreviewView > #top > #title {
+    font-style: bold;
+    font-size: 11;
+}
+
+MasterPreviewView > #top {
+    padding-top: 8;
+    padding-bottom: 8;
+    padding-left: 8;
+    padding-right: 8;
+}
+
+MasterPreviewView > #middle {
+    flex-grow: 1;
+    flex-direction: row;
+    margin-bottom: 40;
+}
+
+MasterPreviewView > #middle > #preview {
+    flex-grow: 1;
+}
+
+MasterPreviewView > #bottom {
+    background-color: rgb(79, 79, 79);
+    position-type: absolute;
+    position-bottom: 0;
+    position-left: 0;
+    position-right: 0;
+    padding-left: 10;
+    padding-right: 10;
+    padding-top: 8;
+    padding-bottom: 12;
+}
+
+MasterPreviewView > #bottom > #picker > ObjectFieldDisplay > Label {
+    font-size: 11;
+}
+
+#resizeBorderFrame > .resize {
-GraphInspectorView > .resize.vertical {
+#resizeBorderFrame > .resize.vertical {
     cursor: resize-vertical;
     height: 10;
     position-left: 10;
     margin-bottom: 0;
 }
 
-GraphInspectorView > .resize.horizontal {
+#resizeBorderFrame > .resize.horizontal {
     cursor: resize-horizontal;
     width: 10;
     position-top: 10;
     margin-right: 0;
 }
 
-GraphInspectorView > .resize.diagonal {
+#resizeBorderFrame > .resize.diagonal {
-GraphInspectorView > .resize.diagonal.top-left {
+#resizeBorderFrame > .resize.diagonal.top-left {
-GraphInspectorView > .resize.diagonal.top-right {
+#resizeBorderFrame > .resize.diagonal.top-right {
-GraphInspectorView > .resize.diagonal.bottom-left {
+#resizeBorderFrame > .resize.diagonal.bottom-left {
-GraphInspectorView > .resize.diagonal.bottom-right {
+#resizeBorderFrame > .resize.diagonal.bottom-right {
-GraphInspectorView > .resize.vertical.top {
+#resizeBorderFrame > .resize.vertical.top {
-GraphInspectorView > .resize.vertical.bottom {
+#resizeBorderFrame > .resize.vertical.bottom {
-GraphInspectorView > .resize.horzontal.left {
+#resizeBorderFrame > .resize.horzontal.left {
-GraphInspectorView > .resize.horizontal.right {
+#resizeBorderFrame > .resize.horizontal.right {
+    position-right: 0;
+}
+
+.reszieBorderFrame {
+    position-type: absolute;
+    position-top: 0;
+    position-bottom: 0;
+    position-left: 0;
 }
 
 ShaderPropertyView {
     flex-grow: 1;
 }
 
-ChannelMixerControlView {
+IntegerControlView {
+    flex-direction: row;
     padding-left: 8;
     padding-right: 8;
     padding-top: 4;
-ChannelMixerControlView > Label {
+IntegerControlView > IntegerField {
-    cursor: slide-arrow;
-}
-
-ChannelMixerControlView > #buttonPanel {
-    flex-direction: row;
+    min-width: 30;
-    margin-bottom: 6;
-ChannelMixerControlView > #buttonPanel > Button {
-    flex-grow: 1;
-    margin-left: 0;
-    margin-right: 0;
-    align-items: center;
+SliderControlView {
+    padding-left: 8;
+    padding-right: 8;
+    padding-top: 4;
+    padding-bottom: 4;
-ChannelMixerControlView > #buttonPanel > Button > Label {
-    flex-grow: 1;
+SliderControlView > #SliderPanel {
-    margin-top: 0;
-    margin-bottom: 0;
-    padding-bottom: 0;
+    padding-bottom: 4;
+    flex-direction: row;
+    flex-grow: 1;
-ChannelMixerControlView > #sliderPanel {
+SliderControlView > #SliderPanel > Slider {
+    margin-left: 0;
+    margin-right: 0;
+    min-width: 164;
-ChannelMixerControlView > #sliderPanel > Label {
-    margin-left: 0;
+SliderControlView > #SliderPanel > FloatField {
+    margin-left: 4;
-    min-width: 20;
+    flex-direction: row;
+    flex-grow: 1;
+    width: 30;
-ChannelMixerControlView > #sliderPanel > Slider {
+SliderControlView > #FieldsPanel {
+    flex-direction: row;
-ChannelMixerControlView > #sliderPanel > FloatField {
-    margin-left: 4;
-    margin-right: 2;
-    min-width: 30;
-    max-width: 30;
+SliderControlView > #FieldsPanel > Label {
+    margin-left: 0;
+    margin-right: 8;
+}
+
+SliderControlView > #FieldsPanel > FloatField {
+    margin-left: 0;
+    margin-right: 0;
+    flex-direction: row;
+    flex-grow: 1;
 }
 
 ToggleControlView > #togglePanel {
     padding-bottom: 0;
 }
 
+ChannelMixerControlView {
+    padding-left: 8;
+    padding-right: 8;
+    padding-top: 4;
+    padding-bottom: 4;
+}
+ChannelMixerControlView > Label {
+    margin-left: 0;
+    margin-right: 0;
+    cursor: slide-arrow;
+}
+
+ChannelMixerControlView > #buttonPanel {
+    flex-direction: row;
+    flex-grow: 1;
+    margin-bottom: 6;
+}
+
+ChannelMixerControlView > #buttonPanel > Button {
+    flex-grow: 1;
+    margin-left: 0;
+    margin-right: 0;
+    align-items: center;
+}
+
+ChannelMixerControlView > #buttonPanel > Button > Label {
+    flex-grow: 1;
+    margin-left: 0;
+    margin-right: 0;
+    margin-top: 0;
+    margin-bottom: 0;
+    padding-left: 0;
+    padding-right: 0;
+    padding-top: 0;
+    padding-bottom: 0;
+}
+
+ChannelMixerControlView > #sliderPanel {
+    flex-direction: row;
+    flex-grow: 1;
+}
+
+ChannelMixerControlView > #sliderPanel > Label {
+    margin-left: 0;
+    margin-right: 0;
+    min-width: 20;
+}
+
+ChannelMixerControlView > #sliderPanel > Slider {
+    flex-grow: 1;
+    margin-left: 0;
+    margin-right: 0;
+}
+
+ChannelMixerControlView > #sliderPanel > FloatField {
+    margin-left: 4;
+    margin-right: 2;
+    min-width: 30;
+    max-width: 30;
+}
 
 /* TEMP STUFF THAT SHOULD ACTUALLY STAY IN GRAPHVIEW */
 

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

 	#include "LWRP/ShaderLibrary/Core.hlsl"
 	#include "LWRP/ShaderLibrary/Lighting.hlsl"
 	#include "CoreRP/ShaderLibrary/Color.hlsl"
+	#include "CoreRP/ShaderLibrary/UnityInstancing.hlsl"
 	#include "ShaderGraphLibrary/Functions.hlsl"
 
 	${Graph}
  		// We either sample GI from lightmap or SH. lightmap UV and vertex SH coefficients
 	    // are packed in lightmapUVOrVertexSH to save interpolator.
 	    // The following funcions initialize
-	    OUTPUT_LIGHTMAP_UV(v.lightmapUV, unity_LightmapST, o.lightmapUVOrVertexSH);
+	    OUTPUT_LIGHTMAP_UV(v.texcoord1, unity_LightmapST, o.lightmapUVOrVertexSH);
 	    OUTPUT_SH(lwWNormal, o.lightmapUVOrVertexSH);
 
 	    half3 vertexLight = VertexLighting(lwWorldPos, lwWNormal);
 
 	half4 frag (GraphVertexOutput IN) : SV_Target
     {
-
     	UNITY_SETUP_INSTANCE_ID(IN);
 
     	${LocalPixelShader}
 
 		// Computes fog factor per-vertex
     	ApplyFog(color.rgb, IN.fogFactorAndVertexLight.x);
-
-#if _AlphaOut
-		color.a = Alpha;
-#else
-		color.a = 1;
-#endif
 
 #if _AlphaClip
 		clip(Alpha - AlphaClipThreshold);

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

 	${ZTest}
 	${ZWrite}
 	
-	HLSLPROGRAM
+    HLSLPROGRAM
+    #pragma vertex vert
+    #pragma fragment frag
+    #pragma shader_feature _SAMPLE_GI
+    #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON
     #pragma multi_compile_instancing
 
 	#pragma vertex vert
     #include "LWRP/ShaderLibrary/Core.hlsl"
     #include "LWRP/ShaderLibrary/Lighting.hlsl"
     #include "CoreRP/ShaderLibrary/Color.hlsl"
+    #include "LWRP/ShaderLibrary/InputSurface.hlsl"
     #include "ShaderGraphLibrary/Functions.hlsl"
 
     ${Defines}
     {
         float4 position : POSITION;
         ${Interpolators}
+        UNITY_VERTEX_INPUT_INSTANCE_ID
     };
 
     GraphVertexOutput vert (GraphVertexInput v)
-        GraphVertexOutput o;
+        GraphVertexOutput o = (GraphVertexOutput)0;
+        
+        UNITY_SETUP_INSTANCE_ID(v);
+        UNITY_TRANSFER_INSTANCE_ID(v, o);
+
         o.position = TransformObjectToHClip(v.vertex.xyz);
         ${VertexShader}
         return o;
     {
+        UNITY_SETUP_INSTANCE_ID(IN);
+
-        SurfaceInputs surfaceInput;
+        SurfaceInputs surfaceInput = (SurfaceInputs)0;
-        float3 Color = 0;
-        float Alpha = 0;
+        float3 Color = float3(0.5, 0.5, 0.5);
+        float Alpha = 1;
+        float AlphaClipThreshold = 0;
+ #if _AlphaClip
+        clip(Alpha - AlphaClipThreshold);
+#endif
     	return half4(Color, Alpha);
     }
     ENDHLSL

MaterialGraphProject/Assets/UnityShaderEditor/package.json

 {
     "name": "com.unity.shadergraph",
     "description": "Shader Graph",
-    "version": "0.1.13",
+    "version": "0.1.14",
     "unity": "2018.1",
     "dependencies": {
     }

MaterialGraphProject/ProjectSettings/ProjectVersion.txt

-m_EditorVersion: 2018.1.0b1
+m_EditorVersion: 2018.1.0b4

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/BooleanMaterialSlot.cs

+using System;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Slots;
+using UnityEngine;
+using UnityEngine.Experimental.UIElements;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Serializable]
+    public class BooleanMaterialSlot : MaterialSlot, IMaterialSlotHasValue<bool>
+    {
+        [SerializeField]
+        private bool m_Value;
+
+        [SerializeField]
+        private bool m_DefaultValue;
+
+        public BooleanMaterialSlot()
+        {}
+
+        public BooleanMaterialSlot(
+            int slotId,
+            string displayName,
+            string shaderOutputName,
+            SlotType slotType,
+            bool value,
+            ShaderStage shaderStage = ShaderStage.Dynamic,
+            bool hidden = false)
+            : base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
+        {
+            m_DefaultValue = value;
+            m_Value = value;
+        }
+
+        public override VisualElement InstantiateControl()
+        {
+            return new BooleanSlotControlView(this);
+        }
+
+        public bool defaultValue { get { return m_DefaultValue; } }
+
+        public bool value
+        {
+            get { return m_Value; }
+            set { m_Value = value; }
+        }
+
+        protected override string ConcreteSlotValueAsVariable(AbstractMaterialNode.OutputPrecision precision)
+        {
+            return (value ? 1 : 0).ToString();
+        }
+
+        public override void AddDefaultProperty(PropertyCollector properties, GenerationMode generationMode)
+        {
+            if (!generationMode.IsPreview())
+                return;
+
+            var matOwner = owner as AbstractMaterialNode;
+            if (matOwner == null)
+                throw new Exception(string.Format("Slot {0} either has no owner, or the owner is not a {1}", this, typeof(AbstractMaterialNode)));
+
+            var property = new BooleanShaderProperty()
+            {
+                overrideReferenceName = matOwner.GetVariableNameForSlot(id),
+                generatePropertyBlock = false,
+                value = value
+            };
+            properties.AddShaderProperty(property);
+        }
+
+        public override SlotValueType valueType { get { return SlotValueType.Boolean; } }
+        public override ConcreteSlotValueType concreteValueType { get { return ConcreteSlotValueType.Boolean; } }
+
+        public override PreviewProperty GetPreviewProperty(string name)
+        {
+            var pp = new PreviewProperty(PropertyType.Boolean)
+            {
+                name = name,
+                booleanValue = value
+            };
+            return pp;
+        }
+
+        public override void CopyValuesFrom(MaterialSlot foundSlot)
+        {
+            var slot = foundSlot as BooleanMaterialSlot;
+            if (slot != null)
+                value = slot.value;
+        }
+    }
+}

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

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/BooleanShaderProperty.cs

+using System;
+using System.Text;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Serializable]
+    public class BooleanShaderProperty : AbstractShaderProperty<bool>
+    {
+        public BooleanShaderProperty()
+        {
+            displayName = "Boolean";
+        }
+
+        public override PropertyType propertyType
+        {
+            get { return PropertyType.Boolean; }
+        }
+
+        public override Vector4 defaultValue
+        {
+            get { return new Vector4(); }
+        }
+
+        public override string GetPropertyBlockString()
+        {
+            var result = new StringBuilder();
+            result.Append("[Toggle] ");
+            result.Append(referenceName);
+            result.Append("(\"");
+            result.Append(displayName);
+            result.Append("\", Float) = ");
+            result.Append(value == true ? 1 : 0);
+            return result.ToString();
+        }
+
+        public override string GetPropertyDeclarationString(string delimiter = ";")
+        {
+            return string.Format("float {0}{1}", referenceName, delimiter);
+        }
+
+        public override PreviewProperty GetPreviewMaterialProperty()
+        {
+            return new PreviewProperty(PropertyType.Boolean)
+            {
+                name = referenceName,
+                booleanValue = value
+            };
+        }
+
+        public override INode ToConcreteNode()
+        {
+            return new BooleanNode { value = new Toggle(value) };
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: 8891f9466e6b01c498c3f4b2c6abc0eb
+timeCreated: 1505346922

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/IntegerShaderProperty.cs

+using System;
+using System.Text;
+using UnityEditor.Graphing;
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Serializable]
+    public class IntegerShaderProperty : AbstractShaderProperty<int>
+    {
+        public IntegerShaderProperty()
+        {
+            displayName = "Integer";
+        }
+
+        public override PropertyType propertyType
+        {
+            get { return PropertyType.Float; }
+        }
+
+        public override Vector4 defaultValue
+        {
+            get { return new Vector4(value, value, value, value); }
+        }
+
+        public override string GetPropertyBlockString()
+        {
+            var result = new StringBuilder();
+            result.Append(referenceName);
+            result.Append("(\"");
+            result.Append(displayName);
+            result.Append("\", Int) = ");
+            result.Append(value);
+            return result.ToString();
+        }
+
+        public override string GetPropertyDeclarationString(string delimiter = ";")
+        {
+            return string.Format("float {0}{1}", referenceName, delimiter);
+        }
+
+        public override PreviewProperty GetPreviewMaterialProperty()
+        {
+            return new PreviewProperty(PropertyType.Float)
+            {
+                name = referenceName,
+                floatValue = value
+            };
+        }
+
+        public override INode ToConcreteNode()
+        {
+            return new IntegerNode { value = value };
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: 5980fe29fe1b01c4fa3fb434dd9eb9e2
+timeCreated: 1505346922

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/SliderShaderProperty.cs

+using System;
+using System.Text;
+using UnityEditor.Graphing;
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Serializable]
+    public class SliderShaderProperty : AbstractShaderProperty<Vector3>
+    {
+        public SliderShaderProperty()
+        {
+            displayName = "Slider";
+            value = new Vector3(0, 0, 1);
+        }
+
+        public override PropertyType propertyType
+        {
+            get { return PropertyType.Float; }
+        }
+
+        public override Vector4 defaultValue
+        {
+            get { return new Vector4(value.x, value.y, value.z, value.x); }
+        }
+
+        public override string GetPropertyBlockString()
+        {
+            var result = new StringBuilder();
+            result.Append(referenceName);
+            result.Append("(\"");
+            result.Append(displayName);
+            result.Append("\", Range(");
+            result.Append(value.y);
+            result.Append(", ");
+            result.Append(value.z);
+            result.Append(")) = ");
+            result.Append(value.x);
+            return result.ToString();
+        }
+
+        public override string GetPropertyDeclarationString(string delimiter = ";")
+        {
+            return string.Format("float {0}{1}", referenceName, delimiter);
+        }
+
+        public override PreviewProperty GetPreviewMaterialProperty()
+        {
+            return new PreviewProperty(PropertyType.Float)
+            {
+                name = referenceName,
+                floatValue = value.x
+            };
+        }
+
+        public override INode ToConcreteNode()
+        {
+            return new SliderNode { value = value };
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: 116edc957722a90438d51cf6610694d3
+timeCreated: 1505346922

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/BooleanNode.cs

+using System.Collections.Generic;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Input", "Basic", "Boolean")]
+    public class BooleanNode : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
+    {
+        [SerializeField]
+        private bool m_Value;
+
+        public const int OutputSlotId = 0;
+        private const string kOutputSlotName = "Out";
+
+        public BooleanNode()
+        {
+            name = "Boolean";
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new BooleanMaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, false));
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
+        }
+
+        [ToggleControl("")]
+        public Toggle value
+        {
+            get { return new Toggle(m_Value); }
+            set
+            {
+                if (m_Value == value.isOn)
+                    return;
+                m_Value = value.isOn;
+                Dirty(ModificationScope.Node);
+            }
+        }
+
+        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
+        {
+            if (!generationMode.IsPreview())
+                return;
+
+            properties.AddShaderProperty(new BooleanShaderProperty()
+            {
+                overrideReferenceName = GetVariableNameForNode(),
+                generatePropertyBlock = false,
+                value = m_Value
+            });
+        }
+
+        public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+        {
+            if (generationMode.IsPreview())
+                return;
+
+            visitor.AddShaderChunk(precision + " " + GetVariableNameForNode() + " = " + (m_Value ? 1 : 0) + ";", true);
+        }
+
+        public override string GetVariableNameForSlot(int slotId)
+        {
+            return GetVariableNameForNode();
+        }
+
+        public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
+        {
+            properties.Add(new PreviewProperty(PropertyType.Boolean)
+            {
+                name = GetVariableNameForNode(),
+                booleanValue = m_Value
+            });
+        }
+
+        public IShaderProperty AsShaderProperty()
+        {
+            return new BooleanShaderProperty { value = m_Value };
+        }
+
+        public int outputSlotId { get { return OutputSlotId; } }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/BooleanNode.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/HDRColorNode.cs

+using System.Collections.Generic;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Input", "Basic", "HDR Color")]
+    public class HDRColorNode : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
+    {
+        [SerializeField]
+        private Color m_Color;
+
+        public const int OutputSlotId = 0;
+        private const string kOutputSlotName = "Out";
+
+        public HDRColorNode()
+        {
+            name = "HDR Color";
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new ColorRGBAMaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.zero));
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
+        }
+
+        [ColorControl("", ColorMode.HDR)]
+        public Color color
+        {
+            get { return m_Color; }
+            set
+            {
+                if (m_Color == value)
+                    return;
+
+                m_Color = value;
+                Dirty(ModificationScope.Node);
+            }
+        }
+
+
+        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
+        {
+            if (!generationMode.IsPreview())
+                return;
+
+            properties.AddShaderProperty(new ColorShaderProperty()
+            {
+                overrideReferenceName = GetVariableNameForNode(),
+                generatePropertyBlock = false,
+                value = color,
+                HDR = true
+            });
+        }
+
+        public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+        {
+            if (generationMode.IsPreview())
+                return;
+
+            visitor.AddShaderChunk(string.Format(
+                @"{0}4 {1} = IsGammaSpace() ? {0}4({2}, {3}, {4}, {5}) : {0}4(SRGBToLinear({0}3({2}, {3}, {4})), {5});"
+                , precision
+                , GetVariableNameForNode()
+                , color.r
+                , color.g
+                , color.b
+                , color.a), true);
+        }
+
+        public override string GetVariableNameForSlot(int slotId)
+        {
+            return GetVariableNameForNode();
+        }
+
+        public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
+        {
+            properties.Add(new PreviewProperty(PropertyType.Color)
+            {
+                name = GetVariableNameForNode(),
+                colorValue = color
+            });
+        }
+
+        public IShaderProperty AsShaderProperty()
+        {
+            return new ColorShaderProperty { value = color, HDR = true };
+        }
+
+        public int outputSlotId { get { return OutputSlotId; } }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/HDRColorNode.cs.meta

+fileFormatVersion: 2
+guid: 948ed387e8c19c14c82965be937d7284
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/IntegerNode.cs

+using System.Collections.Generic;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Input", "Basic", "Integer")]
+    public class IntegerNode : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
+    {
+        [SerializeField]
+        private int m_Value;
+
+        public const int OutputSlotId = 0;
+        private const string kOutputSlotName = "Out";
+
+        public IntegerNode()
+        {
+            name = "Integer";
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new Vector1MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, 0));
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
+        }
+
+        [IntegerControl("")]
+        public int value
+        {
+            get { return m_Value; }
+            set
+            {
+                if (m_Value == value)
+                    return;
+
+                m_Value = value;
+
+                Dirty(ModificationScope.Node);
+            }
+        }
+
+        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
+        {
+            if (!generationMode.IsPreview())
+                return;
+
+            properties.AddShaderProperty(new IntegerShaderProperty()
+            {
+                overrideReferenceName = GetVariableNameForNode(),
+                generatePropertyBlock = false,
+                value = value
+            });
+        }
+
+        public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+        {
+            if (generationMode.IsPreview())
+                return;
+
+            visitor.AddShaderChunk(precision + " " + GetVariableNameForNode() + " = " + m_Value + ";", true);
+        }
+
+        public override string GetVariableNameForSlot(int slotId)
+        {
+            return GetVariableNameForNode();
+        }
+
+        public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
+        {
+            properties.Add(new PreviewProperty(PropertyType.Float)
+            {
+                name = GetVariableNameForNode(),
+                floatValue = m_Value
+            });
+        }
+
+        public IShaderProperty AsShaderProperty()
+        {
+            return new IntegerShaderProperty { value = value };
+        }
+
+        public int outputSlotId { get { return OutputSlotId; } }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/IntegerNode.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/SliderNode.cs

+using System.Collections.Generic;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Input", "Basic", "Slider")]
+    public class SliderNode : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
+    {
+        [SerializeField]
+        private Vector3 m_Value = new Vector3(0f, 0f, 1f);
+
+        public const int OutputSlotId = 0;
+        private const string kOutputSlotName = "Out";
+
+        public SliderNode()
+        {
+            name = "Slider";
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new Vector1MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, 0));
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
+        }
+
+        [SliderControl("", true)]
+        public Vector3 value
+        {
+            get { return m_Value; }
+            set
+            {
+                if (m_Value == value)
+                    return;
+
+                m_Value = value;
+
+                Dirty(ModificationScope.Node);
+            }
+        }
+
+        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
+        {
+            if (!generationMode.IsPreview())
+                return;
+
+            properties.AddShaderProperty(new SliderShaderProperty()
+            {
+                overrideReferenceName = GetVariableNameForNode(),
+                generatePropertyBlock = false,
+                value = value
+            });
+        }
+
+        public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+        {
+            if (generationMode.IsPreview())
+                return;
+
+            visitor.AddShaderChunk(precision + " " + GetVariableNameForNode() + " = " + m_Value.x + ";", true);
+        }
+
+        public override string GetVariableNameForSlot(int slotId)
+        {
+            return GetVariableNameForNode();
+        }
+
+        public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
+        {
+            properties.Add(new PreviewProperty(PropertyType.Float)
+            {
+                name = GetVariableNameForNode(),
+                floatValue = m_Value.x
+            });
+        }
+
+        public IShaderProperty AsShaderProperty()
+        {
+            return new SliderShaderProperty { value = value };
+        }
+
+        public int outputSlotId { get { return OutputSlotId; } }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/SliderNode.cs.meta

+fileFormatVersion: 2
+guid: 39d5ba890306e584c9fb4fede8c37f9c
+timeCreated: 1445864587
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Controls/IntegerControl.cs

+using System;
+using System.Reflection;
+using UnityEditor.Experimental.UIElements;
+using UnityEngine;
+using UnityEngine.Experimental.UIElements;
+
+namespace UnityEditor.ShaderGraph.Drawing.Controls
+{
+    [AttributeUsage(AttributeTargets.Property)]
+    public class IntegerControlAttribute : Attribute, IControlAttribute
+    {
+        string m_Label;
+
+        public IntegerControlAttribute(string label = null)
+        {
+            m_Label = label;
+        }
+
+        public VisualElement InstantiateControl(AbstractMaterialNode node, PropertyInfo propertyInfo)
+        {
+            return new IntegerControlView(m_Label, node, propertyInfo);
+        }
+    }
+
+    public class IntegerControlView : VisualElement
+    {
+        AbstractMaterialNode m_Node;
+        PropertyInfo m_PropertyInfo;
+
+        public IntegerControlView(string label, AbstractMaterialNode node, PropertyInfo propertyInfo)
+        {
+            m_Node = node;
+            m_PropertyInfo = propertyInfo;
+            if (propertyInfo.PropertyType != typeof(int))
+                throw new ArgumentException("Property must be of type integer.", "propertyInfo");
+            label = label ?? ObjectNames.NicifyVariableName(propertyInfo.Name);
+
+            if (!string.IsNullOrEmpty(label))
+                Add(new Label(label));
+
+            var intField = new IntegerField { value = (int)m_PropertyInfo.GetValue(m_Node, null) };
+            intField.OnValueChanged(OnChange);
+            Add(intField);
+        }
+
+        void OnChange(ChangeEvent<long> evt)
+        {
+            m_Node.owner.owner.RegisterCompleteObjectUndo("Integer Change");
+            m_PropertyInfo.SetValue(m_Node, (int)evt.newValue, null);
+            Dirty(ChangeType.Repaint);
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Controls/IntegerControl.cs.meta

+fileFormatVersion: 2
+guid: 57d18a57866821542806ab5253cf4310
+timeCreated: 1507817885

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Controls/SliderControl.cs

+using System;
+using System.Reflection;
+using UnityEditor.Experimental.UIElements;
+using UnityEngine;
+using UnityEngine.Experimental.UIElements;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph.Drawing.Controls
+{
+    [AttributeUsage(AttributeTargets.Property)]
+    public class SliderControlAttribute : Attribute, IControlAttribute
+    {
+        string m_Label;
+        bool m_DisplayMinMax;
+
+        public SliderControlAttribute(string label = null, bool displayMinMax = false)
+        {
+            m_Label = label;
+            m_DisplayMinMax = displayMinMax;
+        }
+
+        public VisualElement InstantiateControl(AbstractMaterialNode node, PropertyInfo propertyInfo)
+        {
+            return new SliderControlView(m_Label, m_DisplayMinMax, node, propertyInfo);
+        }
+    }
+
+    public class SliderControlView : VisualElement, INodeModificationListener
+    {
+        GUIContent m_Label;
+        AbstractMaterialNode m_Node;
+        PropertyInfo m_PropertyInfo;
+        bool m_DisplayMinMax;
+        int m_UndoGroup = -1;
+        Vector3 m_Value;
+
+        VisualElement m_SliderPanel;
+        Slider m_Slider;
+        FloatField m_SliderInput;
+        FloatField m_MinField;
+        FloatField m_MaxField;
+
+        public SliderControlView(string label, bool displayMinMax, AbstractMaterialNode node, PropertyInfo propertyInfo)
+        {
+            m_Node = node;
+            m_PropertyInfo = propertyInfo;
+            m_DisplayMinMax = displayMinMax;
+
+            if (propertyInfo.PropertyType != typeof(Vector3))
+                throw new ArgumentException("Property must be of type Vector3.", "propertyInfo");
+            m_Label = new GUIContent(label ?? ObjectNames.NicifyVariableName(propertyInfo.Name));
+            m_Value = (Vector3)m_PropertyInfo.GetValue(m_Node, null);
+
+            m_SliderPanel = new VisualElement { name = "SliderPanel" };
+            if (!string.IsNullOrEmpty(label))
+                m_SliderPanel.Add(new Label(label));
+            Action<float> changedSlider = (s) => { OnChangeSlider(s); };
+            m_Slider = new Slider(m_Value.y, m_Value.z, changedSlider);
+            m_Slider.value = m_Value.x;
+            m_SliderPanel.Add(m_Slider);
+            m_SliderInput = AddField(m_SliderPanel, "", 0, m_Value);
+            Add(m_SliderPanel);
+
+            if(m_DisplayMinMax)
+            {
+                var fieldsPanel = new VisualElement { name = "FieldsPanel" };
+                m_MinField = AddField(fieldsPanel, "Min", 1, m_Value);
+                m_MaxField = AddField(fieldsPanel, "Max", 2, m_Value);
+                Add(fieldsPanel);
+            }
+        }
+
+        public void OnNodeModified(ModificationScope scope)
+        {
+            if (scope == ModificationScope.Graph)
+            {
+                Dirty(ChangeType.Repaint);
+            } 
+        }
+
+        void OnChangeSlider(float newValue)
+        {
+            m_Node.owner.owner.RegisterCompleteObjectUndo("Slider Change");
+            var value = (Vector3)m_PropertyInfo.GetValue(m_Node, null);
+            value.x = newValue;
+            m_PropertyInfo.SetValue(m_Node, value, null);
+            if(m_SliderInput != null)
+                m_SliderInput.value = newValue;
+            Dirty(ChangeType.Repaint);
+        }
+        
+        FloatField AddField(VisualElement panel, string label, int index, Vector3 initValiue)
+        {
+            var field = new FloatField { userData = index, value = initValiue[index] };
+            
+            if(label != "")
+            {
+                var l = new Label(label);
+                panel.Add(l);
+                var dragger = new FieldMouseDragger<double>(field);
+                dragger.SetDragZone(l);
+            }
+                
+            field.RegisterCallback<MouseDownEvent>(Repaint);
+            field.RegisterCallback<MouseMoveEvent>(Repaint);
+            field.OnValueChanged(evt =>
+                {
+                    var value = (Vector3)m_PropertyInfo.GetValue(m_Node, null);
+                    value[index] = (float)evt.newValue;
+                    m_PropertyInfo.SetValue(m_Node, value, null);
+                    m_UndoGroup = -1;
+                    UpdateSlider(m_SliderPanel, index, value);
+                    Dirty(ChangeType.Repaint);
+                });
+            field.RegisterCallback<InputEvent>(evt =>
+                {
+                    if (m_UndoGroup == -1)
+                    {
+                        m_UndoGroup = Undo.GetCurrentGroup();
+                        m_Node.owner.owner.RegisterCompleteObjectUndo("Change " + m_Node.name);
+                    }
+                    float newValue;
+                    if (!float.TryParse(evt.newData, out newValue))
+                        newValue = 0f;
+                    var value = (Vector3)m_PropertyInfo.GetValue(m_Node, null);
+                    value[index] = newValue;
+                    m_PropertyInfo.SetValue(m_Node, value, null);
+                    Dirty(ChangeType.Repaint);
+                });
+            field.RegisterCallback<KeyDownEvent>(evt =>
+                {
+                    if (evt.keyCode == KeyCode.Escape && m_UndoGroup > -1)
+                    {
+                        Undo.RevertAllDownToGroup(m_UndoGroup);
+                        m_UndoGroup = -1;
+                        m_Value = (Vector3)m_PropertyInfo.GetValue(m_Node, null);
+                        UpdateSlider(m_SliderPanel, index, m_Value);
+                        evt.StopPropagation();
+                    }
+                    Dirty(ChangeType.Repaint);
+                });
+            panel.Add(field);
+            return field;
+        }
+
+        void UpdateSlider(VisualElement panel, int index, Vector3 value)
+        {
+            value.x = Mathf.Max(Mathf.Min(value.x, value.z), value.y);
+            panel.Remove(m_Slider);
+            Action<float> changedSlider = (s) => { OnChangeSlider(s); };
+            m_Slider = new Slider(value.y, value.z, changedSlider);
+            m_Slider.lowValue = value.y;
+            m_Slider.highValue = value.z;
+            m_Slider.value = value.x;
+            panel.Add(m_Slider);
+
+            panel.Remove(m_SliderInput);
+            if(index != 0)
+                m_SliderInput = AddField(panel, "", 0, value);
+            m_SliderInput.value = value.x;
+            panel.Add(m_SliderInput);
+        }
+
+        void Repaint<T>(MouseEventBase<T> evt) where T : MouseEventBase<T>, new()
+        {
+            evt.StopPropagation();
+            Dirty(ChangeType.Repaint);
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Controls/SliderControl.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Inspector/MasterPreviewView.cs

+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor.Experimental.UIElements;
+using UnityEngine.Experimental.UIElements;
+using UnityEditor.Graphing;
+using Object = UnityEngine.Object;
+
+namespace UnityEditor.ShaderGraph.Drawing.Inspector
+{
+    public class MasterPreviewView : VisualElement
+    {
+        AbstractMaterialGraph m_Graph;
+
+        PreviewRenderData m_PreviewRenderHandle;
+        PreviewTextureView m_PreviewTextureView;
+
+        Vector2 m_PreviewScrollPosition;
+        ObjectField m_PreviewMeshPicker;
+
+        MasterNode m_MasterNode;
+
+        public MasterPreviewView(string assetName, PreviewManager previewManager, AbstractMaterialGraph graph)
+        {
+            m_Graph = graph;
+
+            AddStyleSheetPath("Styles/MaterialGraph");
+
+            m_PreviewRenderHandle = previewManager.masterRenderData;
+            m_PreviewRenderHandle.onPreviewChanged += OnPreviewChanged;
+
+            var topContainer = new VisualElement() { name = "top" };
+            {
+                var title = new Label(assetName + " master node preview") { name = "title" };
+                topContainer.Add(title);
+            }
+            Add(topContainer);
+
+            var middleContainer = new VisualElement {name = "middle"};
+            {
+                m_PreviewTextureView = new PreviewTextureView { name = "preview", image = Texture2D.blackTexture };
+                m_PreviewTextureView.AddManipulator(new Draggable(OnMouseDragPreviwMesh, true));
+                middleContainer.Add(m_PreviewTextureView);
+
+                m_PreviewScrollPosition = new Vector2(0f, 0f);
+
+                middleContainer.Add(m_PreviewTextureView);
+            }
+            Add(middleContainer);
+
+            var bottomContainer = new VisualElement() { name = "bottom" };
+            {
+                m_PreviewMeshPicker = new ObjectField { name = "picker", objectType = typeof(Mesh) };
+                m_PreviewMeshPicker.OnValueChanged(OnPreviewMeshChanged);
+
+                bottomContainer.Add(m_PreviewMeshPicker);
+            }
+            Add(bottomContainer);
+        }
+
+        MasterNode masterNode
+        {
+            get { return m_PreviewRenderHandle.shaderData.node as MasterNode; }
+        }
+
+        void OnPreviewChanged()
+        {
+            m_PreviewTextureView.image = m_PreviewRenderHandle.texture ?? Texture2D.blackTexture;
+            m_PreviewTextureView.Dirty(ChangeType.Repaint);
+        }
+
+        void OnPreviewMeshChanged(ChangeEvent<Object> changeEvent)
+        {
+            Mesh changedMesh = changeEvent.newValue as Mesh;
+
+            masterNode.Dirty(ModificationScope.Node);
+
+            if (m_Graph.previewData.serializedMesh.mesh != changedMesh)
+            {
+                m_Graph.previewData.rotation = Quaternion.identity;
+            }
+
+            m_Graph.previewData.serializedMesh.mesh = changedMesh;
+        }
+
+        void OnMouseDragPreviwMesh(Vector2 deltaMouse)
+        {
+            Vector2 previewSize = m_PreviewTextureView.contentRect.size;
+
+            m_PreviewScrollPosition -= deltaMouse * (Event.current.shift ? 3f : 1f) / Mathf.Min(previewSize.x, previewSize.y) * 140f;
+            m_PreviewScrollPosition.y = Mathf.Clamp(m_PreviewScrollPosition.y, -90f, 90f);
+            Quaternion previewRotation = Quaternion.Euler(m_PreviewScrollPosition.y, 0, 0) * Quaternion.Euler(0, m_PreviewScrollPosition.x, 0);
+            m_Graph.previewData.rotation = previewRotation;
+
+            masterNode.Dirty(ModificationScope.Node);
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Inspector/MasterPreviewView.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Manipulators/ResizeBorderFrame.cs

+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Experimental.UIElements;
+using UnityEditor.ShaderGraph.Drawing;
+
+
+public class ResizeBorderFrame : VisualElement
+{
+    public Action OnResizeFinished;
+
+    public ResizeBorderFrame(VisualElement target)
+    {
+        pickingMode = PickingMode.Ignore;
+
+        AddToClassList("reszieBorderFrame");
+
+        ResizeSideHandle topLeft =  new ResizeSideHandle(target, ResizeHandleAnchor.TopLeft);
+        ResizeSideHandle top =  new ResizeSideHandle(target, ResizeHandleAnchor.Top);
+        ResizeSideHandle topRight =  new ResizeSideHandle(target, ResizeHandleAnchor.TopRight);
+        ResizeSideHandle right = new ResizeSideHandle(target, ResizeHandleAnchor.Right);
+        ResizeSideHandle bottomRight = new ResizeSideHandle(target, ResizeHandleAnchor.BottomRight);
+        ResizeSideHandle bottom = new ResizeSideHandle(target, ResizeHandleAnchor.Bottom);
+        ResizeSideHandle bottomLeft = new ResizeSideHandle(target, ResizeHandleAnchor.BottomLeft);
+        ResizeSideHandle left = new ResizeSideHandle(target, ResizeHandleAnchor.Left);
+
+        topLeft.OnResizeFinished += HandleResizefinished;
+        top.OnResizeFinished += HandleResizefinished;
+        topRight.OnResizeFinished += HandleResizefinished;
+        right.OnResizeFinished += HandleResizefinished;
+        bottomRight.OnResizeFinished += HandleResizefinished;
+        bottom.OnResizeFinished += HandleResizefinished;
+        bottomLeft.OnResizeFinished += HandleResizefinished;
+        left.OnResizeFinished += HandleResizefinished;
+
+        Add(topLeft);
+        Add(top);
+        Add(topRight);
+        Add(right);
+        Add(bottomRight);
+        Add(bottom);
+        Add(bottomLeft);
+        Add(left);
+    }
+
+    void HandleResizefinished()
+    {
+        if (OnResizeFinished != null)
+        {
+            OnResizeFinished();
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Manipulators/ResizeBorderFrame.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Manipulators/WindowDraggable.cs

+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Experimental.UIElements;
+using UnityEditor.Experimental.UIElements;
+
+namespace UnityEditor.ShaderGraph.Drawing
+{
+    public class WindowDraggable : MouseManipulator
+    {
+        bool m_ResizeWithParentWindow;
+
+        bool m_Active;
+
+        bool m_DockLeft;
+        bool m_DockTop;
+
+        Vector2 m_LocalMosueOffset;
+        Rect m_PreviousParentRect;
+
+        public Action OnDragFinished;
+
+        public WindowDraggable(bool resizeWithParentwindow = false)
+        {
+            m_ResizeWithParentWindow = resizeWithParentwindow;
+            m_Active = false;
+            m_PreviousParentRect = new Rect(0f, 0f, 0f, 0f);
+        }
+
+        protected override void RegisterCallbacksOnTarget()
+        {
+            target.RegisterCallback(new EventCallback<MouseDownEvent>(OnMouseDown), Capture.NoCapture);
+            target.RegisterCallback(new EventCallback<MouseMoveEvent>(OnMouseMove), Capture.NoCapture);
+            target.RegisterCallback(new EventCallback<MouseUpEvent>(OnMouseUp), Capture.NoCapture);
+            target.RegisterCallback<PostLayoutEvent>(InitialLayoutSetup);
+        }
+
+        protected override void UnregisterCallbacksFromTarget()
+        {
+            target.UnregisterCallback(new EventCallback<MouseDownEvent>(OnMouseDown), Capture.NoCapture);
+            target.UnregisterCallback(new EventCallback<MouseMoveEvent>(OnMouseMove), Capture.NoCapture);
+            target.UnregisterCallback(new EventCallback<MouseUpEvent>(OnMouseUp), Capture.NoCapture);
+        }
+
+        void OnMouseDown(MouseDownEvent evt)
+        {
+            m_Active = true;
+            m_LocalMosueOffset = target.WorldToLocal(evt.mousePosition);
+
+            target.TakeMouseCapture();
+            evt.StopPropagation();
+        }
+
+        void OnMouseMove(MouseMoveEvent evt)
+        {
+            if (m_Active)
+            {
+                Rect layout = target.layout;
+                layout.position = target.parent.WorldToLocal(evt.mousePosition - m_LocalMosueOffset);
+                target.layout = layout;
+            }
+        }
+
+        void OnMouseUp(MouseUpEvent evt)
+        {
+            bool emitDragFinishedEvent = m_Active;
+
+            m_Active = false;
+
+            if (target.HasMouseCapture())
+            {
+                target.ReleaseMouseCapture();
+            }
+
+            evt.StopPropagation();
+
+            RefreshDocking();
+
+            if (emitDragFinishedEvent && OnDragFinished != null)
+            {
+                OnDragFinished();
+            }
+        }
+
+        void RefreshDocking()
+        {
+            Vector2 windowCenter = new Vector2(target.layout.x + target.layout.width * .5f, target.layout.y + target.layout.height * .5f);
+            windowCenter /= target.parent.layout.size;
+
+            m_DockLeft = windowCenter.x < .5f;
+            m_DockTop = windowCenter.y < .5f;
+        }
+
+        void InitialLayoutSetup(PostLayoutEvent postLayoutEvent)
+        {
+            m_PreviousParentRect = target.parent.layout;
+            target.UnregisterCallback<PostLayoutEvent>(InitialLayoutSetup);
+            target.RegisterCallback<PostLayoutEvent>(OnPostLayout);
+
+            RefreshDocking();
+        }
+
+        void OnPostLayout(PostLayoutEvent postLayoutEvent)
+        {
+            Rect windowRect = target.layout;
+
+            Vector2 scaling = target.parent.layout.size / m_PreviousParentRect.size;
+
+            Vector2 minSize = new Vector2(60f, 60f);
+
+            if (!Mathf.Approximately(target.style.minWidth, 0f))
+            {
+                minSize.x = target.style.minWidth;
+            }
+
+            if (!Mathf.Approximately(target.style.minHeight, 0f))
+            {
+                minSize.y = target.style.minHeight;
+            }
+
+            Vector2 distanceFromParentEdge = Vector2.zero;
+            distanceFromParentEdge.x = m_DockLeft ? target.layout.x : (m_PreviousParentRect.width - target.layout.x - target.layout.width);
+            distanceFromParentEdge.y = m_DockTop ? target.layout.y: (m_PreviousParentRect.height - target.layout.y - target.layout.height);
+
+            Vector2 normalizedDistanceFromEdge = distanceFromParentEdge / m_PreviousParentRect.size;
+
+            if (m_ResizeWithParentWindow)
+            {
+                if (scaling.x > 1f)
+                {
+                    scaling.x = target.parent.layout.width * .33f < minSize.x ? 1f : scaling.x;
+                }
+
+                if (scaling.y > 1f)
+                {
+                    scaling.y = target.parent.layout.height * .33f < minSize.y ? 1f : scaling.y;
+                }
+
+                windowRect.size *= scaling;
+            }
+            else
+            {
+                normalizedDistanceFromEdge = distanceFromParentEdge / target.parent.layout.size;
+            }
+
+            if (m_DockLeft)
+            {
+                windowRect.x = normalizedDistanceFromEdge.x * target.parent.layout.width;
+            }
+            else
+            {
+                windowRect.x = (1f - normalizedDistanceFromEdge.x) * target.parent.layout.width - windowRect.width;
+            }
+
+            if (m_DockTop)
+            {
+                windowRect.y = normalizedDistanceFromEdge.y * target.parent.layout.height;
+            }
+            else
+            {
+                windowRect.y = (1f - normalizedDistanceFromEdge.y) * target.parent.layout.height- windowRect.height;
+            }
+
+            windowRect.width = Mathf.Max(Mathf.Min(windowRect.width, target.parent.layout.width), minSize.x);
+            windowRect.height = Mathf.Max(Mathf.Min(windowRect.height, target.parent.layout.height), minSize.y);
+
+            float maximumXPosition = Mathf.Max(target.parent.layout.width - windowRect.width, 0f);
+            float maximumYPosition = Mathf.Max(target.parent.layout.height - windowRect.height, 0f);
+
+            windowRect.x = Mathf.Clamp(windowRect.x, 0f, maximumXPosition);
+            windowRect.y = Mathf.Clamp(windowRect.y, 0f, maximumYPosition);
+
+            m_PreviousParentRect = target.parent.layout;
+
+            target.layout = windowRect;
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Manipulators/WindowDraggable.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/Slots/BooleanSlotControlView.cs

+using System;
+using UnityEditor.Experimental.UIElements;
+using UnityEditor.Graphing;
+using UnityEngine;
+using UnityEngine.Experimental.UIElements;
+
+namespace UnityEditor.ShaderGraph.Drawing.Slots
+{
+    public class BooleanSlotControlView : VisualElement
+    {
+        BooleanMaterialSlot m_Slot;
+
+        public BooleanSlotControlView(BooleanMaterialSlot slot)
+        {
+            m_Slot = slot;
+            Action changedToggle = () => { OnChangeToggle(); };
+            var toggleField = new UnityEngine.Experimental.UIElements.Toggle(changedToggle);
+            Add(toggleField);
+        }
+
+        void OnChangeToggle()
+        {
+            m_Slot.owner.owner.owner.RegisterCompleteObjectUndo("Toggle Change");
+            var value = m_Slot.value;
+            value = !value;
+            m_Slot.value = value;
+            m_Slot.owner.Dirty(ModificationScope.Node);
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/Slots/BooleanSlotControlView.cs.meta

+fileFormatVersion: 2
+guid: 7fc29d436587748dcaaefd8669c3d946
+timeCreated: 1510659384

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Resources/Shaders/BlitNoAlpha.shader

+Shader "Hidden/BlitNoAlpha"
+{
+    Properties
+    {
+        _MainTex ("Texture", any) = "" {}
+    }
+    SubShader {
+        Pass {
+            ZTest Always Cull Off ZWrite Off
+
+            CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #include "UnityCG.cginc"
+
+            UNITY_DECLARE_SCREENSPACE_TEXTURE(_MainTex);
+            uniform float4 _MainTex_ST;
+
+            struct appdata_t {
+                float4 vertex : POSITION;
+                float2 texcoord : TEXCOORD0;
+                UNITY_VERTEX_INPUT_INSTANCE_ID
+            };
+
+            struct v2f {
+                float4 vertex : SV_POSITION;
+                float2 texcoord : TEXCOORD0;
+                UNITY_VERTEX_OUTPUT_STEREO
+            };
+
+            v2f vert (appdata_t v)
+            {
+                v2f o;
+                UNITY_SETUP_INSTANCE_ID(v);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+                o.vertex = UnityObjectToClipPos(v.vertex);
+                o.texcoord = TRANSFORM_TEX(v.texcoord.xy, _MainTex);
+                return o;
+            }
+
+            fixed4 frag (v2f i) : SV_Target
+            {
+                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
+                return half4(UNITY_SAMPLE_SCREENSPACE_TEXTURE(_MainTex, i.texcoord).xyz, 1.0);
+            }
+            ENDCG
+
+        }
+    }
+    Fallback Off
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Resources/Shaders/BlitNoAlpha.shader.meta

+fileFormatVersion: 2
+guid: 50b406436c6214c49aaaa6011b71dde8
+timeCreated: 1502007198
+licenseType: Pro
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/ComparisonNode.cs.meta

+fileFormatVersion: 2
+guid: c66cc68d0d0862b4c8ddfc00093d0ae0
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/BranchNode.cs.meta

+fileFormatVersion: 2
+guid: 15ad3dc0ff22d7748af5e82ef5503d32
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/AllNode.cs

+using System.Reflection;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Utility", "Logic", "All")]
+    public class AllNode : CodeFunctionNode
+    {
+        public AllNode()
+        {
+            name = "All";
+        }
+
+        public override bool hasPreview
+        {
+            get { return false; }
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_All", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_All(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out Boolean Out)
+        {
+            return
+                @"
+{
+    Out = all(In);
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/AllNode.cs.meta

+fileFormatVersion: 2
+guid: aa03a542537ab4fb4a01a004efa97f58
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/AnyNode.cs

+using System.Reflection;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Utility", "Logic", "Any")]
+    public class AnyNode : CodeFunctionNode
+    {
+        public AnyNode()
+        {
+            name = "Any";
+        }
+
+        public override bool hasPreview
+        {
+            get { return false; }
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Any", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Any(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out Boolean Out)
+        {
+            return
+                @"
+{
+    Out = any(In);
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/AnyNode.cs.meta

+fileFormatVersion: 2
+guid: f3d072ddeeee848848f2e59dbb5cf1d9
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/IsInfiniteNode.cs

+using System.Reflection;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Utility", "Logic", "Is Infinite")]
+    public class IsInfiniteNode : CodeFunctionNode
+    {
+        public IsInfiniteNode()
+        {
+            name = "Is Infinite";
+        }
+
+        public override bool hasPreview
+        {
+            get { return false; }
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_IsInfinite", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_IsInfinite(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out Boolean Out)
+        {
+            return
+                @"
+{
+    Out = isinf(In);
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/IsInfiniteNode.cs.meta

+fileFormatVersion: 2
+guid: 6eaf1bad910084b85ac9ead4319c7820
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/IsNanNode.cs

+using System.Reflection;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Utility", "Logic", "Is NaN")]
+    public class IsNanNode : CodeFunctionNode
+    {
+        public IsNanNode()
+        {
+            name = "Is NaN";
+        }
+
+        public override bool hasPreview
+        {
+            get { return false; }
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_IsNaN", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_IsNaN(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out Boolean Out)
+        {
+            return
+                @"
+{
+    Out = isnan(In);
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/IsNanNode.cs.meta

+fileFormatVersion: 2
+guid: 0e15b8359c9db4d0ea27f4deab94137e
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/AndNode.cs

+using System.Reflection;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Utility", "Logic", "And")]
+    public class AndNode : CodeFunctionNode
+    {
+        public AndNode()
+        {
+            name = "And";
+        }
+
+        public override bool hasPreview
+        {
+            get { return false; }
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_And", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_And(
+            [Slot(0, Binding.None)] Boolean A,
+            [Slot(1, Binding.None)] Boolean B,
+            [Slot(2, Binding.None)] out Boolean Out)
+        {
+            return
+                @"
+{
+    Out = A && B;
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/AndNode.cs.meta

+fileFormatVersion: 2
+guid: 34929a6d0bb40407fb00206ab0a10fa1
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/BranchNode.cs

+using System.Reflection;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Utility", "Logic", "Branch")]
+    public class BranchNode : CodeFunctionNode
+    {
+        public BranchNode()
+        {
+            name = "Branch";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Branch", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Branch(
+            [Slot(0, Binding.None)] Boolean Predicate,
+            [Slot(1, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector True,
+            [Slot(2, Binding.None, 0, 0, 0, 0)] DynamicDimensionVector False,
+            [Slot(3, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+                @"
+{
+    Out = (Predicate * True) + abs((Predicate - 1) * False);
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/NandNode.cs

+using System.Reflection;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Utility", "Logic", "Nand")]
+    public class NandNode : CodeFunctionNode
+    {
+        public NandNode()
+        {
+            name = "Nand";
+        }
+
+        public override bool hasPreview
+        {
+            get { return false; }
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Nand", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Nand(
+            [Slot(0, Binding.None)] Boolean A,
+            [Slot(1, Binding.None)] Boolean B,
+            [Slot(2, Binding.None)] out Boolean Out)
+        {
+            return
+                @"
+{
+    Out = !A && !B;
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/NandNode.cs.meta

+fileFormatVersion: 2
+guid: 4defde87a9d5e44d8b8900d3f8ef6440
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/OrNode.cs

+using System.Reflection;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Utility", "Logic", "Or")]
+    public class OrNode : CodeFunctionNode
+    {
+        public OrNode()
+        {
+            name = "Or";
+        }
+
+        public override bool hasPreview
+        {
+            get { return false; }
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Or", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Or(
+            [Slot(0, Binding.None)] Boolean A,
+            [Slot(1, Binding.None)] Boolean B,
+            [Slot(2, Binding.None)] out Boolean Out)
+        {
+            return
+                @"
+{
+    Out = A || B;
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/OrNode.cs.meta

+fileFormatVersion: 2
+guid: 0f6f860c0f1e24214b5d2974cc624227
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/NotNode.cs

+using System.Reflection;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Utility", "Logic", "Not")]
+    public class NotNode : CodeFunctionNode
+    {
+        public NotNode()
+        {
+            name = "Not";
+        }
+
+        public override bool hasPreview
+        {
+            get { return false; }
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Not", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Not(
+            [Slot(0, Binding.None)] Boolean In,
+            [Slot(1, Binding.None)] out Boolean Out)
+        {
+            return
+                @"
+{
+    Out = !In;
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/NotNode.cs.meta

+fileFormatVersion: 2
+guid: acb4138f9cef644dfa59102e871d1820
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Utility/Logic/ComparisonNode.cs

+using System.Reflection;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph
+{
+    public enum ComparisonType
+    {
+        Equal,
+        NotEqual,
+        Less,
+        LessOrEqual,
+        Greater,
+        GreaterOrEqual
+    };
+
+    [Title("Utility", "Logic", "Comparison")]
+    public class ComparisonNode : CodeFunctionNode
+    {
+        public ComparisonNode()
+        {
+            name = "Comparison";
+        }
+
+        [SerializeField]
+        private ComparisonType m_ComparisonType = ComparisonType.Equal;
+
+        [EnumControl("")]
+        public ComparisonType comparisonType
+        {
+            get { return m_ComparisonType; }
+            set
+            {
+                if (m_ComparisonType == value)
+                    return;
+
+                m_ComparisonType = value;
+                Dirty(ModificationScope.Graph);
+            }
+        }
+
+        public override bool hasPreview
+        {
+            get { return false; }
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            switch(comparisonType)
+            {
+                case ComparisonType.NotEqual:
+                    return GetType().GetMethod("Unity_Comparison_NotEqual", BindingFlags.Static | BindingFlags.NonPublic);
+                case ComparisonType.Less:
+                    return GetType().GetMethod("Unity_Comparison_Less", BindingFlags.Static | BindingFlags.NonPublic);
+                case ComparisonType.LessOrEqual:
+                    return GetType().GetMethod("Unity_Comparison_LessOrEqual", BindingFlags.Static | BindingFlags.NonPublic);
+                case ComparisonType.Greater:
+                    return GetType().GetMethod("Unity_Comparison_Greater", BindingFlags.Static | BindingFlags.NonPublic);
+                case ComparisonType.GreaterOrEqual:
+                    return GetType().GetMethod("Unity_Comparison_GreaterOrEqual", BindingFlags.Static | BindingFlags.NonPublic);
+                default:
+                    return GetType().GetMethod("Unity_Comparison_Equal", BindingFlags.Static | BindingFlags.NonPublic);
+            }
+        }
+
+        static string Unity_Comparison_Equal(
+            [Slot(0, Binding.None)] Vector1 A,
+            [Slot(1, Binding.None)] Vector1 B,
+            [Slot(2, Binding.None)] out Boolean Out)
+        {
+            return
+                @"
+{
+    Out = A == B ? 1 : 0;
+}
+";
+        }
+
+        static string Unity_Comparison_NotEqual(
+            [Slot(0, Binding.None)] Vector1 A,
+            [Slot(1, Binding.None)] Vector1 B,
+            [Slot(2, Binding.None)] out Boolean Out)
+        {
+            return
+                @"
+{
+    Out = A != B ? 1 : 0;
+}
+";
+        }
+
+        static string Unity_Comparison_Less(
+            [Slot(0, Binding.None)] Vector1 A,
+            [Slot(1, Binding.None)] Vector1 B,
+            [Slot(2, Binding.None)] out Boolean Out)
+        {
+            return
+                @"
+{
+    Out = A < B ? 1 : 0;
+}
+";
+        }
+
+        static string Unity_Comparison_LessOrEqual(
+            [Slot(0, Binding.None)] Vector1 A,
+            [Slot(1, Binding.None)] Vector1 B,
+            [Slot(2, Binding.None)] out Boolean Out)
+        {
+            return
+                @"
+{
+    Out = A <= B ? 1 : 0;
+}
+";
+        }
+
+        static string Unity_Comparison_Greater(
+            [Slot(0, Binding.None)] Vector1 A,
+            [Slot(1, Binding.None)] Vector1 B,
+            [Slot(2, Binding.None)] out Boolean Out)
+        {
+            return
+                @"
+{
+    Out = A > B ? 1 : 0;
+}
+";
+        }
+
+        static string Unity_Comparison_GreaterOrEqual(
+            [Slot(0, Binding.None)] Vector1 A,
+            [Slot(1, Binding.None)] Vector1 B,
+            [Slot(2, Binding.None)] out Boolean Out)
+        {
+            return
+                @"
+{
+    Out = A >= B ? 1 : 0;
+}
+";
+        }
+    }
+}