Run code format tool

MaterialGraphProject/Assets/NewNodes/Editor/Keep/ParallaxNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-
     [Title("OLD/Parallax")]
     public class ParallaxNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction, IMayRequireMeshUV, IMayRequireViewDirection
     {

MaterialGraphProject/Assets/NewNodes/Editor/Kill/MultiLayerParallaxNode.cs

 
         protected virtual MaterialSlot GetInputDepthSlot()
         {
-            return new Vector1MaterialSlot(InputDepthSlotId, GetInputSlot1Name(), kInputDepthShaderName, SlotType.Input,0);
+            return new Vector1MaterialSlot(InputDepthSlotId, GetInputSlot1Name(), kInputDepthShaderName, SlotType.Input, 0);
         }
 
         protected virtual MaterialSlot GetInputFadeRateSlot()
         {
             return kOutputSlotShaderName;
         }
-        
+
         protected virtual string GetFunctionPrototype(string depth, string fadeRate, string layerCount, string tex, string UVs, string viewTangentSpace)
         {
             var input1 = ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputDepthSlotId).concreteValueType);
             string fadeRateValue = GetSlotValue(InputFadeRateSlotId, generationMode);
             string layerCountValue = GetSlotValue(InputLayerCountSlotId, generationMode);
             string textureValue = GetSlotValue(TextureSlotId, generationMode);
-            
+
             var output = ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType);
             visitor.AddShaderChunk(string.Format("{0} {1} = {2};", output, GetVariableNameForSlot(OutputSlotId), GetFunctionCallBody(depthValue, fadeRateValue, layerCountValue, textureValue)), true);
         }

MaterialGraphProject/Assets/NewNodes/Editor/Kill/SphericalIndentationNode.cs

 {
     /*
     [Title("UV/Spherize 3D")]
-    public class SphericalIndentationNode : CodeFunctionNode 
+    public class SphericalIndentationNode : CodeFunctionNode
     {
         public SphericalIndentationNode()
         {

MaterialGraphProject/Assets/NewNodes/Editor/Kill/ToggleNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-   /* [Title("Input/Toggle")]
-    public class ToggleNode : PropertyNode, IGeneratesBodyCode
-    {
-        [SerializeField]
-        //private float m_Float;
-        private bool m_ToggleState;
+    /* [Title("Input/Toggle")]
+     public class ToggleNode : PropertyNode, IGeneratesBodyCode
+     {
+         [SerializeField]
+         //private float m_Float;
+         private bool m_ToggleState;
-        private const int kOutputSlotId = 0;
-        private const string kOutputSlotName = "Ouput";
+         private const int kOutputSlotId = 0;
+         private const string kOutputSlotName = "Ouput";
-        public ToggleNode()
-        {
-            name = "Toggle";
-            UpdateNodeAfterDeserialization();
-        }
+         public ToggleNode()
+         {
+             name = "Toggle";
+             UpdateNodeAfterDeserialization();
+         }
-        public sealed override void UpdateNodeAfterDeserialization()
-        {
-            AddSlot(new MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, SlotValueType.Vector1, Vector2.zero));
-            RemoveSlotsNameNotMatching(new[] { kOutputSlotId });
-        }
+         public sealed override void UpdateNodeAfterDeserialization()
+         {
+             AddSlot(new MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, SlotValueType.Vector1, Vector2.zero));
+             RemoveSlotsNameNotMatching(new[] { kOutputSlotId });
+         }
-        public override PropertyType propertyType
-        {
-            get { return PropertyType.Float; }
-        }
+         public override PropertyType propertyType
+         {
+             get { return PropertyType.Float; }
+         }
-        public bool value
-        {
-            get { return m_ToggleState; }
-            set
-            {
-                if (m_ToggleState == value)
-                    return;
+         public bool value
+         {
+             get { return m_ToggleState; }
+             set
+             {
+                 if (m_ToggleState == value)
+                     return;
-                m_ToggleState = value;
-                if (onModified != null)
-                {
-                    onModified(this, ModificationScope.Node);
-                }
-            }
-        }
+                 m_ToggleState = value;
+                 if (onModified != null)
+                 {
+                     onModified(this, ModificationScope.Node);
+                 }
+             }
+         }
-        public override void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)
-        {
-            if (exposedState == ExposedState.Exposed)
-                visitor.AddShaderProperty(new FloatPropertyChunk(propertyName, description, 0f, FloatPropertyChunk.FloatType.Toggle, PropertyChunk.HideState.Visible));
-        }
+         public override void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)
+         {
+             if (exposedState == ExposedState.Exposed)
+                 visitor.AddShaderProperty(new FloatPropertyChunk(propertyName, description, 0f, FloatPropertyChunk.FloatType.Toggle, PropertyChunk.HideState.Visible));
+         }
-        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            if (exposedState == ExposedState.Exposed || generationMode.IsPreview())
-                visitor.AddShaderChunk(precision + " " + propertyName + ";", true);
-        }
+         public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+         {
+             if (exposedState == ExposedState.Exposed || generationMode.IsPreview())
+                 visitor.AddShaderChunk(precision + " " + propertyName + ";", true);
+         }
-        public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            if (exposedState == ExposedState.Exposed || generationMode.IsPreview())
-                return;
+         public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+         {
+             if (exposedState == ExposedState.Exposed || generationMode.IsPreview())
+                 return;
-            visitor.AddShaderChunk(value.ToString(), true);
-        }
+             visitor.AddShaderChunk(value.ToString(), true);
+         }
-        public override PreviewProperty GetPreviewProperty()
-        {
-            return new PreviewProperty
-            {
-                m_Name = propertyName,
-                m_PropType = PropertyType.Float,
-                m_Float = value ? 1f : 0f
-            };
-        }
-    }*/
+         public override PreviewProperty GetPreviewProperty()
+         {
+             return new PreviewProperty
+             {
+                 m_Name = propertyName,
+                 m_PropType = PropertyType.Float,
+                 m_Float = value ? 1f : 0f
+             };
+         }
+     }*/
 }

MaterialGraphProject/Assets/NewNodes/Editor/Kill/UVTransform.cs

     [Title("OLD/Transform")]
     public class UVTransform : CodeFunctionNode
     {
-
         [SerializeField]
         private RotationUnit m_constant = RotationUnit.Radians;
 
         {
             name = "Transform";
         }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_ScaleOffsetRotate", BindingFlags.Static | BindingFlags.NonPublic);
             return
                 @"
 {
-    
-    
+
+
     uv -= offset;
 
     {precision} s = sin(rotation);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/AssetCallbacks/CreateLayeredShaderGraph.cs

-using System.IO;
+using System.IO;
 using UnityEditor.ProjectWindowCallback;
 using UnityEditor.ShaderGraph;
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/AbstractMaterialGraph.cs

                 if (property is FloatShaderProperty)
                 {
                     var createdNode = new Vector1Node();
-                    createdNode.value = ((FloatShaderProperty) property).value;
+                    createdNode.value = ((FloatShaderProperty)property).value;
                     slotId = Vector1Node.OutputSlotId;
                     node = createdNode;
                 }
-                    createdNode.value = ((Vector2ShaderProperty) property).value;
+                    createdNode.value = ((Vector2ShaderProperty)property).value;
                     slotId = Vector2Node.OutputSlotId;
                     node = createdNode;
                 }
-                    createdNode.value = ((Vector3ShaderProperty) property).value;
+                    createdNode.value = ((Vector3ShaderProperty)property).value;
                     slotId = Vector3Node.OutputSlotId;
                     node = createdNode;
                 }
-                    createdNode.value = ((Vector4ShaderProperty) property).value;
+                    createdNode.value = ((Vector4ShaderProperty)property).value;
                     slotId = Vector4Node.OutputSlotId;
                     node = createdNode;
                 }
-                    createdNode.color = ((ColorShaderProperty) property).value;
+                    createdNode.color = ((ColorShaderProperty)property).value;
                     slotId = ColorNode.OutputSlotId;
                     node = createdNode;
                 }
-                    createdNode.texture = ((TextureShaderProperty) property).value.texture;
+                    createdNode.texture = ((TextureShaderProperty)property).value.texture;
                     slotId = Texture2DAssetNode.OutputSlotId;
                     node = createdNode;
                 }
-                    createdNode.cubemap = ((CubemapShaderProperty) property).value.cubemap;
+                    createdNode.cubemap = ((CubemapShaderProperty)property).value.cubemap;
                     slotId = CubemapAssetNode.OutputSlotId;
                     node = createdNode;
                 }
             return reqs;
         }
 
-
         public string GetPreviewShader(AbstractMaterialNode node, out PreviewMode previewMode)
         {
             List<PropertyCollector.TextureInfo> configuredTextures;
-        
+
         public string GetUberPreviewShader(Dictionary<Guid, int> ids, out FloatShaderProperty outputIdProperty)
         {
             List<PropertyCollector.TextureInfo> configuredTextures;
                 foreach (var slot in slots)
                     surfaceDescriptionStruct.AddShaderChunk(string.Format("{0} {1};", AbstractMaterialNode.ConvertConcreteSlotValueTypeToString(AbstractMaterialNode.OutputPrecision.@float, slot.concreteValueType), AbstractMaterialNode.GetHLSLSafeName(slot.shaderOutputName)), false);
                 surfaceDescriptionStruct.Deindent();
-
             }
             else
             {
             string surfaceDescriptionName = "SurfaceDescription",
             FloatShaderProperty outputIdProperty = null,
             Dictionary<Guid, int> ids = null,
-           IEnumerable<MaterialSlot> slots = null)
+            IEnumerable<MaterialSlot> slots = null)
         {
             if (graph == null)
                 return;
                         ids[activeNode.guid] = currentId;
                         surfaceDescriptionFunction.AddShaderChunk(string.Format("if ({0} == {1}) {{ surface.PreviewOutput = {2}; return surface; }}", outputIdProperty.referenceName, currentId, ShaderGenerator.AdaptNodeOutputForPreview(activeNode, outputSlot.id, activeNode.GetVariableNameForSlot(outputSlot.id))), false);
                     }
-
                 }
 
                 activeNode.CollectShaderProperties(shaderProperties, mode);
             finalShader.AddShaderChunk("ENDCG", false);
 
             finalShader.AddShaderChunk(ShaderGenerator.GetPreviewSubShader(node, requirements), false);
-            
+
             ListPool<INode>.Release(activeNodeList);
 
             finalShader.Deindent();

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/BitangentMaterialSlot.cs

         {}
 
         public BitangentMaterialSlot(int slotId, string displayName, string shaderOutputName, CoordinateSpace space,
-            ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
+                                     ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
             : base(slotId, displayName, shaderOutputName, space, shaderStage, hidden)
         {}
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/ColorMaterialSlot.cs

-using UnityEditor.Graphing;
+using UnityEditor.Graphing;
 using UnityEditor.ShaderGraph.Drawing.Slots;
 using UnityEngine;
 using UnityEngine.Experimental.UIElements;
             Vector4 value,
             ShaderStage shaderStage = ShaderStage.Dynamic,
             bool hidden = false)
-            :base(slotId, displayName, shaderOutputName, slotType, value, shaderStage, hidden)
+            : base(slotId, displayName, shaderOutputName, slotType, value, shaderStage, hidden)
         {
         }
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/CubemapShaderProperty.cs

-using System;
+using System;
 using System.Text;
 using UnityEngine;
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/DynamicVectorMaterialSlot.cs

             Vector4 value,
             ShaderStage shaderStage = ShaderStage.Dynamic,
             bool hidden = false)
-            :base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
+            : base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
         {
             m_Value = value;
         }
                 concreteValueType == ConcreteSlotValueType.Vector1 ? 1 : 0;
             return new MultiFloatSlotControlView(owner, components, () => value, (newValue) => value = newValue);
         }
-
 
         public override SlotValueType valueType { get { return SlotValueType.Dynamic; } }
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/FloatShaderProperty.cs

         {
             displayName = "Float";
         }
-        
+
         public override PropertyType propertyType
         {
             get { return PropertyType.Float; }
         {
-            get { return new Vector4(value, value, value, value);}
+            get { return new Vector4(value, value, value, value); }
-          //  if (m_FloatType == FloatPropertyChunk.FloatType.Toggle)
-           //     result.Append("[Toggle]");
-          //  else if (m_FloatType == FloatPropertyChunk.FloatType.PowerSlider)
-          //      result.Append("[PowerSlider(" + m_rangeValues.z + ")]");
+            //  if (m_FloatType == FloatPropertyChunk.FloatType.Toggle)
+            //     result.Append("[Toggle]");
+            //  else if (m_FloatType == FloatPropertyChunk.FloatType.PowerSlider)
+            //      result.Append("[PowerSlider(" + m_rangeValues.z + ")]");
             result.Append(referenceName);
             result.Append("(\"");
             result.Append(displayName);
-                result.Append("\", Float) = ");
-           /* }
-            else if (m_FloatType == FloatPropertyChunk.FloatType.Range || m_FloatType == FloatPropertyChunk.FloatType.PowerSlider)
-            {
-                result.Append("\", Range(");
-                result.Append(m_rangeValues.x + ", " + m_rangeValues.y);
-                result.Append(")) = ");
-            }*/
+            result.Append("\", Float) = ");
+            /* }
+             else if (m_FloatType == FloatPropertyChunk.FloatType.Range || m_FloatType == FloatPropertyChunk.FloatType.PowerSlider)
+             {
+                 result.Append("\", Range(");
+                 result.Append(m_rangeValues.x + ", " + m_rangeValues.y);
+                 result.Append(")) = ");
+             }*/
             result.Append(value);
             return result.ToString();
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/IShaderProperty.cs

-using System;
+using System;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/MaterialGraphAsset.cs

-
 using UnityEngine;
 #if UNITY_EDITOR
 using System.Reflection;

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/MaterialSlot.cs

 
         private bool m_HasError;
 
-        protected MaterialSlot() { }
+        protected MaterialSlot() {}
 
         protected MaterialSlot(int slotId, string displayName, string shaderOutputName, SlotType slotType, ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
             : base(slotId, displayName, slotType, hidden)
                 && otherSlot.owner != owner
                 && otherSlot.isInputSlot != isInputSlot
                 && ((isInputSlot
-                    ? otherSlot.IsCompatibleWithInputSlotType(valueType)
-                    : IsCompatibleWithInputSlotType(otherSlot.valueType)));
+                     ? otherSlot.IsCompatibleWithInputSlotType(valueType)
+                     : IsCompatibleWithInputSlotType(otherSlot.valueType)));
         }
 
         public virtual string GetDefaultValue(GenerationMode generationMode)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/Matrix2MaterialSlot.cs

     [Serializable]
     public class Matrix2MaterialSlot : MaterialSlot
     {
-
         public Matrix2MaterialSlot()
         {
         }
             SlotType slotType,
             ShaderStage shaderStage = ShaderStage.Dynamic,
             bool hidden = false)
-            :base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
+            : base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
         {
         }
 
 
         public override void CopyValuesFrom(MaterialSlot foundSlot)
         {
-
-
-
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/Matrix3MaterialSlot.cs

     [Serializable]
     public class Matrix3MaterialSlot : MaterialSlot
     {
-
         public Matrix3MaterialSlot()
         {
         }
             SlotType slotType,
             ShaderStage shaderStage = ShaderStage.Dynamic,
             bool hidden = false)
-            :base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
+            : base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
         {
         }
 
 
         public override void CopyValuesFrom(MaterialSlot foundSlot)
         {
-
         }
 
         public override SlotValueType valueType { get { return SlotValueType.Matrix3; } }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/Matrix4MaterialSlot.cs

             SlotType slotType,
             ShaderStage shaderStage = ShaderStage.Dynamic,
             bool hidden = false)
-            :base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
+            : base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
-
 
         protected override string ConcreteSlotValueAsVariable(AbstractMaterialNode.OutputPrecision precision)
         {
         public override void AddDefaultProperty(PropertyCollector properties, GenerationMode generationMode)
         {
-
-
         }
 
         public override SlotValueType valueType { get { return SlotValueType.Matrix4; } }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/NormalMaterialSlot.cs

     [Serializable]
     public class NormalMaterialSlot : SpaceMaterialSlot, IMayRequireNormal
     {
-
-            ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
+                                  ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
             : base(slotId, displayName, shaderOutputName, space, shaderStage, hidden)
         {}
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/PositionMaterialSlot.cs

         {}
 
         public PositionMaterialSlot(int slotId, string displayName, string shaderOutputName, CoordinateSpace space,
-            ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
+                                    ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
             : base(slotId, displayName, shaderOutputName, space, shaderStage, hidden)
         {}
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/SamplerStateMaterialSlot.cs

             SlotType slotType,
             ShaderStage shaderStage = ShaderStage.Dynamic,
             bool hidden = false)
-            :base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
+            : base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
         {
         }
 
 
         public override void CopyValuesFrom(MaterialSlot foundSlot)
         {
-
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/SamplerStateShaderProperty.cs

-using System;
+using System;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/ScreenPositionMaterialSlot.cs

     public class ScreenPositionMaterialSlot : Vector4MaterialSlot, IMayRequireScreenPosition
     {
         public ScreenPositionMaterialSlot(int slotId, string displayName, string shaderOutputName,
-            ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
+                                          ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
-        { }
+        {}
 
         public override string GetDefaultValue(GenerationMode generationMode)
         {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/SerializableGuid.cs

-using System;
+using System;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph
                 m_Guid = Guid.NewGuid();
         }
     }
-}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/ShaderGraphRequirements.cs

-using System.Collections.Generic;
+using System.Collections.Generic;
 
 namespace UnityEditor.ShaderGraph
 {
                     requiresMeshUVs = new List<UVChannel>()
                 };
             }
-
-                                 | requiresTangent | requiresViewDir | requiresPosition
-                                 | requiresNormal;
+                | requiresTangent | requiresViewDir | requiresPosition
+                | requiresNormal;
 
             return (compoundSpaces & NeededCoordinateSpace.Tangent) > 0;
         }
             newReqs.requiresVertexColor = other.requiresVertexColor | requiresVertexColor;
 
             newReqs.requiresMeshUVs = new List<UVChannel>();
-            if(requiresMeshUVs != null)
+            if (requiresMeshUVs != null)
-            if(other.requiresMeshUVs != null)
+            if (other.requiresMeshUVs != null)
                 newReqs.requiresMeshUVs.AddRange(other.requiresMeshUVs);
             return newReqs;
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/SpaceMaterialSlot.cs

         {}
 
         protected SpaceMaterialSlot(int slotId, string displayName, string shaderOutputName, CoordinateSpace space,
-            ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
+                                    ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
             : base(slotId, displayName, shaderOutputName, SlotType.Input, Vector3.zero, shaderStage, hidden)
         {
             this.space = space;

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/TangentMaterialSlot.cs

         {}
 
         public TangentMaterialSlot(int slotId, string displayName, string shaderOutputName, CoordinateSpace space,
-            ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
+                                   ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
             : base(slotId, displayName, shaderOutputName, space, shaderStage, hidden)
         {}
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/TextureSamplerState.cs

-using UnityEngine;
+using UnityEngine;
 
 namespace UnityEditor.ShaderGraph
 {
             }
         }
     }
-}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/TextureShaderProperty.cs

-using System;
+using System;
 using System.Text;
 using UnityEngine;
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/UVMaterialSlot.cs

         {}
 
         public UVMaterialSlot(int slotId, string displayName, string shaderOutputName, UVChannel channel,
-            ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
+                              ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
             : base(slotId, displayName, shaderOutputName, SlotType.Input, Vector2.zero, shaderStage, hidden)
         {
             this.channel = channel;

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/Vector1MaterialSlot.cs

             float value,
             ShaderStage shaderStage = ShaderStage.Dynamic,
             bool hidden = false)
-            :base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
+            : base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
         {
             m_DefaultValue = value;
             m_Value = value;

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/Vector2MaterialSlot.cs

             Vector2 value,
             ShaderStage shaderStage = ShaderStage.Dynamic,
             bool hidden = false)
-            :base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
+            : base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
         {
             m_Value = value;
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/Vector2ShaderProperty.cs

-using System;
+using System;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph
                 m_Vector4 = value
             };
         }
-
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/Vector3MaterialSlot.cs

             Vector3 value,
             ShaderStage shaderStage = ShaderStage.Dynamic,
             bool hidden = false)
-            :base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
+            : base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
         {
             m_Value = value;
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/Vector3ShaderProperty.cs

-using System;
+using System;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/Vector4MaterialSlot.cs

             Vector4 value,
             ShaderStage shaderStage = ShaderStage.Dynamic,
             bool hidden = false)
-            :base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
+            : base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
         {
             m_Value = value;
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/VectorShaderProperty.cs

-using System;
+using System;
 using System.Text;
 using UnityEngine;
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/VertexColorMaterialSlot.cs

     public class VertexColorMaterialSlot : Vector4MaterialSlot, IMayRequireScreenPosition
     {
         public VertexColorMaterialSlot(int slotId, string displayName, string shaderOutputName,
-            ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
+                                       ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
-        { }
+        {}
 
         public override string GetDefaultValue(GenerationMode generationMode)
         {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/ViewDirectionMaterialSlot.cs

         {}
 
         public ViewDirectionMaterialSlot(int slotId, string displayName, string shaderOutputName, CoordinateSpace space,
-            ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
+                                         ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
             : base(slotId, displayName, shaderOutputName, space, shaderStage, hidden)
         {}
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Interfaces/IMayRequireBitangent.cs

     {
         NeededCoordinateSpace RequiresBitangent();
     }
-}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Interfaces/IMayRequireNormal.cs

-namespace UnityEditor.ShaderGraph
+namespace UnityEditor.ShaderGraph
 {
     public interface IMayRequireNormal
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Interfaces/IMayRequirePosition.cs

     {
         NeededCoordinateSpace RequiresPosition();
     }
-}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Interfaces/IMayRequireTangent.cs

     {
         NeededCoordinateSpace RequiresTangent();
     }
-}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Interfaces/IMayRequireViewDirection.cs

     {
         NeededCoordinateSpace RequiresViewDirection();
     }
-}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Interfaces/MaterialGraphChange.cs

-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Interfaces/NeededCoordinateSpace.cs

-using System;
+using System;
 
 namespace UnityEditor.ShaderGraph
 {
         World = 1 << 2,
         Tangent = 1 << 3
     }
-    
+
     public enum CoordinateSpace : int
     {
         Object,
             }
         }
     }
-}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/LightweightPipeline/LightWeightPBRSubShader.cs

             graph.AddShaderChunk(shaderProperties.GetPropertiesDeclaration(2), false);
             graph.AddShaderChunk(surfaceVertexShader.GetShaderString(2), false);
             graph.AddShaderChunk(surfaceDescriptionFunction.GetShaderString(2), false);
-            
+
-            
+
             materialOptions.GetBlend(blendingVisitor);
             materialOptions.GetCull(cullingVisitor);
             materialOptions.GetDepthTest(zTestVisitor);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/LightweightPipeline/PBRMasterNode.cs

             // we support
             RemoveSlotsNameNotMatching(
                 new[]
-                {
-                    AlbedoSlotId,
-                    NormalSlotId,
-                    EmissionSlotId,
-                    model == Model.Metallic ? MetallicSlotId : SpecularSlotId,
-                    SmoothnessSlotId,
-                    OcclusionSlotId,
-                    AlphaSlotId
-                });
+            {
+                AlbedoSlotId,
+                NormalSlotId,
+                EmissionSlotId,
+                model == Model.Metallic ? MetallicSlotId : SpecularSlotId,
+                SmoothnessSlotId,
+                OcclusionSlotId,
+                AlphaSlotId
+            });
         }
 
         public override string GetShader(GenerationMode mode, string outputName, out List<PropertyCollector.TextureInfo> configuredTextures)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/LightweightPipeline/UnlitMasterNode.cs

             // we support
             RemoveSlotsNameNotMatching(
                 new[]
-                {
-                    ColorSlotId,
-                    AlphaSlotId
-                });
+            {
+                ColorSlotId,
+                AlphaSlotId
+            });
         }
 
         public override string GetShader(GenerationMode mode, string outputName, out List<PropertyCollector.TextureInfo> configuredTextures)

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

                 // are compatable.
                 if (inputSlot is DynamicVectorMaterialSlot)
                 {
-                    dynamicInputSlotsToCompare.Add((DynamicVectorMaterialSlot) inputSlot, outputConcreteType);
+                    dynamicInputSlotsToCompare.Add((DynamicVectorMaterialSlot)inputSlot, outputConcreteType);
                     continue;
                 }
 
 
             ListPool<DynamicVectorMaterialSlot>.Release(skippedDynamicSlots);
             DictionaryPool<DynamicVectorMaterialSlot, ConcreteSlotValueType>.Release(dynamicInputSlotsToCompare);
-
         }
 
         public int version { get; private set; }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Artistic/Adjustment/ChannelMixerNode.cs

-using System;
+using System;
 using System.Collections.Generic;
 using UnityEditor.Graphing;
 using UnityEditor.ShaderGraph.Drawing.Controls;
         }
 
         [SerializeField]
-        ChannelMixer m_ChannelMixer = new ChannelMixer( new Vector3(1, 0, 0), new Vector3(0, 1, 0), new Vector3(0, 0, 1));
+        ChannelMixer m_ChannelMixer = new ChannelMixer(new Vector3(1, 0, 0), new Vector3(0, 1, 0), new Vector3(0, 0, 1));
 
         [Serializable]
         public struct ChannelMixer
 
         string GetFunctionPrototype(string argIn, string argRed, string argGreen, string argBlue, string argOut)
         {
-            return string.Format("void {0} ({1} {2}, {3} {4}, {3} {5}, {3} {6}, out {7} {8})", GetFunctionName(), 
-                ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType), argIn, 
-                precision+"3", argRed, argGreen, argBlue, 
+            return string.Format("void {0} ({1} {2}, {3} {4}, {3} {5}, {3} {6}, out {7} {8})", GetFunctionName(),
+                ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType), argIn,
+                precision + "3", argRed, argGreen, argBlue,
                 ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType), argOut);
         }
 
             string outputValue = GetSlotValue(OutputSlotId, generationMode);
             visitor.AddShaderChunk(string.Format("{0} {1};", ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType), GetVariableNameForSlot(OutputSlotId)), true);
 
-            if(!generationMode.IsPreview())
+            if (!generationMode.IsPreview())
             {
                 visitor.AddShaderChunk(string.Format("{0}3 _{1}_Red = {0}3 ({2}, {3}, {4});", precision, GetVariableNameForNode(), channelMixer.outRed[0], channelMixer.outRed[1], channelMixer.outRed[2]), true);
                 visitor.AddShaderChunk(string.Format("{0}3 _{1}_Green = {0}3 ({2}, {3}, {4});", precision, GetVariableNameForNode(), channelMixer.outGreen[0], channelMixer.outGreen[1], channelMixer.outGreen[2]), true);
             visitor.Indent();
 
             visitor.AddShaderChunk(string.Format("Out = {0} (dot(In, Red), dot(In, Green), dot(In, Blue));",
-                ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType)), true);
+                    ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType)), true);
 
             visitor.Deindent();
             visitor.AddShaderChunk("}", false);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Artistic/Adjustment/HueNode.cs

                     return;
 
                 m_HueMode = value;
-                if(onModified != null)
+                if (onModified != null)
                 {
                     onModified(this, ModificationScope.Graph);
                 }
         protected override MethodInfo GetFunctionToConvert()
         {
-            switch(m_HueMode)
+            switch (m_HueMode)
             {
                 case HueMode.Normalized:
                     return GetType().GetMethod("Unity_Hue_Normalized", BindingFlags.Static | BindingFlags.NonPublic);
             : (hue > 1)
                 ? hue - 1
                 : hue;
-    
+
     // HSV to RGB
     {precision}4 K2 = {precision}4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
     {precision}3 P2 = abs(frac(hsv.xxx + K2.xyz) * 6.0 - K2.www);
             : (hue > 1)
                 ? hue - 1
                 : hue;
-    
+
     // HSV to RGB
     {precision}4 K2 = {precision}4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
     {precision}3 P2 = abs(frac(hsv.xxx + K2.xyz) * 6.0 - K2.www);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Artistic/Adjustment/WhiteBalanceNode.cs

-using System.Reflection;
+using System.Reflection;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Artistic/Mask/ChannelMaskNode.cs

-using System.Reflection;
+using System.Reflection;
 using UnityEngine;
 using UnityEditor.Graphing;
 using UnityEditor.ShaderGraph.Drawing.Controls;
             outputString.AddShaderChunk("{", false);
             outputString.Indent();
 
-            switch(channel)
+            switch (channel)
             {
                 case TextureChannel.Green:
                     outputString.AddShaderChunk("Out = In.yyyy;", false);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Artistic/Mask/ColorMaskNode.cs

-using System.Reflection;
+using System.Reflection;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Channel/FlipNode.cs

-using System;
+using System;
 using System.Collections.Generic;
 using UnityEditor.Graphing;
 using UnityEditor.ShaderGraph.Drawing.Controls;
 
         string GetFunctionPrototype(string inArg, string flipArg, string outArg)
         {
-            return string.Format("void {0} ({1} {2}, {3} {4}, out {5} {6})", GetFunctionName(), 
+            return string.Format("void {0} ({1} {2}, {3} {4}, out {5} {6})", GetFunctionName(),
-                ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType), flipArg, 
+                ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType), flipArg,
                 ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType), outArg);
         }
 
             string outputValue = GetSlotValue(OutputSlotId, generationMode);
             visitor.AddShaderChunk(string.Format("{0} {1};", ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType), GetVariableNameForSlot(OutputSlotId)), true);
 
-            if(!generationMode.IsPreview())
+            if (!generationMode.IsPreview())
-                    ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType),
-                    GetVariableNameForNode(),
-                    Convert.ToInt32(m_RedChannel).ToString(),
-                    channelCount > 1 ? string.Format(", {0}", (Convert.ToInt32(m_GreenChannel)).ToString()) : "",
-                    channelCount > 2 ? string.Format(", {0}", (Convert.ToInt32(m_BlueChannel)).ToString()) : "",
-                    channelCount > 3 ? string.Format(", {0}", (Convert.ToInt32(m_AlphaChannel)).ToString()) : ""), true);
+                        ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType),
+                        GetVariableNameForNode(),
+                        Convert.ToInt32(m_RedChannel).ToString(),
+                        channelCount > 1 ? string.Format(", {0}", (Convert.ToInt32(m_GreenChannel)).ToString()) : "",
+                        channelCount > 2 ? string.Format(", {0}", (Convert.ToInt32(m_BlueChannel)).ToString()) : "",
+                        channelCount > 3 ? string.Format(", {0}", (Convert.ToInt32(m_AlphaChannel)).ToString()) : ""), true);
             }
 
             visitor.AddShaderChunk(GetFunctionCallBody(inputValue, string.Format("_{0}_Flip", GetVariableNameForNode()), outputValue), true);
         {
             return GetFunctionName() + " (" + inputValue + ", " + flipValue + ", " + outputValue + ");";
         }
-        
+
         public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
         {
             base.CollectPreviewMaterialProperties(properties);
                 generatePropertyBlock = false
             });
         }
-        
+
         public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
         {
             var outputString = new ShaderGenerator();
             visitor.AddShaderChunk(outputString.GetShaderString(0), true);
         }
     }
-}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Channel/SwizzleNode.cs

 
         string GetFunctionPrototype(string inArg, string outArg)
         {
-            return string.Format("void {0} ({1} {2}, out {3} {4})", GetFunctionName(), 
-                ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType), inArg, 
+            return string.Format("void {0} ({1} {2}, out {3} {4})", GetFunctionName(),
+                ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType), inArg,
                 ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType), outArg);
         }
 
             outputString.Indent();
 
             outputString.AddShaderChunk(string.Format("Out = {0} ({1}, {2}, {3}, {4});",
-                ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType),
-                kInputSlotName + m_ComponentList[m_RedChannel],
-                kInputSlotName + m_ComponentList[m_GreenChannel],
-                kInputSlotName + m_ComponentList[m_BlueChannel],
-                kInputSlotName + m_ComponentList[m_AlphaChannel]), true);
+                    ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType),
+                    kInputSlotName + m_ComponentList[m_RedChannel],
+                    kInputSlotName + m_ComponentList[m_GreenChannel],
+                    kInputSlotName + m_ComponentList[m_BlueChannel],
+                    kInputSlotName + m_ComponentList[m_AlphaChannel]), true);
 
             outputString.Deindent();
             outputString.AddShaderChunk("}", true);
     }
-}
+}

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

                     s = new ColorMaterialSlot(attribute.slotId, par.Name, par.Name, SlotType.Input, attribute.defaultValue ?? Vector4.zero, hidden: attribute.hidden);
                 else if (attribute.binding == Binding.None || par.IsOut)
                     s = MaterialSlot.CreateMaterialSlot(
-                        ConvertTypeToSlotValueType(par),
-                        attribute.slotId,
-                        par.Name,
-                        par.Name,
-                        par.IsOut ? SlotType.Output : SlotType.Input,
-                        attribute.defaultValue ?? Vector4.zero,
-                        hidden: attribute.hidden);
+                            ConvertTypeToSlotValueType(par),
+                            attribute.slotId,
+                            par.Name,
+                            par.Name,
+                            par.IsOut ? SlotType.Output : SlotType.Input,
+                            attribute.defaultValue ?? Vector4.zero,
+                            hidden: attribute.hidden);
                 else
                     s = CreateBoundSlot(attribute.binding, attribute.slotId, par.Name, par.Name, attribute.hidden);
                 slots.Add(s);

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

             get { return PreviewMode.Preview3D; }
         }
     }
-}
+}

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

         IShaderProperty AsShaderProperty();
         int outputSlotId { get; }
     }
-}
+}

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

                 m_Color = color
             });
         }
-        
+
         public IShaderProperty AsShaderProperty()
         {
             var prop = new ColorShaderProperty();

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

-using UnityEngine;
+using UnityEngine;
 using UnityEditor.Graphing;
 
 namespace UnityEditor.ShaderGraph

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

         /*[SerializeField]
         private FloatPropertyChunk.FloatType m_floatType;*/
 
-       // [SerializeField]
+        // [SerializeField]
         //private Vector3 m_rangeValues = new Vector3(0f, 1f, 2f);
 
         public Vector1Node()
 
         public sealed override void UpdateNodeAfterDeserialization()
         {
-            AddSlot(new Vector1MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output,0));
+            AddSlot(new Vector1MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, 0));
             RemoveSlotsNameNotMatching(new[] { OutputSlotId });
         }
 
             }
         }
 
-       /* public FloatPropertyChunk.FloatType floatType
-        {
-            get { return m_floatType; }
-            set
-            {
-                if (m_floatType == value)
-                    return;
+        /* public FloatPropertyChunk.FloatType floatType
+         {
+             get { return m_floatType; }
+             set
+             {
+                 if (m_floatType == value)
+                     return;
-                m_floatType = value;
+                 m_floatType = value;
-                if (onModified != null)
-                    onModified(this, ModificationScope.Node);
-            }
-        }*/
+                 if (onModified != null)
+                     onModified(this, ModificationScope.Node);
+             }
+         }*/
-      /*  public Vector3 rangeValues
-        {
-            get { return m_rangeValues; }
-            set
-            {
-                if (m_rangeValues == value)
-                    return;
+        /*  public Vector3 rangeValues
+          {
+              get { return m_rangeValues; }
+              set
+              {
+                  if (m_rangeValues == value)
+                      return;
-                m_rangeValues = value;
+                  m_rangeValues = value;
-                if (onModified != null)
-                    onModified(this, ModificationScope.Node);
-            }
-        }
-*/
+                  if (onModified != null)
+                      onModified(this, ModificationScope.Node);
+              }
+          }
+  */
         public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
         {
             if (!generationMode.IsPreview())
                 m_Float = m_Value
             });
         }
-
 
         public IShaderProperty AsShaderProperty()
         {

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

 {
     [Title("Input/Basic/Vector 3")]
     public class Vector3Node : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
-    { 
+    {
         [SerializeField]
         private Vector3 m_Value;
 

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

                 m_Vector4 = m_Value
             });
         }
-        
+
         public IShaderProperty AsShaderProperty()
         {
             var prop = new Vector4ShaderProperty();

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

             AddSlot(new Vector3MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, new Vector4(0, 0, 1)));
             RemoveSlotsNameNotMatching(new[] { kOutputSlotId });
         }
-        
+
         public override string GetVariableNameForSlot(int slotId)
         {
             return space.ToVariableName(InterpolatorType.BiTangent);

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

             switch (m_ScreenSpaceType)
             {
                 case ScreenSpaceType.Raw:
-                    visitor.AddShaderChunk(string.Format("{0}4 {1} = {2};", precision, GetVariableNameForSlot(kOutputSlotId), 
+                    visitor.AddShaderChunk(string.Format("{0}4 {1} = {2};", precision, GetVariableNameForSlot(kOutputSlotId),
-                    visitor.AddShaderChunk(string.Format("{0}4 {1} = {2};", precision, GetVariableNameForSlot(kOutputSlotId), 
+                    visitor.AddShaderChunk(string.Format("{0}4 {1} = {2};", precision, GetVariableNameForSlot(kOutputSlotId),
-                    visitor.AddShaderChunk(string.Format("{0}4 {1} = {2};", precision, GetVariableNameForSlot(kOutputSlotId), 
+                    visitor.AddShaderChunk(string.Format("{0}4 {1} = {2};", precision, GetVariableNameForSlot(kOutputSlotId),
-                    visitor.AddShaderChunk(string.Format("{0} = {1};", GetVariableNameForSlot(kOutputSlotId), 
+                    visitor.AddShaderChunk(string.Format("{0} = {1};", GetVariableNameForSlot(kOutputSlotId),
                         "float4(" + ShaderGeneratorNames.ScreenPosition + ".x * _ScreenParams.x / _ScreenParams.y, " + ShaderGeneratorNames.ScreenPosition + ".y, 0, 0)"), true);
                     break;
                 default:

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

         }
 
         void SetRow(ref Vector2 row, Vector2 value)
-            {
+        {
-                    return;
+                return;
-                if (onModified != null)
+            if (onModified != null)
                 onModified(this, ModificationScope.Graph);
         }
 

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

 
         [MultiFloatControl("", " ", " ", " ", " ")]
         public Vector3 row1
-            {
+        {
             get { return m_Row1; }
             set { SetRow(ref m_Row1, value); }
         }
             if (value == row)
                 return;
             row = value;
-                if (onModified != null)
+            if (onModified != null)
                 onModified(this, ModificationScope.Graph);
         }
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Texture/CubemapAssetNode.cs

-using System.Collections.Generic;
+using System.Collections.Generic;
 using UnityEditor.ShaderGraph.Drawing.Controls;
 using UnityEngine;
 using UnityEditor.Graphing;
 
         public int outputSlotId { get { return OutputSlotId; } }
     }
-}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Texture/CubemapNode.cs

         public virtual void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
         {
             string result = string.Format("{0}4 {1} = texCUBElod ({2}, {0}4(reflect(-{3}, {4}), {5}));"
-                        , precision
-                        , GetVariableNameForSlot(OutputSlotId)
-                        , GetSlotValue(CubemapInputId, generationMode)
-                        , GetSlotValue(ViewDirInputId, generationMode)
-                        , GetSlotValue(NormalInputId, generationMode)
-                        , GetSlotValue(LODInputId, generationMode));
+                    , precision
+                    , GetVariableNameForSlot(OutputSlotId)
+                    , GetSlotValue(CubemapInputId, generationMode)
+                    , GetSlotValue(ViewDirInputId, generationMode)
+                    , GetSlotValue(NormalInputId, generationMode)
+                    , GetSlotValue(LODInputId, generationMode));
 
             visitor.AddShaderChunk(result, true);
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Texture/Delete/CubemapNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-   /* [Title("Input/Texture/Cubemap")]
-    public class CubemapNode : PropertyNode, IGeneratesBodyCode, IMayRequireViewDirection, IMayRequireNormal
-    {
-        protected const string kUVSlotName = "RefVector";
-        protected const string kOutputSlotRGBAName = "RGBA";
-        protected const string kOutputSlotRName = "R";
-        protected const string kOutputSlotGName = "G";
-        protected const string kOutputSlotBName = "B";
-        protected const string kOutputSlotAName = "A";
-        protected const string kInputSlotLodName = "MipLevel";
+    /* [Title("Input/Texture/Cubemap")]
+     public class CubemapNode : PropertyNode, IGeneratesBodyCode, IMayRequireViewDirection, IMayRequireNormal
+     {
+         protected const string kUVSlotName = "RefVector";
+         protected const string kOutputSlotRGBAName = "RGBA";
+         protected const string kOutputSlotRName = "R";
+         protected const string kOutputSlotGName = "G";
+         protected const string kOutputSlotBName = "B";
+         protected const string kOutputSlotAName = "A";
+         protected const string kInputSlotLodName = "MipLevel";
-        public const int RefDirSlot = 0;
-        public const int InputSlotLod = 6;
-        public const int OutputSlotRgbaId = 1;
-        public const int OutputSlotRId = 2;
-        public const int OutputSlotGId = 3;
-        public const int OutputSlotBId = 4;
-        public const int OutputSlotAId = 5;
+         public const int RefDirSlot = 0;
+         public const int InputSlotLod = 6;
+         public const int OutputSlotRgbaId = 1;
+         public const int OutputSlotRId = 2;
+         public const int OutputSlotGId = 3;
+         public const int OutputSlotBId = 4;
+         public const int OutputSlotAId = 5;
-        [SerializeField]
-        private string m_SerializedCube;
+         [SerializeField]
+         private string m_SerializedCube;
-        //[SerializeField]
-        //private TextureType m_TextureType;
+         //[SerializeField]
+         //private TextureType m_TextureType;
-        [Serializable]
-        private class CubemapHelper
-        {
-            public Cubemap cube;
-        }
+         [Serializable]
+         private class CubemapHelper
+         {
+             public Cubemap cube;
+         }
-        public override bool hasPreview { get { return true; } }
+         public override bool hasPreview { get { return true; } }
-        #if UNITY_EDITOR
-        public Cubemap defaultCube
-        {
-            get
-            {
-                if (string.IsNullOrEmpty(m_SerializedCube))
-                    return null;
+         #if UNITY_EDITOR
+         public Cubemap defaultCube
+         {
+             get
+             {
+                 if (string.IsNullOrEmpty(m_SerializedCube))
+                     return null;
-                var tex = new CubemapHelper();
-                EditorJsonUtility.FromJsonOverwrite(m_SerializedCube, tex);
-                return tex.cube;
-            }
-            set
-            {
-                if (defaultCube == value)
-                    return;
+                 var tex = new CubemapHelper();
+                 EditorJsonUtility.FromJsonOverwrite(m_SerializedCube, tex);
+                 return tex.cube;
+             }
+             set
+             {
+                 if (defaultCube == value)
+                     return;
-                var tex = new CubemapHelper();
-                tex.cube = value;
-                m_SerializedCube = EditorJsonUtility.ToJson(tex, true);
+                 var tex = new CubemapHelper();
+                 tex.cube = value;
+                 m_SerializedCube = EditorJsonUtility.ToJson(tex, true);
-                if (onModified != null)
-                {
-                    onModified(this, ModificationScope.Node);
-                }
-            }
-        }
-        #else
-        public Cubemap defaultCube {get; set; }
-        #endif
+                 if (onModified != null)
+                 {
+                     onModified(this, ModificationScope.Node);
+                 }
+             }
+         }
+         #else
+         public Cubemap defaultCube {get; set; }
+         #endif
-        public CubemapNode()
-        {
-            name = "Cubemap";
-            UpdateNodeAfterDeserialization();
-        }
+         public CubemapNode()
+         {
+             name = "Cubemap";
+             UpdateNodeAfterDeserialization();
+         }
-        public sealed override void UpdateNodeAfterDeserialization()
-        {
-            AddSlot(new MaterialSlot(OutputSlotRgbaId, kOutputSlotRGBAName, kOutputSlotRGBAName, SlotType.Output, SlotValueType.Vector4, Vector4.zero));
-            AddSlot(new MaterialSlot(OutputSlotRId, kOutputSlotRName, kOutputSlotRName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
-            AddSlot(new MaterialSlot(OutputSlotGId, kOutputSlotGName, kOutputSlotGName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
-            AddSlot(new MaterialSlot(OutputSlotBId, kOutputSlotBName, kOutputSlotBName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
-            AddSlot(new MaterialSlot(OutputSlotAId, kOutputSlotAName, kOutputSlotAName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
-            AddSlot(new MaterialSlot(RefDirSlot, kUVSlotName, kUVSlotName, SlotType.Input, SlotValueType.Vector3, Vector3.zero));
-            AddSlot(new MaterialSlot(InputSlotLod, kInputSlotLodName, kInputSlotLodName, SlotType.Input, SlotValueType.Vector1, Vector2.zero));
-            RemoveSlotsNameNotMatching(validSlots);
-        }
+         public sealed override void UpdateNodeAfterDeserialization()
+         {
+             AddSlot(new MaterialSlot(OutputSlotRgbaId, kOutputSlotRGBAName, kOutputSlotRGBAName, SlotType.Output, SlotValueType.Vector4, Vector4.zero));
+             AddSlot(new MaterialSlot(OutputSlotRId, kOutputSlotRName, kOutputSlotRName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
+             AddSlot(new MaterialSlot(OutputSlotGId, kOutputSlotGName, kOutputSlotGName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
+             AddSlot(new MaterialSlot(OutputSlotBId, kOutputSlotBName, kOutputSlotBName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
+             AddSlot(new MaterialSlot(OutputSlotAId, kOutputSlotAName, kOutputSlotAName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
+             AddSlot(new MaterialSlot(RefDirSlot, kUVSlotName, kUVSlotName, SlotType.Input, SlotValueType.Vector3, Vector3.zero));
+             AddSlot(new MaterialSlot(InputSlotLod, kInputSlotLodName, kInputSlotLodName, SlotType.Input, SlotValueType.Vector1, Vector2.zero));
+             RemoveSlotsNameNotMatching(validSlots);
+         }
-        public override PreviewMode previewMode
-        {
-            get
-            {
-                return PreviewMode.Preview3D;
-            }
-        }
+         public override PreviewMode previewMode
+         {
+             get
+             {
+                 return PreviewMode.Preview3D;
+             }
+         }
-        protected int[] validSlots
-        {
-            get { return new[] {OutputSlotRgbaId, OutputSlotRId, OutputSlotGId, OutputSlotBId, OutputSlotAId, RefDirSlot, InputSlotLod}; }
-        }
+         protected int[] validSlots
+         {
+             get { return new[] {OutputSlotRgbaId, OutputSlotRId, OutputSlotGId, OutputSlotBId, OutputSlotAId, RefDirSlot, InputSlotLod}; }
+         }
-        // Node generations
-        public virtual void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            var uvSlot = FindInputSlot<MaterialSlot>(RefDirSlot);
-            if (uvSlot == null)
-                return;
+         // Node generations
+         public virtual void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+         {
+             var uvSlot = FindInputSlot<MaterialSlot>(RefDirSlot);
+             if (uvSlot == null)
+                 return;
-            var lodID = FindInputSlot<MaterialSlot>(InputSlotLod);
-            if (lodID == null)
-                return;
+             var lodID = FindInputSlot<MaterialSlot>(InputSlotLod);
+             if (lodID == null)
+                 return;
-            var uvName = "reflect(-worldSpaceViewDirection, worldSpaceNormal).xyz";
-            var lodValue = lodID.currentValue.x.ToString();
-            var edgesUV = owner.GetEdges(uvSlot.slotReference).ToList();
-            var edgesLOD = owner.GetEdges(lodID.slotReference).ToList();
+             var uvName = "reflect(-worldSpaceViewDirection, worldSpaceNormal).xyz";
+             var lodValue = lodID.currentValue.x.ToString();
+             var edgesUV = owner.GetEdges(uvSlot.slotReference).ToList();
+             var edgesLOD = owner.GetEdges(lodID.slotReference).ToList();
-            if (edgesUV.Count > 0)
-            {
-                var edge = edgesUV[0];
-                var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(edge.outputSlot.nodeGuid);
-                uvName = ShaderGenerator.AdaptNodeOutput(fromNode, edge.outputSlot.slotId, ConcreteSlotValueType.Vector3, true);
-            }
+             if (edgesUV.Count > 0)
+             {
+                 var edge = edgesUV[0];
+                 var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(edge.outputSlot.nodeGuid);
+                 uvName = ShaderGenerator.AdaptNodeOutput(fromNode, edge.outputSlot.slotId, ConcreteSlotValueType.Vector3, true);
+             }
-            if (edgesLOD.Count > 0)
-            {
-                var edge = edgesLOD[0];
-                var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(edge.outputSlot.nodeGuid);
-                lodValue = GetSlotValue(edge.inputSlot.slotId, GenerationMode.ForReals);
-            }
-            //reflect(-IN.worldViewDir, normalize(IN.worldNormal)).xyz
-            string body = "texCUBElod (" + propertyName + ", " + precision + "4(" + uvName + "," + lodValue + "))";
-            visitor.AddShaderChunk(precision + "4 " + GetVariableNameForNode() + " = " + body + ";", true);
-        }
+             if (edgesLOD.Count > 0)
+             {
+                 var edge = edgesLOD[0];
+                 var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(edge.outputSlot.nodeGuid);
+                 lodValue = GetSlotValue(edge.inputSlot.slotId, GenerationMode.ForReals);
+             }
+             //reflect(-IN.worldViewDir, normalize(IN.worldNormal)).xyz
+             string body = "texCUBElod (" + propertyName + ", " + precision + "4(" + uvName + "," + lodValue + "))";
+             visitor.AddShaderChunk(precision + "4 " + GetVariableNameForNode() + " = " + body + ";", true);
+         }
-        public override string GetVariableNameForSlot(int slotId)
-        {
-            string slotOutput;
-            switch (slotId)
-            {
-                case OutputSlotRId:
-                    slotOutput = ".r";
-                    break;
-                case InputSlotLod:
-                    slotOutput = "_lod";
-                    break;
-                case RefDirSlot:
-                    slotOutput = "_RefDir";
-                    break;
-                case OutputSlotGId:
-                    slotOutput = ".g";
-                    break;
-                case OutputSlotBId:
-                    slotOutput = ".b";
-                    break;
-                case OutputSlotAId:
-                    slotOutput = ".a";
-                    break;
-                default:
-                    slotOutput = "";
-                    break;
-            }
-            return GetVariableNameForNode() + slotOutput;
-        }
+         public override string GetVariableNameForSlot(int slotId)
+         {
+             string slotOutput;
+             switch (slotId)
+             {
+                 case OutputSlotRId:
+                     slotOutput = ".r";
+                     break;
+                 case InputSlotLod:
+                     slotOutput = "_lod";
+                     break;
+                 case RefDirSlot:
+                     slotOutput = "_RefDir";
+                     break;
+                 case OutputSlotGId:
+                     slotOutput = ".g";
+                     break;
+                 case OutputSlotBId:
+                     slotOutput = ".b";
+                     break;
+                 case OutputSlotAId:
+                     slotOutput = ".a";
+                     break;
+                 default:
+                     slotOutput = "";
+                     break;
+             }
+             return GetVariableNameForNode() + slotOutput;
+         }
-        public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
-        {
-            properties.Add(GetPreviewProperty());
-        }
+         public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
+         {
+             properties.Add(GetPreviewProperty());
+         }
-        // Properties
-        public override void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)
-        {
-            visitor.AddShaderProperty(
-                new CubemapPropertyChunk(
-                    propertyName,
-                    description,
-                    defaultCube,
-                    PropertyChunk.HideState.Visible,
-                    exposedState == ExposedState.Exposed ?
-                    CubemapPropertyChunk.ModifiableState.Modifiable
-                    : CubemapPropertyChunk.ModifiableState.NonModifiable));
-        }
+         // Properties
+         public override void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)
+         {
+             visitor.AddShaderProperty(
+                 new CubemapPropertyChunk(
+                     propertyName,
+                     description,
+                     defaultCube,
+                     PropertyChunk.HideState.Visible,
+                     exposedState == ExposedState.Exposed ?
+                     CubemapPropertyChunk.ModifiableState.Modifiable
+                     : CubemapPropertyChunk.ModifiableState.NonModifiable));
+         }
-        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            visitor.AddShaderChunk("samplerCUBE " + propertyName + ";", true);
-        }
+         public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+         {
+             visitor.AddShaderChunk("samplerCUBE " + propertyName + ";", true);
+         }
-        public override PreviewProperty GetPreviewProperty()
-        {
-            return new PreviewProperty
-            {
-                m_Name = propertyName,
-                m_PropType = PropertyType.Cubemap,
-                m_Cubemap = defaultCube
-            };
-        }
+         public override PreviewProperty GetPreviewProperty()
+         {
+             return new PreviewProperty
+             {
+                 m_Name = propertyName,
+                 m_PropType = PropertyType.Cubemap,
+                 m_Cubemap = defaultCube
+             };
+         }
-        public override PropertyType propertyType { get { return PropertyType.Cubemap; } }
+         public override PropertyType propertyType { get { return PropertyType.Cubemap; } }
-        public bool RequiresViewDirection()
-        {
-            return true;
-        }
+         public bool RequiresViewDirection()
+         {
+             return true;
+         }
-        public bool RequiresNormal()
-        {
-            return true;
-        }
-    }*/
+         public bool RequiresNormal()
+         {
+             return true;
+         }
+     }*/
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Texture/Delete/TextureLODNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
- /*   [Title("Input/Texture/TextureLOD")]
-    public class TextureLODNode : PropertyNode, IGeneratesBodyCode, IMayRequireMeshUV
-    {
-        protected const string kUVSlotName = "UV";
-        protected const string kLODSlotName = "MipMap Level";
-        protected const string kOutputSlotRGBAName = "RGBA";
-        protected const string kOutputSlotRName = "R";
-        protected const string kOutputSlotGName = "G";
-        protected const string kOutputSlotBName = "B";
-        protected const string kOutputSlotAName = "A";
+    /*   [Title("Input/Texture/TextureLOD")]
+       public class TextureLODNode : PropertyNode, IGeneratesBodyCode, IMayRequireMeshUV
+       {
+           protected const string kUVSlotName = "UV";
+           protected const string kLODSlotName = "MipMap Level";
+           protected const string kOutputSlotRGBAName = "RGBA";
+           protected const string kOutputSlotRName = "R";
+           protected const string kOutputSlotGName = "G";
+           protected const string kOutputSlotBName = "B";
+           protected const string kOutputSlotAName = "A";
-        public const int UvSlotId = 0;
-        public const int LODSlotId = 1;
-        public const int OutputSlotRgbaId = 2;
-        public const int OutputSlotRId = 3;
-        public const int OutputSlotGId = 4;
-        public const int OutputSlotBId = 5;
-        public const int OutputSlotAId = 6;
+           public const int UvSlotId = 0;
+           public const int LODSlotId = 1;
+           public const int OutputSlotRgbaId = 2;
+           public const int OutputSlotRId = 3;
+           public const int OutputSlotGId = 4;
+           public const int OutputSlotBId = 5;
+           public const int OutputSlotAId = 6;
-        [SerializeField]
-        private string m_SerializedTexture;
+           [SerializeField]
+           private string m_SerializedTexture;
-        [SerializeField]
-        private TextureType m_TextureType;
+           [SerializeField]
+           private TextureType m_TextureType;
-        [Serializable]
-        private class TextureHelper
-        {
-            public Texture texture;
-        }
+           [Serializable]
+           private class TextureHelper
+           {
+               public Texture texture;
+           }
-        public override bool hasPreview { get { return true; } }
+           public override bool hasPreview { get { return true; } }
-#if UNITY_EDITOR
-        public Texture defaultTexture
-        {
-            get
-            {
-                if (string.IsNullOrEmpty(m_SerializedTexture))
-                    return null;
+   #if UNITY_EDITOR
+           public Texture defaultTexture
+           {
+               get
+               {
+                   if (string.IsNullOrEmpty(m_SerializedTexture))
+                       return null;
-                var tex = new TextureHelper();
-                EditorJsonUtility.FromJsonOverwrite(m_SerializedTexture, tex);
-                return tex.texture;
-            }
-            set
-            {
-                if (defaultTexture == value)
-                    return;
+                   var tex = new TextureHelper();
+                   EditorJsonUtility.FromJsonOverwrite(m_SerializedTexture, tex);
+                   return tex.texture;
+               }
+               set
+               {
+                   if (defaultTexture == value)
+                       return;
-                var tex = new TextureHelper();
-                tex.texture = value;
-                m_SerializedTexture = EditorJsonUtility.ToJson(tex, true);
+                   var tex = new TextureHelper();
+                   tex.texture = value;
+                   m_SerializedTexture = EditorJsonUtility.ToJson(tex, true);
-                if (onModified != null)
-                {
-                    onModified(this, ModificationScope.Node);
-                }
-            }
-        }
-#else
-        public Texture defaultTexture { get; set; }
-#endif
+                   if (onModified != null)
+                   {
+                       onModified(this, ModificationScope.Node);
+                   }
+               }
+           }
+   #else
+           public Texture defaultTexture { get; set; }
+   #endif
-        public TextureType textureType
-        {
-            get { return m_TextureType; }
-            set
-            {
-                if (m_TextureType == value)
-                    return;
+           public TextureType textureType
+           {
+               get { return m_TextureType; }
+               set
+               {
+                   if (m_TextureType == value)
+                       return;
-                m_TextureType = value;
-                if (onModified != null)
-                {
-                    onModified(this, ModificationScope.Graph);
-                }
-            }
-        }
+                   m_TextureType = value;
+                   if (onModified != null)
+                   {
+                       onModified(this, ModificationScope.Graph);
+                   }
+               }
+           }
-        public TextureLODNode()
-        {
-            name = "TextureLOD";
-            UpdateNodeAfterDeserialization();
-        }
+           public TextureLODNode()
+           {
+               name = "TextureLOD";
+               UpdateNodeAfterDeserialization();
+           }
-        public sealed override void UpdateNodeAfterDeserialization()
-        {
-            AddSlot(new MaterialSlot(OutputSlotRgbaId, kOutputSlotRGBAName, kOutputSlotRGBAName, SlotType.Output, SlotValueType.Vector4, Vector4.zero));
-            AddSlot(new MaterialSlot(OutputSlotRId, kOutputSlotRName, kOutputSlotRName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
-            AddSlot(new MaterialSlot(OutputSlotGId, kOutputSlotGName, kOutputSlotGName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
-            AddSlot(new MaterialSlot(OutputSlotBId, kOutputSlotBName, kOutputSlotBName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
-            AddSlot(new MaterialSlot(OutputSlotAId, kOutputSlotAName, kOutputSlotAName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
-            AddSlot(new MaterialSlot(UvSlotId, kUVSlotName, kUVSlotName, SlotType.Input, SlotValueType.Vector2, Vector4.zero));
-            AddSlot(new MaterialSlot(LODSlotId, kLODSlotName, kLODSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero));
-            RemoveSlotsNameNotMatching(validSlots);
-        }
+           public sealed override void UpdateNodeAfterDeserialization()
+           {
+               AddSlot(new MaterialSlot(OutputSlotRgbaId, kOutputSlotRGBAName, kOutputSlotRGBAName, SlotType.Output, SlotValueType.Vector4, Vector4.zero));
+               AddSlot(new MaterialSlot(OutputSlotRId, kOutputSlotRName, kOutputSlotRName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
+               AddSlot(new MaterialSlot(OutputSlotGId, kOutputSlotGName, kOutputSlotGName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
+               AddSlot(new MaterialSlot(OutputSlotBId, kOutputSlotBName, kOutputSlotBName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
+               AddSlot(new MaterialSlot(OutputSlotAId, kOutputSlotAName, kOutputSlotAName, SlotType.Output, SlotValueType.Vector1, Vector4.zero));
+               AddSlot(new MaterialSlot(UvSlotId, kUVSlotName, kUVSlotName, SlotType.Input, SlotValueType.Vector2, Vector4.zero));
+               AddSlot(new MaterialSlot(LODSlotId, kLODSlotName, kLODSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero));
+               RemoveSlotsNameNotMatching(validSlots);
+           }
-        protected int[] validSlots
-        {
-            get { return new[] { OutputSlotRgbaId, OutputSlotRId, OutputSlotGId, OutputSlotBId, OutputSlotAId, UvSlotId, LODSlotId }; }
-        }
+           protected int[] validSlots
+           {
+               get { return new[] { OutputSlotRgbaId, OutputSlotRId, OutputSlotGId, OutputSlotBId, OutputSlotAId, UvSlotId, LODSlotId }; }
+           }
-        // Node generations
-        public virtual void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            var uvSlot = FindInputSlot<MaterialSlot>(UvSlotId);
-            var lodSlot = FindInputSlot<MaterialSlot>(LODSlotId);
+           // Node generations
+           public virtual void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+           {
+               var uvSlot = FindInputSlot<MaterialSlot>(UvSlotId);
+               var lodSlot = FindInputSlot<MaterialSlot>(LODSlotId);
-            if (uvSlot == null)
-                return;
+               if (uvSlot == null)
+                   return;
-            if (lodSlot == null)
-                return;
+               if (lodSlot == null)
+                   return;
-            var uvName = string.Format("{0}", UVChannel.uv0.GetUVName());
-            var lodName = "";
+               var uvName = string.Format("{0}", UVChannel.uv0.GetUVName());
+               var lodName = "";
-            var edges = owner.GetEdges(uvSlot.slotReference).ToList();
-            var edgesLOD = owner.GetEdges(lodSlot.slotReference).ToList();
+               var edges = owner.GetEdges(uvSlot.slotReference).ToList();
+               var edgesLOD = owner.GetEdges(lodSlot.slotReference).ToList();
-            if (edges.Count > 0)
-            {
-                var edge = edges[0];
-                var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(edge.outputSlot.nodeGuid);
-                uvName = ShaderGenerator.AdaptNodeOutput(fromNode, edge.outputSlot.slotId, ConcreteSlotValueType.Vector2, true);
-            }
+               if (edges.Count > 0)
+               {
+                   var edge = edges[0];
+                   var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(edge.outputSlot.nodeGuid);
+                   uvName = ShaderGenerator.AdaptNodeOutput(fromNode, edge.outputSlot.slotId, ConcreteSlotValueType.Vector2, true);
+               }
-            if (edgesLOD.Count > 0)
-            {
-                var edge = edgesLOD[0];
-                var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(edge.outputSlot.nodeGuid);
-                lodName = ShaderGenerator.AdaptNodeOutput(fromNode, edge.outputSlot.slotId, ConcreteSlotValueType.Vector1, true);
-            }
-            //if no input is specified, default to mipmap 0
-            else
-                lodName = "0";
+               if (edgesLOD.Count > 0)
+               {
+                   var edge = edgesLOD[0];
+                   var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(edge.outputSlot.nodeGuid);
+                   lodName = ShaderGenerator.AdaptNodeOutput(fromNode, edge.outputSlot.slotId, ConcreteSlotValueType.Vector1, true);
+               }
+               //if no input is specified, default to mipmap 0
+               else
+                   lodName = "0";
-            string body = "tex2Dlod (" + propertyName + ", " + precision + "4(" + uvName + ".x," + uvName + ".y, 0," + lodName + "));";
-            if (m_TextureType == TextureType.Bump)
-                body = precision + "4(UnpackNormal(" + body + "), 0)";
-            visitor.AddShaderChunk(precision + "4 " + GetVariableNameForNode() + " = " + body + ";", true);
-        }
+               string body = "tex2Dlod (" + propertyName + ", " + precision + "4(" + uvName + ".x," + uvName + ".y, 0," + lodName + "));";
+               if (m_TextureType == TextureType.Bump)
+                   body = precision + "4(UnpackNormal(" + body + "), 0)";
+               visitor.AddShaderChunk(precision + "4 " + GetVariableNameForNode() + " = " + body + ";", true);
+           }
-        public override string GetVariableNameForSlot(int slotId)
-        {
-            string slotOutput;
-            switch (slotId)
-            {
-                case OutputSlotRId:
-                    slotOutput = ".r";
-                    break;
-                case OutputSlotGId:
-                    slotOutput = ".g";
-                    break;
-                case OutputSlotBId:
-                    slotOutput = ".b";
-                    break;
-                case OutputSlotAId:
-                    slotOutput = ".a";
-                    break;
-                default:
-                    slotOutput = "";
-                    break;
-            }
-            return GetVariableNameForNode() + slotOutput;
-        }
+           public override string GetVariableNameForSlot(int slotId)
+           {
+               string slotOutput;
+               switch (slotId)
+               {
+                   case OutputSlotRId:
+                       slotOutput = ".r";
+                       break;
+                   case OutputSlotGId:
+                       slotOutput = ".g";
+                       break;
+                   case OutputSlotBId:
+                       slotOutput = ".b";
+                       break;
+                   case OutputSlotAId:
+                       slotOutput = ".a";
+                       break;
+                   default:
+                       slotOutput = "";
+                       break;
+               }
+               return GetVariableNameForNode() + slotOutput;
+           }
-        public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
-        {
-            properties.Add(GetPreviewProperty());
-        }
+           public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
+           {
+               properties.Add(GetPreviewProperty());
+           }
-        // Properties
-        public override void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)
-        {
-            visitor.AddShaderProperty(
-                new TexturePropertyChunk(
-                    propertyName,
-                    description,
-                    defaultTexture, m_TextureType,
-                    PropertyChunk.HideState.Visible,
-                    exposedState == ExposedState.Exposed ?
-                    TexturePropertyChunk.ModifiableState.Modifiable
-                    : TexturePropertyChunk.ModifiableState.NonModifiable));
-        }
+           // Properties
+           public override void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)
+           {
+               visitor.AddShaderProperty(
+                   new TexturePropertyChunk(
+                       propertyName,
+                       description,
+                       defaultTexture, m_TextureType,
+                       PropertyChunk.HideState.Visible,
+                       exposedState == ExposedState.Exposed ?
+                       TexturePropertyChunk.ModifiableState.Modifiable
+                       : TexturePropertyChunk.ModifiableState.NonModifiable));
+           }
-        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            visitor.AddShaderChunk("sampler2D " + propertyName + ";", true);
-        }
+           public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+           {
+               visitor.AddShaderChunk("sampler2D " + propertyName + ";", true);
+           }
-        /*
-            public override bool DrawSlotDefaultInput(Rect rect, Slot inputSlot)
-            {
-                var uvSlot = FindInputSlot(kUVSlotName);
-                if (uvSlot != inputSlot)
-                    return base.DrawSlotDefaultInput(rect, inputSlot);
+           /*
+               public override bool DrawSlotDefaultInput(Rect rect, Slot inputSlot)
+               {
+                   var uvSlot = FindInputSlot(kUVSlotName);
+                   if (uvSlot != inputSlot)
+                       return base.DrawSlotDefaultInput(rect, inputSlot);
-                var rectXmax = rect.xMax;
-                rect.x = rectXmax - 70;
-                rect.width = 70;
+                   var rectXmax = rect.xMax;
+                   rect.x = rectXmax - 70;
+                   rect.width = 70;
-                EditorGUI.DrawRect(rect, new Color(0.0f, 0.0f, 0.0f, 0.7f));
-                GUI.Label(rect, "From Mesh");
+                   EditorGUI.DrawRect(rect, new Color(0.0f, 0.0f, 0.0f, 0.7f));
+                   GUI.Label(rect, "From Mesh");
-                return false;
-            }
-            *
+                   return false;
+               }
+               *
-        public override PreviewProperty GetPreviewProperty()
-        {
-            return new PreviewProperty
-            {
-                m_Name = propertyName,
-                m_PropType = PropertyType.Texture,
-                m_Texture = defaultTexture
-            };
-        }
+           public override PreviewProperty GetPreviewProperty()
+           {
+               return new PreviewProperty
+               {
+                   m_Name = propertyName,
+                   m_PropType = PropertyType.Texture,
+                   m_Texture = defaultTexture
+               };
+           }
-        public override PropertyType propertyType { get { return PropertyType.Texture; } }
+           public override PropertyType propertyType { get { return PropertyType.Texture; } }
-        public bool RequiresMeshUV(UVChannel channel)
-        {
-            if (channel != UVChannel.uv0)
-            {
-                return false;
-            }
+           public bool RequiresMeshUV(UVChannel channel)
+           {
+               if (channel != UVChannel.uv0)
+               {
+                   return false;
+               }
-            var uvSlot = FindInputSlot<MaterialSlot>(UvSlotId);
-            if (uvSlot == null)
-                return true;
+               var uvSlot = FindInputSlot<MaterialSlot>(UvSlotId);
+               if (uvSlot == null)
+                   return true;
-            var edges = owner.GetEdges(uvSlot.slotReference).ToList();
-            return edges.Count == 0;
-        }
-    }*/
+               var edges = owner.GetEdges(uvSlot.slotReference).ToList();
+               return edges.Count == 0;
+           }
+       }*/
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Texture/Delete/TextureNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Texture/SamplerStateNode.cs

             {
                 overrideReferenceName = GetVariableNameForNode(),
                 generatePropertyBlock = false,
-                
+
                 value = new TextureSamplerState()
                 {
                     filter = m_filter,

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Texture/Texture2DAssetNode.cs

-using System.Collections.Generic;
+using System.Collections.Generic;
 using UnityEditor.ShaderGraph.Drawing.Controls;
 using UnityEngine;
 using UnityEditor.Graphing;
 
         public int outputSlotId { get { return OutputSlotId; } }
     }
-}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Texture/Texture2DNode.cs

         public sealed override void UpdateNodeAfterDeserialization()
         {
             AddSlot(new Vector4MaterialSlot(OutputSlotRGBAId, kOutputSlotRGBAName, kOutputSlotRGBAName, SlotType.Output, Vector4.zero));
-            AddSlot(new Vector1MaterialSlot(OutputSlotRId, kOutputSlotRName, kOutputSlotRName, SlotType.Output,0));
+            AddSlot(new Vector1MaterialSlot(OutputSlotRId, kOutputSlotRName, kOutputSlotRName, SlotType.Output, 0));
             AddSlot(new Vector1MaterialSlot(OutputSlotGId, kOutputSlotGName, kOutputSlotGName, SlotType.Output, 0));
             AddSlot(new Vector1MaterialSlot(OutputSlotBId, kOutputSlotBName, kOutputSlotBName, SlotType.Output, 0));
             AddSlot(new Vector1MaterialSlot(OutputSlotAId, kOutputSlotAName, kOutputSlotAName, SlotType.Output, 0));
             visitor.AddShaderChunk(result, true);
 
             if (textureType == TextureType.Normal)
-                visitor.AddShaderChunk(string.Format("{0}.rgb = UnpackNormal({0});", GetVariableNameForSlot(OutputSlotRGBAId)), true);                
+                visitor.AddShaderChunk(string.Format("{0}.rgb = UnpackNormal({0});", GetVariableNameForSlot(OutputSlotRGBAId)), true);
 
             visitor.AddShaderChunk(string.Format("{0} {1} = {2}.r;", precision, GetVariableNameForSlot(OutputSlotRId), GetVariableNameForSlot(OutputSlotRGBAId)), true);
             visitor.AddShaderChunk(string.Format("{0} {1} = {2}.g;", precision, GetVariableNameForSlot(OutputSlotGId), GetVariableNameForSlot(OutputSlotRGBAId)), true);

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

         public SurfaceMaterialOptions options
         {
             get { return m_MaterialOptions; }
-
         }
 
         public abstract string GetShader(GenerationMode mode, string name, out List<PropertyCollector.TextureInfo> configuredTextures);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Advanced/ExponentialNode.cs

         }
 
         static string Unity_Exponential2(
-    [Slot(0, Binding.None)] DynamicDimensionVector In,
-    [Slot(1, Binding.None)] out DynamicDimensionVector Out)
+            [Slot(0, Binding.None)] DynamicDimensionVector In,
+            [Slot(1, Binding.None)] out DynamicDimensionVector Out)
         {
             return
                 @"

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

                 }
             }
         }
-        
+
         public override bool hasPreview
         {
             get { return true; }
             }
 
             if (requiresTangentTransform)
-                visitor.AddShaderChunk("float3x3 tangentTransform = float3x3("+ spaceFrom.ToString() + "SpaceTangent, "+ spaceFrom.ToString() + "SpaceBiTangent, "+ spaceFrom.ToString() + "SpaceNormal);", false);
+                visitor.AddShaderChunk("float3x3 tangentTransform = float3x3(" + spaceFrom.ToString() + "SpaceTangent, " + spaceFrom.ToString() + "SpaceBiTangent, " + spaceFrom.ToString() + "SpaceNormal);", false);
-                ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType), 
-                GetVariableNameForSlot(OutputSlotId),
-                transformString), true);
+                    ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType),
+                    GetVariableNameForSlot(OutputSlotId),
+                    transformString), true);
         }
 
         public NeededCoordinateSpace RequiresTangent()

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

-using System.Reflection;
+using System.Reflection;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Procedural/CheckerboardNode.cs

         {
             name = "Checkerboard";
         }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Checkerboard", BindingFlags.Static | BindingFlags.NonPublic);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Procedural/MakeSubgraph/RepeatingDotNode.cs

         static string Unity_Repreatingdot(
             [Slot(0, Binding.MeshUV0)] Vector2 UV,
             [Slot(1, Binding.None, 4.0f, 4.0f, 4.0f, 4.0f)] Vector1 Count,
-            [Slot(2, Binding.None, 0.5f,0.5f,0.5f,0.5f)] Vector1 Radius,
+            [Slot(2, Binding.None, 0.5f, 0.5f, 0.5f, 0.5f)] Vector1 Radius,
             [Slot(4, Binding.None)] out Vector1 Out)
         {
             return

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Procedural/NoiseNode.cs

 
         static string Unity_Noise(
             [Slot(0, Binding.MeshUV0)] Vector2 UV,
-            [Slot(1, Binding.None,500f,500f,500f,500f)] Vector1 Scale,
+            [Slot(1, Binding.None, 500f, 500f, 500f, 500f)] Vector1 Scale,
             [Slot(2, Binding.None)] out Vector1 Out)
         {
             return

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Procedural/VoronoiNoise.cs

         static string Unity_VoronoiNoise(
             [Slot(0, Binding.MeshUV0)] Vector2 UV,
             [Slot(1, Binding.None, 2.0f, 0, 0, 0)] Vector1 AngleOffset,
-            [Slot(2, Binding.None,5.0f,5.0f,5.0f,5.0f)] Vector1 CellDensity,
+            [Slot(2, Binding.None, 5.0f, 5.0f, 5.0f, 5.0f)] Vector1 CellDensity,
             [Slot(3, Binding.None)] out Vector1 Out,
             [Slot(4, Binding.None)] out Vector1 Cells)
         {

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

             if (property is FloatShaderProperty)
             {
                 var result = string.Format("{0} {1} = {2};"
-                    , precision
-                    , GetVariableNameForSlot(OutputSlotId)
-                    , property.referenceName);
+                        , precision
+                        , GetVariableNameForSlot(OutputSlotId)
+                        , property.referenceName);
-                    , precision
-                    , GetVariableNameForSlot(OutputSlotId)
-                    , property.referenceName);
+                        , precision
+                        , GetVariableNameForSlot(OutputSlotId)
+                        , property.referenceName);
-                    , precision
-                    , GetVariableNameForSlot(OutputSlotId)
-                    , property.referenceName);
+                        , precision
+                        , GetVariableNameForSlot(OutputSlotId)
+                        , property.referenceName);
-                    , precision
-                    , GetVariableNameForSlot(OutputSlotId)
-                    , property.referenceName);
+                        , precision
+                        , GetVariableNameForSlot(OutputSlotId)
+                        , property.referenceName);
-                    , precision
-                    , GetVariableNameForSlot(OutputSlotId)
-                    , property.referenceName);
+                        , precision
+                        , GetVariableNameForSlot(OutputSlotId)
+                        , property.referenceName);
                 visitor.AddShaderChunk(result, true);
             }
         }

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

-using System;
+using System;
 
 namespace UnityEditor.ShaderGraph
 {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/UV/RadialShearNode.cs

         {
             name = "Radial Shear";
         }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_RadialShear", BindingFlags.Static | BindingFlags.NonPublic);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/UV/RotateNode.cs

     [Title("UV/Rotate")]
     public class RotateNode : CodeFunctionNode
     {
-
         [SerializeField]
         private RotationUnit m_Unit = RotationUnit.Radians;
 
 
         protected override MethodInfo GetFunctionToConvert()
         {
-            if(m_Unit == RotationUnit.Radians)
+            if (m_Unit == RotationUnit.Radians)
                 return GetType().GetMethod("Unity_Rotate_Radians", BindingFlags.Static | BindingFlags.NonPublic);
             else
                 return GetType().GetMethod("Unity_Rotate_Degrees", BindingFlags.Static | BindingFlags.NonPublic);
         {
             Out = Vector2.zero;
 
-            
+
             return
                 @"
 {
     //multiply the UVs by the rotation matrix
     UV.xy = mul(UV.xy, rMatrix);
     UV += Center;
-    
+
     Out = UV;
 }";
         }
             [Slot(3, Binding.None)] out Vector2 Out)
         {
             Out = Vector2.zero;
-           
+
             return @"
 {
     //rotation matrix
     //multiply the UVs by the rotation matrix
     UV.xy = mul(UV.xy, rMatrix);
     UV += Center;
-    
+
-
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/UV/SpherizeNode.cs

         {
             name = "Spherize";
         }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_Spherize", BindingFlags.Static | BindingFlags.NonPublic);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/UV/TilingAndOffsetNode.cs

         {
             name = "Tiling And Offset";
         }
+
         protected override MethodInfo GetFunctionToConvert()
         {
             return GetType().GetMethod("Unity_TilingAndOffset", BindingFlags.Static | BindingFlags.NonPublic);

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

-using UnityEngine;
+using UnityEngine;
 using UnityEditor.Graphing;
 
 namespace UnityEditor.ShaderGraph

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Remapper/MasterRemapGraphAsset.cs

 
 namespace UnityEditor.ShaderGraph
 {
-     public class MasterRemapGraphAsset : ScriptableObject
-     {
-         [SerializeField]
-         private MasterRemapGraph m_RemapGraph = new MasterRemapGraph();
+    public class MasterRemapGraphAsset : ScriptableObject
+    {
+        [SerializeField]
+        private MasterRemapGraph m_RemapGraph = new MasterRemapGraph();
-         public MasterRemapGraph remapGraph
-         {
-             get { return m_RemapGraph; }
-             set { m_RemapGraph = value; }
-         }
-     }
-
+        public MasterRemapGraph remapGraph
+        {
+            get { return m_RemapGraph; }
+            set { m_RemapGraph = value; }
+        }
+    }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/SubGraph/AbstractSubGraph.cs

-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/SubGraph/AbstractSubGraphNode.cs

-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEngine;
         , IMayRequireVertexColor
         , IMayRequireTime
     {
-
         protected abstract AbstractSubGraph referencedGraph { get; }
 
         public override bool hasPreview
                 return NeededCoordinateSpace.None;
 
             return referencedGraph.activeNodes.OfType<IMayRequireNormal>().Aggregate(NeededCoordinateSpace.None, (mask, node) =>
-            {
-                mask |= node.RequiresNormal();
-                return mask;
-            });
+                {
+                    mask |= node.RequiresNormal();
+                    return mask;
+                });
         }
 
         public bool RequiresMeshUV(UVChannel channel)
                 return NeededCoordinateSpace.None;
 
             return referencedGraph.activeNodes.OfType<IMayRequireViewDirection>().Aggregate(NeededCoordinateSpace.None, (mask, node) =>
-            {
-                mask |= node.RequiresViewDirection();
-                return mask;
-            });
+                {
+                    mask |= node.RequiresViewDirection();
+                    return mask;
+                });
-
 
         public NeededCoordinateSpace RequiresPosition()
         {
             return referencedGraph.activeNodes.OfType<IMayRequirePosition>().Aggregate(NeededCoordinateSpace.None, (mask, node) =>
-            {
-                mask |= node.RequiresPosition();
-                return mask;
-            });
+                {
+                    mask |= node.RequiresPosition();
+                    return mask;
+                });
         }
 
         public NeededCoordinateSpace RequiresTangent()
 
             return referencedGraph.activeNodes.OfType<IMayRequireTangent>().Aggregate(NeededCoordinateSpace.None, (mask, node) =>
-            {
-                mask |= node.RequiresTangent();
-                return mask;
-            });
+                {
+                    mask |= node.RequiresTangent();
+                    return mask;
+                });
         }
 
         public bool RequiresTime()
                 return NeededCoordinateSpace.None;
 
             return referencedGraph.activeNodes.OfType<IMayRequireBitangent>().Aggregate(NeededCoordinateSpace.None, (mask, node) =>
-            {
-                mask |= node.RequiresBitangent();
-                return mask;
-            });
+                {
+                    mask |= node.RequiresBitangent();
+                    return mask;
+                });
         }
 
         public bool RequiresVertexColor()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/SubGraph/LayerWeightsOutputNode.cs

-using System;
+using System;
 using System.Collections.Generic;
 using UnityEditor.Graphing;
 
             var goodSlots =  new List<int>();
             foreach (var layer in layeredGraph.layers)
             {
-                AddSlot(new Vector1MaterialSlot(layer.guid.GetHashCode(), LayeredShaderGraph.LayerToFunctionName(layer.guid), LayeredShaderGraph.LayerToFunctionName(layer.guid), SlotType.Input,0));
+                AddSlot(new Vector1MaterialSlot(layer.guid.GetHashCode(), LayeredShaderGraph.LayerToFunctionName(layer.guid), LayeredShaderGraph.LayerToFunctionName(layer.guid), SlotType.Input, 0));
                 goodSlots.Add(layer.guid.GetHashCode());
             }
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/SubGraph/LayeredShaderGraph.cs

-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
             [SerializeField]
             private Shader m_Shader;
 
-            public Layer() { }
+            public Layer() {}
 
             public Guid guid
             {
                 }
 
                 var masterNode = baseGraph.masterNode;
-                GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, ((AbstractMaterialNode) masterNode).GetInputSlots<MaterialSlot>().ToList(), true);
+                GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, ((AbstractMaterialNode)masterNode).GetInputSlots<MaterialSlot>().ToList(), true);
-              /*  foreach (var layer in layerMap)
-                {
-                    activeNodes.Clear();
-                    NodeUtils.DepthFirstCollectNodesFromNode(activeNodes, layer.Value.masterNode as AbstractMaterialNode);
-                    GenerateSurfaceDescription(
-                        activeNodes,
-                        layer.Value.masterNode as AbstractMaterialNode,
-                        this,
-                        surfaceDescriptionFunction,
-                        shaderFunctionVisitor,
-                        shaderProperties,
-                        requirements,
-                        mode,
-                        LayerToFunctionName(layer.Key));
-                }*/
+                /*  foreach (var layer in layerMap)
+                  {
+                      activeNodes.Clear();
+                      NodeUtils.DepthFirstCollectNodesFromNode(activeNodes, layer.Value.masterNode as AbstractMaterialNode);
+                      GenerateSurfaceDescription(
+                          activeNodes,
+                          layer.Value.masterNode as AbstractMaterialNode,
+                          this,
+                          surfaceDescriptionFunction,
+                          shaderFunctionVisitor,
+                          shaderProperties,
+                          requirements,
+                          mode,
+                          LayerToFunctionName(layer.Key));
+                  }*/
 
                 surfaceDescriptionStruct.AddShaderChunk("struct WeightsSurfaceDescription{", false);
                 surfaceDescriptionStruct.Indent();
                 if (masterNode != null)
                 {
                     //var subShaders = masterNode.GetSubshader(requirements, null);
-                   // foreach (var ss in subShaders)
+                    // foreach (var ss in subShaders)
                     //    finalShader.AddShaderChunk(ss, false);
                 }
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/SubGraph/SubGraph.cs

                 return nodes.OfType<AbstractMaterialNode>();
             }
         }
-
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/SurfaceModel/ExportTextureMasterNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
- /*   [Serializable]
-    [Title("Master/Custom Texture")]
-    public class ExportTextureMasterNode : MasterNode
-    {
-        public const string ColorSlotName = "Color";
-        public const int ColorSlotId = 0;
+    /*   [Serializable]
+       [Title("Master/Custom Texture")]
+       public class ExportTextureMasterNode : MasterNode
+       {
+           public const string ColorSlotName = "Color";
+           public const int ColorSlotId = 0;
-        public ExportTextureMasterNode()
-        {
-            name = "ExportTextureMasterNode";
-            UpdateNodeAfterDeserialization();
-        }
+           public ExportTextureMasterNode()
+           {
+               name = "ExportTextureMasterNode";
+               UpdateNodeAfterDeserialization();
+           }
-        public sealed override void UpdateNodeAfterDeserialization()
-        {
-            AddSlot(new MaterialSlot(ColorSlotId, ColorSlotName, ColorSlotName, SlotType.Input, SlotValueType.Vector4, Vector4.zero));
+           public sealed override void UpdateNodeAfterDeserialization()
+           {
+               AddSlot(new MaterialSlot(ColorSlotId, ColorSlotName, ColorSlotName, SlotType.Input, SlotValueType.Vector4, Vector4.zero));
-            // clear out slot names that do not match the slots we support
-            RemoveSlotsNameNotMatching(new[] { ColorSlotId });
-        }
+               // clear out slot names that do not match the slots we support
+               RemoveSlotsNameNotMatching(new[] { ColorSlotId });
+           }
-        public override PreviewMode previewMode
-        {
-            get
-            {
-                return PreviewMode.Preview2D;
-            }
-        }
+           public override PreviewMode previewMode
+           {
+               get
+               {
+                   return PreviewMode.Preview2D;
+               }
+           }
-        public override string GetSubShader(GenerationMode mode, PropertyCollector shaderPropertiesVisitor)
-        {
-            return "";
-        }
+           public override string GetSubShader(GenerationMode mode, PropertyCollector shaderPropertiesVisitor)
+           {
+               return "";
+           }
-        public override bool has3DPreview()
-        {
-            return false;
-        }
+           public override bool has3DPreview()
+           {
+               return false;
+           }
-        public override string GetFullShader(GenerationMode generationMode, string name, out List<PropertyCollector.TextureInfo> configuredTextures)
-        {
-            // figure out what kind of preview we want!
-            var activeNodeList = ListPool<INode>.Get();
-            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, this);
+           public override string GetFullShader(GenerationMode generationMode, string name, out List<PropertyCollector.TextureInfo> configuredTextures)
+           {
+               // figure out what kind of preview we want!
+               var activeNodeList = ListPool<INode>.Get();
+               NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, this);
-            string templateLocation = ShaderGenerator.GetTemplatePath("ExportTexture.template");
-            if (!File.Exists(templateLocation))
-            {
-                configuredTextures = new List<PropertyCollector.TextureInfo>();
-                return string.Empty;
-            }
+               string templateLocation = ShaderGenerator.GetTemplatePath("ExportTexture.template");
+               if (!File.Exists(templateLocation))
+               {
+                   configuredTextures = new List<PropertyCollector.TextureInfo>();
+                   return string.Empty;
+               }
-            string template = File.ReadAllText(templateLocation);
+               string template = File.ReadAllText(templateLocation);
-            var shaderBodyVisitor = new ShaderGenerator();
-            var shaderFunctionVisitor = new ShaderGenerator();
-            var shaderPropertiesVisitor = new PropertyCollector();
-            var shaderPropertyUsagesVisitor = new ShaderGenerator();
-            var shaderInputVisitor = new ShaderGenerator();
+               var shaderBodyVisitor = new ShaderGenerator();
+               var shaderFunctionVisitor = new ShaderGenerator();
+               var shaderPropertiesVisitor = new PropertyCollector();
+               var shaderPropertyUsagesVisitor = new ShaderGenerator();
+               var shaderInputVisitor = new ShaderGenerator();
-            // always add color because why not.
-            shaderInputVisitor.AddShaderChunk("float4 color : COLOR;", true);
+               // always add color because why not.
+               shaderInputVisitor.AddShaderChunk("float4 color : COLOR;", true);
-            bool needBitangent = activeNodeList.OfType<IMayRequireBitangent>().Any(x => x.RequiresBitangent());
-            bool needsWorldPos = activeNodeList.OfType<IMayRequireViewDirection>().Any(x => x.RequiresViewDirection());
-            if (needsWorldPos || activeNodeList.OfType<IMayRequireWorldPosition>().Any(x => x.RequiresWorldPosition()))
-            {
-                shaderBodyVisitor.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpacePosition + " = float3(0.0, 0.0, 0.0);", true);
-            }
+               bool needBitangent = activeNodeList.OfType<IMayRequireBitangent>().Any(x => x.RequiresBitangent());
+               bool needsWorldPos = activeNodeList.OfType<IMayRequireViewDirection>().Any(x => x.RequiresViewDirection());
+               if (needsWorldPos || activeNodeList.OfType<IMayRequireWorldPosition>().Any(x => x.RequiresWorldPosition()))
+               {
+                   shaderBodyVisitor.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpacePosition + " = float3(0.0, 0.0, 0.0);", true);
+               }
-            if (needBitangent || activeNodeList.OfType<IMayRequireNormal>().Any(x => x.RequiresNormal()))
-            {
-                shaderBodyVisitor.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpaceNormal + " = float3(0.0, 0.0, 1.0);", true);
-            }
+               if (needBitangent || activeNodeList.OfType<IMayRequireNormal>().Any(x => x.RequiresNormal()))
+               {
+                   shaderBodyVisitor.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpaceNormal + " = float3(0.0, 0.0, 1.0);", true);
+               }
-            for (int uvIndex = 0; uvIndex < ShaderGeneratorNames.UVCount; ++uvIndex)
-            {
-                var channel = (UVChannel)uvIndex;
-                if (activeNodeList.OfType<IMayRequireMeshUV>().Any(x => x.RequiresMeshUV(channel)))
-                {
-                    shaderBodyVisitor.AddShaderChunk("half4 " + channel.GetUVName() + " = float4(IN.localTexcoord.xyz,1.0);", true);
-                }
-            }
+               for (int uvIndex = 0; uvIndex < ShaderGeneratorNames.UVCount; ++uvIndex)
+               {
+                   var channel = (UVChannel)uvIndex;
+                   if (activeNodeList.OfType<IMayRequireMeshUV>().Any(x => x.RequiresMeshUV(channel)))
+                   {
+                       shaderBodyVisitor.AddShaderChunk("half4 " + channel.GetUVName() + " = float4(IN.localTexcoord.xyz,1.0);", true);
+                   }
+               }
-            if (activeNodeList.OfType<IMayRequireViewDirection>().Any(x => x.RequiresViewDirection()))
-            {
-                shaderBodyVisitor.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpaceViewDirection + " = float3(0.0, 0.0, -1.0);", true);
-            }
+               if (activeNodeList.OfType<IMayRequireViewDirection>().Any(x => x.RequiresViewDirection()))
+               {
+                   shaderBodyVisitor.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpaceViewDirection + " = float3(0.0, 0.0, -1.0);", true);
+               }
-            if (activeNodeList.OfType<IMayRequireScreenPosition>().Any(x => x.RequiresScreenPosition()))
-            {
-                shaderBodyVisitor.AddShaderChunk("half4 " + ShaderGeneratorNames.ScreenPosition + " = float4(IN.globalTexcoord.xyz, 1.0);", true);
-            }
-            if (needBitangent || activeNodeList.OfType<IMayRequireTangent>().Any(x => x.RequiresTangent()))
-            {
-                shaderBodyVisitor.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpaceTangent + " = float3(1.0,0.0,0.0);", true);
-            }
-            if (needBitangent)
-            {
-                shaderBodyVisitor.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpaceBitangent + " = float3(0.0,1.0,0.0);", true);
-            }
+               if (activeNodeList.OfType<IMayRequireScreenPosition>().Any(x => x.RequiresScreenPosition()))
+               {
+                   shaderBodyVisitor.AddShaderChunk("half4 " + ShaderGeneratorNames.ScreenPosition + " = float4(IN.globalTexcoord.xyz, 1.0);", true);
+               }
+               if (needBitangent || activeNodeList.OfType<IMayRequireTangent>().Any(x => x.RequiresTangent()))
+               {
+                   shaderBodyVisitor.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpaceTangent + " = float3(1.0,0.0,0.0);", true);
+               }
+               if (needBitangent)
+               {
+                   shaderBodyVisitor.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpaceBitangent + " = float3(0.0,1.0,0.0);", true);
+               }
-            if (activeNodeList.OfType<IMayRequireVertexColor>().Any(x => x.RequiresVertexColor()))
-            {
-                shaderBodyVisitor.AddShaderChunk("float4 " + ShaderGeneratorNames.VertexColor + " = float4(1.0,1.0,1.0,1.0);", true);
-            }
+               if (activeNodeList.OfType<IMayRequireVertexColor>().Any(x => x.RequiresVertexColor()))
+               {
+                   shaderBodyVisitor.AddShaderChunk("float4 " + ShaderGeneratorNames.VertexColor + " = float4(1.0,1.0,1.0,1.0);", true);
+               }
-            foreach (var activeNode in activeNodeList.OfType<AbstractMaterialNode>())
-            {
-                if (activeNode is IGeneratesFunction)
-                    (activeNode as IGeneratesFunction).GenerateNodeFunction(shaderFunctionVisitor, generationMode);
-                if (activeNode is IGeneratesBodyCode)
-                    (activeNode as IGeneratesBodyCode).GenerateNodeCode(shaderBodyVisitor, generationMode);
+               foreach (var activeNode in activeNodeList.OfType<AbstractMaterialNode>())
+               {
+                   if (activeNode is IGeneratesFunction)
+                       (activeNode as IGeneratesFunction).GenerateNodeFunction(shaderFunctionVisitor, generationMode);
+                   if (activeNode is IGeneratesBodyCode)
+                       (activeNode as IGeneratesBodyCode).GenerateNodeCode(shaderBodyVisitor, generationMode);
-                activeNode.GeneratePropertyBlock(shaderPropertiesVisitor, generationMode);
-                activeNode.GeneratePropertyUsages(shaderPropertyUsagesVisitor, generationMode);
-            }
+                   activeNode.GeneratePropertyBlock(shaderPropertiesVisitor, generationMode);
+                   activeNode.GeneratePropertyUsages(shaderPropertyUsagesVisitor, generationMode);
+               }
-            var inputSlot = GetInputSlots<MaterialSlot>().First();
-            var edges = owner.GetEdges(inputSlot.slotReference);
-            if (edges.Count() > 0)
-            {
-                var outputRef = edges.First().outputSlot;
-                var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(outputRef.nodeGuid);
-                shaderBodyVisitor.AddShaderChunk("return " + fromNode.GetVariableNameForSlot(outputRef.slotId) + ";", true);
-            }
-            else
-            {
-                shaderBodyVisitor.AddShaderChunk("return float4(0.5, 0.5, 0.5, 0.5);", true);
-            }
+               var inputSlot = GetInputSlots<MaterialSlot>().First();
+               var edges = owner.GetEdges(inputSlot.slotReference);
+               if (edges.Count() > 0)
+               {
+                   var outputRef = edges.First().outputSlot;
+                   var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(outputRef.nodeGuid);
+                   shaderBodyVisitor.AddShaderChunk("return " + fromNode.GetVariableNameForSlot(outputRef.slotId) + ";", true);
+               }
+               else
+               {
+                   shaderBodyVisitor.AddShaderChunk("return float4(0.5, 0.5, 0.5, 0.5);", true);
+               }
-            ListPool<INode>.Release(activeNodeList);
+               ListPool<INode>.Release(activeNodeList);
-            template = template.Replace("${ShaderName}", name);
-            template = template.Replace("${ShaderPropertiesHeader}", shaderPropertiesVisitor.GetPropertiesBlock(2));
-            template = template.Replace("${ShaderPropertyUsages}", shaderPropertyUsagesVisitor.GetShaderString(3));
-            template = template.Replace("${ShaderFunctions}", shaderFunctionVisitor.GetShaderString(3));
-            template = template.Replace("${PixelShaderBody}", shaderBodyVisitor.GetShaderString(4));
+               template = template.Replace("${ShaderName}", name);
+               template = template.Replace("${ShaderPropertiesHeader}", shaderPropertiesVisitor.GetPropertiesBlock(2));
+               template = template.Replace("${ShaderPropertyUsages}", shaderPropertyUsagesVisitor.GetShaderString(3));
+               template = template.Replace("${ShaderFunctions}", shaderFunctionVisitor.GetShaderString(3));
+               template = template.Replace("${PixelShaderBody}", shaderBodyVisitor.GetShaderString(4));
-            //In preview mode we use a different vertex shader, as the custom texture shaders are customized and not preview compatible.
-            template = template.Replace("${ShaderIsUsingPreview}", generationMode == GenerationMode.Preview ? "_Preview" : "");
+               //In preview mode we use a different vertex shader, as the custom texture shaders are customized and not preview compatible.
+               template = template.Replace("${ShaderIsUsingPreview}", generationMode == GenerationMode.Preview ? "_Preview" : "");
-            configuredTextures = shaderPropertiesVisitor.GetConfiguredTexutres();
-            return Regex.Replace(template, @"\r\n|\n\r|\n|\r", Environment.NewLine);
-        }
-    }*/
+               configuredTextures = shaderPropertiesVisitor.GetConfiguredTexutres();
+               return Regex.Replace(template, @"\r\n|\n\r|\n|\r", Environment.NewLine);
+           }
+       }*/
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/SurfaceModel/MetallicMasterNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-  /*  [Serializable]
-    [Title("Master/Metallic")]
-    public class MetallicMasterNode : AbstractSurfaceMasterNode
-    {
-        public const string MetallicSlotName = "Metallic";
-        public const int MetallicSlotId = 2;
+    /*  [Serializable]
+      [Title("Master/Metallic")]
+      public class MetallicMasterNode : AbstractSurfaceMasterNode
+      {
+          public const string MetallicSlotName = "Metallic";
+          public const int MetallicSlotId = 2;
-        public const string LightFunctionName = "Standard";
-        public const string SurfaceOutputStructureName = "SurfaceOutputStandard";
+          public const string LightFunctionName = "Standard";
+          public const string SurfaceOutputStructureName = "SurfaceOutputStandard";
-        public MetallicMasterNode()
-        {
-            name = "MetallicMasterNode";
-            UpdateNodeAfterDeserialization();
-        }
+          public MetallicMasterNode()
+          {
+              name = "MetallicMasterNode";
+              UpdateNodeAfterDeserialization();
+          }
-        public sealed override void UpdateNodeAfterDeserialization()
-        {
-            AddSlot(new MaterialSlot(VertexOffsetId, VertexOffsetName, VertexOffsetName, SlotType.Input, SlotValueType.Vector3, Vector4.zero, ShaderStage.Vertex));
-            AddSlot(new MaterialSlot(AlbedoSlotId, AlbedoSlotName, AlbedoSlotName, SlotType.Input, SlotValueType.Vector3, Vector4.zero, ShaderStage.Fragment));
-            AddSlot(new MaterialSlot(NormalSlotId, NormalSlotName, NormalSlotName, SlotType.Input, SlotValueType.Vector3, Vector4.zero, ShaderStage.Fragment));
-            AddSlot(new MaterialSlot(EmissionSlotId, EmissionSlotName, EmissionSlotName, SlotType.Input, SlotValueType.Vector3, Vector4.zero, ShaderStage.Fragment));
-            AddSlot(new MaterialSlot(MetallicSlotId, MetallicSlotName, MetallicSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero, ShaderStage.Fragment));
-            AddSlot(new MaterialSlot(SmoothnessSlotId, SmoothnessSlotName, SmoothnessSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero, ShaderStage.Fragment));
-            AddSlot(new MaterialSlot(OcclusionSlotId, OcclusionSlotName, OcclusionSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero, ShaderStage.Fragment));
-            AddSlot(new MaterialSlot(AlphaSlotId, AlphaSlotName, AlphaSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero, ShaderStage.Fragment));
+          public sealed override void UpdateNodeAfterDeserialization()
+          {
+              AddSlot(new MaterialSlot(VertexOffsetId, VertexOffsetName, VertexOffsetName, SlotType.Input, SlotValueType.Vector3, Vector4.zero, ShaderStage.Vertex));
+              AddSlot(new MaterialSlot(AlbedoSlotId, AlbedoSlotName, AlbedoSlotName, SlotType.Input, SlotValueType.Vector3, Vector4.zero, ShaderStage.Fragment));
+              AddSlot(new MaterialSlot(NormalSlotId, NormalSlotName, NormalSlotName, SlotType.Input, SlotValueType.Vector3, Vector4.zero, ShaderStage.Fragment));
+              AddSlot(new MaterialSlot(EmissionSlotId, EmissionSlotName, EmissionSlotName, SlotType.Input, SlotValueType.Vector3, Vector4.zero, ShaderStage.Fragment));
+              AddSlot(new MaterialSlot(MetallicSlotId, MetallicSlotName, MetallicSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero, ShaderStage.Fragment));
+              AddSlot(new MaterialSlot(SmoothnessSlotId, SmoothnessSlotName, SmoothnessSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero, ShaderStage.Fragment));
+              AddSlot(new MaterialSlot(OcclusionSlotId, OcclusionSlotName, OcclusionSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero, ShaderStage.Fragment));
+              AddSlot(new MaterialSlot(AlphaSlotId, AlphaSlotName, AlphaSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero, ShaderStage.Fragment));
-            // clear out slot names that do not match the slots
-            // we support
-            RemoveSlotsNameNotMatching(
-                new[]
-            {
-                AlbedoSlotId,
-                NormalSlotId,
-                EmissionSlotId,
-                MetallicSlotId,
-                SmoothnessSlotId,
-                OcclusionSlotId,
-                AlphaSlotId,
-                VertexOffsetId
-            });
-        }
+              // clear out slot names that do not match the slots
+              // we support
+              RemoveSlotsNameNotMatching(
+                  new[]
+              {
+                  AlbedoSlotId,
+                  NormalSlotId,
+                  EmissionSlotId,
+                  MetallicSlotId,
+                  SmoothnessSlotId,
+                  OcclusionSlotId,
+                  AlphaSlotId,
+                  VertexOffsetId
+              });
+          }
-        protected override int[] surfaceInputs
-        {
-            get
-            {
-                return new[]
-                {
-                    AlbedoSlotId,
-                    NormalSlotId,
-                    EmissionSlotId,
-                    MetallicSlotId,
-                    SmoothnessSlotId,
-                    OcclusionSlotId,
-                    AlphaSlotId,
-                };
-            }
-        }
+          protected override int[] surfaceInputs
+          {
+              get
+              {
+                  return new[]
+                  {
+                      AlbedoSlotId,
+                      NormalSlotId,
+                      EmissionSlotId,
+                      MetallicSlotId,
+                      SmoothnessSlotId,
+                      OcclusionSlotId,
+                      AlphaSlotId,
+                  };
+              }
+          }
-        protected override int[] vertexInputs
-        {
-            get
-            {
-                return new[]
-                {
-                    VertexOffsetId
-                };
-            }
-        }
+          protected override int[] vertexInputs
+          {
+              get
+              {
+                  return new[]
+                  {
+                      VertexOffsetId
+                  };
+              }
+          }
-        public override string GetSurfaceOutputName()
-        {
-            return SurfaceOutputStructureName;
-        }
+          public override string GetSurfaceOutputName()
+          {
+              return SurfaceOutputStructureName;
+          }
-        public override string GetLightFunction()
-        {
-            return LightFunctionName;
-        }
-    }*/
+          public override string GetLightFunction()
+          {
+              return LightFunctionName;
+          }
+      }*/
 }