ja

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 198ec765a01574320a8199338d27d9f1
+folderAsset: yes
+timeCreated: 1495526831
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/AbsoluteNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Advanced", "Absolute")]
+    class AbsoluteNode : CodeFunctionNode
+    {
+        public AbsoluteNode()
+        {
+            name = "Absolute";
+            synonyms = new string[] { "positive" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Absolute", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Absolute(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = abs(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/AbsoluteNode.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4b496ffd32c22d94bb525897d152da05
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/ExponentialNode.cs

@@ -0,0 +1,74 @@
+using System.Reflection;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph
+{
+    enum ExponentialBase
+    {
+        BaseE,
+        Base2
+    };
+
+    [Title("Math", "Advanced", "Exponential")]
+    class ExponentialNode : CodeFunctionNode
+    {
+        public ExponentialNode()
+        {
+            name = "Exponential";
+        }
+
+        [SerializeField]
+        private ExponentialBase m_ExponentialBase = ExponentialBase.BaseE;
+
+        [EnumControl("Base")]
+        public ExponentialBase exponentialBase
+        {
+            get { return m_ExponentialBase; }
+            set
+            {
+                if (m_ExponentialBase == value)
+                    return;
+
+                m_ExponentialBase = value;
+                Dirty(ModificationScope.Graph);
+            }
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            switch (m_ExponentialBase)
+            {
+                case ExponentialBase.Base2:
+                    return GetType().GetMethod("Unity_Exponential2", BindingFlags.Static | BindingFlags.NonPublic);
+                default:
+                    return GetType().GetMethod("Unity_Exponential", BindingFlags.Static | BindingFlags.NonPublic);
+            }
+        }
+
+        static string Unity_Exponential(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = exp(In);
+}
+";
+        }
+
+        static string Unity_Exponential2(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = exp2(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/ExponentialNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 2caea2ece6d6b4cbebf8bd122b11258a
+timeCreated: 1490745697
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/LengthNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Advanced", "Length")]
+    class LengthNode : CodeFunctionNode
+    {
+        public LengthNode()
+        {
+            name = "Length";
+            synonyms = new string[] { "measure" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Length", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Length(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out Vector1 Out)
+        {
+            return
+@"
+{
+    Out = length(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/LengthNode.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 52afae1b1271e864c9c6965dc738c2dd
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/LogNode.cs

@@ -0,0 +1,89 @@
+using System.Reflection;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph
+{
+    enum LogBase
+    {
+        BaseE,
+        Base2,
+        Base10
+    };
+
+    [Title("Math", "Advanced", "Log")]
+    class LogNode : CodeFunctionNode
+    {
+        public LogNode()
+        {
+            name = "Log";
+        }
+
+        [SerializeField]
+        private LogBase m_LogBase = LogBase.BaseE;
+
+        [EnumControl("Base")]
+        public LogBase logBase
+        {
+            get { return m_LogBase; }
+            set
+            {
+                if (m_LogBase == value)
+                    return;
+
+                m_LogBase = value;
+                Dirty(ModificationScope.Graph);
+            }
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            switch (m_LogBase)
+            {
+                case LogBase.Base2:
+                    return GetType().GetMethod("Unity_Log2", BindingFlags.Static | BindingFlags.NonPublic);
+                case LogBase.Base10:
+                    return GetType().GetMethod("Unity_Log10", BindingFlags.Static | BindingFlags.NonPublic);
+                default:
+                    return GetType().GetMethod("Unity_Log", BindingFlags.Static | BindingFlags.NonPublic);
+            }
+        }
+
+        static string Unity_Log(
+            [Slot(0, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = log(In);
+}
+";
+        }
+
+        static string Unity_Log2(
+            [Slot(0, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = log2(In);
+}
+";
+        }
+
+        static string Unity_Log10(
+            [Slot(0, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = log10(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/LogNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: a8880ad54646f8b469de662f4f0785c9
+timeCreated: 1490740341
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/ModuloNode.cs

@@ -0,0 +1,32 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Advanced", "Modulo")]
+    class ModuloNode : CodeFunctionNode
+    {
+        public ModuloNode()
+        {
+            name = "Modulo";
+            synonyms = new string[] { "fmod" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Modulo", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Modulo(
+            [Slot(0, Binding.None, 0, 0, 0, 0)] DynamicDimensionVector A,
+            [Slot(1, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector B,
+            [Slot(2, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = fmod(A, B);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/ModuloNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 058897be65bcd42f6ba05a4918c46629
+timeCreated: 1490745697
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/NegateNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Advanced", "Negate")]
+    class NegateNode : CodeFunctionNode
+    {
+        public NegateNode()
+        {
+            name = "Negate";
+            synonyms = new string[] { "invert", "opposite" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Negate", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Negate(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = -1 * In;
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/NegateNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 27a3ba76eb1c9a54f8355034489b2e83
+timeCreated: 1495446331
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/NormalizeNode.cs

@@ -0,0 +1,30 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Advanced", "Normalize")]
+    class NormalizeNode : CodeFunctionNode
+    {
+        public NormalizeNode()
+        {
+            name = "Normalize";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Normalize", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Normalize(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = normalize(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/NormalizeNode.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7eb73d726827e2c41ae4d68018bc97e1
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/PosterizeNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Advanced", "Posterize")]
+    class PosterizeNode : CodeFunctionNode
+    {
+        public PosterizeNode()
+        {
+            name = "Posterize";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Posterize", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Posterize(
+            [Slot(0, Binding.None, 0, 0, 0, 0)] DynamicDimensionVector In,
+            [Slot(1, Binding.None, 4, 4, 4, 4)] DynamicDimensionVector Steps,
+            [Slot(2, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = floor(In / (1 / Steps)) * (1 / Steps);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/PosterizeNode.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4322ad8d0cd83df47afd741a6b97d57b
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/ReciprocalNode.cs

@@ -0,0 +1,75 @@
+using System.Reflection;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph
+{
+    enum ReciprocalMethod
+    {
+        Default,
+        Fast
+    };
+
+    [Title("Math", "Advanced", "Reciprocal")]
+    class ReciprocalNode : CodeFunctionNode
+    {
+        public ReciprocalNode()
+        {
+            name = "Reciprocal";
+            synonyms = new string[] { "rcp" };
+        }
+
+        [SerializeField]
+        private ReciprocalMethod m_ReciprocalMethod = ReciprocalMethod.Default;
+
+        [EnumControl("Method")]
+        public ReciprocalMethod reciprocalMethod
+        {
+            get { return m_ReciprocalMethod; }
+            set
+            {
+                if (m_ReciprocalMethod == value)
+                    return;
+
+                m_ReciprocalMethod = value;
+                Dirty(ModificationScope.Graph);
+            }
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            switch (m_ReciprocalMethod)
+            {
+                case ReciprocalMethod.Fast:
+                    return GetType().GetMethod("Unity_Reciprocal_Fast", BindingFlags.Static | BindingFlags.NonPublic);
+                default:
+                    return GetType().GetMethod("Unity_Reciprocal", BindingFlags.Static | BindingFlags.NonPublic);
+            }
+        }
+
+        static string Unity_Reciprocal(
+            [Slot(0, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = 1.0/In;
+}
+";
+        }
+
+        static string Unity_Reciprocal_Fast(
+            [Slot(0, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = rcp(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/ReciprocalNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 2b52706eb67bd8445b13f43ae287c679
+timeCreated: 1495445608
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/ReciprocalSquareRootNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Advanced", "Reciprocal Square Root")]
+    class ReciprocalSquareRootNode : CodeFunctionNode
+    {
+        public ReciprocalSquareRootNode()
+        {
+            name = "Reciprocal Square Root";
+            synonyms = new string[] { "rsqrt", "inversesqrt" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Rsqrt", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Rsqrt(
+            [Slot(0, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = rsqrt(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Advanced/ReciprocalSquareRootNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d67c532974f20f74ca83c79573c45a61
+timeCreated: 1495627989
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Basic.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 4120c70d7c1a34d92b74137bf0b1bc67
+folderAsset: yes
+timeCreated: 1495526365
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Basic/AddNode.cs

@@ -0,0 +1,32 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Basic", "Add")]
+    class AddNode : CodeFunctionNode
+    {
+        public AddNode()
+        {
+            name = "Add";
+            synonyms = new string[] { "addition", "sum", "plus" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Add", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Add(
+            [Slot(0, Binding.None)] DynamicDimensionVector A,
+            [Slot(1, Binding.None)] DynamicDimensionVector B,
+            [Slot(2, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = A + B;
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Basic/AddNode.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 357a15b35b0cd9e47a66e10c5b627fcd
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Basic/DivideNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Basic", "Divide")]
+    class DivideNode : CodeFunctionNode
+    {
+        public DivideNode()
+        {
+            name = "Divide";
+            synonyms = new string[] { "division", "divided by" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Divide", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Divide(
+            [Slot(0, Binding.None, 0, 0, 0, 0)] DynamicDimensionVector A,
+            [Slot(1, Binding.None, 2, 2, 2, 2)] DynamicDimensionVector B,
+            [Slot(2, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return @"
+{
+    Out = A / B;
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Basic/DivideNode.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8e9d13e64300d6942ad51651d39f9ac6
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Basic/MultiplyNode.cs

@@ -0,0 +1,305 @@
+//using System.Reflection;
+using System;
+using System.Collections.Generic;
+using UnityEditor.Graphing;
+using UnityEngine;
+using System.Linq;
+using UnityEditor.Graphing.Util;
+using UnityEngine.Pool;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Basic", "Multiply")]
+    class MultiplyNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction
+    {
+        public MultiplyNode()
+        {
+            name = "Multiply";
+            synonyms = new string[] { "multiplication", "times", "x" };
+            UpdateNodeAfterDeserialization();
+        }
+
+        const int Input1SlotId = 0;
+        const int Input2SlotId = 1;
+        const int OutputSlotId = 2;
+        const string kInput1SlotName = "A";
+        const string kInput2SlotName = "B";
+        const string kOutputSlotName = "Out";
+
+        enum MultiplyType
+        {
+            Vector,
+            Matrix,
+            Mixed
+        }
+
+        MultiplyType m_MultiplyType;
+
+        public override bool hasPreview => true;
+
+        string GetFunctionName()
+        {
+            return $"Unity_Multiply_{FindSlot<MaterialSlot>(Input1SlotId).concreteValueType.ToShaderString()}_{FindSlot<MaterialSlot>(Input2SlotId).concreteValueType.ToShaderString()}";
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new DynamicValueMaterialSlot(Input1SlotId, kInput1SlotName, kInput1SlotName, SlotType.Input, Matrix4x4.zero));
+            AddSlot(new DynamicValueMaterialSlot(Input2SlotId, kInput2SlotName, kInput2SlotName, SlotType.Input, new Matrix4x4(new Vector4(2, 2, 2, 2), new Vector4(2, 2, 2, 2), new Vector4(2, 2, 2, 2), new Vector4(2, 2, 2, 2))));
+            AddSlot(new DynamicValueMaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Matrix4x4.zero));
+            RemoveSlotsNameNotMatching(new[] { Input1SlotId, Input2SlotId, OutputSlotId });
+        }
+
+        public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
+        {
+            var input1Value = GetSlotValue(Input1SlotId, generationMode);
+            var input2Value = GetSlotValue(Input2SlotId, generationMode);
+            var outputValue = GetSlotValue(OutputSlotId, generationMode);
+
+            sb.AppendLine("{0} {1};", FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType.ToShaderString(), GetVariableNameForSlot(OutputSlotId));
+            sb.AppendLine("{0}({1}, {2}, {3});", GetFunctionName(), input1Value, input2Value, outputValue);
+        }
+
+        public void GenerateNodeFunction(FunctionRegistry registry, GenerationMode generationMode)
+        {
+            var functionName = GetFunctionName();
+
+            registry.ProvideFunction(functionName, s =>
+            {
+                s.AppendLine("void {0}({1} A, {2} B, out {3} Out)",
+                    functionName,
+                    FindInputSlot<MaterialSlot>(Input1SlotId).concreteValueType.ToShaderString(),
+                    FindInputSlot<MaterialSlot>(Input2SlotId).concreteValueType.ToShaderString(),
+                    FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType.ToShaderString());     // TODO: should this type be part of the function name?
+                                                                                                        // is output concrete value type related to node's concrete precision??
+                using (s.BlockScope())
+                {
+                    switch (m_MultiplyType)
+                    {
+                        case MultiplyType.Vector:
+                            s.AppendLine("Out = A * B;");
+                            break;
+                        default:
+                            s.AppendLine("Out = mul(A, B);");
+                            break;
+                    }
+                }
+            });
+        }
+
+        // Internal validation
+        // -------------------------------------------------
+
+        public override void EvaluateDynamicMaterialSlots(List<MaterialSlot> inputSlots, List<MaterialSlot> outputSlots)
+        {
+            var dynamicInputSlotsToCompare = DictionaryPool<DynamicValueMaterialSlot, ConcreteSlotValueType>.Get();
+            var skippedDynamicSlots = ListPool<DynamicValueMaterialSlot>.Get();
+
+            // iterate the input slots
+            {
+                foreach (var inputSlot in inputSlots)
+                {
+                    inputSlot.hasError = false;
+
+                    // if there is a connection
+                    var edges = owner.GetEdges(inputSlot.slotReference).ToList();
+                    if (!edges.Any())
+                    {
+                        if (inputSlot is DynamicValueMaterialSlot)
+                            skippedDynamicSlots.Add(inputSlot as DynamicValueMaterialSlot);
+                        continue;
+                    }
+
+                    // get the output details
+                    var outputSlotRef = edges[0].outputSlot;
+                    var outputNode = outputSlotRef.node;
+                    if (outputNode == null)
+                        continue;
+
+                    var outputSlot = outputNode.FindOutputSlot<MaterialSlot>(outputSlotRef.slotId);
+                    if (outputSlot == null)
+                        continue;
+
+                    if (outputSlot.hasError)
+                    {
+                        inputSlot.hasError = true;
+                        continue;
+                    }
+
+                    var outputConcreteType = outputSlot.concreteValueType;
+                    // dynamic input... depends on output from other node.
+                    // we need to compare ALL dynamic inputs to make sure they
+                    // are compatable.
+                    if (inputSlot is DynamicValueMaterialSlot)
+                    {
+                        dynamicInputSlotsToCompare.Add((DynamicValueMaterialSlot)inputSlot, outputConcreteType);
+                        continue;
+                    }
+                }
+
+                m_MultiplyType = GetMultiplyType(dynamicInputSlotsToCompare.Values);
+
+                // Resolve dynamics depending on matrix/vector configuration
+                switch (m_MultiplyType)
+                {
+                    // If all matrix resolve as per dynamic matrix
+                    case MultiplyType.Matrix:
+                        var dynamicMatrixType = ConvertDynamicMatrixInputTypeToConcrete(dynamicInputSlotsToCompare.Values);
+                        foreach (var dynamicKvP in dynamicInputSlotsToCompare)
+                            dynamicKvP.Key.SetConcreteType(dynamicMatrixType);
+                        foreach (var skippedSlot in skippedDynamicSlots)
+                            skippedSlot.SetConcreteType(dynamicMatrixType);
+                        break;
+                    // If mixed handle differently:
+                    // Iterate all slots and set their concretes based on their edges
+                    // Find matrix slot and convert its type to a vector type
+                    // Reiterate all slots and set non matrix slots to the vector type
+                    case MultiplyType.Mixed:
+                        foreach (var dynamicKvP in dynamicInputSlotsToCompare)
+                        {
+                            SetConcreteValueTypeFromEdge(dynamicKvP.Key);
+                        }
+                        MaterialSlot matrixSlot = GetMatrixSlot();
+                        ConcreteSlotValueType vectorType = SlotValueHelper.ConvertMatrixToVectorType(matrixSlot.concreteValueType);
+                        foreach (var dynamicKvP in dynamicInputSlotsToCompare)
+                        {
+                            if (dynamicKvP.Key != matrixSlot)
+                                dynamicKvP.Key.SetConcreteType(vectorType);
+                        }
+                        foreach (var skippedSlot in skippedDynamicSlots)
+                        {
+                            skippedSlot.SetConcreteType(vectorType);
+                        }
+                        break;
+                    // If all vector resolve as per dynamic vector
+                    default:
+                        var dynamicVectorType = ConvertDynamicVectorInputTypeToConcrete(dynamicInputSlotsToCompare.Values);
+                        foreach (var dynamicKvP in dynamicInputSlotsToCompare)
+                            dynamicKvP.Key.SetConcreteType(dynamicVectorType);
+                        foreach (var skippedSlot in skippedDynamicSlots)
+                            skippedSlot.SetConcreteType(dynamicVectorType);
+                        break;
+                }
+
+                bool inputError = inputSlots.Any(x => x.hasError);
+                if (inputError)
+                {
+                    owner.AddConcretizationError(objectId, string.Format("Node {0} had input error", objectId));
+                    hasError = true;
+                }
+                // configure the output slots now
+                // their slotType will either be the default output slotType
+                // or the above dynanic slotType for dynamic nodes
+                // or error if there is an input error
+                foreach (var outputSlot in outputSlots)
+                {
+                    outputSlot.hasError = false;
+
+                    if (inputError)
+                    {
+                        outputSlot.hasError = true;
+                        continue;
+                    }
+
+                    if (outputSlot is DynamicValueMaterialSlot)
+                    {
+                        // Apply similar logic to output slot
+                        switch (m_MultiplyType)
+                        {
+                            // As per dynamic matrix
+                            case MultiplyType.Matrix:
+                                var dynamicMatrixType = ConvertDynamicMatrixInputTypeToConcrete(dynamicInputSlotsToCompare.Values);
+                                (outputSlot as DynamicValueMaterialSlot).SetConcreteType(dynamicMatrixType);
+                                break;
+                            // Mixed configuration
+                            // Find matrix slot and convert type to vector
+                            // Set output concrete to vector
+                            case MultiplyType.Mixed:
+                                MaterialSlot matrixSlot = GetMatrixSlot();
+                                ConcreteSlotValueType vectorType = SlotValueHelper.ConvertMatrixToVectorType(matrixSlot.concreteValueType);
+                                (outputSlot as DynamicValueMaterialSlot).SetConcreteType(vectorType);
+                                break;
+                            // As per dynamic vector
+                            default:
+                                var dynamicVectorType = ConvertDynamicVectorInputTypeToConcrete(dynamicInputSlotsToCompare.Values);
+                                (outputSlot as DynamicValueMaterialSlot).SetConcreteType(dynamicVectorType);
+                                break;
+                        }
+                        continue;
+                    }
+                }
+
+                if (outputSlots.Any(x => x.hasError))
+                {
+                    owner.AddConcretizationError(objectId, string.Format("Node {0} had output error", objectId));
+                    hasError = true;
+                }
+            }
+
+            CalculateNodeHasError();
+
+            ListPool<DynamicValueMaterialSlot>.Release(skippedDynamicSlots);
+            DictionaryPool<DynamicValueMaterialSlot, ConcreteSlotValueType>.Release(dynamicInputSlotsToCompare);
+        }
+
+        private MultiplyType GetMultiplyType(IEnumerable<ConcreteSlotValueType> inputTypes)
+        {
+            var concreteSlotValueTypes = inputTypes as List<ConcreteSlotValueType> ?? inputTypes.ToList();
+            int matrixCount = 0;
+            int vectorCount = 0;
+            for (int i = 0; i < concreteSlotValueTypes.Count; i++)
+            {
+                if (concreteSlotValueTypes[i] == ConcreteSlotValueType.Vector4
+                    || concreteSlotValueTypes[i] == ConcreteSlotValueType.Vector3
+                    || concreteSlotValueTypes[i] == ConcreteSlotValueType.Vector2
+                    || concreteSlotValueTypes[i] == ConcreteSlotValueType.Vector1)
+                {
+                    vectorCount++;
+                }
+                else if (concreteSlotValueTypes[i] == ConcreteSlotValueType.Matrix4
+                         || concreteSlotValueTypes[i] == ConcreteSlotValueType.Matrix3
+                         || concreteSlotValueTypes[i] == ConcreteSlotValueType.Matrix2)
+                {
+                    matrixCount++;
+                }
+            }
+            if (matrixCount == 2)
+                return MultiplyType.Matrix;
+            else if (vectorCount == 2)
+                return MultiplyType.Vector;
+            else if (matrixCount == 1)
+                return MultiplyType.Mixed;
+            else
+                return MultiplyType.Vector;
+        }
+
+        private MaterialSlot GetMatrixSlot()
+        {
+            List<MaterialSlot> slots = new List<MaterialSlot>();
+            GetInputSlots(slots);
+            for (int i = 0; i < slots.Count; i++)
+            {
+                var edges = owner.GetEdges(slots[i].slotReference).ToList();
+                if (!edges.Any())
+                    continue;
+                var outputNode = edges[0].outputSlot.node;
+                var outputSlot = outputNode.FindOutputSlot<MaterialSlot>(edges[0].outputSlot.slotId);
+                if (outputSlot.concreteValueType == ConcreteSlotValueType.Matrix4
+                    || outputSlot.concreteValueType == ConcreteSlotValueType.Matrix3
+                    || outputSlot.concreteValueType == ConcreteSlotValueType.Matrix2)
+                    return slots[i];
+            }
+            return null;
+        }
+
+        private void SetConcreteValueTypeFromEdge(DynamicValueMaterialSlot slot)
+        {
+            var edges = owner.GetEdges(slot.slotReference).ToList();
+            if (!edges.Any())
+                return;
+            var outputNode = edges[0].outputSlot.node;
+            var outputSlot = outputNode.FindOutputSlot<MaterialSlot>(edges[0].outputSlot.slotId);
+            slot.SetConcreteType(outputSlot.concreteValueType);
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Basic/MultiplyNode.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 088fb5bde3ece0f4190136b3ab43f7c4
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Basic/PowerNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Basic", "Power")]
+    class PowerNode : CodeFunctionNode
+    {
+        public PowerNode()
+        {
+            name = "Power";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Power", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Power(
+            [Slot(0, Binding.None, 0, 0, 0, 0)] DynamicDimensionVector A,
+            [Slot(1, Binding.None, 2, 2, 2, 2)] DynamicDimensionVector B,
+            [Slot(2, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = pow(A, B);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Basic/PowerNode.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b2957c4e08e061444a7444a1a03fb584
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Basic/SquareRootNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Basic", "Square Root")]
+    class SquareRootNode : CodeFunctionNode
+    {
+        public SquareRootNode()
+        {
+            name = "Square Root";
+            synonyms = new string[] { "sqrt" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_SquareRoot", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_SquareRoot(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = sqrt(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Basic/SquareRootNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: de49bddaf105fe34483c97b6546e54d7
+timeCreated: 1490740146
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Basic/SubtractNode.cs

@@ -0,0 +1,32 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Basic", "Subtract")]
+    class SubtractNode : CodeFunctionNode
+    {
+        public SubtractNode()
+        {
+            name = "Subtract";
+            synonyms = new string[] { "subtraction", "remove", "minus", "take away" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Subtract", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Subtract(
+            [Slot(0, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector A,
+            [Slot(1, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector B,
+            [Slot(2, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = A - B;
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Basic/SubtractNode.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b251c305a044f49438dff356f1e7bb84
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Derivative.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c10838deaed74574a94a340e53c2b229
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Derivative/DDXNode.cs

@@ -0,0 +1,33 @@
+using System.Reflection;
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Derivative", "DDX")]
+    class DDXNode : CodeFunctionNode
+    {
+        public DDXNode()
+        {
+            name = "DDX";
+            synonyms = new string[] { "derivative" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_DDX", BindingFlags.Instance | BindingFlags.NonPublic);
+        }
+
+        string Unity_DDX(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None, ShaderStageCapability.Fragment)] out DynamicDimensionVector Out)
+        {
+            return
+$@"
+{{
+    {GetRayTracingError()}
+    Out = ddx(In);
+}}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Derivative/DDXNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f13ae4db3be37ef4bbb46a37782ecd1a
+timeCreated: 1490780593
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Derivative/DDXYNode.cs

@@ -0,0 +1,33 @@
+using System.Reflection;
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Derivative", "DDXY")]
+    class DDXYNode : CodeFunctionNode
+    {
+        public DDXYNode()
+        {
+            name = "DDXY";
+            synonyms = new string[] { "derivative" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_DDXY", BindingFlags.Instance | BindingFlags.NonPublic);
+        }
+
+        string Unity_DDXY(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None, ShaderStageCapability.Fragment)] out DynamicDimensionVector Out)
+        {
+            return
+$@"
+{{
+    {GetRayTracingError()}
+    Out = abs(ddx(In)) + abs(ddy(In));
+}}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Derivative/DDXYNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c18b14d941c03eb4d90c30f51c1d4fe1
+timeCreated: 1490780593
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Derivative/DDYNode.cs

@@ -0,0 +1,33 @@
+using System.Reflection;
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Derivative", "DDY")]
+    class DDYNode : CodeFunctionNode
+    {
+        public DDYNode()
+        {
+            name = "DDY";
+            synonyms = new string[] { "derivative" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_DDY", BindingFlags.Instance | BindingFlags.NonPublic);
+        }
+
+        string Unity_DDY(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None, ShaderStageCapability.Fragment)] out DynamicDimensionVector Out)
+        {
+            return
+$@"
+{{
+    {GetRayTracingError()}
+    Out = ddy(In);
+}}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Derivative/DDYNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 421366e7b391f2c45902b735c4f45cb9
+timeCreated: 1490780593
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Interpolation.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 458e098c89ad64ed3a48cb5f63a5a498
+folderAsset: yes
+timeCreated: 1495529238
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Interpolation/InverseLerpNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Interpolation", "Inverse Lerp")]
+    class InverseLerpNode : CodeFunctionNode
+    {
+        public InverseLerpNode()
+        {
+            name = "Inverse Lerp";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_InverseLerp", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_InverseLerp(
+            [Slot(0, Binding.None, 0, 0, 0, 0)] DynamicDimensionVector A,
+            [Slot(1, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector B,
+            [Slot(2, Binding.None, 0, 0, 0, 0)] DynamicDimensionVector T,
+            [Slot(3, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = (T - A)/(B - A);
+}";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Interpolation/InverseLerpNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 25857c1c6903f40f382b8857bba28668
+timeCreated: 1444218016
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Interpolation/LerpNode.cs

@@ -0,0 +1,32 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Interpolation", "Lerp")]
+    class LerpNode : CodeFunctionNode
+    {
+        public LerpNode()
+        {
+            name = "Lerp";
+            synonyms = new string[] { "mix", "blend", "linear interpolate" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Lerp", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Lerp(
+            [Slot(0, Binding.None, 0, 0, 0, 0)] DynamicDimensionVector A,
+            [Slot(1, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector B,
+            [Slot(2, Binding.None, 0, 0, 0, 0)] DynamicDimensionVector T,
+            [Slot(3, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = lerp(A, B, T);
+}";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Interpolation/LerpNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: a5622947be2d8cd48beb2362351ddf12
+timeCreated: 1444218016
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Interpolation/SmoothstepNode.cs

@@ -0,0 +1,32 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Interpolation", "Smoothstep")]
+    class SmoothstepNode : CodeFunctionNode
+    {
+        public SmoothstepNode()
+        {
+            name = "Smoothstep";
+            synonyms = new string[] { "curve" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Smoothstep", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Smoothstep(
+            [Slot(0, Binding.None, 0, 0, 0, 0)] DynamicDimensionVector Edge1,
+            [Slot(1, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector Edge2,
+            [Slot(2, Binding.None, 0, 0, 0, 0)] DynamicDimensionVector In,
+            [Slot(3, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = smoothstep(Edge1, Edge2, In);
+}";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Interpolation/SmoothstepNode.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a9ced96a233d64541b3c5d374a057d6b
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Matrix.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: bfc8dbcaa9711c945b8fd983b819335d
+folderAsset: yes
+timeCreated: 1495700996
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Matrix/MatrixConstructionNode.cs

@@ -0,0 +1,116 @@
+using System;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Matrix", "Matrix Construction")]
+    class MatrixConstructionNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction
+    {
+        const string kInputSlotM0Name = "M0";
+        const string kInputSlotM1Name = "M1";
+        const string kInputSlotM2Name = "M2";
+        const string kInputSlotM3Name = "M3";
+        const string kOutput4x4SlotName = "4x4";
+        const string kOutput3x3SlotName = "3x3";
+        const string kOutput2x2SlotName = "2x2";
+
+        public const int InputSlotM0Id = 0;
+        public const int InputSlotM1Id = 1;
+        public const int InputSlotM2Id = 2;
+        public const int InputSlotM3Id = 3;
+        public const int Output4x4SlotId = 4;
+        public const int Output3x3SlotId = 5;
+        public const int Output2x2SlotId = 6;
+
+        public MatrixConstructionNode()
+        {
+            name = "Matrix Construction";
+            UpdateNodeAfterDeserialization();
+        }
+
+        [SerializeField]
+        MatrixAxis m_Axis;
+
+        [EnumControl("")]
+        MatrixAxis axis
+        {
+            get { return m_Axis; }
+            set
+            {
+                if (m_Axis.Equals(value))
+                    return;
+                m_Axis = value;
+                Dirty(ModificationScope.Graph);
+            }
+        }
+
+        string GetFunctionName()
+        {
+            return $"Unity_MatrixConstruction_{axis}_$precision";
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new Vector4MaterialSlot(InputSlotM0Id, kInputSlotM0Name, kInputSlotM0Name, SlotType.Input, Vector4.zero));
+            AddSlot(new Vector4MaterialSlot(InputSlotM1Id, kInputSlotM1Name, kInputSlotM1Name, SlotType.Input, Vector4.zero));
+            AddSlot(new Vector4MaterialSlot(InputSlotM2Id, kInputSlotM2Name, kInputSlotM2Name, SlotType.Input, Vector4.zero));
+            AddSlot(new Vector4MaterialSlot(InputSlotM3Id, kInputSlotM3Name, kInputSlotM3Name, SlotType.Input, Vector4.zero));
+            AddSlot(new Matrix4MaterialSlot(Output4x4SlotId, kOutput4x4SlotName, kOutput4x4SlotName, SlotType.Output));
+            AddSlot(new Matrix3MaterialSlot(Output3x3SlotId, kOutput3x3SlotName, kOutput3x3SlotName, SlotType.Output));
+            AddSlot(new Matrix2MaterialSlot(Output2x2SlotId, kOutput2x2SlotName, kOutput2x2SlotName, SlotType.Output));
+            RemoveSlotsNameNotMatching(new int[] { InputSlotM0Id, InputSlotM1Id, InputSlotM2Id, InputSlotM3Id, Output4x4SlotId, Output3x3SlotId, Output2x2SlotId });
+        }
+
+        public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
+        {
+            var inputM0Value = GetSlotValue(InputSlotM0Id, generationMode);
+            var inputM1Value = GetSlotValue(InputSlotM1Id, generationMode);
+            var inputM2Value = GetSlotValue(InputSlotM2Id, generationMode);
+            var inputM3Value = GetSlotValue(InputSlotM3Id, generationMode);
+
+            sb.AppendLine("{0} {1};", FindOutputSlot<MaterialSlot>(Output4x4SlotId).concreteValueType.ToShaderString(), GetVariableNameForSlot(Output4x4SlotId));
+            sb.AppendLine("{0} {1};", FindOutputSlot<MaterialSlot>(Output3x3SlotId).concreteValueType.ToShaderString(), GetVariableNameForSlot(Output3x3SlotId));
+            sb.AppendLine("{0} {1};", FindOutputSlot<MaterialSlot>(Output2x2SlotId).concreteValueType.ToShaderString(), GetVariableNameForSlot(Output2x2SlotId));
+            sb.AppendLine("{0}({1}, {2}, {3}, {4}, {5}, {6}, {7});",
+                GetFunctionName(),
+                inputM0Value,
+                inputM1Value,
+                inputM2Value,
+                inputM3Value,
+                GetVariableNameForSlot(Output4x4SlotId),
+                GetVariableNameForSlot(Output3x3SlotId),
+                GetVariableNameForSlot(Output2x2SlotId));
+        }
+
+        public void GenerateNodeFunction(FunctionRegistry registry, GenerationMode generationMode)
+        {
+            registry.ProvideFunction(GetFunctionName(), s =>
+            {
+                s.AppendLine("void {0} ({1} M0, {1} M1, {1} M2, {1} M3, out {2} Out4x4, out {3} Out3x3, out {4} Out2x2)",
+                    GetFunctionName(),
+                    FindInputSlot<MaterialSlot>(InputSlotM0Id).concreteValueType.ToShaderString(),
+                    FindOutputSlot<MaterialSlot>(Output4x4SlotId).concreteValueType.ToShaderString(),
+                    FindOutputSlot<MaterialSlot>(Output3x3SlotId).concreteValueType.ToShaderString(),
+                    FindOutputSlot<MaterialSlot>(Output2x2SlotId).concreteValueType.ToShaderString());
+                using (s.BlockScope())
+                {
+                    switch (m_Axis)
+                    {
+                        case MatrixAxis.Column:
+                            s.AppendLine("Out4x4 = $precision4x4(M0.x, M1.x, M2.x, M3.x, M0.y, M1.y, M2.y, M3.y, M0.z, M1.z, M2.z, M3.z, M0.w, M1.w, M2.w, M3.w);");
+                            s.AppendLine("Out3x3 = $precision3x3(M0.x, M1.x, M2.x, M0.y, M1.y, M2.y, M0.z, M1.z, M2.z);");
+                            s.AppendLine("Out2x2 = $precision2x2(M0.x, M1.x, M0.y, M1.y);");
+                            break;
+                        default:
+                            s.AppendLine("Out4x4 = $precision4x4(M0.x, M0.y, M0.z, M0.w, M1.x, M1.y, M1.z, M1.w, M2.x, M2.y, M2.z, M2.w, M3.x, M3.y, M3.z, M3.w);");
+                            s.AppendLine("Out3x3 = $precision3x3(M0.x, M0.y, M0.z, M1.x, M1.y, M1.z, M2.x, M2.y, M2.z);");
+                            s.AppendLine("Out2x2 = $precision2x2(M0.x, M0.y, M1.x, M1.y);");
+                            break;
+                    }
+                }
+            });
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Matrix/MatrixConstructionNode.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7f3857db61fc34eaabd871901ae5a2b6
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Matrix/MatrixDeterminantNode.cs

@@ -0,0 +1,33 @@
+using System.Reflection;
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Matrix", "Matrix Determinant")]
+    class MatrixDeterminantNode : CodeFunctionNode
+    {
+        public MatrixDeterminantNode()
+        {
+            name = "Matrix Determinant";
+        }
+
+        public override bool hasPreview => false;
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_MatrixDeterminant", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_MatrixDeterminant(
+            [Slot(0, Binding.None)] DynamicDimensionMatrix In,
+            [Slot(1, Binding.None)] out Vector1 Out)
+        {
+            return
+@"
+{
+    Out = determinant(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Matrix/MatrixDeterminantNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 41d69945fb0fa45ec8e14292dfb9074d
+timeCreated: 1495542985
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Matrix/MatrixSplitNode.cs

@@ -0,0 +1,249 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEditor.Graphing.Util;
+using UnityEngine.Pool;
+
+namespace UnityEditor.ShaderGraph
+{
+    enum MatrixAxis
+    {
+        Row,
+        Column
+    }
+
+    [Title("Math", "Matrix", "Matrix Split")]
+    class MatrixSplitNode : AbstractMaterialNode, IGeneratesBodyCode
+    {
+        const string kInputSlotName = "In";
+        const string kOutputSlotM0Name = "M0";
+        const string kOutputSlotM1Name = "M1";
+        const string kOutputSlotM2Name = "M2";
+        const string kOutputSlotM3Name = "M3";
+
+        public const int InputSlotId = 0;
+        public const int OutputSlotRId = 1;
+        public const int OutputSlotGId = 2;
+        public const int OutputSlotBId = 3;
+        public const int OutputSlotAId = 4;
+
+        public MatrixSplitNode()
+        {
+            name = "Matrix Split";
+            UpdateNodeAfterDeserialization();
+        }
+
+        [SerializeField]
+        MatrixAxis m_Axis;
+
+        [EnumControl("")]
+        MatrixAxis axis
+        {
+            get { return m_Axis; }
+            set
+            {
+                if (m_Axis.Equals(value))
+                    return;
+                m_Axis = value;
+                Dirty(ModificationScope.Graph);
+            }
+        }
+
+        static string[] s_ComponentList = new string[4] { "r", "g", "b", "a" };
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new DynamicMatrixMaterialSlot(InputSlotId, kInputSlotName, kInputSlotName, SlotType.Input));
+            AddSlot(new DynamicVectorMaterialSlot(OutputSlotRId, kOutputSlotM0Name, kOutputSlotM0Name, SlotType.Output, Vector4.zero));
+            AddSlot(new DynamicVectorMaterialSlot(OutputSlotGId, kOutputSlotM1Name, kOutputSlotM1Name, SlotType.Output, Vector4.zero));
+            AddSlot(new DynamicVectorMaterialSlot(OutputSlotBId, kOutputSlotM2Name, kOutputSlotM2Name, SlotType.Output, Vector4.zero));
+            AddSlot(new DynamicVectorMaterialSlot(OutputSlotAId, kOutputSlotM3Name, kOutputSlotM3Name, SlotType.Output, Vector4.zero));
+            RemoveSlotsNameNotMatching(new int[] { InputSlotId, OutputSlotRId, OutputSlotGId, OutputSlotBId, OutputSlotAId });
+        }
+
+        static int[] s_OutputSlots = { OutputSlotRId, OutputSlotGId, OutputSlotBId, OutputSlotAId };
+
+        public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
+        {
+            var inputValue = GetSlotValue(InputSlotId, generationMode);
+
+            var inputSlot = FindInputSlot<MaterialSlot>(InputSlotId);
+            var numInputRows = 0;
+            bool useIndentity = false;
+
+            if (inputSlot != null)
+            {
+                numInputRows = SlotValueHelper.GetMatrixDimension(inputSlot.concreteValueType);
+                if (numInputRows > 4)
+                    numInputRows = 0;
+
+                if (!owner.GetEdges(inputSlot.slotReference).Any())
+                {
+                    numInputRows = 0;
+                    useIndentity = true;
+                }
+            }
+
+            int concreteRowCount = useIndentity ? 2 : numInputRows;
+
+            for (var r = 0; r < 4; r++)
+            {
+                string outputValue;
+                if (r >= numInputRows)
+                {
+                    outputValue = string.Format("$precision{0}(", concreteRowCount);
+                    for (int c = 0; c < concreteRowCount; c++)
+                    {
+                        if (c != 0)
+                            outputValue += ", ";
+                        outputValue += Matrix4x4.identity.GetRow(r)[c];
+                    }
+                    outputValue += ")";
+                }
+                else
+                {
+                    switch (m_Axis)
+                    {
+                        case MatrixAxis.Column:
+                            outputValue = string.Format("$precision{0}(", numInputRows);
+                            for (int c = 0; c < numInputRows; c++)
+                            {
+                                if (c != 0)
+                                    outputValue += ", ";
+                                outputValue += string.Format("{0}[{1}].{2}", inputValue, c, s_ComponentList[r]);
+                            }
+                            outputValue += ")";
+                            break;
+                        default:
+                            outputValue = string.Format("{0}[{1}]", inputValue, r);
+                            break;
+                    }
+                }
+                sb.AppendLine(string.Format("$precision{0} {1} = {2};", concreteRowCount, GetVariableNameForSlot(s_OutputSlots[r]), outputValue));
+            }
+        }
+
+        public override void EvaluateDynamicMaterialSlots(List<MaterialSlot> inputSlots, List<MaterialSlot> outputSlots)
+        {
+            var dynamicInputSlotsToCompare = DictionaryPool<DynamicVectorMaterialSlot, ConcreteSlotValueType>.Get();
+            var skippedDynamicSlots = ListPool<DynamicVectorMaterialSlot>.Get();
+
+            var dynamicMatrixInputSlotsToCompare = DictionaryPool<DynamicMatrixMaterialSlot, ConcreteSlotValueType>.Get();
+            var skippedDynamicMatrixSlots = ListPool<DynamicMatrixMaterialSlot>.Get();
+
+            // iterate the input slots
+            {
+                foreach (var inputSlot in inputSlots)
+                {
+                    inputSlot.hasError = false;
+
+                    // if there is a connection
+                    var edges = owner.GetEdges(inputSlot.slotReference).ToList();
+                    if (!edges.Any())
+                    {
+                        if (inputSlot is DynamicVectorMaterialSlot)
+                            skippedDynamicSlots.Add(inputSlot as DynamicVectorMaterialSlot);
+                        if (inputSlot is DynamicMatrixMaterialSlot)
+                            skippedDynamicMatrixSlots.Add(inputSlot as DynamicMatrixMaterialSlot);
+                        continue;
+                    }
+
+                    // get the output details
+                    var outputSlotRef = edges[0].outputSlot;
+                    var outputNode = outputSlotRef.node;
+                    if (outputNode == null)
+                        continue;
+
+                    var outputSlot = outputNode.FindOutputSlot<MaterialSlot>(outputSlotRef.slotId);
+                    if (outputSlot == null)
+                        continue;
+
+                    if (outputSlot.hasError)
+                    {
+                        inputSlot.hasError = true;
+                        continue;
+                    }
+
+                    var outputConcreteType = outputSlot.concreteValueType;
+                    // dynamic input... depends on output from other node.
+                    // we need to compare ALL dynamic inputs to make sure they
+                    // are compatable.
+                    if (inputSlot is DynamicVectorMaterialSlot)
+                    {
+                        dynamicInputSlotsToCompare.Add((DynamicVectorMaterialSlot)inputSlot, outputConcreteType);
+                        continue;
+                    }
+                    else if (inputSlot is DynamicMatrixMaterialSlot)
+                    {
+                        dynamicMatrixInputSlotsToCompare.Add((DynamicMatrixMaterialSlot)inputSlot, outputConcreteType);
+                        continue;
+                    }
+                }
+
+                // and now dynamic matrices
+                var dynamicMatrixType = ConvertDynamicMatrixInputTypeToConcrete(dynamicMatrixInputSlotsToCompare.Values);
+                foreach (var dynamicKvP in dynamicMatrixInputSlotsToCompare)
+                    dynamicKvP.Key.SetConcreteType(dynamicMatrixType);
+                foreach (var skippedSlot in skippedDynamicMatrixSlots)
+                    skippedSlot.SetConcreteType(dynamicMatrixType);
+
+                // we can now figure out the dynamic slotType
+                // from here set all the
+                var dynamicType = SlotValueHelper.ConvertMatrixToVectorType(dynamicMatrixType);
+                foreach (var dynamicKvP in dynamicInputSlotsToCompare)
+                    dynamicKvP.Key.SetConcreteType(dynamicType);
+                foreach (var skippedSlot in skippedDynamicSlots)
+                    skippedSlot.SetConcreteType(dynamicType);
+
+                bool inputError = inputSlots.Any(x => x.hasError);
+                if (inputError)
+                {
+                    owner.AddConcretizationError(objectId, string.Format("Node {0} had input error", objectId));
+                    hasError = true;
+                }
+                // configure the output slots now
+                // their slotType will either be the default output slotType
+                // or the above dynanic slotType for dynamic nodes
+                // or error if there is an input error
+                foreach (var outputSlot in outputSlots)
+                {
+                    outputSlot.hasError = false;
+
+                    if (inputError)
+                    {
+                        outputSlot.hasError = true;
+                        continue;
+                    }
+
+                    if (outputSlot is DynamicVectorMaterialSlot)
+                    {
+                        (outputSlot as DynamicVectorMaterialSlot).SetConcreteType(dynamicType);
+                        continue;
+                    }
+                    else if (outputSlot is DynamicMatrixMaterialSlot)
+                    {
+                        (outputSlot as DynamicMatrixMaterialSlot).SetConcreteType(dynamicMatrixType);
+                        continue;
+                    }
+                }
+
+                if (outputSlots.Any(x => x.hasError))
+                {
+                    owner.AddConcretizationError(objectId, string.Format("Node {0} had output error", objectId));
+                    hasError = true;
+                }
+            }
+
+            CalculateNodeHasError();
+
+            ListPool<DynamicVectorMaterialSlot>.Release(skippedDynamicSlots);
+            DictionaryPool<DynamicVectorMaterialSlot, ConcreteSlotValueType>.Release(dynamicInputSlotsToCompare);
+
+            ListPool<DynamicMatrixMaterialSlot>.Release(skippedDynamicMatrixSlots);
+            DictionaryPool<DynamicMatrixMaterialSlot, ConcreteSlotValueType>.Release(dynamicMatrixInputSlotsToCompare);
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Matrix/MatrixSplitNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 03599e40507c24caba0dd9b596f3b5dc
+timeCreated: 1490896965
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Matrix/MatrixTransposeNode.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Matrix", "Matrix Transpose")]
+    class MatrixTransposeNode : CodeFunctionNode
+    {
+        public MatrixTransposeNode()
+        {
+            name = "Matrix Transpose";
+        }
+
+        public override bool hasPreview
+        {
+            get { return false; }
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_MatrixTranspose", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_MatrixTranspose(
+            [Slot(0, Binding.None)] DynamicDimensionMatrix In,
+            [Slot(1, Binding.None)] out DynamicDimensionMatrix Out)
+        {
+            return
+@"
+{
+    Out = transpose(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Matrix/MatrixTransposeNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 19da2635a60154a6793334e535a0a856
+timeCreated: 1495542985
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 2018cd81f24ba46748d8b85c8f289f4f
+folderAsset: yes
+timeCreated: 1495527047
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range/ClampNode.cs

@@ -0,0 +1,32 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Range", "Clamp")]
+    class ClampNode : CodeFunctionNode
+    {
+        public ClampNode()
+        {
+            name = "Clamp";
+            synonyms = new string[] { "limit" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Clamp", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Clamp(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] DynamicDimensionVector Min,
+            [Slot(2, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector Max,
+            [Slot(3, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = clamp(In, Min, Max);
+}";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range/ClampNode.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b58e88ce87f05b241b7dc5d9a31bac69
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range/FractionNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Range", "Fraction")]
+    class FractionNode : CodeFunctionNode
+    {
+        public FractionNode()
+        {
+            name = "Fraction";
+            synonyms = new string[] { "remainder" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Fraction", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Fraction(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = frac(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range/FractionNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 4229c656c10cc1c43aa631f8f6357764
+timeCreated: 1490780593
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range/MaximumNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Range", "Maximum")]
+    class MaximumNode : CodeFunctionNode
+    {
+        public MaximumNode()
+        {
+            name = "Maximum";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Maximum", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Maximum(
+            [Slot(0, Binding.None)] DynamicDimensionVector A,
+            [Slot(1, Binding.None)] DynamicDimensionVector B,
+            [Slot(2, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = max(A, B);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range/MaximumNode.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1de46e012f3608843978529b36704c2b
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range/MinimumNode.cs

@@ -0,0 +1,30 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Range", "Minimum")]
+    class MinimumNode : CodeFunctionNode
+    {
+        public MinimumNode()
+        {
+            name = "Minimum";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Minimum", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Minimum(
+            [Slot(0, Binding.None, 0, 0, 0, 0)] DynamicDimensionVector A,
+            [Slot(1, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector B,
+            [Slot(2, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = min(A, B);
+};";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range/MinimumNode.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 79ffed9a70f191f4c966a6eb3ae10d07
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range/OneMinusNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Range", "One Minus")]
+    class OneMinusNode : CodeFunctionNode
+    {
+        public OneMinusNode()
+        {
+            name = "One Minus";
+            synonyms = new string[] { "complement", "invert", "opposite" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_OneMinus", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_OneMinus(
+            [Slot(0, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = 1 - In;
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range/OneMinusNode.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ea3f39b56fc9544ff80cbe84aa0753d0
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range/RandomRangeNode.cs

@@ -0,0 +1,33 @@
+using UnityEngine;
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Range", "Random Range")]
+    class RandomRangeNode : CodeFunctionNode
+    {
+        public RandomRangeNode()
+        {
+            name = "Random Range";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_RandomRange", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_RandomRange(
+            [Slot(0, Binding.None)] Vector2 Seed,
+            [Slot(1, Binding.None)] Vector1 Min,
+            [Slot(2, Binding.None, 1, 1, 1, 1)] Vector1 Max,
+            [Slot(3, Binding.None)] out Vector1 Out)
+        {
+            return
+@"
+{
+     $precision randomno =  frac(sin(dot(Seed, $precision2(12.9898, 78.233)))*43758.5453);
+     Out = lerp(Min, Max, randomno);
+}";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range/RandomRangeNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 5e7048f6323341547955eab30f96151f
+timeCreated: 1495703851
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range/RemapNode.cs

@@ -0,0 +1,33 @@
+using System.Reflection;
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Range", "Remap")]
+    class RemapNode : CodeFunctionNode
+    {
+        public RemapNode()
+        {
+            name = "Remap";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Remap", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Remap(
+            [Slot(0, Binding.None, -1, -1, -1, -1)] DynamicDimensionVector In,
+            [Slot(1, Binding.None, -1, 1, 0, 0)] Vector2 InMinMax,
+            [Slot(2, Binding.None, 0, 1, 0, 0)] Vector2 OutMinMax,
+            [Slot(3, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = OutMinMax.x + (In - InMinMax.x) * (OutMinMax.y - OutMinMax.x) / (InMinMax.y - InMinMax.x);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range/RemapNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 1d2a789d52c4340c98278ca90d8563fe
+timeCreated: 1446473341
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range/SaturateNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Range", "Saturate")]
+    class SaturateNode : CodeFunctionNode
+    {
+        public SaturateNode()
+        {
+            name = "Saturate";
+            synonyms = new string[] { "clamp" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Saturate", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Saturate(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = saturate(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Range/SaturateNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: fb36f8243cc0c1b4b862405cc67fa2d1
+timeCreated: 1495454549
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Round.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 4da29d4d0744f43f8aaa921918f1f879
+folderAsset: yes
+timeCreated: 1495530810
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Round/CeilingNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Round", "Ceiling")]
+    class CeilingNode : CodeFunctionNode
+    {
+        public CeilingNode()
+        {
+            name = "Ceiling";
+            synonyms = new string[] { "up" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Ceiling", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Ceiling(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = ceil(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Round/CeilingNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ab2601bf38a580a46945e707fecb7943
+timeCreated: 1490744931
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Round/FloorNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Round", "Floor")]
+    class FloorNode : CodeFunctionNode
+    {
+        public FloorNode()
+        {
+            name = "Floor";
+            synonyms = new string[] { "down" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Floor", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Floor(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = floor(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Round/FloorNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 8d1b4bf99b86c474f8a0bcb2015cf3da
+timeCreated: 1490745697
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Round/RoundNode.cs

@@ -0,0 +1,30 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Round", "Round")]
+    class RoundNode : CodeFunctionNode
+    {
+        public RoundNode()
+        {
+            name = "Round";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Round", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Round(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = round(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Round/RoundNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 03c297b39ff293f4ebc923eb7e60a565
+timeCreated: 1490745167
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Round/SignNode.cs

@@ -0,0 +1,30 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Round", "Sign")]
+    class SignNode : CodeFunctionNode
+    {
+        public SignNode()
+        {
+            name = "Sign";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Sign", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Sign(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = sign(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Round/SignNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 670ee9966f3a13d4e91477e4fb3ff1dd
+timeCreated: 1490741386
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Round/StepNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Round", "Step")]
+    class StepNode : CodeFunctionNode
+    {
+        public StepNode()
+        {
+            name = "Step";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Step", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Step(
+            [Slot(0, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector Edge,
+            [Slot(1, Binding.None, 0, 0, 0, 0)] DynamicDimensionVector In,
+            [Slot(2, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = step(Edge, In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Round/StepNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: af47cc48edd11514ba0c965aae166f2f
+timeCreated: 1490780593
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Round/TruncateNode.cs

@@ -0,0 +1,30 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Round", "Truncate")]
+    class TruncateNode : CodeFunctionNode
+    {
+        public TruncateNode()
+        {
+            name = "Truncate";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Truncate", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Truncate(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = trunc(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Round/TruncateNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: b9b4b0e1cbbca934a8bb06144cf84730
+timeCreated: 1490745905
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Trigonometry.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 28b2b06f6ff88404c8c0d855b9599203
+folderAsset: yes
+timeCreated: 1495529705
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Trigonometry/ArccosineNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Trigonometry", "Arccosine")]
+    class ArccosineNode : CodeFunctionNode
+    {
+        public ArccosineNode()
+        {
+            name = "Arccosine";
+            synonyms = new string[] { "acos" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Arccosine", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Arccosine(
+            [Slot(0, Binding.None, 1, 1, 1, 1)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = acos(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Trigonometry/ArccosineNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 455566eec6487b04e92c32110f05073a
+timeCreated: 1495459453
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Trigonometry/ArcsineNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Trigonometry", "Arcsine")]
+    class ArcsineNode : CodeFunctionNode
+    {
+        public ArcsineNode()
+        {
+            name = "Arcsine";
+            synonyms = new string[] { "asin" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Arcsine", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Arcsine(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = asin(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Trigonometry/ArcsineNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e0bd4c0099ef82240b5e91e77990628e
+timeCreated: 1495459543
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Trigonometry/Arctangent2Node.cs

@@ -0,0 +1,32 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Trigonometry", "Arctangent2")]
+    class Arctangent2Node : CodeFunctionNode
+    {
+        public Arctangent2Node()
+        {
+            name = "Arctangent2";
+            synonyms = new string[] { "atan2" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Arctangent2", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Arctangent2(
+            [Slot(0, Binding.None)] DynamicDimensionVector A,
+            [Slot(1, Binding.None)] DynamicDimensionVector B,
+            [Slot(2, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = atan2(A, B);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Trigonometry/Arctangent2Node.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: fdd3de2442c50d74da35552bdbe0be74
+timeCreated: 1495459701
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Trigonometry/ArctangentNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Trigonometry", "Arctangent")]
+    class ArctangentNode : CodeFunctionNode
+    {
+        public ArctangentNode()
+        {
+            name = "Arctangent";
+            synonyms = new string[] { "atan" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Arctangent", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Arctangent(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = atan(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Trigonometry/ArctangentNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 9db0fbefda58761488455432f3133271
+timeCreated: 1495459625
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Trigonometry/CosineNode.cs

@@ -0,0 +1,30 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Trigonometry", "Cosine")]
+    class CosineNode : CodeFunctionNode
+    {
+        public CosineNode()
+        {
+            name = "Cosine";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Cosine", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Cosine(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = cos(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Trigonometry/CosineNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 27c8eab8410ea16418392d646ec92572
+timeCreated: 1495446924
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Trigonometry/DegreesToRadiansNode.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Math", "Trigonometry", "Degrees To Radians")]
+    class DegreesToRadiansNode : CodeFunctionNode
+    {
+        public DegreesToRadiansNode()
+        {
+            name = "Degrees To Radians";
+            synonyms = new string[] { "degtorad", "radians", "convert" };
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_DegreesToRadians", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_DegreesToRadians(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+@"
+{
+    Out = radians(In);
+}
+";
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Math/Trigonometry/DegreesToRadiansNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 30f44257fb54ebf48908aef7ecc9b285
+timeCreated: 1495459878
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: