Update node titles to use new array-based grouping `[Title("UV/Flipbook")]` -> `[Title("UV", "Flipbook")]`

MaterialGraphProject/Assets/NewNodes/Editor/ChannelBlendNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    /*  [Title("Art/ChannelBlend")]
+    /*  [Title("Art", "ChannelBlend")]
       public class ChannelBlend : FunctionNInNOut, IGeneratesFunction
       {
 

MaterialGraphProject/Assets/NewNodes/Editor/FunctionNAddNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    /*  [Title("Math/Advanced/Adder")]
+    /*  [Title("Math", "Advanced", "Adder")]
       public class AddManyNode : FunctionNInNOut, IGeneratesFunction
       {
           int m_nodeInputCount = 2;

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Art/BlendMode")]
+    [Title("Art", "BlendMode")]
     public class BlendModeNode : CodeFunctionNode
     {
         public BlendModeNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Art/Adjustments/ColorBalance")]
+    [Title("Art", "Adjustments", "ColorBalance")]
     public class ColorBalanceNode : CodeFunctionNode
     {
         public ColorBalanceNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Utility/Heightmap To Normalmap")]
+    [Title("Utility", "Heightmap To Normalmap")]
     public class HeightToNormalNode : AbstractMaterialNode, IGeneratesBodyCode, IMayRequireMeshUV
     {
         public const int TextureInput = 0;

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("OLD/Parallax")]
+    [Title("OLD", "Parallax")]
     public class ParallaxNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction, IMayRequireMeshUV, IMayRequireViewDirection
     {
         protected const string kInputSlot1ShaderName = "Depth";

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

 
 namespace UnityEditor.ShaderGraph
 {
-    /* [Title("UV/Tri-Planar Mapping")]
+    /* [Title("UV", "Tri-Planar Mapping")]
      public class UVTriPlanar : FunctionNInNOut, IGeneratesFunction, IMayRequireNormal, IMayRequireWorldPosition
      {
          private int slot0, slot1, slot2, slot3, slot4, slot5, slot6 = 0;
 
  namespace UnityEditor.ShaderGraph
  {
-     [Title("UV/Tri-Planar Mapping")]
+     [Title("UV", "Tri-Planar Mapping")]
      public class UVTriPlanar : FunctionNInNOut, IGeneratesFunction, IMayRequireNormal, IMayRequireWorldPosition
      {
          private int slot0, slot1, slot2, slot3, slot4, slot5, slot6 = 0;

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("OLD/AACheckerboard3d")]
+    [Title("OLD", "AACheckerboard3d")]
     public class AACheckerboard3dNode : CodeFunctionNode
     {
         protected override MethodInfo GetFunctionToConvert()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("OLD/Checkerboard")]
+    [Title("OLD", "Checkerboard")]
     public class CheckerboardNode : CodeFunctionNode
     {
         public CheckerboardNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("OLD/Gradient Ramp")]
+    [Title("OLD", "Gradient Ramp")]
     public class GradientRampNode : CodeFunctionNode
     {
         public GradientRampNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("OLD/Line")]
+    [Title("OLD", "Line")]
     public class LineNode : CodeFunctionNode
     {
         public LineNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("OLD/MultiLayerParallax")]
+    [Title("OLD", "MultiLayerParallax")]
     public class MultiLayerParallaxNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction, IMayRequireMeshUV, IMayRequireViewDirection
     {
         protected const string kInputDepthShaderName = "Depth";

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("OLD/ParallaxOcclusionMapping")]
+    [Title("OLD", "ParallaxOcclusionMapping")]
     public class ParallaxOcclusionMappingNode : CodeFunctionNode
     {
         protected override MethodInfo GetFunctionToConvert()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("OLD/Pulse")]
+    [Title("OLD", "Pulse")]
     public class PulseNode : CodeFunctionNode
     {
         public PulseNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    /*  [Title("Procedural/Scatter")]
+    /*  [Title("Procedural", "Scatter")]
       public class ScatterNode : FunctionNInNOut, IGeneratesFunction
       {
 

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

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

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

 namespace UnityEditor.ShaderGraph
 {
     /*
-    [Title("OLD/SpherizeOLD")]
+    [Title("OLD", "SpherizeOLD")]
     public class SpherizeNode : CodeFunctionNode
     {
         public SpherizeNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    /* [Title("Input/Toggle")]
+    /* [Title("Input", "Toggle")]
      public class ToggleNode : PropertyNode, IGeneratesBodyCode
      {
          [SerializeField]

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("OLD/UV Panner")]
+    [Title("OLD", "UV Panner")]
     public class PannerNode : CodeFunctionNode
     {
         public PannerNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("OLD/UV Tile")]
+    [Title("OLD", "UV Tile")]
     public class UVTileNode : CodeFunctionNode
     {
         public UVTileNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("OLD/Transform")]
+    [Title("OLD", "Transform")]
     public class UVTransform : CodeFunctionNode
     {
         [SerializeField]

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

 namespace UnityEditor.ShaderGraph
 {
 /*    [Serializable]
-    [Title("Master/Lightweight/Fast Blinn")]
+    [Title("Master", "Lightweight", "Fast Blinn")]
     public class LightweightFastBlinnMasterNode : AbstractMasterNode
     {
         public const string AlbedoSlotName = "Diffuse";

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

 namespace UnityEditor.ShaderGraph
 {
     [Serializable]
-    [Title("Master/PBR")]
+    [Title("Master", "PBR")]
     public class PBRMasterNode : MasterNode
     {
         public const string AlbedoSlotName = "Albedo";

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

 namespace UnityEditor.ShaderGraph
 {
     [Serializable]
-    [Title("Master/Unlit")]
+    [Title("Master", "Unlit")]
     public class UnlitMasterNode : MasterNode
     {
         public const string ColorSlotName = "Color";

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Artistic/Adjustment/Channel Mixer")]
+    [Title("Artistic", "Adjustment", "Channel Mixer")]
     public class ChannelMixerNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction
     {
         public ChannelMixerNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Artistic/Adjustment/Contrast")]
+    [Title("Artistic", "Adjustment", "Contrast")]
     public class ContrastNode : CodeFunctionNode
     {
         public ContrastNode()

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

         Normalized
     };
 
-    [Title("Artistic/Adjustment/Hue")]
+    [Title("Artistic", "Adjustment", "Hue")]
     public class HueNode : CodeFunctionNode
     {
         public HueNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Art/Adjustments/Levels")]
+    [Title("Art", "Adjustments", "Levels")]
     public class LevelsNode : CodeFunctionNode
     {
         public LevelsNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Artistic/Adjustment/Replace Color")]
+    [Title("Artistic", "Adjustment", "Replace Color")]
     public class ReplaceColorNode : CodeFunctionNode
     {
         public ReplaceColorNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Artistic/Adjustment/Saturation")]
+    [Title("Artistic", "Adjustment", "Saturation")]
     public class SaturationNode : CodeFunctionNode
     {
         public SaturationNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Artistic/Adjustment/White Balance")]
+    [Title("Artistic", "Adjustment", "White Balance")]
     public class WhiteBalanceNode : CodeFunctionNode
     {
         public WhiteBalanceNode()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Artistic/Conversion/HSVtoRGBNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Art/Conversion/HSVtoRGB")]
+    [Title("Art", "Conversion", "HSVtoRGB")]
     public class HSVtoRGBNode : CodeFunctionNode
     {
         public HSVtoRGBNode()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Artistic/Conversion/LinearToRGBNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Art/Conversion/LineartoRGB")]
+    [Title("Art", "Conversion", "LineartoRGB")]
     public class LineartoRGBNode : CodeFunctionNode
     {
         public LineartoRGBNode()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Artistic/Conversion/RGBtoHSVNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Art/Conversion/RGBtoHSV")]
+    [Title("Art", "Conversion", "RGBtoHSV")]
     public class RGBtoHSVNode : CodeFunctionNode
     {
         public RGBtoHSVNode()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Artistic/Conversion/RGBtoLinearNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Art/Conversion/RGBtoLinear")]
+    [Title("Art", "Conversion", "RGBtoLinear")]
     public class RGBtoLinearNode : CodeFunctionNode
     {
         public RGBtoLinearNode()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Artistic/Conversion/RGBtoLuminanceNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Art/Conversion/RGBtoLuminance")]
+    [Title("Art", "Conversion", "RGBtoLuminance")]
     public class RGBtoLuminanceNode : CodeFunctionNode
     {
         public RGBtoLuminanceNode()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Artistic/Filters/ConvolutionFilterNode.cs

 
 /*namespace UnityEditor.ShaderGraph
 {
-    [Title("Art/Filters/Convolution")]
+    [Title("Art", "Filters", "Convolution")]
     public class ConvolutionFilterNode : Function2Input, IGeneratesFunction, IGeneratesBodyCode, IMayRequireMeshUV
     {
         private const string kUVSlotName = "UV";

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;
         Alpha
     }
 
-    [Title("Artistic/Mask/Channel Mask")]
+    [Title("Artistic", "Mask", "Channel Mask")]
     public class ChannelMaskNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction
     {
         public ChannelMaskNode()

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

-using System.Reflection;
+using System.Reflection;
-    [Title("Artistic/Mask/Color Mask")]
+    [Title("Artistic", "Mask", "Color Mask")]
     public class ColorMaskNode : CodeFunctionNode
     {
         public ColorMaskNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Channel/Combine")]
+    [Title("Channel", "Combine")]
     public class CombineNode : CodeFunctionNode
     {
         public CombineNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Channel/Flip")]
+    [Title("Channel", "Flip")]
     public class FlipNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction
     {
         public FlipNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Channel/Split")]
+    [Title("Channel", "Split")]
     public class SplitNode : AbstractMaterialNode, IGeneratesBodyCode
     {
         const string kInputSlotName = "Input";

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Channel/Swizzle")]
+    [Title("Channel", "Swizzle")]
     public class SwizzleNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction
     {
         public SwizzleNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Basic/Color")]
+    [Title("Input", "Basic", "Color")]
     public class ColorNode : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
     {
         [SerializeField]

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

         SQRT2
     };
 
-    [Title("Input/Basic/Constant")]
+    [Title("Input", "Basic", "Constant")]
     public class ConstantNode : AbstractMaterialNode, IGeneratesBodyCode
     {
         static Dictionary<ConstantType, float> m_constantList = new Dictionary<ConstantType, float>

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

-using UnityEngine;
+using UnityEngine;
-    [Title("Input/Basic/Time")]
+    [Title("Input", "Basic", "Time")]
     public class TimeNode : AbstractMaterialNode, IMayRequireTime
     {
         private const string kOutputSlotName = "Time";

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Basic/Vector 1")]
+    [Title("Input", "Basic", "Vector 1")]
     public class Vector1Node : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
     {
         [SerializeField]

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Basic/Vector 2")]
+    [Title("Input", "Basic", "Vector 2")]
     public class Vector2Node : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
     {
         [SerializeField]

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Basic/Vector 3")]
+    [Title("Input", "Basic", "Vector 3")]
     public class Vector3Node : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
     {
         [SerializeField]

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Basic/Vector 4")]
+    [Title("Input", "Basic", "Vector 4")]
     public class Vector4Node : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
     {
         [SerializeField]

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Geometry/Bitangent Vector")]
+    [Title("Input", "Geometry", "Bitangent Vector")]
     public class BitangentVectorNode : GeometryNode, IMayRequireBitangent
     {
         public const int kOutputSlotId = 0;

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Geometry/Normal Vector")]
+    [Title("Input", "Geometry", "Normal Vector")]
     public class NormalVectorNode : GeometryNode, IMayRequireNormal
     {
         public const int kOutputSlotId = 0;

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Geometry/Position")]
+    [Title("Input", "Geometry", "Position")]
     public class PositionNode : GeometryNode, IMayRequirePosition
     {
         private const int kOutputSlotId = 0;

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

         Tiled
     };
 
-    [Title("Input/Geometry/Screen Position")]
+    [Title("Input", "Geometry", "Screen Position")]
     public class ScreenPositionNode : AbstractMaterialNode, IGeneratesBodyCode, IMayRequireScreenPosition
     {
         public ScreenPositionNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Geometry/Tangent Vector")]
+    [Title("Input", "Geometry", "Tangent Vector")]
     public class TangentVectorNode : GeometryNode, IMayRequireTangent
     {
         public const int kOutputSlotId = 0;

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

         bool RequiresMeshUV(UVChannel channel);
     }
 
-    [Title("Input/Geometry/UV")]
+    [Title("Input", "Geometry", "UV")]
     public class UVNode : AbstractMaterialNode, IGeneratesBodyCode, IMayRequireMeshUV
     {
         public const int OutputSlotId = 0;

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

         bool RequiresVertexColor();
     }
 
-    [Title("Input/Geometry/Vertex Color")]
+    [Title("Input", "Geometry", "Vertex Color")]
     public class VertexColorNode : AbstractMaterialNode, IMayRequireVertexColor
     {
         private const int kOutputSlotId = 0;

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Geometry/View Direction")]
+    [Title("Input", "Geometry", "View Direction")]
     public class ViewDirectionNode : GeometryNode, IMayRequireViewDirection
     {
         private const int kOutputSlotId = 0;

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Matrix/Matrix 2x2")]
+    [Title("Input", "Matrix", "Matrix 2x2")]
     public class Matrix2Node : AbstractMaterialNode, IGeneratesBodyCode
     {
         const int kOutputSlotId = 0;

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Matrix/Matrix 3x3")]
+    [Title("Input", "Matrix", "Matrix 3x3")]
     public class Matrix3Node : AbstractMaterialNode, IGeneratesBodyCode
     {
         const int kOutputSlotId = 0;

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Matrix/Matrix 4x4")]
+    [Title("Input", "Matrix", "Matrix 4x4")]
     public class Matrix4Node : AbstractMaterialNode, IGeneratesBodyCode
     {
         const int kOutputSlotId = 0;

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

         WorldToObject
     };
 
-    [Title("Input/Matrix/Transformation Matrix")]
+    [Title("Input", "Matrix", "Transformation Matrix")]
     public class TransformationMatrixNode : AbstractMaterialNode
     {
         static Dictionary<TransformationMatrixType, string> m_matrixList = new Dictionary<TransformationMatrixType, string>

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Scene/CameraNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Scene/Camera")]
+    [Title("Input", "Scene", "Camera")]
     public class CameraNode : AbstractMaterialNode
     {
         private const string kOutputSlotName = "Pos";

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Scene/LightProbeNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Scene/Light Probe")]
+    [Title("Input", "Scene", "Light Probe")]
     public class LightProbeNode : CodeFunctionNode
     {
         public override bool hasPreview { get { return false; } }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Scene/ReflectionProbeNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Scene/Reflection Probe")]
+    [Title("Input", "Scene", "Reflection Probe")]
     public class ReflectionProbeNode : CodeFunctionNode
     {
         public ReflectionProbeNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Texture/Cubemap Asset")]
+    [Title("Input", "Texture", "Cubemap Asset")]
     public class CubemapAssetNode : AbstractMaterialNode, IPropertyFromNode
     {
         public const int OutputSlotId = 0;

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Texture/Cubemap")]
+    [Title("Input", "Texture", "Cubemap")]
     public class CubemapNode : AbstractMaterialNode, IGeneratesBodyCode, IMayRequireViewDirection, IMayRequireNormal
     {
         public const int OutputSlotId = 0;

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

 
 namespace UnityEditor.ShaderGraph
 {
-    /* [Title("Input/Texture/Cubemap")]
+    /* [Title("Input", "Texture", "Cubemap")]
      public class CubemapNode : PropertyNode, IGeneratesBodyCode, IMayRequireViewDirection, IMayRequireNormal
      {
          protected const string kUVSlotName = "RefVector";

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

 
 namespace UnityEditor.ShaderGraph
 {
-    /* [Title("Input/Texture/Sampler Asset")]
+    /* [Title("Input", "Texture", "Sampler Asset")]
      public class SamplerAssetNode : PropertyNode
      {
 

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

 
 namespace UnityEditor.ShaderGraph
 {
-    /*   [Title("Input/Texture/TextureLOD")]
+    /*   [Title("Input", "Texture", "TextureLOD")]
        public class TextureLODNode : PropertyNode, IGeneratesBodyCode, IMayRequireMeshUV
        {
            protected const string kUVSlotName = "UV";

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Input/Texture/Sampler State")]
+    [Title("Input", "Texture", "Sampler State")]
     public class SamplerStateNode : AbstractMaterialNode
     {
         [SerializeField]

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;
-    [Title("Input/Texture/Texture 2D Asset")]
+    [Title("Input", "Texture", "Texture 2D Asset")]
     public class Texture2DAssetNode : AbstractMaterialNode, IPropertyFromNode
     {
         public const int OutputSlotId = 0;

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

         Normal
     };
 
-    [Title("Input/Texture/Texture 2D")]
+    [Title("Input", "Texture", "Texture 2D")]
     public class Texture2DNode : AbstractMaterialNode, IGeneratesBodyCode, IMayRequireMeshUV
     {
         public const int OutputSlotRGBAId = 0;

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Time/SinTimeNode.cs

 namespace UnityEditor.ShaderGraph
 {
     /*
-    [Title("Input/Time/Sine Time")]
+    [Title("Input", "Time", "Sine Time")]
     public class SinTimeNode : AbstractMaterialNode, IMayRequireTime
     {
         public SinTimeNode()

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

 namespace UnityEditor.ShaderGraph
 {
     /*
-    [Title("Input/Time/Time")]
+    [Title("Input", "Time", "Time")]
     public class TimeNode : AbstractMaterialNode, IMayRequireTime
     {
         private const string kOutputSlotName = "Time";

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Logic/CustomCodeNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-/*    [Title("Logic/CustomCode")]
+/*    [Title("Logic", "CustomCode")]
     public class CustomCodeNode : FunctionNInNOut, IGeneratesFunction
     {
         [SerializeField] private string m_code;

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Logic/IFNode.cs

 namespace UnityEditor.ShaderGraph
 {
 // PROBABLY USEFUL, BUT BROKEN AT THE MOMENT
-//    [Title("Logic/If")]
+//    [Title("Logic", "If")]
 //    public class IfNode : CodeFunctionNode
 //    {
 //        public enum ComparisonOperationType

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Advanced/Absolute")]
+    [Title("Math", "Advanced", "Absolute")]
     public class AbsoluteNode : CodeFunctionNode
     {
         public AbsoluteNode()

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

         Base2
     };
 
-    [Title("Math/Advanced/Exponential")]
+    [Title("Math", "Advanced", "Exponential")]
     public class ExponentialNode : CodeFunctionNode
     {
         public ExponentialNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Advanced/Length")]
+    [Title("Math", "Advanced", "Length")]
     public class LengthNode : CodeFunctionNode
     {
         public LengthNode()

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

         Base10
     };
 
-    [Title("Math/Advanced/Log")]
+    [Title("Math", "Advanced", "Log")]
     public class LogNode : CodeFunctionNode
     {
         public LogNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Advanced/Modulo")]
+    [Title("Math", "Advanced", "Modulo")]
     public class ModuloNode : CodeFunctionNode
     {
         public ModuloNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Advanced/Negate")]
+    [Title("Math", "Advanced", "Negate")]
     public class NegateNode : CodeFunctionNode
     {
         public NegateNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Advanced/Normalize")]
+    [Title("Math", "Advanced", "Normalize")]
     class NormalizeNode : CodeFunctionNode
     {
         public NormalizeNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Advanced/Posterize")]
+    [Title("Math", "Advanced", "Posterize")]
     class PosterizeNode : CodeFunctionNode
     {
         public PosterizeNode()

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

         Fast
     };
 
-    [Title("Math/Advanced/Reciprocal")]
+    [Title("Math", "Advanced", "Reciprocal")]
     public class ReciprocalNode : CodeFunctionNode
     {
         public ReciprocalNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Advanced/Reciprocal Square Root")]
+    [Title("Math", "Advanced", "Reciprocal Square Root")]
     public class ReciprocalSquareRootNode : CodeFunctionNode
     {
         public ReciprocalSquareRootNode()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Basic/AddNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Basic/Add")]
+    [Title("Math", "Basic", "Add")]
     public class AddNode : CodeFunctionNode
     {
         public AddNode()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Basic/DivideNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Basic/Divide")]
+    [Title("Math", "Basic", "Divide")]
     public class DivideNode : CodeFunctionNode
     {
         public DivideNode()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Basic/MultiplyNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Basic/Multiply")]
+    [Title("Math", "Basic", "Multiply")]
     public class MultiplyNode : CodeFunctionNode
     {
         public MultiplyNode()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Basic/PowerNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Basic/Power")]
+    [Title("Math", "Basic", "Power")]
     public class PowerNode : CodeFunctionNode
     {
         public PowerNode()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Basic/SquareRootNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Basic/Square Root")]
+    [Title("Math", "Basic", "Square Root")]
     public class SquareRootNode : CodeFunctionNode
     {
         public SquareRootNode()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Basic/SubtractNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Basic/Subtract")]
+    [Title("Math", "Basic", "Subtract")]
     class SubtractNode : CodeFunctionNode
     {
         public SubtractNode()

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

         Fine
     };
 
-    [Title("Math/Derivative/DDX")]
+    [Title("Math", "Derivative", "DDX")]
     public class DDXNode : CodeFunctionNode
     {
         public DDXNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Derivative/DDXY")]
+    [Title("Math", "Derivative", "DDXY")]
     public class DDXYNode : CodeFunctionNode
     {
         public DDXYNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Derivative/DDY")]
+    [Title("Math", "Derivative", "DDY")]
     public class DDYNode : CodeFunctionNode
     {
         public DDYNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Interpolation/Inverse Lerp")]
+    [Title("Math", "Interpolation", "Inverse Lerp")]
     public class InverseLerpNode : CodeFunctionNode
     {
         public InverseLerpNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Interpolation/Lerp")]
+    [Title("Math", "Interpolation", "Lerp")]
     public class LerpNode : CodeFunctionNode
     {
         public LerpNode()

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

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Interpolation/Smoothstep")]
+    [Title("Math", "Interpolation", "Smoothstep")]
     class SmoothstepNode : CodeFunctionNode
     {
         public SmoothstepNode()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Math/Matrix/MatrixMultiplyByVectorNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
-    [Title("Math/Matrix/MultiplyMatrixByVector")]
+    [Title("Math", "Matrix", "MultiplyMatrixByVector")]
     public class MatrixMultiplyByVectorNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction
     {
         protected const string kInputSlot1ShaderName = "Input1";