Add documentation links for all nodes

com.unity.shadergraph/Editor/Data/MasterNodes/PBRMasterNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/PBR-Master-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             name = "PBR Master";

com.unity.shadergraph/Editor/Data/MasterNodes/UnlitMasterNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Unlit-Master-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             name = "Unlit Master";

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Adjustment/ChannelMixerNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Channel-Mixer-Node"; }
+        }
+
         const int InputSlotId = 0;
         const int OutputSlotId = 1;
         const string kInputSlotName = "In";

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Adjustment/ContrastNode.cs

             name = "Contrast";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Contrast-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Contrast", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Adjustment/HueNode.cs

             name = "Hue";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Hue-Node"; }
+        }
+
         [SerializeField]
         private HueMode m_HueMode = HueMode.Degrees;
 

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Adjustment/InvertColorsNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Invert-Colors-Node"; }
+        }
+
         const int InputSlotId = 0;
         const int OutputSlotId = 1;
         const string kInputSlotName = "In";

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Adjustment/ReplaceColorNode.cs

             name = "Replace Color";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Replace-Color-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_ReplaceColor", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Adjustment/SaturationNode.cs

             name = "Saturation";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Saturation-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Saturation", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Adjustment/WhiteBalanceNode.cs

             name = "White Balance";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/White-Balance-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_WhiteBalance", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Blend/BlendNode.cs

             name = "Blend";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Blend-Node"; }
+        }
+
         string GetCurrentBlendName()
         {
             return System.Enum.GetName(typeof(BlendMode), m_BlendMode);

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Filter/DitherNode.cs

             name = "Dither";
             UpdateNodeAfterDeserialization();
         }
+
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Dither-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Dither", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Mask/ChannelMaskNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Channel-Mask-Node"; }
+        }
+
         const int InputSlotId = 0;
         const int OutputSlotId = 1;
         const string kInputSlotName = "In";

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Mask/ColorMaskNode.cs

             name = "Color Mask";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Color-Mask-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_ColorMask", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Normal/NormalBlendNode.cs

             name = "Normal Blend";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Normal-Blend-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_NormalBlend", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Normal/NormalCreateNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Normal-Create-Node"; }
+        }
+
         string GetFunctionName()
         {
             return string.Format("Unity_NormalCreate_{0}", precision);

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Normal/NormalStrengthNode.cs

             name = "Normal Strength";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Normal-Strength-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_NormalStrength", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Normal/NormalUnpackNode.cs

             name = "Normal Unpack";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Normal-Unpack-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_NormalUnpack", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Artistic/Utility/ColorspaceConversion.cs

             name = "Colorspace Conversion";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Colorspace-Conversion-Node"; }
+        }
+
         [SerializeField]
         ColorspaceConversion m_Conversion = new ColorspaceConversion(Colorspace.RGB, Colorspace.RGB);
 

com.unity.shadergraph/Editor/Data/Nodes/Channel/CombineNode.cs

             name = "Combine";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Combine-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Combine", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Channel/FlipNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Flip-Node"; }
+        }
+
         const int InputSlotId = 0;
         const int OutputSlotId = 1;
         const string kInputSlotName = "In";

com.unity.shadergraph/Editor/Data/Nodes/Channel/SplitNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Split-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new DynamicVectorMaterialSlot(InputSlotId, kInputSlotName, kInputSlotName, SlotType.Input, Vector4.zero));

com.unity.shadergraph/Editor/Data/Nodes/Channel/SwizzleNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Swizzle-Node"; }
+        }
+
         const int InputSlotId = 0;
         const int OutputSlotId = 1;
         const string kInputSlotName = "In";

com.unity.shadergraph/Editor/Data/Nodes/Input/Basic/BooleanNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Boolean-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new BooleanMaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, false));

com.unity.shadergraph/Editor/Data/Nodes/Input/Basic/ColorNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Color-Node"; }
+        }
+
         [SerializeField]
         Color m_Color = new Color(UnityEngine.Color.clear, ColorMode.Default);
 

com.unity.shadergraph/Editor/Data/Nodes/Input/Basic/ConstantNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Absolute-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector1MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, 0));

com.unity.shadergraph/Editor/Data/Nodes/Input/Basic/IntegerNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Integer-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector1MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, 0));

com.unity.shadergraph/Editor/Data/Nodes/Input/Basic/SliderNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Slider-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector1MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, 0));

com.unity.shadergraph/Editor/Data/Nodes/Input/Basic/TimeNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Time-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector1MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, 0));

com.unity.shadergraph/Editor/Data/Nodes/Input/Basic/Vector1Node.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Vector-1-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector1MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, 0));

com.unity.shadergraph/Editor/Data/Nodes/Input/Basic/Vector2Node.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Vector-2-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector2MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.zero));

com.unity.shadergraph/Editor/Data/Nodes/Input/Basic/Vector3Node.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Vector-3-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector3MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.zero));

com.unity.shadergraph/Editor/Data/Nodes/Input/Basic/Vector4Node.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Vector-4-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector4MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.zero));

com.unity.shadergraph/Editor/Data/Nodes/Input/Geometry/BitangentVectorNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Bitangent-Vector-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector3MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, new Vector4(0, 0, 1)));

com.unity.shadergraph/Editor/Data/Nodes/Input/Geometry/NormalVectorNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Normal-Vector-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector3MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, new Vector4(0, 0, 1)));

com.unity.shadergraph/Editor/Data/Nodes/Input/Geometry/PositionNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Position-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector3MaterialSlot(

com.unity.shadergraph/Editor/Data/Nodes/Input/Geometry/ScreenPositionNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Screen-Position-Node"; }
+        }
+
         [SerializeField]
         private ScreenSpaceType m_ScreenSpaceType = ScreenSpaceType.Default;
 

com.unity.shadergraph/Editor/Data/Nodes/Input/Geometry/TangentVectorNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Tangent-Vector-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector3MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, new Vector4(0, 0, 1, 1)));

com.unity.shadergraph/Editor/Data/Nodes/Input/Geometry/UVNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/UV-Node"; }
+        }
+
         public override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector4MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector2.zero));

com.unity.shadergraph/Editor/Data/Nodes/Input/Geometry/VertexColorNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Vertex-Color-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector4MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.one));

com.unity.shadergraph/Editor/Data/Nodes/Input/Geometry/ViewDirectionNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/View-Direction-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector3MaterialSlot(

com.unity.shadergraph/Editor/Data/Nodes/Input/Matrix/Matrix2Node.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Matrix-2x2-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Matrix2MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output));

com.unity.shadergraph/Editor/Data/Nodes/Input/Matrix/Matrix3Node.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Matrix-3x3-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Matrix3MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output));

com.unity.shadergraph/Editor/Data/Nodes/Input/Matrix/Matrix4Node.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Matrix-4x4-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Matrix4MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output));

com.unity.shadergraph/Editor/Data/Nodes/Input/Matrix/TransformationMatrixNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Transformation-Matrix-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Matrix4MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output));

com.unity.shadergraph/Editor/Data/Nodes/Input/PBR/DielectricSpecularNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Dielectric-Specular-Node"; }
+        }
+
         [SerializeField]
         DielectricMaterial m_Material = new DielectricMaterial(DielectricMaterialType.Common, 0.5f, 1.0f);
 

com.unity.shadergraph/Editor/Data/Nodes/Input/PBR/MetalReflectanceNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Metal-Reflectance-Node"; }
+        }
+
         [SerializeField]
         private MetalMaterialType m_Material = MetalMaterialType.Iron;
 

com.unity.shadergraph/Editor/Data/Nodes/Input/PropertyNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Property-Node"; }
+        }
+
         private void UpdateNode()
         {
             var graph = owner as AbstractMaterialGraph;

com.unity.shadergraph/Editor/Data/Nodes/Input/Scene/AmbientNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Ambient-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new ColorRGBMaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.zero));

com.unity.shadergraph/Editor/Data/Nodes/Input/Scene/CameraNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Camera-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector3MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector3.zero));

com.unity.shadergraph/Editor/Data/Nodes/Input/Scene/FogNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Fog-Node"; }
+        }
+
         const int OutputSlotId = 0;
         const int OutputSlot1Id = 1;
         const string k_OutputSlotName = "Color";

com.unity.shadergraph/Editor/Data/Nodes/Input/Scene/LightProbeNode.cs

             name = "Light Probe";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Light-Probe-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_LightProbe", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Input/Scene/ObjectNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Object-Node"; }
+        }
+
         public override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector3MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector3.zero));

com.unity.shadergraph/Editor/Data/Nodes/Input/Scene/ReflectionProbeNode.cs

             name = "Reflection Probe";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Reflection-Probe-Node"; }
+        }
+
         public override PreviewMode previewMode
         {
             get

com.unity.shadergraph/Editor/Data/Nodes/Input/Scene/ScreenNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Screen-Node"; }
+        }
+
         public override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector1MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, 0));

com.unity.shadergraph/Editor/Data/Nodes/Input/Texture/CubemapAssetNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Cubemap-Asset-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new CubemapMaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output));

com.unity.shadergraph/Editor/Data/Nodes/Input/Texture/SampleCubemapNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Sample-Cubemap-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector4MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.zero));

com.unity.shadergraph/Editor/Data/Nodes/Input/Texture/SampleTexture2DNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Sample-Texture-2D-Node"; }
+        }
+
         [SerializeField]
         private TextureType m_TextureType = TextureType.Default;
 

com.unity.shadergraph/Editor/Data/Nodes/Input/Texture/SamplerStateNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Sampler-State-Node"; }
+        }
+
         public override bool hasPreview { get { return false; } }
 
         private const int kOutputSlotId = 0;

com.unity.shadergraph/Editor/Data/Nodes/Input/Texture/Texture2DAssetNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Texture-2D-Asset-Node"; }
+        }
+
         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Texture2DMaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output));

com.unity.shadergraph/Editor/Data/Nodes/Math/Matrix/MatrixConstructionNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Matrix-Construction-Node"; }
+        }
+
         [SerializeField]
         MatrixAxis m_Axis;
 

com.unity.shadergraph/Editor/Data/Nodes/Math/Matrix/MatrixDeterminantNode.cs

             name = "Matrix Determinant";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Matrix-Determinant-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_MatrixDeterminant", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Matrix/MatrixSplitNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Matrix-Split-Node"; }
+        }
+
         [SerializeField]
         MatrixAxis m_Axis;
 

com.unity.shadergraph/Editor/Data/Nodes/Math/Matrix/MatrixTransposeNode.cs

             name = "Matrix Transpose";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Matrix-Transpose-Node"; }
+        }
+
         public override bool hasPreview
         {
             get { return false; }

com.unity.shadergraph/Editor/Data/Nodes/Math/Round/CeilingNode.cs

             name = "Ceiling";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Ceiling-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Ceiling", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Round/FloorNode.cs

             name = "Floor";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Floor-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Floor", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Round/RoundNode.cs

             name = "Round";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Round-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Round", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Round/SignNode.cs

             name = "Sign";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Sign-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Sign", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Round/StepNode.cs

             name = "Step";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Step-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Step", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Round/TruncateNode.cs

             name = "Truncate";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Truncate-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Truncate", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Trigonometry/ArccosineNode.cs

             name = "Arccosine";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Arccosine-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Arccosine", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Trigonometry/ArcsineNode.cs

             name = "Arcsine";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Arcsine-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Arcsine", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Trigonometry/Arctangent2Node.cs

             name = "Arctangent2";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Arctangent2-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Arctangent2", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Trigonometry/ArctangentNode.cs

             name = "Arctangent";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Arctangent-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Arctangent", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Trigonometry/CosineNode.cs

             name = "Cosine";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Cosine-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Cosine", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Trigonometry/DegreesToRadiansNode.cs

             name = "Degrees To Radians";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Degrees-To-Radians-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_DegreesToRadians", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Trigonometry/HyperbolicCosineNode.cs

             name = "Hyperbolic Cosine";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Hyperbolic-Cosine-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_HyperbolicCosine", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Trigonometry/HyperbolicSineNode.cs

             name = "Hyperbolic Sine";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Hyperbolic-Sine-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_HyperbolicSine", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Trigonometry/HyperbolicTangentNode.cs

             name = "Hyperbolic Tangent";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Hyperbolic-Tangent-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_HyperbolicTangent", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Trigonometry/RadiansToDegreesNode.cs

             name = "Radians To Degrees";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Radians-To-Degrees-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_RadiansToDegrees", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Trigonometry/SineNode.cs

             name = "Sine";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Sine-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Sine", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Trigonometry/TangentNode.cs

             name = "Tangent";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Tangent-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Tangent", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Vector/CrossProductNode.cs

             name = "Cross Product";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Cross-Product-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_CrossProduct", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Vector/DistanceNode.cs

             name = "Distance";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Distance-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Distance", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Vector/DotProductNode.cs

             name = "Dot Product";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Dot-Product-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_DotProduct", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Vector/FresnelEffectNode.cs

             name = "Fresnel Effect";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Fresnel-Effect-Node"; }
+        }
+
         public override PreviewMode previewMode
         {
             get { return PreviewMode.Preview3D; }

com.unity.shadergraph/Editor/Data/Nodes/Math/Vector/ProjectionNode.cs

             name = "Projection";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Projection-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Projection", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Vector/ReflectionNode.cs

             name = "Reflection";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Reflection-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Reflection", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Vector/RejectionNode.cs

             name = "Rejection";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Rejection-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Rejection", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Math/Vector/TransformNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Transform-Node"; }
+        }
+
         [SerializeField]
         CoordinateSpaceConversion m_Conversion = new CoordinateSpaceConversion(CoordinateSpace.Object, CoordinateSpace.World);
 

com.unity.shadergraph/Editor/Data/Nodes/Procedural/CheckerboardNode.cs

             name = "Checkerboard";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Checkerboard-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Checkerboard", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Procedural/Noise/GradientNoiseNode.cs

             name = "Gradient Noise";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Gradient-Noise-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_GradientNoise", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Procedural/Noise/SimpleNoiseNode.cs

             name = "Simple Noise";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Simple-Noise-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_SimpleNoise", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Procedural/Noise/VoronoiNode.cs

             name = "Voronoi";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Voronoi-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Voronoi", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Procedural/Shape/EllipseNode.cs

             name = "Ellipse";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Ellipse-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Ellipse", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Procedural/Shape/PolygonNode.cs

             name = "Polygon";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Polygon-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Polygon", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Procedural/Shape/RectangleNode.cs

             name = "Rectangle";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Rectangle-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Rectangle", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/Procedural/Shape/RoundedRectangleNode.cs

             name = "Rounded Rectangle";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Rounded-Rectangle-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_RoundedRectangle", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/UV/FlipbookNode.cs

             UpdateNodeAfterDeserialization();
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Flipbook-Node"; }
+        }
+
         const int UVSlotId = 0;
         const int WidthSlotId = 1;
         const int HeightSlotId = 2;

com.unity.shadergraph/Editor/Data/Nodes/UV/PolarCoordinatesNode.cs

             name = "Polar Coordinates";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Polar-Coordinates-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_PolarCoordinates", BindingFlags.Static | BindingFlags.NonPublic);

com.unity.shadergraph/Editor/Data/Nodes/UV/RadialShearNode.cs

             name = "Radial Shear";
         }
 
+        public override string documentationURL
+        {
+            get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Radial-Shear-Node"; }
+        }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_RadialShear", BindingFlags.Static | BindingFlags.NonPublic);