Add ShaderStringBuilder and change non-CodeFunctionNodes to use it

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

             }
         }
 
-        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,
-                ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType), argOut);
-        }
-
-            string inputValue = GetSlotValue(InputSlotId, generationMode);
-            string outputValue = GetSlotValue(OutputSlotId, generationMode);
-            visitor.AddShaderChunk(string.Format("{0} {1};", ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType), GetVariableNameForSlot(OutputSlotId)), true);
+            var sb = new ShaderStringBuilder();
+            var inputValue = GetSlotValue(InputSlotId, generationMode);
+            var outputValue = GetSlotValue(OutputSlotId, generationMode);
+            sb.AppendLine("{0} {1};", ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType), GetVariableNameForSlot(OutputSlotId));
-                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.AddShaderChunk(string.Format("{0}3 _{1}_Blue = {0}3 ({2}, {3}, {4});", precision, GetVariableNameForNode(), channelMixer.outBlue[0], channelMixer.outBlue[1], channelMixer.outBlue[2]), true);
+                sb.AppendLine("{0}3 _{1}_Red = {0}3 ({2}, {3}, {4});", precision, GetVariableNameForNode(), channelMixer.outRed[0], channelMixer.outRed[1], channelMixer.outRed[2]);
+                sb.AppendLine("{0}3 _{1}_Green = {0}3 ({2}, {3}, {4});", precision, GetVariableNameForNode(), channelMixer.outGreen[0], channelMixer.outGreen[1], channelMixer.outGreen[2]);
+                sb.AppendLine("{0}3 _{1}_Blue = {0}3 ({2}, {3}, {4});", precision, GetVariableNameForNode(), channelMixer.outBlue[0], channelMixer.outBlue[1], channelMixer.outBlue[2]);
-
-            visitor.AddShaderChunk(GetFunctionCallBody(inputValue, string.Format("_{0}_Red", GetVariableNameForNode()), string.Format("_{0}_Green", GetVariableNameForNode()), string.Format("_{0}_Blue", GetVariableNameForNode()), outputValue), true);
-        }
+            sb.AppendLine("{0}({1}, _{2}_Red, _{2}_Green, _{2}_Blue, {3});", GetFunctionName(), inputValue, GetVariableNameForNode(), outputValue);
-        string GetFunctionCallBody(string inputValue, string red, string green, string blue, string outputValue)
-        {
-            return GetFunctionName() + " (" + inputValue + ", " + red + ", " + green + ", " + blue + ", " + outputValue + ");";
+            visitor.AddShaderChunk(sb.ToString(), false);
         }
 
         public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
 
         public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
         {
-            var sg = new ShaderGenerator();
-            sg.AddShaderChunk(GetFunctionPrototype("In", "Red", "Green", "Blue", "Out"), false);
-            sg.AddShaderChunk("{", false);
-            sg.Indent();
+            var sb = new ShaderStringBuilder();
-            sg.AddShaderChunk(string.Format("Out = {0} (dot(In, Red), dot(In, Green), dot(In, Blue));",
-                    ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType)), true);
-
-            sg.Deindent();
-            sg.AddShaderChunk("}", false);
+            sb.AppendLine("void {0} ({1} In, {2}3 Red, {2}3 Green, {2}3 Blue, out {3} Out)",
+                GetFunctionName(),
+                FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType.ToString(precision),
+                precision,
+                FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType.ToString(precision));
+            using (sb.BlockScope())
+            {
+                sb.AppendLine("Out = {0}(dot(In, Red), dot(In, Green), dot(In, Blue));",
+                    FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType.ToString(precision));
+            }
-            visitor.AddShaderChunk(sg.GetShaderString(0), true);
+            visitor.AddShaderChunk(sb.ToString(), true);
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Artistic/Normal/NormalCreateNode.cs

         public const int StrengthInputId = 4;
         public const int OutputSlotId = 5;
 
-        const string kTextureInputName = "Texture";
-        const string kUVInputName = "UV";
-        const string kSamplerInputName = "Sampler";
-        const string kOffsetInputName = "Offset";
-        const string kStrengthInputName = "Strength";
-        const string kOutputSlotName = "Out";
+        const string k_TextureInputName = "Texture";
+        const string k_UVInputName = "UV";
+        const string k_SamplerInputName = "Sampler";
+        const string k_OffsetInputName = "Offset";
+        const string k_StrengthInputName = "Strength";
+        const string k_OutputSlotName = "Out";
 
         public NormalCreateNode()
         {
 
         public sealed override void UpdateNodeAfterDeserialization()
         {
-            AddSlot(new Texture2DInputMaterialSlot(TextureInputId, kTextureInputName, kTextureInputName));
-            AddSlot(new UVMaterialSlot(UVInputId, kUVInputName, kUVInputName, UVChannel.uv0));
-            AddSlot(new SamplerStateMaterialSlot(SamplerInputId, kSamplerInputName, kSamplerInputName, SlotType.Input));
-            AddSlot(new Vector1MaterialSlot(OffsetInputId, kOffsetInputName, kOffsetInputName, SlotType.Input, 0.5f));
-            AddSlot(new Vector1MaterialSlot(StrengthInputId, kStrengthInputName, kStrengthInputName, SlotType.Input, 8f));
-            AddSlot(new Vector3MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector3.zero));
+            AddSlot(new Texture2DInputMaterialSlot(TextureInputId, k_TextureInputName, k_TextureInputName));
+            AddSlot(new UVMaterialSlot(UVInputId, k_UVInputName, k_UVInputName, UVChannel.uv0));
+            AddSlot(new SamplerStateMaterialSlot(SamplerInputId, k_SamplerInputName, k_SamplerInputName, SlotType.Input));
+            AddSlot(new Vector1MaterialSlot(OffsetInputId, k_OffsetInputName, k_OffsetInputName, SlotType.Input, 0.5f));
+            AddSlot(new Vector1MaterialSlot(StrengthInputId, k_StrengthInputName, k_StrengthInputName, SlotType.Input, 8f));
+            AddSlot(new Vector3MaterialSlot(OutputSlotId, k_OutputSlotName, k_OutputSlotName, SlotType.Output, Vector3.zero));
-        string GetFunctionPrototype(string textureIn, string samplerIn, string uvIn, string offsetIn, string strengthIn, string argOut)
-        {
-            return string.Format("void {0} ({1} {2}, {3} {4}, {5} {6}, {7} {8}, {9} {10}, out {11} {12})", GetFunctionName(),
-                ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(TextureInputId).concreteValueType), textureIn,
-                ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(SamplerInputId).concreteValueType), samplerIn,
-                ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(UVInputId).concreteValueType), uvIn,
-                ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(OffsetInputId).concreteValueType), offsetIn,
-                ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(StrengthInputId).concreteValueType), strengthIn,
-                ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType), argOut);
-        }
-
-            string textureValue = GetSlotValue(TextureInputId, generationMode);
-            string uvValue = GetSlotValue(UVInputId, generationMode);
-            string offsetValue = GetSlotValue(OffsetInputId, generationMode);
-            string strengthValue = GetSlotValue(StrengthInputId, generationMode);
-            string outputValue = GetSlotValue(OutputSlotId, generationMode);
+            var textureValue = GetSlotValue(TextureInputId, generationMode);
+            var uvValue = GetSlotValue(UVInputId, generationMode);
+            var offsetValue = GetSlotValue(OffsetInputId, generationMode);
+            var strengthValue = GetSlotValue(StrengthInputId, generationMode);
+            var outputValue = GetSlotValue(OutputSlotId, generationMode);
 
             var samplerSlot = FindInputSlot<MaterialSlot>(SamplerInputId);
             var edgesSampler = owner.GetEdges(samplerSlot.slotReference);
             else
                 samplerValue = string.Format("sampler{0}", GetSlotValue(TextureInputId, generationMode));
 
-            visitor.AddShaderChunk(string.Format("{0} {1};", ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType), GetVariableNameForSlot(OutputSlotId)), true);
-            visitor.AddShaderChunk(GetFunctionCallBody(textureValue, samplerValue, uvValue, offsetValue, strengthValue, outputValue), true);
-        }
+            var sb = new ShaderStringBuilder();
+            sb.AppendLine("{0} {1};", FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType.ToString(precision), GetVariableNameForSlot(OutputSlotId));
+            sb.AppendLine("{0}({1}, {2}, {3}, {4}, {5}, {6});", GetFunctionName(), textureValue, samplerValue, uvValue, offsetValue, strengthValue, outputValue);
-        string GetFunctionCallBody(string textureValue, string samplerValue, string uvValue, string offsetValue, string strengthValue, string outputValue)
-        {
-            return GetFunctionName() + " (" + textureValue + ", " + samplerValue + ", " + uvValue + ", " + offsetValue + ", " + strengthValue + ", " + outputValue + ");";
+            visitor.AddShaderChunk(sb.ToString(), false);
-            var sg = new ShaderGenerator();
-            sg.AddShaderChunk(GetFunctionPrototype("Texture", "Sampler", "UV", "Offset", "Strength", "Out"), false);
-            sg.AddShaderChunk("{", false);
-            sg.Indent();
+            var sb = new ShaderStringBuilder();
+            sb.AppendLine("void {0}({1} Texture, {2} Sampler, {3} UV, {4} Offset, {5} Strength, out {6} Out)", GetFunctionName(),
+                FindInputSlot<MaterialSlot>(TextureInputId).concreteValueType.ToString(precision),
+                FindInputSlot<MaterialSlot>(SamplerInputId).concreteValueType.ToString(precision),
+                FindInputSlot<MaterialSlot>(UVInputId).concreteValueType.ToString(precision),
+                FindInputSlot<MaterialSlot>(OffsetInputId).concreteValueType.ToString(precision),
+                FindInputSlot<MaterialSlot>(StrengthInputId).concreteValueType.ToString(precision),
+                FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType.ToString(precision));
+            using (sb.BlockScope())
+            {
+                sb.AppendLine("Offset = pow(Offset, 3) * 0.1;");
+                sb.AppendLine("{0}2 offsetU = float2(UV.x + Offset, UV.y);", precision);
+                sb.AppendLine("{0}2 offsetV = float2(UV.x, UV.y + Offset);", precision);
-            sg.AddShaderChunk("Offset = pow(Offset, 3) * 0.1;", false);
-            sg.AddShaderChunk(string.Format("{0}2 offsetU = float2(UV.x + Offset, UV.y);", precision), false);
-            sg.AddShaderChunk(string.Format("{0}2 offsetV = float2(UV.x, UV.y + Offset);", precision), false);
+                sb.AppendLine("{0} normalSample = Texture.Sample(Sampler, UV);", precision);
+                sb.AppendLine("{0} uSample = Texture.Sample(Sampler, offsetU);", precision);
+                sb.AppendLine("{0} vSample = Texture.Sample(Sampler, offsetV);", precision);
-            sg.AddShaderChunk(string.Format("{0} normalSample = Texture.Sample(Sampler, UV);", precision), false);
-            sg.AddShaderChunk(string.Format("{0} uSample = Texture.Sample(Sampler, offsetU);", precision), false);
-            sg.AddShaderChunk(string.Format("{0} vSample = Texture.Sample(Sampler, offsetV);", precision), false);
+                sb.AppendLine("{0}3 va = float3(1, 0, (uSample - normalSample) * Strength);", precision);
+                sb.AppendLine("{0}3 vb = float3(0, 1, (vSample - normalSample) * Strength);", precision);
+                sb.AppendLine("Out = normalize(cross(va, vb));");
+            }
-            sg.AddShaderChunk(string.Format("{0}3 va = float3(1, 0, (uSample - normalSample) * Strength);", precision), false);
-            sg.AddShaderChunk(string.Format("{0}3 vb = float3(0, 1, (vSample - normalSample) * Strength);", precision), false);
-            sg.AddShaderChunk("Out = normalize(cross(va, vb));", false);
-
-            sg.Deindent();
-            sg.AddShaderChunk("}", false);
-
-            visitor.AddShaderChunk(sg.GetShaderString(0), true);
+            visitor.AddShaderChunk(sb.ToString(), true);
         }
 
         public bool RequiresMeshUV(UVChannel channel)

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

             }
         }
 
-        string GetFunctionPrototype(string inArg, string flipArg, string outArg)
-        {
-            return string.Format("void {0} ({1} {2}, {3} {4}, out {5} {6})", GetFunctionName(),
-                ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType), inArg,
-                ConvertConcreteSlotValueTypeToString(precision, FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType), flipArg,
-                ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType), outArg);
-        }
-
-            string inputValue = GetSlotValue(InputSlotId, generationMode);
-            string outputValue = GetSlotValue(OutputSlotId, generationMode);
-            visitor.AddShaderChunk(string.Format("{0} {1};", ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType), GetVariableNameForSlot(OutputSlotId)), true);
+            var sb = new ShaderStringBuilder();
+
+            var inputValue = GetSlotValue(InputSlotId, generationMode);
+            var outputValue = GetSlotValue(OutputSlotId, generationMode);
+            sb.AppendLine("{0} {1};", FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType.ToString(precision), GetVariableNameForSlot(OutputSlotId));
-                visitor.AddShaderChunk(string.Format("{0} _{1}_Flip = {0} ({2}{3}{4}{5});",
-                        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);
+                sb.AppendLine("{0} _{1}_Flip = {0} ({2}",
+                    FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType.ToString(precision),
+                    GetVariableNameForNode(),
+                    Convert.ToInt32(m_RedChannel));
+                if (channelCount > 1)
+                    sb.Append(", {0}", Convert.ToInt32(m_GreenChannel));
+                if (channelCount > 2)
+                    sb.Append(", {0}", Convert.ToInt32(m_BlueChannel));
+                if (channelCount > 3)
+                    sb.Append(", {0}", Convert.ToInt32(m_AlphaChannel));
+                sb.Append(");");
-            visitor.AddShaderChunk(GetFunctionCallBody(inputValue, string.Format("_{0}_Flip", GetVariableNameForNode()), outputValue), true);
-        }
+            sb.AppendLine("{0}({1}, _{2}_Flip, {3});", GetFunctionName(), inputValue, GetVariableNameForNode(), outputValue);
-        string GetFunctionCallBody(string inputValue, string flipValue, string outputValue)
-        {
-            return GetFunctionName() + " (" + inputValue + ", " + flipValue + ", " + outputValue + ");";
+            visitor.AddShaderChunk(sb.ToString(), false);
         }
 
         public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
 
         public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
         {
-            var outputString = new ShaderGenerator();
-            outputString.AddShaderChunk(GetFunctionPrototype("In", "Flip", "Out"), false);
-            outputString.AddShaderChunk("{", false);
-            outputString.Indent();
-            outputString.AddShaderChunk("Out = abs(Flip - In);", false);
-            outputString.Deindent();
-            outputString.AddShaderChunk("}", false);
-            visitor.AddShaderChunk(outputString.GetShaderString(0), true);
+            var sb = new ShaderStringBuilder();
+            sb.AppendLine("void {0}({1} In, {2} Flip, out {3} Out)",
+                GetFunctionName(),
+                FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType.ToString(precision),
+                FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType.ToString(precision),
+                FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType.ToString(precision));
+            using (sb.BlockScope())
+            {
+                sb.AppendLine("Out = abs(Flip - In);");
+            }
+            visitor.AddShaderChunk(sb.ToString(), true);
         }
     }
 }

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

                 alphaChannel = TextureChannel.Red;
         }
 
-        string GetFunctionPrototype(string inArg, string outArg)
-        {
-            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);
-        }
-
-            visitor.AddShaderChunk(string.Format("{0} {1};", ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType), GetVariableNameForSlot(OutputSlotId)), true);
-            visitor.AddShaderChunk(GetFunctionCallBody(inputValue, outputValue), true);
+            visitor.AddShaderChunk(string.Format("{0} {1};", FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType.ToString(precision), GetVariableNameForSlot(OutputSlotId)), false);
+            visitor.AddShaderChunk(GetFunctionCallBody(inputValue, outputValue), false);
         }
 
         string GetFunctionCallBody(string inputValue, string outputValue)
         public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
         {
             ValidateChannelCount();
-            var outputString = new ShaderGenerator();
-            outputString.AddShaderChunk(GetFunctionPrototype("In", "Out"), false);
-            outputString.AddShaderChunk("{", false);
-            outputString.Indent();
+            var sb = new ShaderStringBuilder();
+            sb.AppendLine("void {0} ({1} In, out {2} Out)", GetFunctionName(), FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType.ToString(precision), FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType.ToString(precision));
+            using (sb.BlockScope())
+            {
+                sb.AppendLine("Out = {0}({1}{2}, {1}{3}, {1}{4}, {1}{5});", FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType.ToString(precision), kInputSlotName, m_ComponentList[m_RedChannel], m_ComponentList[m_GreenChannel], m_ComponentList[m_BlueChannel], m_ComponentList[m_AlphaChannel]);
+            }
-            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]), false);
-
-            outputString.Deindent();
-            outputString.AddShaderChunk("}", false);
-
-            visitor.AddShaderChunk(outputString.GetShaderString(0), true);
+            visitor.AddShaderChunk(sb.ToString(), true);
         }
     }
 }

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

 
         const int OutputSlotId = 0;
         const int OutputSlot1Id = 1;
-        const string kOutputSlotName = "Color";
-        const string kOutputSlot1Name = "Density";
+        const string k_OutputSlotName = "Color";
+        const string k_OutputSlot1Name = "Density";
 
         public override bool hasPreview
         {
 
         public sealed override void UpdateNodeAfterDeserialization()
         {
-            AddSlot(new Vector4MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.zero));
-            AddSlot(new Vector1MaterialSlot(OutputSlot1Id, kOutputSlot1Name, kOutputSlot1Name, SlotType.Output, 0));
+            AddSlot(new Vector4MaterialSlot(OutputSlotId, k_OutputSlotName, k_OutputSlotName, SlotType.Output, Vector4.zero));
+            AddSlot(new Vector1MaterialSlot(OutputSlot1Id, k_OutputSlot1Name, k_OutputSlot1Name, SlotType.Output, 0));
-        string GetFunctionPrototype(string argIn, string argOut, string argOut2)
-        {
-            return string.Format("void {0} ({1}3 {2}, out {3} {4}, out {5} {6})", GetFunctionName(), precision, argIn,
-                ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType), argOut,
-                ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlot1Id).concreteValueType), argOut2);
-        }
-
-            string colorValue = GetSlotValue(OutputSlotId, generationMode);
-            string densityValue = GetSlotValue(OutputSlot1Id, generationMode);
-            visitor.AddShaderChunk(string.Format("{0} {1};", ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType), GetVariableNameForSlot(OutputSlotId)), true);
-            visitor.AddShaderChunk(string.Format("{0} {1};", ConvertConcreteSlotValueTypeToString(precision, FindOutputSlot<MaterialSlot>(OutputSlot1Id).concreteValueType), GetVariableNameForSlot(OutputSlot1Id)), true);
-            string objectSpacePosition = string.Format("IN.{0}", CoordinateSpace.Object.ToVariableName(InterpolatorType.Position));
-            visitor.AddShaderChunk(GetFunctionCallBody(objectSpacePosition, colorValue, densityValue), true);
-        }
-
-        string GetFunctionCallBody(string objectSpaceValue, string outputValue, string output1Value)
-        {
-            return GetFunctionName() + " (" + objectSpaceValue + ", " + outputValue + ", " + output1Value + ");";
+            var colorValue = GetSlotValue(OutputSlotId, generationMode);
+            var densityValue = GetSlotValue(OutputSlot1Id, generationMode);
+            visitor.AddShaderChunk(string.Format("{0} {1};", FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType.ToString(precision), GetVariableNameForSlot(OutputSlotId)), false);
+            visitor.AddShaderChunk(string.Format("{0} {1};", FindOutputSlot<MaterialSlot>(OutputSlot1Id).concreteValueType.ToString(precision), GetVariableNameForSlot(OutputSlot1Id)), false);
+            visitor.AddShaderChunk(string.Format("{0}(IN.{1}, {2}, {3});", GetFunctionName(), CoordinateSpace.Object.ToVariableName(InterpolatorType.Position), colorValue, densityValue), false);
-            var sg = new ShaderGenerator();
-            sg.AddShaderChunk(GetFunctionPrototype("ObjectSpacePosition", "Color", "Density"), false);
-            sg.AddShaderChunk("{", false);
-            sg.Indent();
-
-            sg.AddShaderChunk("Color = unity_FogColor;", false);
-
-            sg.AddShaderChunk(string.Format("{0} clipZ_01 = UNITY_Z_0_FAR_FROM_CLIPSPACE(UnityObjectToClipPos(ObjectSpacePosition).z);", precision), false);
-            sg.AddShaderChunk("#if defined(FOG_LINEAR)", false);
-            sg.Indent();
-            sg.AddShaderChunk(string.Format("{0} fogFactor = saturate(clipZ_01 * unity_FogParams.z + unity_FogParams.w);", precision), false);
-            sg.AddShaderChunk("Density = fogFactor;", false);
-            sg.Deindent();
-            sg.AddShaderChunk("#elif defined(FOG_EXP)", false);
-            sg.Indent();
-            sg.AddShaderChunk(string.Format("{0} fogFactor = unity_FogParams.y * clipZ_01;", precision), false);
-            sg.AddShaderChunk("Density = {2}(saturate(exp2(-fogFactor)));", false);
-            sg.Deindent();
-            sg.AddShaderChunk("#elif defined(FOG_EXP2)", false);
-            sg.Indent();
-            sg.AddShaderChunk(string.Format("{0} fogFactor = unity_FogParams.x * clipZ_01;", precision), false);
-            sg.AddShaderChunk("Density = {2}(saturate(exp2(-fogFactor*fogFactor)));", false);
-            sg.Deindent();
-            sg.AddShaderChunk("#else", false);
-            sg.Indent();
-            sg.AddShaderChunk("Density = 0.0h;", false);
-            sg.Deindent();
-            sg.AddShaderChunk("#endif", false);
+            var sg = new ShaderStringBuilder();
+            sg.AppendLine("void {0}({1}3 ObjectSpacePosition, out {2} Color, out {3} Density)",
+                GetFunctionName(),
+                precision,
+                FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType.ToString(precision),
+                FindOutputSlot<MaterialSlot>(OutputSlot1Id).concreteValueType.ToString(precision));
+            using (sg.BlockScope())
+            {
+                sg.AppendLine("Color = unity_FogColor;");
-            sg.Deindent();
-            sg.AddShaderChunk("}", false);
+                sg.AppendLine("{0} clipZ_01 = UNITY_Z_0_FAR_FROM_CLIPSPACE(UnityObjectToClipPos(ObjectSpacePosition).z);", precision);
+                sg.AppendLine("#if defined(FOG_LINEAR)");
+                using (sg.IndentScope())
+                {
+                    sg.AppendLine("{0} fogFactor = saturate(clipZ_01 * unity_FogParams.z + unity_FogParams.w);", precision);
+                    sg.AppendLine("Density = fogFactor;");
+                }
+                sg.AppendLine("#elif defined(FOG_EXP)");
+                using (sg.IndentScope())
+                {
+                    sg.AppendLine("{0} fogFactor = unity_FogParams.y * clipZ_01;", precision);
+                    sg.AppendLine("Density = saturate(exp2(-fogFactor));");
+                }
+                sg.AppendLine("#elif defined(FOG_EXP2)");
+                using (sg.IndentScope())
+                {
+                    sg.AppendLine("{0} fogFactor = unity_FogParams.x * clipZ_01;", precision);
+                    sg.AppendLine("Density = saturate(exp2(-fogFactor*fogFactor));");
+                }
+                sg.AppendLine("#else");
+                using (sg.IndentScope())
+                {
+                    sg.AppendLine("Density = 0.0h;");
+                }
+                sg.AppendLine("#endif");
+            }
-            visitor.AddShaderChunk(sg.GetShaderString(0), true);
+            visitor.AddShaderChunk(sg.ToString(), true);
         }
 
         public NeededCoordinateSpace RequiresPosition()

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

         {
             return k_ConcreteSlotValueTypeClassNames[(int)type];
         }
+
+        public static string ToString(this ConcreteSlotValueType type, AbstractMaterialNode.OutputPrecision precision)
+        {
+            return AbstractMaterialNode.ConvertConcreteSlotValueTypeToString(precision, type);
+        }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Util/ShaderStringBuilder.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+using JetBrains.Annotations;
+
+namespace UnityEditor.ShaderGraph
+{
+    public class ShaderStringBuilder : IDisposable
+    {
+        enum ScopeType
+        {
+            Indent,
+            Block
+        }
+
+        StringBuilder m_StringBuilder;
+        Stack<ScopeType> m_ScopeStack;
+        int m_IndentationLevel;
+        const string k_IndentationString = "    ";
+
+        public ShaderStringBuilder()
+        {
+            m_StringBuilder = new StringBuilder();
+            m_ScopeStack = new Stack<ScopeType>();
+        }
+
+        public void AppendNewLine()
+        {
+            m_StringBuilder.Append(Environment.NewLine);
+        }
+
+        public void AppendLine(string value)
+        {
+            AppendNewLine();
+            AppendIndentation();
+            m_StringBuilder.Append(value);
+        }
+
+        [StringFormatMethod("formatString")]
+        public void AppendLine(string formatString, params object[] args)
+        {
+            AppendNewLine();
+            AppendIndentation();
+            m_StringBuilder.AppendFormat(formatString, args);
+        }
+
+        public void Append(string value)
+        {
+            m_StringBuilder.Append(value);
+        }
+
+        [StringFormatMethod("formatString")]
+        public void Append(string formatString, params object[] args)
+        {
+            m_StringBuilder.AppendFormat(formatString, args);
+        }
+
+        public void AppendIndentation()
+        {
+            for (var i = 0; i < m_IndentationLevel; i++)
+                m_StringBuilder.Append(k_IndentationString);
+        }
+
+        public IDisposable IndentScope()
+        {
+            m_ScopeStack.Push(ScopeType.Indent);
+            m_IndentationLevel++;
+            return this;
+        }
+
+        public IDisposable BlockScope()
+        {
+            AppendLine("{");
+            m_IndentationLevel++;
+            m_ScopeStack.Push(ScopeType.Block);
+            return this;
+        }
+
+        public void Dispose()
+        {
+            switch (m_ScopeStack.Pop())
+            {
+                case ScopeType.Indent:
+                    m_IndentationLevel--;
+                    break;
+                case ScopeType.Block:
+                    m_IndentationLevel--;
+                    AppendLine("}");
+                    break;
+            }
+        }
+
+        public override string ToString()
+        {
+            return m_StringBuilder.ToString();
+        }
+
+        public string ToString(int startIndex, int length)
+        {
+            return m_StringBuilder.ToString(startIndex, length);
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Util/ShaderStringBuilder.cs.meta

+fileFormatVersion: 2
+guid: e64ba38b003f49bdb6ae4a2259be61c6
+timeCreated: 1513172221