Maths Part 4

- Maths/Vector (finish)
- Maths/Derivative
- Maths/Trigonometry
- Maths/Matrix (temporarily removed for rewrite)
- Moved CommonMatrix enum to MatrixCommonNode.cs and removed file

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Matrix/MatrixCommonNode.cs

 
 namespace UnityEngine.MaterialGraph
 {
+    public enum CommonMatrixType
+    {
+        ModelView,
+        View,
+        Projection,
+        ViewProjection,
+        TransposeModelView,
+        InverseTransposeModelView,
+        ObjectToWorld,
+        WorldToObject
+    };
+
     [Title("Input/Matrix/CommonMatrix")]
     public class MatrixCommonNode : AbstractMaterialNode
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Trigonometry/ArcCosNode.cs

 namespace UnityEngine.MaterialGraph
 {
     [Title("Math/Trigonometry/ArcCos")]
-    public class ACosNode : CodeFunctionNode
+    public class ArcCosNode : CodeFunctionNode
-        public ACosNode()
+        public ArcCosNode()
         {
             name = "ArcCos";
         }
-            return GetType().GetMethod("Unity_ACos", BindingFlags.Static | BindingFlags.NonPublic);
+            return GetType().GetMethod("Unity_ArcCos", BindingFlags.Static | BindingFlags.NonPublic);
-        static string Unity_ACos(
-            [Slot(0, Binding.None)] DynamicDimensionVector argument,
-            [Slot(1, Binding.None)] out DynamicDimensionVector result)
+        static string Unity_ArcCos(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
-    result = acos(argument);
+    Out = acos(In);
 }
 ";
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Trigonometry/ArcSinNode.cs

 namespace UnityEngine.MaterialGraph
 {
     [Title("Math/Trigonometry/ArcSin")]
-    public class ASinNode : CodeFunctionNode
+    public class ArcSinNode : CodeFunctionNode
-        public ASinNode()
+        public ArcSinNode()
         {
             name = "ArcSin";
         }
-            return GetType().GetMethod("Unity_ASin", BindingFlags.Static | BindingFlags.NonPublic);
+            return GetType().GetMethod("Unity_ArcSin", BindingFlags.Static | BindingFlags.NonPublic);
-        static string Unity_ASin(
-            [Slot(0, Binding.None)] DynamicDimensionVector argument,
-            [Slot(1, Binding.None)] out DynamicDimensionVector result)
+        static string Unity_ArcSin(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
-    result = asin(argument);
+    Out = asin(In);
 }
 ";
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Trigonometry/ArcTanNode.cs

 namespace UnityEngine.MaterialGraph
 {
     [Title("Math/Trigonometry/ArcTan")]
-    public class ATanNode : CodeFunctionNode
+    public class ArcTanNode : CodeFunctionNode
-        public ATanNode()
+        public ArcTanNode()
         {
             name = "ArcTan";
         }
-            return GetType().GetMethod("Unity_ATan", BindingFlags.Static | BindingFlags.NonPublic);
+            return GetType().GetMethod("Unity_ArcTan", BindingFlags.Static | BindingFlags.NonPublic);
-        static string Unity_ATan(
-            [Slot(0, Binding.None)] DynamicDimensionVector argument,
-            [Slot(1, Binding.None)] out DynamicDimensionVector result)
+        static string Unity_ArcTan(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
-    result = atan(argument);
+    Out = atan(In);
 }
 ";
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Trigonometry/CosNode.cs

         }
 
         static string Unity_Cos(
-            [Slot(0, Binding.None)] DynamicDimensionVector argument,
-            [Slot(1, Binding.None)] out DynamicDimensionVector result)
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
-    result = cos(argument);
+    Out = cos(In);
 }
 ";
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Trigonometry/DegreesToRadiansNode.cs

     {
         public DegreesToRadiansNode()
         {
-            name = "DegreesToRadians";
+            name = "Degrees To Radians";
         }
 
         protected override MethodInfo GetFunctionToConvert()
 
         static string Unity_DegreesToRadians(
-            [Slot(0, Binding.None)] DynamicDimensionVector argument,
-            [Slot(1, Binding.None)] out DynamicDimensionVector result)
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
-    result = radians(argument);
+    Out = radians(In);
 }
 ";
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Trigonometry/RadiansToDegreesNode.cs

     {
         public RadiansToDegreesNode()
         {
-            name = "RadiansToDegrees";
+            name = "Radians To Degrees";
         }
 
         protected override MethodInfo GetFunctionToConvert()
 
         static string Unity_RadiansToDegrees(
-            [Slot(0, Binding.None)] DynamicDimensionVector argument,
-            [Slot(1, Binding.None)] out DynamicDimensionVector result)
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
-    result = degrees(argument);
+    Out = degrees(In);
 }
 ";
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Trigonometry/SinNode.cs

         }
 
         static string Unity_Sin(
-            [Slot(0, Binding.None)] DynamicDimensionVector argument,
-            [Slot(1, Binding.None)] out DynamicDimensionVector result)
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
-    result = sin(argument);
+    Out = sin(In);
 }
 ";
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Trigonometry/TanNode.cs

         }
 
         static string Unity_Tan(
-            [Slot(0, Binding.None)] DynamicDimensionVector argument,
-            [Slot(1, Binding.None)] out DynamicDimensionVector result)
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
-    result = tan(argument);
+    Out = tan(In);
 }
 ";
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Vector/FresnelNode.cs

         }
 
         static string Unity_Fresnel(
-            [Slot(0, Binding.None)] Vector3 first,
-            [Slot(1, Binding.None)] Vector3 second,
-            [Slot(2, Binding.None)] out Vector1 result)
+            [Slot(0, Binding.None)] Vector3 Normal,
+            [Slot(1, Binding.None)] Vector3 ViewDir,
+            [Slot(2, Binding.None, 1, 1, 1, 1)] Vector1 Power,
+            [Slot(3, Binding.None)] out Vector1 Out)
-    result = (1.0 - dot (normalize (first), normalize (second)));
+    Out = pow((1.0 - dot (normalize (Normal), normalize (ViewDir))), Power);
 }
 ";
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Vector/ReflectNode.cs

         }
 
         static string Unity_Reflect(
-            [Slot(0, Binding.None)] Vector3 normal,
-            [Slot(1, Binding.None)] Vector3 direction,
-            [Slot(2, Binding.None)] out Vector3 reflection)
+            [Slot(0, Binding.None)] Vector3 In,
+            [Slot(1, Binding.None)] Vector3 Normal,
+            [Slot(2, Binding.None)] out Vector3 Out)
-            reflection = Vector3.one;
+            Out = Vector3.one;
-    {precision}3 vn = normalize(normal);
-    {precision}3 vd = normalize(direction);
-    reflection =  2 * dot(vn, vd) * vn - vd, 1.0;
+    Out = reflect(In, Normal);
 }";
         }
     }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Derivative.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Interpolation/InverseLerpNode.cs

+using System.Reflection;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("Math/Interpolation/Inverse Lerp")]
+    public 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)] DynamicDimensionVector A,
+            [Slot(1, Binding.None)] DynamicDimensionVector B,
+            [Slot(2, Binding.None)] DynamicDimensionVector T,
+            [Slot(3, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+                @"
+{
+    Out = (T - A)/(B - A);
+}";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Interpolation/LerpNode.cs

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Interpolation/SmoothstepNode.cs

+using System.Reflection;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("Math/Interpolation/Smoothstep")]
+    class SmoothstepNode : CodeFunctionNode
+    {
+        public SmoothstepNode()
+        {
+            name = "Smoothstep";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Smoothstep", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Smoothstep(
+            [Slot(0, Binding.None)] DynamicDimensionVector A,
+            [Slot(1, Binding.None)] DynamicDimensionVector B,
+            [Slot(2, Binding.None)] DynamicDimensionVector T,
+            [Slot(3, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+                @"
+{
+    Out = smoothstep(A, B, T);
+}";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Trigonometry/ArcTan2Node.cs

+using System.Reflection;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("Math/Trigonometry/ArcTan2")]
+    public class ArcTan2Node : CodeFunctionNode
+    {
+        public ArcTan2Node()
+        {
+            name = "ArcTan2";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_ArcTan2", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_ArcTan2(
+            [Slot(0, Binding.None)] DynamicDimensionVector A,
+            [Slot(1, Binding.None)] DynamicDimensionVector B,
+            [Slot(2, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+                @"
+{
+    Out = atan2(A, B);
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Trigonometry/HyperbolicSinNode.cs

+using System.Reflection;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("Math/Trigonometry/Hyperbolic Sin")]
+    class HyperbolicSinNode : CodeFunctionNode
+    {
+        public HyperbolicSinNode()
+        {
+            name = "Hyperbolic Sin";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_HyperbolicSin", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_HyperbolicSin(
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+                @"
+{
+    Out = sinh(In);
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Trigonometry/HyperbolicSinNode.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Vector/DistanceNode.cs

+using System.Reflection;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("Math/Vector/Distance")]
+    public class DistanceNode : CodeFunctionNode
+    {
+        public DistanceNode()
+        {
+            name = "Distance";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Distance", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Distance(
+            [Slot(0, Binding.None)] DynamicDimensionVector A,
+            [Slot(1, Binding.None)] DynamicDimensionVector B,
+            [Slot(2, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+                @"
+{
+    Out = distance(A, B);
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Vector/DotProductNode.cs

+using System.Reflection;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("Math/Vector/Dot Product")]
+    public class DotProductNode : CodeFunctionNode
+    {
+        public DotProductNode()
+        {
+            name = "Dot Product";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_DotProduct", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_DotProduct(
+            [Slot(0, Binding.None)] Vector3 A,
+            [Slot(1, Binding.None)] Vector3 B,
+            [Slot(2, Binding.None)] out Vector1 Out)
+        {
+            return
+                @"
+{
+    Out = dot(A, B);
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Vector/ProjectNode.cs

+using System.Reflection;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("Math/Vector/Project")]
+    public class ProjectNode : CodeFunctionNode
+    {
+        public ProjectNode()
+        {
+            name = "Project";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Project", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Project(
+            [Slot(0, Binding.None)] DynamicDimensionVector A,
+            [Slot(1, Binding.None)] DynamicDimensionVector B,
+            [Slot(2, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+                @"
+{
+    Out = B * dot(A, B) / dot(B, B);
+}";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Vector/RejectNode.cs

+using System.Reflection;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("Math/Vector/Reject")]
+    public class RejectNode : CodeFunctionNode
+    {
+        public RejectNode()
+        {
+            name = "Reject";
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod("Unity_Reject", BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_Reject(
+            [Slot(0, Binding.None)] DynamicDimensionVector A,
+            [Slot(1, Binding.None)] DynamicDimensionVector B,
+            [Slot(2, Binding.None)] out DynamicDimensionVector Out)
+        {
+            return
+                @"
+{
+    Out = A - (B * dot(A, B) / dot(B, B));
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Derivative/DDXNode.cs

+using System.Reflection;
+using UnityEditor.MaterialGraph.Drawing.Controls;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    public enum PartialDerivativePrecision
+    {
+        Coarse,
+        Default,
+        Fine
+    };
+
+    [Title("Math/Derivative/DDX")]
+    public class DDXNode : CodeFunctionNode
+    {
+        public DDXNode()
+        {
+            name = "DDX";
+        }
+
+        [SerializeField]
+        private PartialDerivativePrecision m_PartialDerivativePrecision = PartialDerivativePrecision.Default;
+
+        [EnumControl("Precision")]
+        public PartialDerivativePrecision partialDerivativePrecision
+        {
+            get { return m_PartialDerivativePrecision; }
+            set
+            {
+                if (m_PartialDerivativePrecision == value)
+                    return;
+
+                m_PartialDerivativePrecision = value;
+                if (onModified != null)
+                {
+                    onModified(this, ModificationScope.Graph);
+                }
+            }
+        }
+
+        string GetCurrentPrecision()
+        {
+            return System.Enum.GetName(typeof(PartialDerivativePrecision), m_PartialDerivativePrecision);
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod(string.Format("Unity_DDX_{0}", GetCurrentPrecision()),
+                BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_DDX_Default(
+            [Slot(0, Binding.None)] Vector1 In,
+            [Slot(1, Binding.None)] out Vector1 Out)
+        {
+            return
+                @"
+{
+    Out = ddx(In);
+}
+";
+        }
+
+        static string Unity_DDX_Coarse(
+            [Slot(0, Binding.None)] Vector1 In,
+            [Slot(1, Binding.None)] out Vector1 Out)
+        {
+            return
+                @"
+{
+    Out = ddx_coarse(In);
+}
+";
+        }
+
+        static string Unity_DDX_Fine(
+            [Slot(0, Binding.None)] Vector1 In,
+            [Slot(1, Binding.None)] out Vector1 Out)
+        {
+            return
+                @"
+{
+    Out = ddx_fine(In);
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Derivative/DDXYNode.cs

+using System.Reflection;
+using UnityEditor.MaterialGraph.Drawing.Controls;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("Math/Derivative/DDXY")]
+    public class DDXYNode : CodeFunctionNode
+    {
+        public DDXYNode()
+        {
+            name = "DDXY";
+        }
+
+        [SerializeField]
+        private PartialDerivativePrecision m_PartialDerivativePrecision = PartialDerivativePrecision.Default;
+
+        [EnumControl("Precision")]
+        public PartialDerivativePrecision partialDerivativePrecision
+        {
+            get { return m_PartialDerivativePrecision; }
+            set
+            {
+                if (m_PartialDerivativePrecision == value)
+                    return;
+
+                m_PartialDerivativePrecision = value;
+                if (onModified != null)
+                {
+                    onModified(this, ModificationScope.Graph);
+                }
+            }
+        }
+
+        string GetCurrentPrecision()
+        {
+            return System.Enum.GetName(typeof(PartialDerivativePrecision), m_PartialDerivativePrecision);
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod(string.Format("Unity_DDXY_{0}", GetCurrentPrecision()),
+                BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_DDXY_Default(
+            [Slot(0, Binding.None)] Vector1 In,
+            [Slot(1, Binding.None)] out Vector1 Out)
+        {
+            return
+                @"
+{
+    Out = abs(ddx(In) + ddy(In));
+}
+";
+        }
+
+        static string Unity_DDXY_Coarse(
+            [Slot(0, Binding.None)] Vector1 In,
+            [Slot(1, Binding.None)] out Vector1 Out)
+        {
+            return
+                @"
+{
+    Out = abs(ddx_coarse(In) + ddy_coarse(In));
+}
+";
+        }
+
+        static string Unity_DDXY_Fine(
+            [Slot(0, Binding.None)] Vector1 In,
+            [Slot(1, Binding.None)] out Vector1 Out)
+        {
+            return
+                @"
+{
+    Out = abs(ddx_fine(In) + ddy_fine(In));
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Derivative/DDYNode.cs

+using System.Reflection;
+using UnityEditor.MaterialGraph.Drawing.Controls;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("Math/Derivative/DDY")]
+    public class DDYNode : CodeFunctionNode
+    {
+        public DDYNode()
+        {
+            name = "DDY";
+        }
+
+        [SerializeField]
+        private PartialDerivativePrecision m_PartialDerivativePrecision = PartialDerivativePrecision.Default;
+
+        [EnumControl("Precision")]
+        public PartialDerivativePrecision partialDerivativePrecision
+        {
+            get { return m_PartialDerivativePrecision; }
+            set
+            {
+                if (m_PartialDerivativePrecision == value)
+                    return;
+
+                m_PartialDerivativePrecision = value;
+                if (onModified != null)
+                {
+                    onModified(this, ModificationScope.Graph);
+                }
+            }
+        }
+
+        string GetCurrentPrecision()
+        {
+            return System.Enum.GetName(typeof(PartialDerivativePrecision), m_PartialDerivativePrecision);
+        }
+
+        protected override MethodInfo GetFunctionToConvert()
+        {
+            return GetType().GetMethod(string.Format("Unity_DDY_{0}", GetCurrentPrecision()),
+                BindingFlags.Static | BindingFlags.NonPublic);
+        }
+
+        static string Unity_DDY_Default(
+            [Slot(0, Binding.None)] Vector1 In,
+            [Slot(1, Binding.None)] out Vector1 Out)
+        {
+            return
+                @"
+{
+    Out = ddy(In);
+}
+";
+        }
+
+        static string Unity_DDY_Coarse(
+            [Slot(0, Binding.None)] Vector1 In,
+            [Slot(1, Binding.None)] out Vector1 Out)
+        {
+            return
+                @"
+{
+    Out = ddy_coarse(In);
+}
+";
+        }
+
+        static string Unity_DDY_Fine(
+            [Slot(0, Binding.None)] Vector1 In,
+            [Slot(1, Binding.None)] out Vector1 Out)
+        {
+            return
+                @"
+{
+    Out = ddy_fine(In);
+}
+";
+        }
+    }
+}

MaterialGraphProject/Assets/NewNodes/Editor/CommonMatrixType.cs.meta

-fileFormatVersion: 2
-guid: e466cff33b1ebe64eb2b897b9534a4a4
-timeCreated: 1495703998
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

MaterialGraphProject/Assets/NewNodes/Editor/CommonMatrixType.cs

-namespace UnityEngine.MaterialGraph
-{
-    public enum CommonMatrixType
-    {
-        ModelView,
-        View,
-        Projection,
-        ViewProjection,
-        TransposeModelView,
-        InverseTransposeModelView,
-        ObjectToWorld,
-        WorldToObject
-    };
-}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Interpolation/InverseLinearInterpolationNode.cs

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Interpolation/LinearInterpolationNode.cs

-using System.Reflection;
-
-namespace UnityEngine.MaterialGraph
-{
-    [Title("Math/Interpolation/Linear Interpolation")]
-    public class LinearInterpolationNode : CodeFunctionNode
-    {
-        public LinearInterpolationNode()
-        {
-            name = "Linear Interpolation";
-        }
-
-        protected override MethodInfo GetFunctionToConvert()
-        {
-            return GetType().GetMethod("Unity_LinearInterpolation", BindingFlags.Static | BindingFlags.NonPublic);
-        }
-
-        static string Unity_LinearInterpolation(
-            [Slot(0, Binding.None)] DynamicDimensionVector A,
-            [Slot(1, Binding.None)] DynamicDimensionVector B,
-            [Slot(2, Binding.None)] DynamicDimensionVector T,
-            [Slot(3, Binding.None)] out DynamicDimensionVector Out)
-        {
-            return
-                @"
-{
-    Out = lerp(A, B, T);
-}";
-        }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Interpolation/SmoothHermiteInterpolationNode.cs

-using System.Reflection;
-
-namespace UnityEngine.MaterialGraph
-{
-    [Title("Math/Interpolation/Smooth Hermite Interpolation")]
-    class SmoothHermiteInterpolationNode : CodeFunctionNode
-    {
-        public SmoothHermiteInterpolationNode()
-        {
-            name = "Smooth Hermite Interpolation";
-        }
-
-        protected override MethodInfo GetFunctionToConvert()
-        {
-            return GetType().GetMethod("Unity_SmoothHermiteInterpolation", BindingFlags.Static | BindingFlags.NonPublic);
-        }
-
-        static string Unity_SmoothHermiteInterpolation(
-            [Slot(0, Binding.None)] DynamicDimensionVector A,
-            [Slot(1, Binding.None)] DynamicDimensionVector B,
-            [Slot(2, Binding.None)] DynamicDimensionVector T,
-            [Slot(3, Binding.None)] out DynamicDimensionVector Out)
-        {
-            return
-                @"
-{
-    Out = smoothstep(A, B, T);
-}";
-        }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Trigonometry/SinCosNode.cs.meta

-fileFormatVersion: 2
-guid: 61e8adbfbb5cd244fa9bb6dcc900b2bc
-timeCreated: 1495447065
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Trigonometry/ATan2Node.cs

-using System.Reflection;
-
-namespace UnityEngine.MaterialGraph
-{
-    [Title("Math/Trigonometry/ArcTan2")]
-    public class ATan2Node : CodeFunctionNode
-    {
-        public ATan2Node()
-        {
-            name = "ArcTan2";
-        }
-
-        protected override MethodInfo GetFunctionToConvert()
-        {
-            return GetType().GetMethod("Unity_ATan2", BindingFlags.Static | BindingFlags.NonPublic);
-        }
-
-        static string Unity_ATan2(
-            [Slot(0, Binding.None)] DynamicDimensionVector first,
-            [Slot(1, Binding.None)] DynamicDimensionVector second,
-            [Slot(2, Binding.None)] out DynamicDimensionVector result)
-        {
-            return
-                @"
-{
-    result = atan2(first, second);
-}
-";
-        }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Trigonometry/SinCosNode.cs

-using System.Reflection;
-
-namespace UnityEngine.MaterialGraph
-{
-    [Title("Math/Trigonometry/SinCos")]
-    public class SinCosNode : CodeFunctionNode
-    {
-        public SinCosNode()
-        {
-            name = "SinCos";
-        }
-
-        protected override MethodInfo GetFunctionToConvert()
-        {
-            return GetType().GetMethod("Unity_SinCos", BindingFlags.Static | BindingFlags.NonPublic);
-        }
-
-        static string Unity_SinCos(
-            [Slot(0, Binding.None)] Vector1 argument,
-            [Slot(1, Binding.None)] out Vector1 sin,
-            [Slot(2, Binding.None)] out Vector1 cos)
-        {
-            return
-                @"
-{
-    sincos(argument, sin, cos);
-}
-";
-        }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Vector/DotNode.cs

-using System.Reflection;
-
-namespace UnityEngine.MaterialGraph
-{
-    [Title("Math/Vector/Dot Product")]
-    public class DotNode : CodeFunctionNode
-    {
-        public DotNode()
-        {
-            name = "DotProduct";
-        }
-
-        protected override MethodInfo GetFunctionToConvert()
-        {
-            return GetType().GetMethod("Unity_DotProduct", BindingFlags.Static | BindingFlags.NonPublic);
-        }
-
-        static string Unity_DotProduct(
-            [Slot(0, Binding.None)] Vector3 first,
-            [Slot(1, Binding.None)] Vector3 second,
-            [Slot(2, Binding.None)] out Vector1 result)
-        {
-            return
-                @"
-{
-    result = dot(first, second);
-}
-";
-        }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Vector/DDX.cs

-using System.Reflection;
-
-namespace UnityEngine.MaterialGraph
-{
-    [Title("Math/Vector/DDX")]
-    public class DDXNode : CodeFunctionNode
-    {
-        public DDXNode()
-        {
-            name = "DDX";
-        }
-
-        protected override MethodInfo GetFunctionToConvert()
-        {
-            return GetType().GetMethod("Unity_DDX", BindingFlags.Static | BindingFlags.NonPublic);
-        }
-
-        static string Unity_DDX(
-            [Slot(0, Binding.None)] Vector1 argument,
-            [Slot(1, Binding.None)] out Vector1 result)
-        {
-            return
-                @"
-{
-    result = ddx(argument);
-}
-";
-        }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Vector/DDXY.cs

-using System.Reflection;
-
-namespace UnityEngine.MaterialGraph
-{
-    [Title("Math/Vector/DDXY")]
-    public class DDXYNode : CodeFunctionNode
-    {
-        public DDXYNode()
-        {
-            name = "DDXY";
-        }
-
-        protected override MethodInfo GetFunctionToConvert()
-        {
-            return GetType().GetMethod("Unity_DDXY", BindingFlags.Static | BindingFlags.NonPublic);
-        }
-
-        static string Unity_DDXY(
-            [Slot(0, Binding.None)] Vector1 argument,
-            [Slot(1, Binding.None)] out Vector1 result)
-        {
-            return
-                @"
-{
-    result = abs(ddx(argument) + ddy(argument));
-}
-";
-        }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Vector/DDY.cs

-using System.Reflection;
-
-namespace UnityEngine.MaterialGraph
-{
-    [Title("Math/Vector/DDY")]
-    public class DDYNode : CodeFunctionNode
-    {
-        public DDYNode()
-        {
-            name = "DDY";
-        }
-
-        protected override MethodInfo GetFunctionToConvert()
-        {
-            return GetType().GetMethod("Unity_DDY", BindingFlags.Static | BindingFlags.NonPublic);
-        }
-
-        static string Unity_DDY(
-            [Slot(0, Binding.None)] Vector1 argument,
-            [Slot(1, Binding.None)] out Vector1 result)
-        {
-            return
-                @"
-{
-    result = ddy(argument);
-}
-";
-        }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Vector/Distance.cs

-using System.Reflection;
-
-namespace UnityEngine.MaterialGraph
-{
-    [Title("Math/Vector/Distance")]
-    public class DistanceNode : CodeFunctionNode
-    {
-        public DistanceNode()
-        {
-            name = "Distance";
-        }
-
-        protected override MethodInfo GetFunctionToConvert()
-        {
-            return GetType().GetMethod("Unity_Distance", BindingFlags.Static | BindingFlags.NonPublic);
-        }
-
-        static string Unity_Distance(
-            [Slot(0, Binding.None)] DynamicDimensionVector first,
-            [Slot(1, Binding.None)] DynamicDimensionVector second,
-            [Slot(2, Binding.None)] out DynamicDimensionVector result)
-        {
-            return
-                @"
-{
-    result = distance(first, second);
-}
-";
-        }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Vector/PartialDerivativeNode.cs

-using System.Reflection;
-using UnityEditor.MaterialGraph.Drawing.Controls;
-using UnityEngine.Graphing;
-
-namespace UnityEngine.MaterialGraph
-{
-    [Title("Math/Vector/Partial Derivative")]
-    public class PartialDerivativeNode : CodeFunctionNode
-    {
-        public enum Precision
-        {
-            Coarse,
-            Default,
-            Fine
-        };
-
-        public enum Coordinate
-        {
-            X,
-            Y
-        };
-
-        public PartialDerivativeNode()
-        {
-            name = "Partial Derivative";
-        }
-
-        [SerializeField]
-        private Precision m_Precision = Precision.Default;
-
-        [EnumControl("Precision")]
-        public Precision _precision
-        {
-            get { return m_Precision; }
-            set
-            {
-                if (m_Precision == value)
-                    return;
-
-                m_Precision = value;
-                if (onModified != null)
-                {
-                    onModified(this, ModificationScope.Graph);
-                }
-            }
-        }
-
-        string GetCurrentPrecision()
-        {
-            return System.Enum.GetName(typeof(Precision), m_Precision);
-        }
-
-        [SerializeField]
-        private Coordinate m_Coordinate = Coordinate.X;
-
-        [EnumControl("Respect Coordinate")]
-        public Coordinate coordinate
-        {
-            get { return m_Coordinate; }
-            set
-            {
-                if (m_Coordinate == value)
-                    return;
-
-                m_Coordinate = value;
-                if (onModified != null)
-                {
-                    onModified(this, ModificationScope.Graph);
-                }
-            }
-        }
-
-        string GetCurrentCoordinate()
-        {
-            return System.Enum.GetName(typeof(Coordinate), m_Coordinate);
-        }
-
-        protected override MethodInfo GetFunctionToConvert()
-        {
-            return GetType().GetMethod(string.Format("Unity_DD{0}_{1}", GetCurrentCoordinate(), GetCurrentPrecision()),
-                BindingFlags.Static | BindingFlags.NonPublic);
-        }
-
-        static string Unity_DDX_Default(
-            [Slot(0, Binding.None)] Vector1 In,
-            [Slot(1, Binding.None)] out Vector1 Out)
-        {
-            return
-                @"
-{
-    Out = ddx(In);
-}
-";
-        }
-
-        static string Unity_DDX_Coarse(
-            [Slot(0, Binding.None)] Vector1 In,
-            [Slot(1, Binding.None)] out Vector1 Out)
-        {
-            return
-                @"
-{
-    Out = ddx_coarse(In);
-}
-";
-        }
-
-        static string Unity_DDX_Fine(
-            [Slot(0, Binding.None)] Vector1 In,
-            [Slot(1, Binding.None)] out Vector1 Out)
-        {
-            return
-                @"
-{
-    Out = ddx_fine(In);
-}
-";
-        }
-
-        static string Unity_DDY_Default(
-            [Slot(0, Binding.None)] Vector1 In,
-            [Slot(1, Binding.None)] out Vector1 Out)
-        {
-            return
-                @"
-{
-    Out = ddy(In);
-}
-";
-        }
-
-        static string Unity_DDY_Coarse(
-            [Slot(0, Binding.None)] Vector1 In,
-            [Slot(1, Binding.None)] out Vector1 Out)
-        {
-            return
-                @"
-{
-    Out = ddy_coarse(In);
-}
-";
-        }
-
-        static string Unity_DDY_Fine(
-            [Slot(0, Binding.None)] Vector1 In,
-            [Slot(1, Binding.None)] out Vector1 Out)
-        {
-            return
-                @"
-{
-    Out = ddy_fine(In);
-}
-";
-        }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Vector/PartialDerivativeNode.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Vector/TangentToWorldNode.cs

-using System.Reflection;
-
-namespace UnityEngine.MaterialGraph
-{
-    [Title("Math/Vector/Tangent To World")]
-    public class TangentToWorldNode : CodeFunctionNode
-    {
-        public TangentToWorldNode()
-        {
-            name = "Tangent To World";
-        }
-
-        protected override MethodInfo GetFunctionToConvert()
-        {
-            return GetType().GetMethod("Unity_TangentToWorld", BindingFlags.Static | BindingFlags.NonPublic);
-        }
-
-        static string Unity_TangentToWorld(
-            [Slot(0, Binding.None)] Vector3 In,
-            [Slot(1, Binding.None)] out Vector3 Out,
-            [Slot(2, Binding.WorldSpaceTangent)] Vector3 Tangent,
-            [Slot(3, Binding.WorldSpaceBitangent)] Vector3 Bitangent,
-            [Slot(4, Binding.WorldSpaceNormal)] Vector3 Normal)
-        {
-            Out = Vector3.zero;
-            return
-                @"
-{
-    {precision}3x3 tangentToWorld = transpose({precision}3x3(Tangent, Bitangent, Normal));
-    Out = saturate(mul(tangentToWorld, normalize(In)));
-}
-";
-        }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Vector/TangentToWorldNode.cs.meta

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

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

-using System.Reflection;
-
-namespace UnityEngine.MaterialGraph
-{
-    [Title("Vector/Projection Node")]
-    public class VectorProjectionNode : CodeFunctionNode
-    {
-        public VectorProjectionNode()
-        {
-            name = "VectorProjection";
-        }
-
-        protected override MethodInfo GetFunctionToConvert()
-        {
-            return GetType().GetMethod("Unity_VectorProjection", BindingFlags.Static | BindingFlags.NonPublic);
-        }
-
-        static string Unity_VectorProjection(
-            [Slot(0, Binding.None)] DynamicDimensionVector first,
-            [Slot(1, Binding.None)] DynamicDimensionVector second,
-            [Slot(2, Binding.None)] out DynamicDimensionVector result)
-        {
-            return
-                @"
-{
-    result = second * dot(first, second) / dot(second, second);
-}";
-        }
-    }
-}

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

-using System.Reflection;
-
-namespace UnityEngine.MaterialGraph
-{
-    [Title("Vector/Rejection Node")]
-    public class VectorRejectionNode : CodeFunctionNode
-    {
-        public VectorRejectionNode()
-        {
-            name = "VectorRejection";
-        }
-
-        protected override MethodInfo GetFunctionToConvert()
-        {
-            return GetType().GetMethod("Unity_VectorRejection", BindingFlags.Static | BindingFlags.NonPublic);
-        }
-
-        static string Unity_VectorRejection(
-            [Slot(0, Binding.None)] DynamicDimensionVector first,
-            [Slot(1, Binding.None)] DynamicDimensionVector second,
-            [Slot(2, Binding.None)] out DynamicDimensionVector result)
-        {
-            return
-                @"
-{
-    result = first - (second * dot(first, second) / dot(second, second));
-}
-";
-        }
-    }
-}