Maths Part 2

- Maths/Interpolation
- Maths/Round
- Fix merge conflict for PR

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

 
         public sealed override void UpdateNodeAfterDeserialization()
         {
-            AddSlot(new MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
+            AddSlot(new Vector1MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, 0));
             RemoveSlotsNameNotMatching(new[] { kOutputSlotId });
         }
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Geometry/WorldSpaceTangentNode.cs

 
         public sealed override void UpdateNodeAfterDeserialization()
         {
-            AddSlot(new MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, SlotValueType.Vector3, new Vector4(0, 0, 1, 1)));
+            AddSlot(new MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, SlotValueType.Vector4, new Vector4(0, 0, 1, 1)));
             RemoveSlotsNameNotMatching(new[] { kOutputSlotId });
         }
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Round/FloorNode.cs

         }
 
         static string Unity_Floor(
-            [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 = floor(argument);
+    Out = floor(In);
 }
 ";
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Round/RoundNode.cs

         }
 
         static string Unity_Round(
-            [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 = round(argument);
+    Out = round(In);
 }
 ";
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Round/SignNode.cs

         }
 
         static string Unity_Sign(
-            [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 = sign(argument);
+    Out = sign(In);
 }
 ";
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Round/StepNode.cs

         }
 
         static string Unity_Step(
-            [Slot(0, Binding.None)] DynamicDimensionVector first,
-            [Slot(1, Binding.None)] DynamicDimensionVector second,
-            [Slot(2, Binding.None)] out DynamicDimensionVector result)
+            [Slot(0, Binding.None)] DynamicDimensionVector A,
+            [Slot(1, Binding.None)] DynamicDimensionVector B,
+            [Slot(2, Binding.None)] out DynamicDimensionVector Out)
-    result = step(first, second);
+    Out = step(A, B);
 }
 ";
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Round/TruncateNode.cs

         }
 
         static string Unity_Truncate(
-            [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 = truncate(argument);
+    Out = trunc(In);
 }
 ";
         }

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

         {
             get { return ConvertConcreteSlotValueTypeToString(FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType); }
         }
+
         private string inputDimension
         {
             get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType); }
         {
-            return NeededCoordinateSpace.World;
+            return NeededCoordinateSpace.Local;
-            return NeededCoordinateSpace.World;
+            return NeededCoordinateSpace.Local;
-            return NeededCoordinateSpace.World;
+            return NeededCoordinateSpace.Local;
         }
     }
 }

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/Round/CeilingNode.cs

+using System.Reflection;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("Math/Round/Ceiling")]
+    public class CeilingNode : CodeFunctionNode
+    {
+        public CeilingNode()
+        {
+            name = "Ceiling";
+        }
+
+        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);
+}
+";
+        }
+    }
+}

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/NewNodes/Editor/Keep/TangentToWorldNode.cs

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

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 inputA,
-            [Slot(1, Binding.None)] DynamicDimensionVector inputB,
-            [Slot(2, Binding.None)] DynamicDimensionVector t,
-            [Slot(3, Binding.None)] out DynamicDimensionVector result)
-        {
-            return
-                @"
-{
-    result = lerp(inputA, inputB, 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 inputA,
-            [Slot(1, Binding.None)] DynamicDimensionVector inputB,
-            [Slot(2, Binding.None)] DynamicDimensionVector t,
-            [Slot(3, Binding.None)] out DynamicDimensionVector result)
-        {
-            return
-                @"
-{
-    result = smoothstep(inputA, inputB, t);
-}";
-        }
-    }
-}

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

-using System.Reflection;
-
-namespace UnityEngine.MaterialGraph
-{
-    [Title("Math/Interpolation/InverseLerp")]
-    public class InverseLerpNode : CodeFunctionNode
-    {
-        public InverseLerpNode()
-        {
-            name = "InverseLerp";
-        }
-
-        protected override MethodInfo GetFunctionToConvert()
-        {
-            return GetType().GetMethod("Unity_InverseLerp", BindingFlags.Static | BindingFlags.NonPublic);
-        }
-
-        static string Unity_InverseLerp(
-            [Slot(0, Binding.None)] DynamicDimensionVector inputA,
-            [Slot(1, Binding.None)] DynamicDimensionVector inputB,
-            [Slot(2, Binding.None)] DynamicDimensionVector t,
-            [Slot(3, Binding.None)] out DynamicDimensionVector result)
-        {
-            return
-                @"
-{
-    result = (t - inputA)/(inputB - inputA);
-}";
-        }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Round/CeilNode.cs

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