ja

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Input/Basic/BooleanNode.cs

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

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Input/Basic/BooleanNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: a6bd4d4655c0b9046a14e6ab0caebdc3
+timeCreated: 1445864587
+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/Input/Basic/ColorNode.cs

@@ -0,0 +1,175 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Internal;
+
+namespace UnityEditor.ShaderGraph.Internal
+{
+    public enum ColorMode
+    {
+        Default,
+        HDR
+    }
+}
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Input", "Basic", "Color")]
+    class ColorNode : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
+    {
+        public const int OutputSlotId = 0;
+        private const string kOutputSlotName = "Out";
+
+        public override int latestVersion => 1;
+
+        public ColorNode()
+        {
+            name = "Color";
+            synonyms = new string[] { "rgba" };
+            UpdateNodeAfterDeserialization();
+        }
+
+        [SerializeField]
+        Color m_Color = new Color(UnityEngine.Color.clear, ColorMode.Default);
+
+        [Serializable]
+        public struct Color
+        {
+            public UnityEngine.Color color;
+            public ColorMode mode;
+
+            public Color(UnityEngine.Color color, ColorMode mode)
+            {
+                this.color = color;
+                this.mode = mode;
+            }
+        }
+
+        [ColorControl("")]
+        public Color color
+        {
+            get { return m_Color; }
+            set
+            {
+                if ((value.color == m_Color.color) && (value.mode == m_Color.mode))
+                    return;
+
+                if ((value.mode != m_Color.mode) && (value.mode == ColorMode.Default))
+                {
+                    float r = Mathf.Clamp(value.color.r, 0, 1);
+                    float g = Mathf.Clamp(value.color.g, 0, 1);
+                    float b = Mathf.Clamp(value.color.b, 0, 1);
+                    float a = Mathf.Clamp(value.color.a, 0, 1);
+                    value.color = new UnityEngine.Color(r, g, b, a);
+                }
+
+                m_Color = value;
+                Dirty(ModificationScope.Graph);
+            }
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new Vector4MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.zero));
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
+        }
+
+        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
+        {
+            if (!generationMode.IsPreview())
+                return;
+
+            properties.AddShaderProperty(new ColorShaderProperty()
+            {
+                overrideReferenceName = GetVariableNameForNode(),
+                generatePropertyBlock = false,
+                value = color.color,
+                colorMode = color.mode
+            });
+        }
+
+        public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
+        {
+            if (generationMode.IsPreview())
+                return;
+
+            switch (sgVersion)
+            {
+                case 0:
+                    sb.AppendLine(@"$precision4 {0} = IsGammaSpace() ? $precision4({1}, {2}, {3}, {4}) : $precision4(SRGBToLinear($precision3({1}, {2}, {3})), {4});"
+                        , GetVariableNameForNode()
+                        , NodeUtils.FloatToShaderValue(color.color.r)
+                        , NodeUtils.FloatToShaderValue(color.color.g)
+                        , NodeUtils.FloatToShaderValue(color.color.b)
+                        , NodeUtils.FloatToShaderValue(color.color.a));
+                    break;
+                case 1:
+                    //HDR color picker assumes Linear space, regular color picker assumes SRGB. Handle both cases
+                    if (color.mode == ColorMode.Default)
+                    {
+                        sb.AppendLine(@"$precision4 {0} = IsGammaSpace() ? $precision4({1}, {2}, {3}, {4}) : $precision4(SRGBToLinear($precision3({1}, {2}, {3})), {4});"
+                            , GetVariableNameForNode()
+                            , NodeUtils.FloatToShaderValue(color.color.r)
+                            , NodeUtils.FloatToShaderValue(color.color.g)
+                            , NodeUtils.FloatToShaderValue(color.color.b)
+                            , NodeUtils.FloatToShaderValue(color.color.a));
+                    }
+                    else
+                    {
+                        sb.AppendLine(@"$precision4 {0} = IsGammaSpace() ? LinearToSRGB($precision4({1}, {2}, {3}, {4})) : $precision4({1}, {2}, {3}, {4});"
+                            , GetVariableNameForNode()
+                            , NodeUtils.FloatToShaderValue(color.color.r)
+                            , NodeUtils.FloatToShaderValue(color.color.g)
+                            , NodeUtils.FloatToShaderValue(color.color.b)
+                            , NodeUtils.FloatToShaderValue(color.color.a));
+                    }
+                    break;
+            }
+        }
+
+        public override string GetVariableNameForSlot(int slotId)
+        {
+            return GetVariableNameForNode();
+        }
+
+        public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
+        {
+            UnityEngine.Color propColor = color.color;
+            if (color.mode == ColorMode.Default)
+            {
+                if (PlayerSettings.colorSpace == ColorSpace.Linear)
+                    propColor = propColor.linear;
+            }
+            if (color.mode == ColorMode.HDR)
+            {
+                switch (sgVersion)
+                {
+                    case 0:
+                        if (PlayerSettings.colorSpace == ColorSpace.Linear)
+                            propColor = propColor.linear;
+                        break;
+                    case 1:
+                        if (PlayerSettings.colorSpace == ColorSpace.Gamma)
+                            propColor = propColor.gamma;
+                        break;
+                }
+            }
+
+            // we use Vector4 type to avoid all of the automatic color conversions of PropertyType.Color
+            properties.Add(new PreviewProperty(PropertyType.Vector4)
+            {
+                name = GetVariableNameForNode(),
+                vector4Value = propColor
+            });
+        }
+
+        public AbstractShaderProperty AsShaderProperty()
+        {
+            return new ColorShaderProperty() { value = color.color, colorMode = color.mode };
+        }
+
+        public int outputSlotId { get { return OutputSlotId; } }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Input/Basic/ColorNode.cs.meta

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

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Input/Basic/ConstantNode.cs

@@ -0,0 +1,75 @@
+using System.Collections.Generic;
+using System.Globalization;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph
+{
+    enum ConstantType
+    {
+        PI,
+        TAU,
+        PHI,
+        E,
+        SQRT2
+    };
+
+    [Title("Input", "Basic", "Constant")]
+    class ConstantNode : AbstractMaterialNode, IGeneratesBodyCode
+    {
+        static Dictionary<ConstantType, float> m_constantList = new Dictionary<ConstantType, float>
+        {
+            {ConstantType.PI, 3.1415926f },
+            {ConstantType.TAU, 6.28318530f},
+            {ConstantType.PHI, 1.618034f},
+            {ConstantType.E, 2.718282f},
+            {ConstantType.SQRT2, 1.414214f},
+        };
+
+        [SerializeField]
+        private ConstantType m_constant = ConstantType.PI;
+
+        private const int kOutputSlotId = 0;
+        private const string kOutputSlotName = "Out";
+
+        [EnumControl("")]
+        public ConstantType constant
+        {
+            get { return m_constant; }
+            set
+            {
+                if (m_constant == value)
+                    return;
+
+                m_constant = value;
+                Dirty(ModificationScope.Graph);
+            }
+        }
+
+        public ConstantNode()
+        {
+            name = "Constant";
+            synonyms = new string[] { "pi", "tau", "phi" };
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new Vector1MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, 0));
+            RemoveSlotsNameNotMatching(new[] { kOutputSlotId });
+        }
+
+        public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
+        {
+            sb.AppendLine(string.Format("$precision {0} = {1};"
+                , GetVariableNameForNode()
+                , m_constantList[constant].ToString(CultureInfo.InvariantCulture)));
+        }
+
+        public override string GetVariableNameForSlot(int slotId)
+        {
+            return GetVariableNameForNode();
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Input/Basic/ConstantNode.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f48f68efc30ae334098ff30e88fbf9db
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Input/Basic/IntegerNode.cs

@@ -0,0 +1,89 @@
+using System.Collections.Generic;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Internal;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Input", "Basic", "Integer")]
+    class IntegerNode : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
+    {
+        [SerializeField]
+        private int m_Value;
+
+        public const int OutputSlotId = 0;
+        private const string kOutputSlotName = "Out";
+
+        public IntegerNode()
+        {
+            name = "Integer";
+            synonyms = new string[] { "whole number" };
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new Vector1MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, 0));
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
+        }
+
+        [IntegerControl("")]
+        public int value
+        {
+            get { return m_Value; }
+            set
+            {
+                if (m_Value == value)
+                    return;
+
+                m_Value = value;
+
+                Dirty(ModificationScope.Node);
+            }
+        }
+
+        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
+        {
+            if (!generationMode.IsPreview())
+                return;
+
+            properties.AddShaderProperty(new Vector1ShaderProperty()
+            {
+                overrideReferenceName = GetVariableNameForNode(),
+                generatePropertyBlock = false,
+                value = value,
+                floatType = FloatType.Integer
+            });
+        }
+
+        public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
+        {
+            if (generationMode.IsPreview())
+                return;
+
+            sb.AppendLine(string.Format("$precision {0} = {1};", GetVariableNameForNode(), m_Value));
+        }
+
+        public override string GetVariableNameForSlot(int slotId)
+        {
+            return GetVariableNameForNode();
+        }
+
+        public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
+        {
+            properties.Add(new PreviewProperty(PropertyType.Float)
+            {
+                name = GetVariableNameForNode(),
+                floatValue = m_Value
+            });
+        }
+
+        public AbstractShaderProperty AsShaderProperty()
+        {
+            return new Vector1ShaderProperty { value = value, floatType = FloatType.Integer };
+        }
+
+        public int outputSlotId { get { return OutputSlotId; } }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Input/Basic/IntegerNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e449bdf3b245898489ebab4f709ded62
+timeCreated: 1445864587
+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/Input/Basic/SliderNode.cs

@@ -0,0 +1,95 @@
+using System.Collections.Generic;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.Graphing;
+using System.Globalization;
+using UnityEditor.ShaderGraph.Internal;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Input", "Basic", "Slider")]
+    class SliderNode : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
+    {
+        [SerializeField]
+        private Vector3 m_Value = new Vector3(0f, 0f, 1f);
+
+        public const int OutputSlotId = 0;
+        private const string kOutputSlotName = "Out";
+
+        public SliderNode()
+        {
+            name = "Slider";
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new Vector1MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, 0));
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
+        }
+
+        [SliderControl("", true)]
+        public Vector3 value
+        {
+            get { return m_Value; }
+            set
+            {
+                if (m_Value == value)
+                    return;
+
+                m_Value = value;
+
+                Dirty(ModificationScope.Node);
+            }
+        }
+
+        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
+        {
+            if (!generationMode.IsPreview())
+                return;
+
+            properties.AddShaderProperty(new Vector1ShaderProperty()
+            {
+                overrideReferenceName = GetVariableNameForNode(),
+                generatePropertyBlock = false,
+                value = value.x,
+                rangeValues = new Vector2(value.y, value.z),
+                floatType = FloatType.Slider
+            });
+        }
+
+        public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
+        {
+            if (generationMode.IsPreview())
+                return;
+
+            sb.AppendLine(string.Format(CultureInfo.InvariantCulture, "$precision {0} = {1};", GetVariableNameForNode(), m_Value.x));
+        }
+
+        public override string GetVariableNameForSlot(int slotId)
+        {
+            return GetVariableNameForNode();
+        }
+
+        public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
+        {
+            properties.Add(new PreviewProperty(PropertyType.Float)
+            {
+                name = GetVariableNameForNode(),
+                floatValue = m_Value.x
+            });
+        }
+
+        public AbstractShaderProperty AsShaderProperty()
+        {
+            return new Vector1ShaderProperty
+            {
+                value = value.x,
+                rangeValues = new Vector2(value.y, value.z),
+                floatType = FloatType.Slider
+            };
+        }
+
+        public int outputSlotId { get { return OutputSlotId; } }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Input/Basic/SliderNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 39d5ba890306e584c9fb4fede8c37f9c
+timeCreated: 1445864587
+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/Input/Basic/TimeNode.cs

@@ -0,0 +1,64 @@
+using UnityEngine;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Input", "Basic", "Time")]
+    class TimeNode : AbstractMaterialNode, IMayRequireTime
+    {
+        private const string kOutputSlotName = "Time";
+        private const string kOutputSlot1Name = "Sine Time";
+        private const string kOutputSlot2Name = "Cosine Time";
+        private const string kOutputSlot3Name = "Delta Time";
+        private const string kOutputSlot4Name = "Smooth Delta";
+
+        public const int OutputSlotId = 0;
+        public const int OutputSlot1Id = 1;
+        public const int OutputSlot2Id = 2;
+        public const int OutputSlot3Id = 3;
+        public const int OutputSlot4Id = 4;
+
+        public TimeNode()
+        {
+            name = "Time";
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new Vector1MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, 0));
+            AddSlot(new Vector1MaterialSlot(OutputSlot1Id, kOutputSlot1Name, kOutputSlot1Name, SlotType.Output, 0));
+            AddSlot(new Vector1MaterialSlot(OutputSlot2Id, kOutputSlot2Name, kOutputSlot2Name, SlotType.Output, 0));
+            AddSlot(new Vector1MaterialSlot(OutputSlot3Id, kOutputSlot3Name, kOutputSlot3Name, SlotType.Output, 0));
+            AddSlot(new Vector1MaterialSlot(OutputSlot4Id, kOutputSlot4Name, kOutputSlot4Name, SlotType.Output, 0));
+            RemoveSlotsNameNotMatching(validSlots);
+        }
+
+        protected int[] validSlots
+        {
+            get { return new[] { OutputSlotId, OutputSlot1Id, OutputSlot2Id, OutputSlot3Id, OutputSlot4Id }; }
+        }
+
+        public override string GetVariableNameForSlot(int slotId)
+        {
+            switch (slotId)
+            {
+                case OutputSlot1Id:
+                    return "IN.TimeParameters.y";
+                case OutputSlot2Id:
+                    return "IN.TimeParameters.z";
+                case OutputSlot3Id:
+                    return "unity_DeltaTime.x";
+                case OutputSlot4Id:
+                    return "unity_DeltaTime.z";
+                default:
+                    return "IN.TimeParameters.x";
+            }
+        }
+
+        public bool RequiresTime()
+        {
+            return true;
+        }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Input/Basic/TimeNode.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 66310de0dabd3074aa56ab7714324cc0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Input/Basic/Vector1Node.cs

@@ -0,0 +1,57 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Internal;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Input", "Basic", "Float")]
+    class Vector1Node : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
+    {
+        [SerializeField]
+        private float m_Value = 0;
+
+        const string kInputSlotXName = "X";
+        const string kOutputSlotName = "Out";
+
+        public const int InputSlotXId = 1;
+        public const int OutputSlotId = 0;
+
+        public Vector1Node()
+        {
+            name = "Float";
+            synonyms = new string[] { "Vector 1", "1", "v1", "vec1", "scalar" };
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new Vector1MaterialSlot(InputSlotXId, kInputSlotXName, kInputSlotXName, SlotType.Input, m_Value));
+            AddSlot(new Vector1MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, 0));
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId, InputSlotXId });
+        }
+
+        public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
+        {
+            var inputValue = GetSlotValue(InputSlotXId, generationMode);
+            sb.AppendLine(string.Format("$precision {0} = {1};", GetVariableNameForSlot(OutputSlotId), inputValue));
+        }
+
+        public AbstractShaderProperty AsShaderProperty()
+        {
+            var slot = FindInputSlot<Vector1MaterialSlot>(InputSlotXId);
+            return new Vector1ShaderProperty { value = slot.value };
+        }
+
+        public override void OnAfterDeserialize()
+        {
+            base.OnAfterDeserialize();
+
+            name = "Float";
+        }
+
+        int IPropertyFromNode.outputSlotId { get { return OutputSlotId; } }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Input/Basic/Vector1Node.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 87c4299b09d95d64c99884296038ceeb
+timeCreated: 1445864587
+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/Input/Basic/Vector2Node.cs

@@ -0,0 +1,62 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Internal;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Input", "Basic", "Vector 2")]
+    class Vector2Node : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
+    {
+        [SerializeField]
+        private Vector2 m_Value = Vector2.zero;
+
+        const string kInputSlotXName = "X";
+        const string kInputSlotYName = "Y";
+        const string kOutputSlotName = "Out";
+
+        public const int OutputSlotId = 0;
+        public const int InputSlotXId = 1;
+        public const int InputSlotYId = 2;
+
+
+        public Vector2Node()
+        {
+            name = "Vector 2";
+            synonyms = new string[] { "2", "v2", "vec2", "float2" };
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new Vector1MaterialSlot(InputSlotXId, kInputSlotXName, kInputSlotXName, SlotType.Input, m_Value.x));
+            AddSlot(new Vector1MaterialSlot(InputSlotYId, kInputSlotYName, kInputSlotYName, SlotType.Input, m_Value.y, label1: "Y"));
+            AddSlot(new Vector2MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.zero));
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId, InputSlotXId, InputSlotYId });
+        }
+
+        public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
+        {
+            var inputXValue = GetSlotValue(InputSlotXId, generationMode);
+            var inputYValue = GetSlotValue(InputSlotYId, generationMode);
+            var outputName = GetVariableNameForSlot(OutputSlotId);
+
+            var s = string.Format("$precision2 {0} = $precision2({1}, {2});",
+                outputName,
+                inputXValue,
+                inputYValue);
+            sb.AppendLine(s);
+        }
+
+        public AbstractShaderProperty AsShaderProperty()
+        {
+            var slotX = FindInputSlot<Vector1MaterialSlot>(InputSlotXId);
+            var slotY = FindInputSlot<Vector1MaterialSlot>(InputSlotYId);
+            return new Vector2ShaderProperty { value = new Vector2(slotX.value, slotY.value) };
+        }
+
+        int IPropertyFromNode.outputSlotId { get { return OutputSlotId; } }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Input/Basic/Vector2Node.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 8361d1f9d12a489438c0b1e2e48c8542
+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/Input/Basic/Vector3Node.cs

@@ -0,0 +1,67 @@
+using System.Collections.Generic;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Internal;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Input", "Basic", "Vector 3")]
+    class Vector3Node : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
+    {
+        [SerializeField]
+        private Vector3 m_Value = Vector3.zero;
+
+        const string kInputSlotXName = "X";
+        const string kInputSlotYName = "Y";
+        const string kInputSlotZName = "Z";
+        const string kOutputSlotName = "Out";
+
+        public const int OutputSlotId = 0;
+        public const int InputSlotXId = 1;
+        public const int InputSlotYId = 2;
+        public const int InputSlotZId = 3;
+
+
+        public Vector3Node()
+        {
+            name = "Vector 3";
+            synonyms = new string[] { "3", "v3", "vec3", "float3" };
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new Vector1MaterialSlot(InputSlotXId, kInputSlotXName, kInputSlotXName, SlotType.Input, m_Value.x));
+            AddSlot(new Vector1MaterialSlot(InputSlotYId, kInputSlotYName, kInputSlotYName, SlotType.Input, m_Value.y, label1: "Y"));
+            AddSlot(new Vector1MaterialSlot(InputSlotZId, kInputSlotZName, kInputSlotZName, SlotType.Input, m_Value.z, label1: "Z"));
+            AddSlot(new Vector3MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.zero));
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId, InputSlotXId, InputSlotYId, InputSlotZId });
+        }
+
+        public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
+        {
+            var inputXValue = GetSlotValue(InputSlotXId, generationMode);
+            var inputYValue = GetSlotValue(InputSlotYId, generationMode);
+            var inputZValue = GetSlotValue(InputSlotZId, generationMode);
+            var outputName = GetVariableNameForSlot(outputSlotId);
+
+            var s = string.Format("$precision3 {0} = $precision3({1}, {2}, {3});",
+                outputName,
+                inputXValue,
+                inputYValue,
+                inputZValue);
+            sb.AppendLine(s);
+        }
+
+        public AbstractShaderProperty AsShaderProperty()
+        {
+            var slotX = FindInputSlot<Vector1MaterialSlot>(InputSlotXId);
+            var slotY = FindInputSlot<Vector1MaterialSlot>(InputSlotYId);
+            var slotZ = FindInputSlot<Vector1MaterialSlot>(InputSlotZId);
+            return new Vector3ShaderProperty { value = new Vector3(slotX.value, slotY.value, slotZ.value) };
+        }
+
+        public int outputSlotId { get { return OutputSlotId; } }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Input/Basic/Vector3Node.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 1350e4a38ff5ae44a9d8627d33b48de8
+timeCreated: 1453378777
+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/Input/Basic/Vector4Node.cs

@@ -0,0 +1,73 @@
+using System.Collections.Generic;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Internal;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Input", "Basic", "Vector 4")]
+    class Vector4Node : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
+    {
+        [SerializeField]
+        private Vector4 m_Value = Vector4.zero;
+
+        const string kInputSlotXName = "X";
+        const string kInputSlotYName = "Y";
+        const string kInputSlotZName = "Z";
+        const string kInputSlotWName = "W";
+        const string kOutputSlotName = "Out";
+
+        public const int OutputSlotId = 0;
+        public const int InputSlotXId = 1;
+        public const int InputSlotYId = 2;
+        public const int InputSlotZId = 3;
+        public const int InputSlotWId = 4;
+
+
+        public Vector4Node()
+        {
+            name = "Vector 4";
+            synonyms = new string[] { "4", "v4", "vec4", "float4" };
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new Vector1MaterialSlot(InputSlotXId, kInputSlotXName, kInputSlotXName, SlotType.Input, m_Value.x));
+            AddSlot(new Vector1MaterialSlot(InputSlotYId, kInputSlotYName, kInputSlotYName, SlotType.Input, m_Value.y, label1: "Y"));
+            AddSlot(new Vector1MaterialSlot(InputSlotZId, kInputSlotZName, kInputSlotZName, SlotType.Input, m_Value.z, label1: "Z"));
+            AddSlot(new Vector1MaterialSlot(InputSlotWId, kInputSlotWName, kInputSlotWName, SlotType.Input, m_Value.w, label1: "W"));
+            AddSlot(new Vector4MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.zero));
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId, InputSlotXId, InputSlotYId, InputSlotZId, InputSlotWId });
+        }
+
+        public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
+        {
+            var inputXValue = GetSlotValue(InputSlotXId, generationMode);
+            var inputYValue = GetSlotValue(InputSlotYId, generationMode);
+            var inputZValue = GetSlotValue(InputSlotZId, generationMode);
+            var inputWValue = GetSlotValue(InputSlotWId, generationMode);
+            var outputName = GetVariableNameForSlot(outputSlotId);
+
+            var s = string.Format("$precision4 {0} = $precision4({1}, {2}, {3}, {4});",
+                outputName,
+                inputXValue,
+                inputYValue,
+                inputZValue,
+                inputWValue);
+            sb.AppendLine(s);
+        }
+
+        public AbstractShaderProperty AsShaderProperty()
+        {
+            var slotX = FindInputSlot<Vector1MaterialSlot>(InputSlotXId);
+            var slotY = FindInputSlot<Vector1MaterialSlot>(InputSlotYId);
+            var slotZ = FindInputSlot<Vector1MaterialSlot>(InputSlotZId);
+            var slotW = FindInputSlot<Vector1MaterialSlot>(InputSlotWId);
+            return new Vector4ShaderProperty { value = new Vector4(slotX.value, slotY.value, slotZ.value, slotW.value) };
+        }
+
+        public int outputSlotId { get { return OutputSlotId; } }
+    }
+}

Library/PackageCache/com.unity.shadergraph@14.0.8/Editor/Data/Nodes/Input/Basic/Vector4Node.cs.meta

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